125 lines
4.8 KiB
Python
125 lines
4.8 KiB
Python
|
|
import sys
|
|
import os
|
|
import logging
|
|
from sqlalchemy import create_engine
|
|
from sqlalchemy.orm import sessionmaker
|
|
|
|
# Setup environment
|
|
sys.path.append(os.path.dirname(os.path.abspath(__file__)))
|
|
|
|
from src.models.base import Base
|
|
from src.models.activity import Activity
|
|
from src.models.segment import Segment
|
|
from src.models.segment_effort import SegmentEffort
|
|
from src.services.postgresql_manager import PostgreSQLManager
|
|
from src.services.segment_matcher import SegmentMatcher
|
|
from src.services.power_estimator import PowerEstimatorService
|
|
from src.utils.config import config
|
|
|
|
# Configure logging
|
|
logging.basicConfig(level=logging.INFO)
|
|
logger = logging.getLogger(__name__)
|
|
|
|
def verify_segment_power():
|
|
db_url = config.DATABASE_URL
|
|
if not db_url:
|
|
print("DATABASE_URL not set")
|
|
return
|
|
|
|
manager = PostgreSQLManager(db_url)
|
|
with manager.get_db_session() as session:
|
|
# 1. Get our test activity (ID 256)
|
|
activity = session.query(Activity).filter(Activity.id == 256).first()
|
|
if not activity:
|
|
print("Activity 256 not found")
|
|
return
|
|
|
|
print(f"Activity {activity.id}: is_estimated_power={activity.is_estimated_power}, avg_power={activity.avg_power}")
|
|
|
|
if not activity.is_estimated_power:
|
|
print("Activity does not have estimated power enabled. Please run verify_filters.py or backfill/estimate job first.")
|
|
return
|
|
|
|
# 2. Ensure we have at least one segment that matches this activity
|
|
# We'll check if any segments exist, if not create a dummy one for the activity bounds
|
|
# Or better, just check if any exist.
|
|
segments_count = session.query(Segment).count()
|
|
print(f"Found {segments_count} segments in DB.")
|
|
|
|
# 3. Clear existing efforts for this activity to test fresh matching
|
|
existing_efforts = session.query(SegmentEffort).filter(SegmentEffort.activity_id == activity.id).all()
|
|
print(f"Deleting {len(existing_efforts)} existing efforts.")
|
|
for e in existing_efforts:
|
|
session.delete(e)
|
|
session.commit()
|
|
|
|
# 4. Trigger Matching
|
|
matcher = SegmentMatcher(session)
|
|
# We need points. Accessing parsers...
|
|
from src.services.parsers import extract_activity_data
|
|
data = extract_activity_data(activity.file_content, activity.file_type)
|
|
if not data:
|
|
print("Could not extract data.")
|
|
return
|
|
|
|
print(f"Extracted data keys: {data.keys()}")
|
|
if 'position_lat' in data:
|
|
print(f"Lat points: {len(data['position_lat'])}")
|
|
|
|
if 'points' in data:
|
|
points = data['points']
|
|
# Ensure format is [lon, lat]
|
|
# print(f"Sample point: {points[0] if points else 'None'}")
|
|
else:
|
|
lats = data.get('position_lat')
|
|
longs = data.get('position_long')
|
|
if lats and longs:
|
|
for i in range(len(lats)):
|
|
if lats[i] is not None and longs[i] is not None:
|
|
points.append([longs[i], lats[i]])
|
|
|
|
print(f"Matching with {len(points)} points...")
|
|
efforts = matcher.match_activity(activity, points)
|
|
|
|
if len(efforts) == 0 and len(points) > 100:
|
|
print("No segments matched. Creating a dummy segment to verify logic...")
|
|
# Create a simple segment from the middle of the activity
|
|
mid = len(points) // 2
|
|
seg_points = points[mid:mid+50] # 50 points
|
|
|
|
# Bounds
|
|
from src.utils.geo import calculate_bounds
|
|
import json
|
|
bounds = calculate_bounds(seg_points)
|
|
|
|
dummy_segment = Segment(
|
|
name="Temp Verify Segment",
|
|
activity_type=activity.activity_type,
|
|
distance=1000.0, # Approximate
|
|
points=json.dumps(seg_points),
|
|
bounds=json.dumps(bounds)
|
|
)
|
|
session.add(dummy_segment)
|
|
session.commit()
|
|
print(f"Created dummy segment {dummy_segment.id}")
|
|
|
|
# Retry Match
|
|
efforts = matcher.match_activity(activity, points)
|
|
print(f"Retried Match: {len(efforts)} segments.")
|
|
|
|
# 5. Verify Power
|
|
for effort in efforts:
|
|
print(f"Effort ID: {effort.id}, Segment ID: {effort.segment_id}")
|
|
print(f" Avg Power: {effort.avg_power}")
|
|
print(f" Avg HR: {effort.avg_hr}")
|
|
print(f" Elapsed: {effort.elapsed_time}s")
|
|
|
|
if effort.avg_power and effort.avg_power > 0:
|
|
print("SUCCESS: Segment Effort has power!")
|
|
else:
|
|
print("FAILURE: Segment Effort missing power.")
|
|
|
|
if __name__ == "__main__":
|
|
verify_segment_power()
|