# Solar farm monitoring configuration
mqtt:
  broker: "mqtts://solar-farm-mqtt.example.com:8883"
  client_id: "solar_monitor_prod"
  topics:
    - "farm/inverter/+/telemetry"
    - "farm/weather/+/observations"
  qos: 1
  tls:
    ca_certs: "/certs/ca.pem"
    certfile: "/certs/client.crt" 
    keyfile: "/certs/client.key"
  auth:
    username: "${MQTT_USERNAME}"
    password: "${MQTT_PASSWORD}"

adapters:
  units:
    power_target: "kW"
    energy_target: "kWh"
    temperature_target: "C"
  timezone:
    site_timezone: "America/Los_Angeles"
    target_timezone: "UTC"
  validation:
    schema_version: "0.2"
    quality_threshold: 0.8

storage:
  timeseries_db: "postgresql://user:pass@db.example.com/energy"
  influxdb_url: "http://influx.example.com:8086"

qubit-energy-schemas>=0.2.0
qubit-energy-connectors[mqtt]>=1.0.0
qubit-energy-adapters>=1.0.0
asyncio
pydantic
influxdb-client
psycopg2-binary

import asyncio
import yaml
from qubit.connectors.mqtt import MQTTConnector
from qubit.adapters import AdapterPipeline
from handlers import SolarDataHandler
from storage import TimeSeriesStore

async def main():
    # Load configuration
    with open('config/production.yaml') as f:
        config = yaml.safe_load(f)
    
    # Set up components
    connector = MQTTConnector(config['mqtt'])
    adapter_pipeline = AdapterPipeline.from_config(config['adapters'])
    storage = TimeSeriesStore(config['storage'])
    handler = SolarDataHandler(adapter_pipeline, storage)
    
    # Connect and start processing
    await connector.connect()
    
    for topic in config['mqtt']['topics']:
        await connector.subscribe(topic, handler.process_message)
    
    print("🌞 Solar farm monitoring started")
    
    try:
        # Run indefinitely
        while True:
            await asyncio.sleep(1)
    except KeyboardInterrupt:
        print("👋 Shutting down...")
    finally:
        await connector.disconnect()
        await storage.close()

if __name__ == "__main__":
    asyncio.run(main())

from qubit.adapters import AdapterPipeline
from qubit.schemas import TimeSeries
import logging

logger = logging.getLogger(__name__)

class SolarDataHandler:
    def __init__(self, adapter_pipeline, storage):
        self.pipeline = adapter_pipeline
        self.storage = storage
    
    async def process_message(self, topic: str, message: dict):
        """Process incoming MQTT message from solar equipment."""
        try:
            # Determine message type from topic
            topic_parts = topic.split('/')
            device_type = topic_parts[1]  # inverter, weather
            device_id = topic_parts[2]
            
            if device_type == "inverter":
                return await self._process_inverter_data(device_id, message)
            elif device_type == "weather":
                return await self._process_weather_data(device_id, message)
            
        except Exception as e:
            logger.error(f"Failed to process message from {topic}: {e}")
            raise
    
    async def _process_inverter_data(self, device_id: str, data: dict):
        """Process solar inverter telemetry."""
        # Run through adapter pipeline
        timeseries_list = self.pipeline.process_inverter_batch(data)
        
        # Store all metrics
        for ts in timeseries_list:
            await self.storage.insert(ts)
            logger.info(f"Stored {ts.metric}: {ts.value} {ts.unit}")
        
        return timeseries_list
    
    async def _process_weather_data(self, device_id: str, data: dict):
        """Process weather station data."""
        timeseries = self.pipeline.process_weather(data)
        await self.storage.insert(timeseries)
        
        return timeseries

# Set environment variables
export MQTT_USERNAME=your_username
export MQTT_PASSWORD=your_password

# Run locally
python src/main.py

# Use Docker Compose
docker-compose up -d

# Check logs
docker-compose logs -f solar-monitor

# Monitor metrics
curl http://localhost:8080/metrics

version: '3.8'

services:
  solar-monitor:
    build: .
    environment:
      - CONFIG_FILE=config/production.yaml
      - MQTT_USERNAME=${MQTT_USERNAME}
      - MQTT_PASSWORD=${MQTT_PASSWORD}
    volumes:
      - ./config:/app/config
      - ./certs:/certs
    depends_on:
      - influxdb
      - postgres
    restart: unless-stopped
  
  influxdb:
    image: influxdb:2.0
    environment:
      - INFLUXDB_DB=energy
      - INFLUXDB_ADMIN_USER=admin
      - INFLUXDB_ADMIN_PASSWORD=password
    volumes:
      - influx_data:/var/lib/influxdb2
  
  postgres:
    image: postgres:14
    environment:
      - POSTGRES_DB=energy_metadata
      - POSTGRES_USER=energy
      - POSTGRES_PASSWORD=secure_password
    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
  influx_data:
  postgres_data: