🗂️ API Documentation

# pip install requests
import requests
import json
import re
from datetime import datetime

def get_wiltshire_addresses(postcode):
    """Get addresses for a postcode from Wiltshire Council API"""
    url = 'https://ilforms.wiltshire.gov.uk/wastecollectiondays/addresslist'
    
    headers = {
        'X-Requested-With': 'XMLHttpRequest',
        'Content-Type': 'application/x-www-form-urlencoded',
        'Referer': 'https://ilforms.wiltshire.gov.uk/wastecollectiondays',
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
    }
    
    data = {'Postcode': postcode}
    
    try:
        response = requests.post(url, data=data, headers=headers, timeout=10)
        response.raise_for_status()
        
        json_data = response.json()
        return json_data.get('Model', {}).get('PostcodeAddresses', [])
        
    except requests.RequestException as e:
        raise Exception(f"Failed to fetch addresses: {e}")

def get_waste_collections(property_ref, postcode, month, year):
    """Get waste collection data for a specific property"""
    url = 'https://ilforms.wiltshire.gov.uk/wastecollectiondays/wastecollectioncalendar'
    
    # Pad property reference to 12 digits
    padded_ref = str(property_ref).zfill(12)
    
    headers = {
        'X-Requested-With': 'XMLHttpRequest',
        'Content-Type': 'application/x-www-form-urlencoded',
        'Referer': 'https://ilforms.wiltshire.gov.uk/wastecollectiondays'
    }
    
    data = {
        'Postcode': postcode,
        'PropertyRef': padded_ref,
        'Month': month,
        'Year': year
    }
    
    try:
        response = requests.post(url, data=data, headers=headers, timeout=10)
        response.raise_for_status()
        
        # Extract JSON data from HTML response
        match = re.search(r'modelData\s*=\s*({.*?});', response.text)
        if match:
            json_data = json.loads(match.group(1))
            return json_data.get('MonthCollectionDates', [])
        
        return []
        
    except requests.RequestException as e:
        raise Exception(f"Failed to fetch collections: {e}")

# pip install flask flask-cors
from flask import Flask, jsonify, request
from flask_cors import CORS
from datetime import datetime

app = Flask(__name__)
CORS(app)

@app.route('/api/addresses/<postcode>', methods=['GET'])
def get_addresses_api(postcode):
    """API endpoint to get addresses by postcode"""
    try:
        addresses = get_wiltshire_addresses(postcode)
        return jsonify({
            'success': True,
            'postcode': postcode,
            'addresses': addresses,
            'count': len(addresses)
        })
    except Exception as e:
        return jsonify({
            'success': False,
            'error': str(e)
        }), 500

@app.route('/api/collections', methods=['GET'])
def get_collections_api():
    """API endpoint to get waste collections"""
    property_ref = request.args.get('property_ref')
    postcode = request.args.get('postcode')
    month = request.args.get('month', datetime.now().month)
    year = request.args.get('year', datetime.now().year)
    
    if not property_ref or not postcode:
        return jsonify({
            'success': False,
            'error': 'property_ref and postcode are required'
        }), 400
    
    try:
        collections = get_waste_collections(property_ref, postcode, 
                                          int(month), int(year))
        return jsonify({
            'success': True,
            'property_ref': property_ref,
            'postcode': postcode,
            'month': int(month),
            'year': int(year),
            'collections': collections,
            'count': len(collections)
        })
    except Exception as e:
        return jsonify({
            'success': False,
            'error': str(e)
        }), 500

if __name__ == '__main__':
    app.run(debug=True, port=5000)

#!/usr/bin/env python3
"""
Wiltshire Waste Collection CLI Tool
Usage: python waste_lookup.py BA14 7RS
"""

import sys
import argparse
from datetime import datetime
from typing import List, Dict, Any

def parse_dotnet_date(date_string: str) -> str:
    """Parse .NET date format /Date(timestamp)/"""
    import re
    match = re.search(r'/Date\((\d+)\)/', date_string)
    if match:
        timestamp = int(match.group(1)) / 1000  # Convert to seconds
        return datetime.fromtimestamp(timestamp).strftime('%Y-%m-%d')
    return date_string

def main():
    parser = argparse.ArgumentParser(
        description='Lookup waste collection dates for Wiltshire properties'
    )
    parser.add_argument('postcode', help='Postcode to lookup (e.g., "BA14 7RS")')
    parser.add_argument('--property-index', type=int, default=0,
                      help='Property index if multiple addresses found (default: 0)')
    parser.add_argument('--month', type=int, default=datetime.now().month,
                      help='Month to lookup (1-12, default: current month)')
    parser.add_argument('--year', type=int, default=datetime.now().year,
                      help='Year to lookup (default: current year)')
    
    args = parser.parse_args()
    
    try:
        # Get addresses
        print(f"Looking up addresses for postcode: {args.postcode}")
        addresses = get_wiltshire_addresses(args.postcode)
        
        if not addresses:
            print("No addresses found for this postcode.")
            sys.exit(1)
        
        print(f"Found {len(addresses)} address(es):")
        for i, addr in enumerate(addresses):
            print(f"  {i}: {addr['Address']} (Ref: {addr['PropertyRef']})")
        
        # Select property
        if args.property_index >= len(addresses):
            print(f"Property index {args.property_index} out of range.")
            sys.exit(1)
        
        selected_address = addresses[args.property_index]
        print(f"\nSelected: {selected_address['Address']}")
        
        # Get collections
        print(f"Getting collections for {args.month}/{args.year}...")
        collections = get_waste_collections(
            selected_address['PropertyRef'], 
            args.postcode, 
            args.month, 
            args.year
        )
        
        if not collections:
            print("No collections found for this period.")
        else:
            print(f"\nWaste Collections for {args.month}/{args.year}:")
            for collection in collections:
                date_parsed = parse_dotnet_date(collection.get('Date', ''))
                print(f"  {collection['RoundTypeName']}: {date_parsed}")
    
    except Exception as e:
        print(f"Error: {e}")
        sys.exit(1)

if __name__ == '__main__':
    main()