aws stuff and optimized sql queries

Co-authored-by: aaron-ridges <aaron@hiddenharvestventures.com>
Co-authored-by: calvin688 <calvin@hiddenharvestventures.com>

Author: 3 people

.github/workflows/deploy.yml

@@ -0,0 +1,59 @@
+name: Build & Deploy to AWS
+
+on:
+  push:
+    branches: [ main ]
+
+env:
+  AWS_REGION: us-east-1
+  ECR_REPO: 160684124315.dkr.ecr.us-east-1.amazonaws.com/ridges-api
+  SERVICE_NAME: api
+  ENV_NAME: prod
+
+jobs:
+  build-deploy:
+    runs-on: ubuntu-latest
+
+    permissions:
+      id-token: write  # GitHub OIDC for AWS
+      contents: read
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Configure AWS credentials (OIDC)
+        uses: aws-actions/configure-aws-credentials@v4
+        with:
+          role-to-assume: arn:aws:iam::160684124315:role/github-actions-ridges-api
+          aws-region: ${{ env.AWS_REGION }}
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Login to Amazon ECR
+        uses: aws-actions/amazon-ecr-login@v2
+
+      - name: Derive image tag from commit SHA
+        id: vars
+        run: echo "TAG=${GITHUB_SHA::7}" >> "$GITHUB_OUTPUT"
+
+      - name: Build and push multi-architecture image
+        run: |
+          docker buildx build \
+            --platform linux/amd64,linux/arm64 \
+            -t $ECR_REPO:${{ steps.vars.outputs.TAG }} \
+            -t $ECR_REPO:latest \
+            --push .
+
+      - name: Install AWS Copilot CLI
+        run: |
+          sudo curl -Lo /usr/local/bin/copilot https://github.com/aws/copilot-cli/releases/latest/download/copilot-linux
+          sudo chmod +x /usr/local/bin/copilot
+
+      - name: Deploy with AWS Copilot
+        run: |
+          copilot svc deploy \
+            --name $SERVICE_NAME \
+            --env  $ENV_NAME \
+            --tag  ${{ steps.vars.outputs.TAG }} 

Dockerfile

@@ -0,0 +1,27 @@
+FROM python:3.11-slim
+
+# Prevent Python from writing .pyc files and buffering stdout/stderr
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1
+
+# Install OS packages (if psycopg2 wants build deps add them here)
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    libpq-dev \
+ && rm -rf /var/lib/apt/lists/*
+
+# Set workdir
+WORKDIR /app
+
+# Install python dependencies first (leverages Docker layer caching)
+COPY requirements.txt ./
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Expose port expected by App Runner
+EXPOSE 8080
+
+# Start the FastAPI app
+CMD ["uvicorn", "src.main:app", "--host", "0.0.0.0", "--port", "8080"] 

copilot/.workspace

@@ -0,0 +1 @@
+application: ridges-api

copilot/api/manifest.yml

@@ -0,0 +1,55 @@
+# The manifest for the "api" service.
+# Read the full specification for the "Load Balanced Web Service" type at:
+#  https://aws.github.io/copilot-cli/docs/manifest/lb-web-service/
+
+# Your service name will be used in naming your resources like log groups, ECS services, etc.
+name: api
+type: Load Balanced Web Service
+
+# Distribute traffic to your service.
+http:
+  # Requests to this path will be forwarded to your service.
+  # To match all requests you can use the "/" path.
+  path: '/'
+  # You can specify a custom health check path. The default is "/".
+  healthcheck: '/docs'
+
+# Configuration for your containers and service.
+image:
+  location: 160684124315.dkr.ecr.us-east-1.amazonaws.com/ridges-api:latest
+  # Port exposed through your container to route traffic to it.
+  port: 8080
+
+cpu: 256       # Number of CPU units for the task.
+memory: 512    # Amount of memory in MiB used by the task.
+count: 1       # Number of tasks that should be running in your service.
+exec: true     # Enable running commands in your container.
+network:
+  connect: true # Enable Service Connect for intra-environment traffic between services.
+
+# storage:
+  # readonly_fs: true       # Limit to read-only access to mounted root filesystems.
+
+# Optional fields for more advanced use-cases.
+#
+#variables:                    # Pass environment variables as key value pairs.
+#  LOG_LEVEL: info
+
+#secrets:                      # Pass secrets from AWS Systems Manager (SSM) Parameter Store.
+#  GITHUB_TOKEN: GITHUB_TOKEN  # The key is the name of the environment variable, the value is the name of the SSM parameter.
+
+# You can override any of the values defined above by environment.
+#environments:
+#  test:
+#    count: 2               # Number of tasks to run for the "test" environment.
+#    deployment:            # The deployment strategy for the "test" environment.
+#       rolling: 'recreate' # Stops existing tasks before new ones are started for faster deployments.
+
+platform: linux/arm64
+
+variables:
+  AWS_RDS_PLATFORM_ENDPOINT: platform.cqnsk0q6war0.us-east-1.rds.amazonaws.com
+  AWS_MASTER_USERNAME: ridges_master
+  AWS_MASTER_PASSWORD: '>~AIQ?nLu>ksrI5rTpt[1gb:k.a|'
+  AWS_RDS_PLATFORM_DB_NAME: platform_db
+  PYTHONUNBUFFERED: '1'

copilot/environments/prod/manifest.yml

@@ -0,0 +1,22 @@
+# The manifest for the "prod" environment.
+# Read the full specification for the "Environment" type at:
+#  https://aws.github.io/copilot-cli/docs/manifest/environment/
+
+# Your environment name will be used in naming your resources like VPC, cluster, etc.
+name: prod
+type: Environment
+
+
+# Import your own VPC and subnets or configure how they should be created.
+# network:
+#   vpc:
+#     id:
+
+# Configure the load balancers in your environment, once created.
+# http:
+#   public:
+#   private:
+
+# Configure observability for your environment resources.
+observability:
+  container_insights: false

src/db/models.py

@@ -35,6 +35,8 @@ class CodegenResponse(BaseModel):
     score: Optional[float] = None
     evaluated_at: Optional[datetime] = None
     response_patch: str
+    response_count: Optional[int] = None
+    average_score: Optional[float] = None
 
 class RegressionResponse(BaseModel):
     challenge_id: str

src/db/operations.py

@@ -308,38 +308,27 @@ def get_codegen_challenges(self, challenge_id: str = None) -> List[Dict]:
             print(f"Error getting codegen challenges: {str(e)}")
             return []
 
-    def get_codegen_challenge_responses(self, challenge_id: str = None, miner_hotkey: str = None) -> List[CodegenResponse]:
+    def get_codegen_challenge_responses(self, challenge_id: str = None, miner_hotkey: str = None, min_score: float = 0, min_response_count: int = 0, sort_by_score: bool = False, max_miners: int = 5, hours: int = 24) -> List[Dict]:
         """Retrieve codegen responses from the database (AWS Postgres RDS).
-        Returns a list of CodegenResponse objects matching the original output format.
+        Returns a list of dictionaries containing miner information and their responses.
         Only includes responses where evaluated is TRUE and score is not NULL.
+        
+        Additional parameters:
+        - min_score: Minimum average score for miners to be included
+        - min_response_count: Minimum number of responses required per miner
+        - sort_by_score: Whether to sort miners by average score
+        - max_miners: Maximum number of miners to return
+        - hours: Number of hours to look back (-1 for all time)
         """
         try:
             with self.conn:
                 with self.conn.cursor() as cursor:
-                    if challenge_id:
-                        cursor.execute("""
+                    # Base query with optimized structure
+                    base_query = """
+                        WITH RECURSIVE time_bucket AS (
                             SELECT 
-                                r.challenge_id,
                                 r.miner_hotkey,
-                                r.node_id,
-                                r.processing_time,
-                                r.received_at,
-                                r.completed_at,
-                                r.evaluated,
-                                r.score,
-                                r.evaluated_at,
-                                cr.response_patch
-                            FROM responses r
-                            JOIN codegen_responses cr 
-                                ON r.challenge_id = cr.challenge_id 
-                                AND r.miner_hotkey = cr.miner_hotkey
-                            WHERE r.challenge_id = %s AND r.evaluated = TRUE AND r.score IS NOT NULL
-                        """, (challenge_id,))
-                    elif miner_hotkey:
-                        cursor.execute("""
-                            SELECT 
                                 r.challenge_id,
-                                r.miner_hotkey,
                                 r.node_id,
                                 r.processing_time,
                                 r.received_at,
@@ -352,43 +341,89 @@ def get_codegen_challenge_responses(self, challenge_id: str = None, miner_hotkey
                             JOIN codegen_responses cr 
                                 ON r.challenge_id = cr.challenge_id 
                                 AND r.miner_hotkey = cr.miner_hotkey
-                            WHERE r.miner_hotkey = %s AND r.evaluated = TRUE AND r.score IS NOT NULL
-                        """, (miner_hotkey,))
+                            WHERE r.evaluated = TRUE 
+                                AND r.score IS NOT NULL
+                    """
+
+                    # Add time filter if hours is not -1
+                    if hours != -1:
+                        base_query += " AND r.completed_at >= NOW() - INTERVAL '%s hours'"
+                        params = [hours]
                     else:
-                        cursor.execute("""
+                        params = []
+
+                    # Add challenge_id or miner_hotkey filter if provided
+                    if challenge_id:
+                        base_query += " AND r.challenge_id = %s"
+                        params.append(challenge_id)
+                    elif miner_hotkey:
+                        base_query += " AND r.miner_hotkey = %s"
+                        params.append(miner_hotkey)
+
+                    base_query += """
+                        ),
+                        miner_stats AS (
                             SELECT 
-                                r.challenge_id,
-                                r.miner_hotkey,
-                                r.node_id,
-                                r.processing_time,
-                                r.received_at,
-                                r.completed_at,
-                                r.evaluated,
-                                r.score,
-                                r.evaluated_at,
-                                cr.response_patch
-                            FROM responses r
-                            JOIN codegen_responses cr 
-                                ON r.challenge_id = cr.challenge_id 
-                                AND r.miner_hotkey = cr.miner_hotkey
-                            WHERE r.evaluated = TRUE AND r.score IS NOT NULL
-                        """)
+                                miner_hotkey,
+                                COUNT(*) as response_count,
+                                AVG(score) as average_score
+                            FROM time_bucket
+                            GROUP BY miner_hotkey
+                            HAVING COUNT(*) >= %s AND AVG(score) >= %s
+                        ),
+                        miner_responses AS (
+                            SELECT 
+                                t.miner_hotkey,
+                                json_agg(
+                                    json_build_object(
+                                        'challenge_id', t.challenge_id,
+                                        'miner_hotkey', t.miner_hotkey,
+                                        'node_id', t.node_id,
+                                        'processing_time', t.processing_time,
+                                        'received_at', t.received_at,
+                                        'completed_at', t.completed_at,
+                                        'evaluated', t.evaluated,
+                                        'score', t.score,
+                                        'evaluated_at', t.evaluated_at,
+                                        'response_patch', t.response_patch
+                                    )
+                                    ORDER BY t.completed_at DESC
+                                ) as responses
+                            FROM time_bucket t
+                            JOIN miner_stats ms ON t.miner_hotkey = ms.miner_hotkey
+                            GROUP BY t.miner_hotkey
+                        )
+                        SELECT 
+                            mr.miner_hotkey,
+                            ms.response_count,
+                            ms.average_score,
+                            mr.responses
+                        FROM miner_responses mr
+                        JOIN miner_stats ms ON mr.miner_hotkey = ms.miner_hotkey
+                    """
+
+                    # Add final sorting
+                    if sort_by_score:
+                        base_query += " ORDER BY ms.average_score DESC, mr.miner_hotkey"
+                    else:
+                        base_query += " ORDER BY mr.miner_hotkey"
+
+                    # Add final limit
+                    base_query += " LIMIT %s"
+                    params.extend([min_response_count, min_score, max_miners])
+
+                    cursor.execute(base_query, params)
                     rows = cursor.fetchall()
                     if not rows:
                         return []
+                    
                     return [
-                        CodegenResponse(
-                            challenge_id=row[0],
-                            miner_hotkey=row[1],
-                            node_id=row[2],
-                            processing_time=row[3],
-                            received_at=row[4],
-                            completed_at=row[5],
-                            evaluated=row[6],
-                            score=row[7],
-                            evaluated_at=row[8],
-                            response_patch=row[9]
-                        )
+                        {
+                            "miner_hotkey": row[0],
+                            "response_count": row[1],
+                            "average_score": row[2],
+                            "responses": [CodegenResponse(**response) for response in row[3]]
+                        }
                         for row in rows
                     ]
         except Exception as e: