db/models/experiment_category.py

@@ -9,7 +9,7 @@ from db.models.base import Base
 class ExperimentCategory(Base):
     __tablename__ = 'experiment_category'
 
-    id: Mapped[int] = mapped_column(Identity(start=21, cycle=True),
+    id: Mapped[int] = mapped_column(Identity(start=1, cycle=True),
                                     primary_key=True)
     name: Mapped[str]
 

db/repositories/experiment_category_repos.py

@@ -3,10 +3,13 @@ from typing import Sequence
 from sqlalchemy import update, delete
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.future import select
-
+from typing_extensions import deprecated
 from db.models import ExperimentCategory
 
 
+@deprecated(
+    "теперь есть параметризованный круд, а уже свои специфичные методы у каждой сущности в своем репозитории"
+)
 class ExperimentCategoryRepository:
     def __init__(self, session: AsyncSession):
         self.session = session

db/repositories/experiment_data_repos.py

@@ -1,42 +1,14 @@
-from typing import Sequence, Optional
+from typing import Sequence
 
-from sqlalchemy import update, delete
-from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.future import select
 
 from db.models.experiment_data_model import ExperimentData
+from db.postgres_db_connection import async_session_postgres
 
 
-
+async def get_exp_data_by_file_id(file_id: str) -> Sequence[ExperimentData]:
-
+    async with async_session_postgres() as session:
-
+        result = await session.execute(
-class ExperimentDataRepository:
+            select(ExperimentData).where(ExperimentData.file_id == file_id)
-    def __init__(self, session: AsyncSession):
-        self.session = session
-
-    async def get_all(self) -> Sequence[ExperimentData]:
-        result = await self.session.execute(select(ExperimentData))
-        return result.scalars().all()
-
-    async def get_by_id(self, id: int) -> ExperimentData:
-        result = await self.session.execute(select(ExperimentData).where(ExperimentData.id == id))
-        return result.scalar_one_or_none()
-
-    async def create(self, new_data: ExperimentData):
-        self.session.add(new_data)
-        await self.session.commit()
-
-    async def update(self, id: int, updated_data: dict):
-        stmt = (
-            update(ExperimentData).
-            where(ExperimentData.id == id).
-            values(**updated_data)
         )
-        await self.session.execute(stmt)
+        return result.scalars().all()
-        await self.session.commit()
-
-    async def delete(self, id: int):
-        stmt = delete(ExperimentData).where(ExperimentData.id == id)
-        await self.session.execute(stmt)
-        await self.session.commit()
-

db/repositories/experiment_parameters_repos.py

@@ -1,44 +1,21 @@
 from typing import Sequence
 
-from sqlalchemy import update, delete
-from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.future import select
 
 from db.models.experiment_parameters_model import ExperimentParameters
+from db.postgres_db_connection import async_session_postgres
 
 
-class ExperimentParametersRepository:
+async def get_exp_parameters_by_category(category_id: int) -> Sequence[ExperimentParameters]:
-    def __init__(self, session: AsyncSession):
+    async with async_session_postgres() as session:
-        self.session = session
+        result = await session.execute(
-
-    async def get_all(self) -> Sequence[ExperimentParameters]:
-        result = await self.session.execute(select(ExperimentParameters))
-        return result.scalars().all()
-
-    async def get_by_id(self, id: int) -> ExperimentParameters:
-        result = await self.session.execute(select(ExperimentParameters).where(ExperimentParameters.id == id))
-        return result.scalar_one_or_none()
-
-    async def get_experiment_parameters_by_category(self, session: AsyncSession, category_id: int) -> Sequence[ExperimentParameters]:
-        result = await self.session.execute(
             select(ExperimentParameters).where(ExperimentParameters.experiment_category_id == category_id)
         )
         return result.scalars().all()
 
-    async def create(self, new_data: ExperimentParameters):
+async def get_exp_parameters_by_exp_hash(exp_hash: str) -> Sequence[ExperimentParameters]:
-        self.session.add(new_data)
+    async with async_session_postgres() as session:
-        await self.session.commit()
+        result = await session.execute(
-
+            select(ExperimentParameters).where(ExperimentParameters.experiment_hash == exp_hash)
-    async def update(self, id: int, updated_data: dict):
-        stmt = (
-            update(ExperimentParameters).
-            where(ExperimentParameters.id == id).
-            values(**updated_data)
         )
-        await self.session.execute(stmt)
+        return result.scalars().all()
-        await self.session.commit()
-
-    async def delete(self, id: int):
-        stmt = delete(ExperimentParameters).where(ExperimentParameters.id == id)
-        await self.session.execute(stmt)
-        await self.session.commit()

db/repositories/load_parameters_repos.py

@@ -8,41 +8,41 @@ from db.models.load_parameters_model import LoadParameters
 from db.postgres_db_connection import async_session_postgres
 
 
-async def get_all() -> Sequence[LoadParameters]:
+# async def get_all() -> Sequence[LoadParameters]:
-    async with async_session_postgres() as session:
+#     async with async_session_postgres() as session:
-        result = await session.execute(select(LoadParameters))
+#         result = await session.execute(select(LoadParameters))
-        return result.scalars().all()
+#         return result.scalars().all()
-
+#
-
+#
-async def get_by_id(id: int) -> LoadParameters:
+# async def get_by_id(id: int) -> LoadParameters:
-    async with async_session_postgres() as session:
+#     async with async_session_postgres() as session:
-        result = await session.execute(select(LoadParameters).where(LoadParameters.id == id))
+#         result = await session.execute(select(LoadParameters).where(LoadParameters.id == id))
-        return result.scalar_one_or_none()
+#         return result.scalar_one_or_none()
-
+#
-
+#
-async def create(new_data: LoadParameters):
+# async def create(new_data: LoadParameters):
-    async with async_session_postgres() as session:
+#     async with async_session_postgres() as session:
-        session.add(new_data)
+#         session.add(new_data)
-        await session.commit()
+#         await session.commit()
-
+#
-
+#
-async def update(id: int, updated_data: dict):
+# async def update(id: int, updated_data: dict):
-    async with async_session_postgres() as session:
+#     async with async_session_postgres() as session:
-        stmt = (
+#         stmt = (
-            update_(LoadParameters).
+#             update_(LoadParameters).
-            where(LoadParameters.id == id).
+#             where(LoadParameters.id == id).
-            values(**updated_data)
+#             values(**updated_data)
-        )
+#         )
-        await session.execute(stmt)
+#         await session.execute(stmt)
-        await session.commit()
+#         await session.commit()
-
+#
-
+#
-async def delete(id: int) -> bool:
+# async def delete(id: int) -> bool:
-    async with async_session_postgres() as session:
+#     async with async_session_postgres() as session:
-        stmt = delete_(LoadParameters).where(LoadParameters.id == id)
+#         stmt = delete_(LoadParameters).where(LoadParameters.id == id)
-        result = await session.execute(stmt)
+#         result = await session.execute(stmt)
-        await session.commit()
+#         await session.commit()
-        return result.rowcount > 0
+#         return result.rowcount > 0
 
 
 # class LoadParametersRepository:

db/repositories/recycling_parameters_repos.py

@@ -1,4 +1,5 @@
 from typing import Sequence
+from typing_extensions import deprecated
 
 from sqlalchemy import select
 from sqlalchemy import update, delete
@@ -6,7 +7,9 @@ from sqlalchemy.ext.asyncio import AsyncSession
 
 from db.models.recycling_parameters_model import RecyclingParameters
 
-
+@deprecated(
+    "теперь есть параметризованный круд, а уже свои специфичные методы у каждой сущности в своем репозитории"
+)
 class RecyclingParametersRepository:
     def __init__(self, session: AsyncSession):
         self.session = session

main.py

@@ -1,5 +1,5 @@
-import asyncio
 from fastapi import FastAPI, HTTPException, BackgroundTasks
+
 from db.csv_to_db import csv_to_db
 from network.routes import (ch_experimentdb_experiment_data_router, experiment_data_router,
                             experiment_parameters_router, experiment_category_router)

network/routes/experiment_data_router.py

@@ -2,6 +2,7 @@ from fastapi import APIRouter, HTTPException
 
 from db.crud import *
 from db.models import ExperimentData
+from db.repositories import get_exp_data_by_file_id
 from network.schemas import ExperimentDataBody
 
 router = APIRouter()
@@ -50,6 +51,19 @@ async def get_by_id_experiment_data(id: int):
         raise HTTPException(status_code=500, detail=f"An error occurred: {str(e)}")
 
 
+@router.get('/{file_id}')
+async def get_experiment_data_by_file_id(file_id: str):
+    try:
+        result = await get_exp_data_by_file_id(file_id)
+
+        if result is not None:
+            return result
+        else:
+            return {"message": f'<ExperimentData> с file_id = {id} - не найдены'}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"An error occurred: {str(e)}")
+
+
 @router.delete('/{id}/delete')
 async def delete_experiment_data(id: int):
     try:

network/routes/experiment_parameters_router.py

@@ -2,6 +2,7 @@ from fastapi import APIRouter, HTTPException
 
 from db.crud import *
 from db.models import LoadParameters
+from db.repositories import get_exp_parameters_by_category, get_exp_parameters_by_exp_hash
 from network.schemas import ExperimentParametersBody
 
 router = APIRouter()
@@ -51,6 +52,32 @@ async def get_by_id_experiment_parameters(id: int):
         raise HTTPException(status_code=500, detail=f"An error occurred: {str(e)}")
 
 
+@router.get('/by_category/{id}')
+async def get_experiment_parameters_by_exp_category(id: int):
+    try:
+        result = await get_exp_parameters_by_category(id)
+
+        if result is not None:
+            return result
+        else:
+            return {"message": f'<ExperimentParameters> с идентификатором категории - {id} - не найдены'}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"An error occurred: {str(e)}")
+
+
+@router.get('/by_exp_hash/{hash}')
+async def get_experiment_parameters_by_exp_category(hash: str):
+    try:
+        result = await get_exp_parameters_by_exp_hash(hash)
+
+        if result is not None:
+            return result
+        else:
+            return {"message": f'<ExperimentParameters> с experiment_hash = {id} - не найдены'}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"An error occurred: {str(e)}")
+
+
 @router.delete('/{id}/delete')
 async def delete_experiment_parameters(id: int):
     try: