flock-core 0.5.0b28__py3-none-any.whl → 0.5.56b0__py3-none-any.whl

flock/webapp/app/middleware.py

@@ -1,113 +0,0 @@
-
-# Custom middleware for handling proxy headers
-from starlette.middleware.base import BaseHTTPMiddleware
-from starlette.requests import Request as StarletteRequest
-
-#from uvicorn.middleware.proxy_headers import ProxyHeadersMiddleware
-
-class ProxyHeadersMiddleware(BaseHTTPMiddleware):
-    """Middleware to handle proxy headers for HTTPS detection.
-    This ensures url_for() generates HTTPS URLs when behind an HTTPS proxy.
-    """
-    def __init__(self, app, force_https: bool = False):
-        super().__init__(app)
-        self.force_https = force_https
-
-    async def dispatch(self, request: StarletteRequest, call_next):
-        import json
-        import logging
-        logger = logging.getLogger(__name__)
-
-        # Log original scheme and relevant headers for debugging
-        original_scheme = request.scope.get("scheme", "unknown")
-        original_host = request.headers.get("host")
-        logger.info(f"ProxyHeadersMiddleware - Original scheme: {original_scheme}, Host: {original_host}, URL: {request.url}")
-
-        # If force_https is enabled, always use HTTPS
-        if self.force_https:
-            request.scope["scheme"] = "https"
-            logger.info("ProxyHeadersMiddleware - Force HTTPS enabled, setting scheme to https")
-        else:
-            # Check for common proxy headers that indicate HTTPS
-            forwarded_proto = request.headers.get("x-forwarded-proto")
-            forwarded_scheme = request.headers.get("x-forwarded-scheme")
-            forwarded_host = request.headers.get("x-forwarded-host")
-            cloudflare_proto = request.headers.get("cf-visitor")
-            forwarded_ssl = request.headers.get("x-forwarded-ssl")
-            front_end_https = request.headers.get("front-end-https")
-
-            # Log proxy headers for debugging
-            proxy_headers = {
-                "x-forwarded-proto": forwarded_proto,
-                "x-forwarded-scheme": forwarded_scheme,
-                "x-forwarded-host": forwarded_host,
-                "cf-visitor": cloudflare_proto,
-                "x-forwarded-ssl": forwarded_ssl,
-                "front-end-https": front_end_https,
-                "x-forwarded-for": request.headers.get("x-forwarded-for"),
-                "host": request.headers.get("host")
-            }
-            logger.info(f"ProxyHeadersMiddleware - Proxy headers: {proxy_headers}")
-
-            scheme_updated = False
-
-            # Handle X-Forwarded-Proto header (most common)
-            if forwarded_proto:
-                request.scope["scheme"] = forwarded_proto.lower()
-                scheme_updated = True
-                logger.info(f"ProxyHeadersMiddleware - Updated scheme from X-Forwarded-Proto: {forwarded_proto}")
-
-            # Handle X-Forwarded-Scheme header
-            elif forwarded_scheme:
-                request.scope["scheme"] = forwarded_scheme.lower()
-                scheme_updated = True
-                logger.info(f"ProxyHeadersMiddleware - Updated scheme from X-Forwarded-Scheme: {forwarded_scheme}")
-
-            # Handle X-Forwarded-SSL header (on/off)
-            elif forwarded_ssl and forwarded_ssl.lower() == "on":
-                request.scope["scheme"] = "https"
-                scheme_updated = True
-                logger.info(f"ProxyHeadersMiddleware - Updated scheme from X-Forwarded-SSL: on -> https")
-
-            # Handle Front-End-Https header (on/off)
-            elif front_end_https and front_end_https.lower() == "on":
-                request.scope["scheme"] = "https"
-                scheme_updated = True
-                logger.info(f"ProxyHeadersMiddleware - Updated scheme from Front-End-Https: on -> https")
-
-            # Handle Cloudflare's CF-Visitor header (JSON format)
-            elif cloudflare_proto:
-                try:
-                    visitor_info = json.loads(cloudflare_proto)
-                    if visitor_info.get("scheme"):
-                        request.scope["scheme"] = visitor_info["scheme"].lower()
-                        scheme_updated = True
-                        logger.info(f"ProxyHeadersMiddleware - Updated scheme from CF-Visitor: {visitor_info['scheme']}")
-                except (json.JSONDecodeError, KeyError) as e:
-                    logger.warning(f"ProxyHeadersMiddleware - Failed to parse CF-Visitor header: {e}")
-
-            if not scheme_updated:
-                logger.info("ProxyHeadersMiddleware - No proxy headers found, keeping original scheme")
-
-        # Handle X-Forwarded-Host for proper host handling
-        forwarded_host = request.headers.get("x-forwarded-host")
-        if forwarded_host:
-            # Update the server scope to reflect the original host
-            request.scope["server"] = (forwarded_host, 443 if request.scope.get("scheme") == "https" else 80)
-            logger.info(f"ProxyHeadersMiddleware - Updated host from X-Forwarded-Host: {forwarded_host}")
-
-        # Handle X-Forwarded-For for client IP (optional but good practice)
-        forwarded_for = request.headers.get("x-forwarded-for")
-        if forwarded_for:
-            # Take the first IP in the chain (the original client)
-            client_ip = forwarded_for.split(",")[0].strip()
-            request.scope["client"] = (client_ip, request.scope.get("client", ["", 0])[1])
-
-        # Log final scheme and reconstructed URL
-        final_scheme = request.scope.get("scheme")
-        final_server = request.scope.get("server", ("unknown", 0))
-        logger.info(f"ProxyHeadersMiddleware - Final scheme: {final_scheme}, server: {final_server}")
-        logger.info(f"ProxyHeadersMiddleware - Reconstructed URL would be: {final_scheme}://{final_server[0]}{request.url.path}")
-
-        response = await call_next(request)
-        return response

flock/webapp/app/models_ui.py

@@ -1,7 +0,0 @@
-# Pydantic models specific to UI interactions, if needed.
-# For MVP, we might not need many here, as we'll primarily pass basic dicts to flock_service.
-# Example:
-# from pydantic import BaseModel
-# class SaveFlockRequest(BaseModel):
-#     current_flock_json: str # Or a more structured model if preferred
-#     new_filename: str

flock/webapp/app/services/feedback_file_service.py

@@ -1,363 +0,0 @@
-"""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"
-      )