flock-core 0.5.0b10__py3-none-any.whl → 0.5.0b12__py3-none-any.whl

flock/webapp/app/services/feedback_file_service.py

@@ -0,0 +1,363 @@
+"""Methods for creating Feedback-File Downloads."""
+import csv
+import tempfile
+from datetime import datetime
+from pathlib import Path
+from werkzeug.utils import secure_filename
+from fastapi import Request
+from fastapi.responses import FileResponse
+
+from flock.webapp.app.services.sharing_store import SharedLinkStoreInterface
+
+
+async def create_xlsx_feedback_file_for_agent(
+  request: Request,
+  store: SharedLinkStoreInterface,
+  agent_name: str,
+) -> FileResponse:
+  """Creates an XLSX-File containing all feedback-entries for a single agent."""
+  from flock.core.flock import Flock
+
+  current_flock_instance: Flock | None = getattr(
+    request.app.state, "flock_instance", None
+  )
+
+  if not current_flock_instance:
+    from fastapi import HTTPException
+
+    raise HTTPException(
+      status_code=400,
+      detail="No Flock loaded to download feedback for"
+    )
+
+  all_agent_names = list(current_flock_instance.agents.keys())
+
+  if not all_agent_names:
+    from fastapi import HTTPException
+
+    raise HTTPException(
+      status_code=400,
+      detail="No agents found in the current Flock"
+    )
+
+  all_records = await store.get_all_feedback_records_for_agent(
+    agent_name=agent_name
+  )
+
+  temp_dir = tempfile.gettempdir()
+  timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+  safe_agent_name = secure_filename(agent_name)
+  xlsx_filename = f"flock_feedback_{safe_agent_name}_{timestamp}.xlsx"
+  xlsx_path = Path(temp_dir) / xlsx_filename
+  headers = [
+      "feedback_id",
+      "share_id",
+      "context_type",
+      "reason",
+      "expected_response",
+      "actual_response",
+      "created_at",
+      "flock_name",
+      "agent_name",
+      "flock_definition",
+    ]
+
+  return await _write_xlsx_file(
+    records=all_records,
+    path=xlsx_path,
+    filename=xlsx_filename,
+    headers=headers,
+  )
+
+async def create_xlsx_feedback_file(
+  request: Request,
+  store: SharedLinkStoreInterface
+) -> FileResponse:
+  """Creates an XLSX-File containing all feddback-entries for all agents."""
+  from flock.core.flock import Flock
+
+  current_flock_instance: Flock | None = getattr(
+    request.app.state, "flock_instance", None
+  )
+
+  if not current_flock_instance:
+    # If no flock is loaded, return an error response
+    from fastapi import HTTPException
+
+    raise HTTPException(
+      status_code=400,
+      detail="No Flock loaded to download feedback for"
+    )
+
+  # Get all agent names from the current flock
+  all_agent_names = list(current_flock_instance.agents.keys())
+
+  if not all_agent_names:
+
+    from fastapi import HTTPException
+
+    raise HTTPException(
+      status_code=400,
+      detail="No agents found in the current Flock"
+    )
+
+  all_records = []
+  for agent_name in all_agent_names:
+    agent_records = await store.get_all_feedback_records_for_agent(
+      agent_name=agent_name,
+    )
+    all_records.extend(agent_records)
+
+  temp_dir = tempfile.gettempdir()
+  timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+  xlsx_filename = f"flock_feedback_all_agents_{timestamp}.xlsx"
+  xlsx_path = Path(temp_dir) / xlsx_filename
+  headers = [
+      "feedback_id",
+      "share_id",
+      "context_type",
+      "reason",
+      "expected_response",
+      "actual_response",
+      "created_at",
+      "flock_name",
+      "agent_name",
+      "flock_definition",
+    ]
+
+  return await _write_xlsx_file(
+    records=all_records,
+    path=xlsx_path,
+    filename=xlsx_filename,
+    headers=headers,
+  )
+
+
+async def create_csv_feedback_file_for_agent(
+  request: Request,
+  store: SharedLinkStoreInterface,
+  agent_name: str,
+  separator: str = ",",
+) -> FileResponse:
+  """Creates a CSV-File filled with the feedback-records for a single agent."""
+  from flock.core.flock import Flock
+
+  current_flock_instance: Flock | None = getattr(
+    request.app.state, "flock_instance", None
+  )
+
+  if not current_flock_instance:
+    # If no flock is loaded, return an error response
+    from fastapi import HTTPException
+
+    raise HTTPException(
+      status_code=400,
+      detail="No Flock loaded to download feedback for"
+    )
+
+
+  # Get all agent names from the current flock
+  all_agent_names = list(current_flock_instance.agents.keys())
+
+
+  if not all_agent_names:
+
+    from fastapi import HTTPException
+
+    raise HTTPException(
+      status_code=400,
+      detail="No agents found in the current Flock"
+    )
+
+  all_records = await store.get_all_feedback_records_for_agent(
+    agent_name=agent_name
+  )
+  temp_dir = tempfile.gettempdir()
+  timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+  safe_agent_name = secure_filename(agent_name)
+  csv_filename = f"flock_feedback_{safe_agent_name}_{timestamp}.csv"
+  csv_path = Path(temp_dir) / csv_filename
+  headers = [
+    "feedback_id",
+    "share_id",
+    "context_type",
+    "reason",
+    "expected_response",
+    "actual_response",
+    "created_at",
+    "flock_name",
+    "agent_name",
+    "flock_definition",
+  ]
+  return await _write_csv_file(
+    records=all_records,
+    path=csv_path,
+    headers=headers,
+    separator=separator,
+    filename=csv_filename,
+  )
+
+
+async def create_csv_feedback_file(
+  request: Request,
+  store: SharedLinkStoreInterface,
+  separator: str = ",",
+
+  ) -> FileResponse:
+  """Creates a CSV-File filled with the feedback-records for all agents."""
+  from flock.core.flock import Flock
+
+  current_flock_instance: Flock | None = getattr(
+    request.app.state, "flock_instance", None
+  )
+
+  if not current_flock_instance:
+    # If no flock is loaded, return an error response
+    from fastapi import HTTPException
+
+    raise HTTPException(
+      status_code=400,
+      detail="No Flock loaded to download feedback for"
+    )
+
+  # Get all agent names from the current flock
+  all_agent_names = list(current_flock_instance.agents.keys())
+
+  if not all_agent_names:
+
+    from fastapi import HTTPException
+
+    raise HTTPException(
+      status_code=400,
+      detail="No agents found in the current Flock"
+    )
+
+  all_records = []
+  for agent_name in all_agent_names:
+    records_for_agent = await store.get_all_feedback_records_for_agent(
+      agent_name=agent_name
+    )
+    all_records.extend(records_for_agent)
+
+  temp_dir = tempfile.gettempdir()
+  timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+  csv_filename = f"flock_feedback_all_agents_{timestamp}.csv"
+  csv_path = Path(temp_dir) / csv_filename
+  headers = [
+    "feedback_id",
+    "share_id",
+    "context_type",
+    "reason",
+    "expected_response",
+    "actual_response",
+    "created_at",
+    "flock_name",
+    "agent_name",
+    "flock_definition",
+  ]
+
+  return await _write_csv_file(
+    records=all_records,
+    path=csv_path,
+    headers=headers,
+    filename=csv_filename,
+    separator=separator,
+  )
+
+async def _write_xlsx_file(
+  records: list[dict],
+  headers: list,
+  path: str | Path,
+  filename: str,
+) -> FileResponse:
+  """Writes an xlsx-file with the specified records."""
+  try:
+    import pandas as pd
+
+    # Convert records to a format suitable for
+    # pandas DataFrame
+    data_rows = []
+    for record in records:
+      row_data = {}
+      for header in headers:
+        value = getattr(record, header, None)
+        # Convert datetime to string for excel
+        if header == "created_at" and value:
+          row_data[header] = (
+            value.isoformat()
+            if isinstance(value, datetime)
+            else str(value)
+          )
+        else:
+          row_data[header] = str(value) if value is not None else ""
+      data_rows.append(row_data)
+
+    # Create DataFrame and write to Excel
+    df = pd.DataFrame(data_rows)
+    df.to_excel(str(path), index=False)
+
+    return FileResponse(
+      path=str(path),
+      filename=filename,
+      media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+      headers={
+        "Content-Disposition": f"attachment; filename={filename}"
+      }
+    )
+
+  except Exception:
+    from fastapi import HTTPException
+
+    raise HTTPException(
+      status_code=500,
+      detail="Unable to create feedback Excel file"
+    )
+
+async def _write_csv_file(
+  records: list[dict],
+  path: str | Path,
+  filename: str,
+  headers: list,
+  separator: str = ","
+) -> FileResponse:
+  """Writes a CSV_File with the specified records."""
+  try:
+    with open(path, "w", newline="", encoding="utf-8") as csvfile:
+      writer = csv.DictWriter(
+        csvfile,
+        fieldnames=headers,
+        delimiter=separator
+      )
+      writer.writeheader()
+      for record in records:
+        # Convert the Pydantic model
+        # to dict and ensure all fields are present
+        row_data = {}
+        for header in headers:
+          value = getattr(record, header, None)
+          # Convert datetime to ISO string for CSV
+          if header == "created_at" and value:
+            row_data[header] = (
+              value.isoformat()
+              if isinstance(value, datetime)
+              else str(value)
+            )
+          else:
+            row_data[header] = str(value) if value is not None else ""
+        writer.writerow(row_data)
+
+    return FileResponse(
+      path=str(path),
+      filename=filename,
+      media_type="text/csv",
+      headers={
+        "Content-Disposition": f"attachment; filename={filename}"
+      }
+    )
+  except Exception:
+    from fastapi import HTTPException
+
+    raise HTTPException(
+        status_code=500,
+        detail="Unable to create feedback-file"
+      )

flock/webapp/app/services/sharing_store.py

@@ -56,6 +56,16 @@ class SharedLinkStoreInterface(ABC):
         """Persist a feedback record."""
         pass
 
+    @abstractmethod
+    async def get_feedback(self, id: str) -> FeedbackRecord | None:
+        """Get a single feedback record."""
+        pass
+
+    @abstractmethod
+    async def get_all_feedback_records_for_agent(self, agent_name: str) -> list[FeedbackRecord]:
+        """Get all feedback records for a given agent."""
+        pass
+
 class SQLiteSharedLinkStore(SharedLinkStoreInterface):
     """SQLite implementation for storing and retrieving shared link configurations."""
 
@@ -199,6 +209,71 @@ class SQLiteSharedLinkStore(SharedLinkStoreInterface):
             return False # Or raise
 
     # ----------------------- Feedback methods -----------------------
+    async def get_feedback(self, id: str) -> FeedbackRecord | None:
+        """Retrieve a single feedback record from SQLite."""
+        try:
+            async with aiosqlite.connect(self.db_path) as db, db.execute(
+                """SELECT
+                    feedback_id, share_id, context_type, reason,
+                    expected_response, actual_response, flock_name, agent_name, flock_definition, created_at
+                FROM feedback WHERE feedback_id = ?""",
+                (id,)
+            ) as cursor:
+                row = await cursor.fetchone()
+
+            if row:
+                logger.debug(f"Retrieved feedback record for ID: {id}")
+                return FeedbackRecord(
+                    feedback_id=row[0],
+                    share_id=row[1],
+                    context_type=row[2],
+                    reason=row[3],
+                    expected_response=row[4],
+                    actual_response=row[5],
+                    flock_name=row[6],
+                    agent_name=row[7],
+                    flock_definition=row[8],
+                    created_at=row[9],  # SQLite stores as TEXT, Pydantic will parse from ISO format
+                )
+
+            logger.debug(f"No feedback record found for ID: {id}")
+            return None
+        except sqlite3.Error as e:
+            logger.error(f"SQLite error retrieving feedback for ID {id}: {e}", exc_info=True)
+            return None  # Or raise, depending on desired error handling
+
+    async def get_all_feedback_records_for_agent(self, agent_name: str) -> list[FeedbackRecord]:
+        """Retrieve all feedback records from SQLite."""
+        try:
+            async with aiosqlite.connect(self.db_path) as db, db.execute(
+                """SELECT
+                    feedback_id, share_id, context_type, reason,
+                    expected_response, actual_response, flock_name, agent_name, flock_definition, created_at
+                FROM feedback WHERE agent_name = ? ORDER BY created_at DESC""",
+                (agent_name,)
+            ) as cursor:
+                rows = await cursor.fetchall()
+
+            records = []
+            for row in rows:
+                records.append(FeedbackRecord(
+                    feedback_id=row[0],
+                    share_id=row[1],
+                    context_type=row[2],
+                    reason=row[3],
+                    expected_response=row[4],
+                    actual_response=row[5],
+                    flock_name=row[6],
+                    agent_name=row[7],
+                    flock_definition=row[8],
+                    created_at=row[9],  # SQLite stores as TEXT, Pydantic will parse from ISO format
+                ))
+
+            logger.debug(f"Retrieved {len(records)} feedback records")
+            return records
+        except sqlite3.Error as e:
+            logger.error(f"SQLite error retrieving all feedback records: {e}", exc_info=True)
+            return []  # Return empty list on error
 
     async def save_feedback(self, record: FeedbackRecord) -> FeedbackRecord:
         """Persist a feedback record to SQLite."""
@@ -367,9 +442,7 @@ class AzureTableSharedLinkStore(SharedLinkStoreInterface):
 
     # -------------------------------------------------------- save_feedback --
     async def save_feedback(self, record: FeedbackRecord) -> FeedbackRecord:
-        """Persist a feedback record. If a flock_definition is present, upload it as a blob and
-        store only a reference in the table row to avoid oversized entities (64 KiB limit).
-        """
+        """Persist a feedback record. If a flock_definition is present, upload it as a blob and store only a reference in the table row to avoid oversized entities (64 KiB limit)."""
         tbl_client = self.table_svc.get_table_client(self._FEEDBACK_TBL_NAME)
 
         # Core entity fields (avoid dumping the full Pydantic model – too many columns / large value)
@@ -383,6 +456,9 @@ class AzureTableSharedLinkStore(SharedLinkStoreInterface):
             "actual_response":   record.actual_response,
             "created_at":   record.created_at.isoformat(),
         }
+
+        # additional sanity check
+
         if record.flock_name is not None:
             entity["flock_name"] = record.flock_name
         if record.agent_name is not None:
@@ -405,17 +481,103 @@ class AzureTableSharedLinkStore(SharedLinkStoreInterface):
                     f" → blob '{entity['flock_blob_name']}'" if "flock_blob_name" in entity else "")
         return record
 
+    # -------------------------------------------------------- get_feedback --
+    async def get_feedback(self, id: str) -> FeedbackRecord | None:
+        """Retrieve a single feedback record from Azure Table Storage."""
+        tbl_client = self.table_svc.get_table_client(self._FEEDBACK_TBL_NAME)
+        try:
+            entity = await tbl_client.get_entity("feedback", id)
+        except ResourceNotFoundError:
+            logger.debug("No feedback record found for ID: %s", id)
+            return None
+
+        # Get flock_definition from blob if it exists
+        flock_definition = None
+        if "flock_blob_name" in entity:
+            blob_name = entity["flock_blob_name"]
+            blob_client = self.blob_svc.get_blob_client(self._CONTAINER_NAME, blob_name)
+            try:
+                blob_bytes = await (await blob_client.download_blob()).readall()
+                flock_definition = blob_bytes.decode()
+            except Exception as e:
+                logger.error("Cannot download blob '%s' for feedback_id=%s: %s",
+                           blob_name, id, e, exc_info=True)
+                # Continue without flock_definition rather than failing
+
+        return FeedbackRecord(
+            feedback_id=id,
+            share_id=entity.get("share_id"),
+            context_type=entity["context_type"],
+            reason=entity["reason"],
+            expected_response=entity.get("expected_response"),
+            actual_response=entity.get("actual_response"),
+            flock_name=entity.get("flock_name"),
+            agent_name=entity.get("agent_name"),
+            flock_definition=flock_definition,
+            created_at=entity["created_at"],
+        )
+
+
+    # ------------------------------------------------ get_all_feedback_records --
+    async def get_all_feedback_records_for_agent(self, agent_name: str) -> list[FeedbackRecord]:
+        """Retrieve all feedback records from Azure Table Storage for a specific agent."""
+        tbl_client = self.table_svc.get_table_client(self._FEEDBACK_TBL_NAME)
+
+        # Use Azure Table Storage filtering to only get records for the specified agent
+        escaped_agent_name = agent_name.replace("'", "''")
+        filter_query = f"agent_name eq '{escaped_agent_name}'"
+
+        logger.debug(f"Querying feedback records with filter: {filter_query}")
+
+        records = []
+        try:
+            async for entity in tbl_client.query_entities(filter_query):
+                # Get flock_definition from blob if it exists
+                flock_definition = None
+                if "flock_blob_name" in entity:
+                    blob_name = entity["flock_blob_name"]
+                    blob_client = self.blob_svc.get_blob_client(self._CONTAINER_NAME, blob_name)
+                    try:
+                        blob_bytes = await (await blob_client.download_blob()).readall()
+                        flock_definition = blob_bytes.decode()
+                    except Exception as e:
+                        logger.error("Cannot download blob '%s' for feedback_id=%s: %s",
+                                   blob_name, entity["RowKey"], e, exc_info=True)
+                        # Continue without flock_definition rather than failing
+
+                records.append(FeedbackRecord(
+                    feedback_id=entity["RowKey"],
+                    share_id=entity.get("share_id"),
+                    context_type=entity["context_type"],
+                    reason=entity["reason"],
+                    expected_response=entity.get("expected_response"),
+                    actual_response=entity.get("actual_response"),
+                    flock_name=entity.get("flock_name"),
+                    agent_name=entity.get("agent_name"),
+                    flock_definition=flock_definition,
+                    created_at=entity["created_at"],
+                ))
+
+            logger.debug("Retrieved %d feedback records for agent %s", len(records), agent_name)
+            return records
+
+        except Exception as e:
+            # Log the error.
+            logger.error(
+                f"Unable to query entries for agent {agent_name}. Exception: {e}"
+            )
+            return records
 
 
 # ----------------------- Factory Function -----------------------
 
 def create_shared_link_store(store_type: str | None = None, connection_string: str | None = None) -> SharedLinkStoreInterface:
     """Factory function to create the appropriate shared link store based on configuration.
-    
+
     Args:
         store_type: Type of store to create ("local" for SQLite, "azure-storage" for Azure Table Storage)
         connection_string: Connection string for the store (file path for SQLite, connection string for Azure)
-    
+
     Returns:
         Configured SharedLinkStoreInterface implementation
     """