feat: group python version by minor (#24)

* feat: Group Python versions by minor version in dashboard

Modified Python version analytics to group by minor version (e.g., 3.14)
instead of patch version (e.g., 3.14.1, 3.14.2) for cleaner dashboard metrics.

Changes:
- Updated get_python_version_distribution() to extract and group by major.minor
- Updated get_unique_python_versions_count() to count unique minor versions
- Updated get_unique_users_by_dimension() to handle python_version dimension with minor version grouping

Uses PostgreSQL regexp_replace to extract "3.14" from versions like "3.14.1", "3.14.2", etc.

* feat: Add database-agnostic Python version grouping with tests

Added support for both PostgreSQL and SQLite databases in Python version
minor version extraction logic. This allows tests to run on SQLite while
production uses PostgreSQL.

Changes:
- Added _extract_minor_version() helper method in AnalyticsEventRepository
  - PostgreSQL: Uses regexp_replace for version extraction
  - SQLite: Uses substr/instr for version extraction
- Updated get_python_version_distribution() to use helper method
- Updated get_unique_python_versions_count() to use helper method
- Updated get_unique_users_by_dimension() to use helper method
- Added comprehensive test suite in test_python_version_grouping.py
  - Tests version distribution grouping
  - Tests unique version counting
  - Tests user grouping by version
  - Tests edge case of already-minor versions

All tests pass, linting clean, type checking passes.

---------

Co-authored-by: Claude <noreply@anthropic.com>

Author: psincraian

app/src/repositories/analytics_event_repository.py

@@ -1,6 +1,6 @@
 from datetime import datetime
 from typing import List, Optional, Dict, Any
-from sqlalchemy import select, func, desc, and_
+from sqlalchemy import select, func, desc, and_, case
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from src.models.analytics_event import AnalyticsEvent
@@ -24,6 +24,43 @@ class AnalyticsEventRepository(BaseRepository[AnalyticsEvent]):
     def __init__(self, db: AsyncSession):
         super().__init__(db, AnalyticsEvent)
 
+    def _extract_minor_version(self, version_column):
+        """
+        Extract minor version (e.g., "3.14" from "3.14.1") in a database-agnostic way.
+
+        Uses PostgreSQL's regexp_replace for PostgreSQL databases,
+        and a substring approach for SQLite.
+        """
+        # Detect database type from the session's bind
+        dialect_name = self.db.bind.dialect.name if self.db.bind else 'postgresql'
+
+        if dialect_name == 'postgresql':
+            # PostgreSQL: Use regexp_replace
+            return func.regexp_replace(
+                version_column,
+                r'^(\d+\.\d+).*$',
+                r'\1'
+            )
+        else:
+            # SQLite: Use substr and instr to extract major.minor
+            # Find the position of the second dot, then extract substring before it
+            # E.g., "3.14.1" -> find second "." at position 5 -> substr(0, 4) -> "3.14"
+            second_dot_pos = func.instr(
+                func.substr(version_column, func.instr(version_column, '.') + 1),
+                '.'
+            ) + func.instr(version_column, '.')
+
+            return func.substr(
+                version_column,
+                1,
+                case(
+                    # If there's a second dot, extract up to it
+                    (second_dot_pos > func.instr(version_column, '.'), second_dot_pos - 1),
+                    # Otherwise, return the whole version (it's already major.minor)
+                    else_=func.length(version_column)
+                )
+            )
+
     async def get_by_api_key(self, api_key: str, limit: Optional[int] = None) -> List[AnalyticsEvent]:
         """Get events by API key."""
         query = select(AnalyticsEvent).filter(AnalyticsEvent.api_key == api_key)
@@ -57,13 +94,16 @@ async def get_stats_for_api_key(self, api_key: str, start_date: datetime,
             "active_days": int(stats.active_days or 0)  # type: ignore[possibly-missing-attribute]
         }
 
-    async def get_python_version_distribution(self, api_keys: List[str], 
-                                            start_date: datetime, 
+    async def get_python_version_distribution(self, api_keys: List[str],
+                                            start_date: datetime,
                                             end_date: datetime) -> List[Dict[str, Any]]:
         """Get Python version distribution for given API keys."""
+        # Extract minor version (e.g., "3.14" from "3.14.1")
+        minor_version = self._extract_minor_version(AnalyticsEvent.python_version).label("minor_version")
+
         python_stats_query = (
             select(
-                AnalyticsEvent.python_version,
+                minor_version,
                 func.count(AnalyticsEvent.id).label("total_events"),
                 func.count(func.distinct(AnalyticsEvent.session_id)).label("total_sessions"),
             )
@@ -74,14 +114,14 @@ async def get_python_version_distribution(self, api_keys: List[str],
                     AnalyticsEvent.event_timestamp <= end_date,
                 )
             )
-            .group_by(AnalyticsEvent.python_version)
+            .group_by(minor_version)
             .order_by(desc("total_events"))
         )
 
         result = await self.db.execute(python_stats_query)
         return [
             {
-                "python_version": row.python_version,
+                "python_version": row.minor_version,
                 "total_events": row.total_events,
                 "total_sessions": row.total_sessions
             }
@@ -210,11 +250,14 @@ async def get_events_in_date_range_count(self, api_keys: List[str],
         )
         return result.scalar()
 
-    async def get_unique_python_versions_count(self, api_key: str, 
+    async def get_unique_python_versions_count(self, api_key: str,
                                              start_date: datetime) -> int:
-        """Get count of unique Python versions for an API key."""
+        """Get count of unique Python versions (by minor version) for an API key."""
+        # Extract minor version (e.g., "3.14" from "3.14.1")
+        minor_version = self._extract_minor_version(AnalyticsEvent.python_version)
+
         result = await self.db.execute(
-            select(func.count(func.distinct(AnalyticsEvent.python_version))).filter(
+            select(func.count(func.distinct(minor_version))).filter(
                 and_(
                     AnalyticsEvent.api_key == api_key,
                     AnalyticsEvent.event_timestamp >= start_date,
@@ -446,6 +489,10 @@ async def get_unique_users_by_dimension(
         # Map dimension field to model attribute
         dimension_column = getattr(AnalyticsEvent, dimension_field)
 
+        # Special handling for python_version: group by minor version
+        if dimension_field == "python_version":
+            dimension_column = self._extract_minor_version(dimension_column)
+
         query = (
             select(
                 dimension_column.label("dimension_name"),