bachtrackapi 0.1.0__py3-none-any.whl

api/__init__.py

@@ -0,0 +1 @@
+"""FastAPI backend for Bachtrack opera events API."""

api/main.py

@@ -0,0 +1,35 @@
+"""FastAPI application factory."""
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from api.routes.events import router as events_router
+
+
+def create_app() -> FastAPI:
+    """Create and configure FastAPI application."""
+    app = FastAPI(
+        title="BachtrackAPI",
+        description="API to search and retrieve opera events from Bachtrack.com",
+        version="0.1.0",
+    )
+    
+    # Add CORS middleware
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+    
+    # Include routers
+    app.include_router(events_router)
+    
+    # Health check endpoint
+    @app.get("/health")
+    async def health_check():
+        return {"status": "ok"}
+    
+    return app
+
+
+app = create_app()

bachtrackapi-0.1.0.dist-info/METADATA

@@ -0,0 +1,163 @@
+Metadata-Version: 2.4
+Name: bachtrackapi
+Version: 0.1.0
+Summary: A Python web scraper and REST API for extracting classical music opera events from Bachtrack.com
+Author-email: Clark Maio <clark@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/clarkmaio/bachtrackapi
+Project-URL: Repository, https://github.com/clarkmaio/bachtrackapi.git
+Project-URL: Documentation, https://github.com/clarkmaio/bachtrackapi#readme
+Project-URL: Issues, https://github.com/clarkmaio/bachtrackapi/issues
+Keywords: scraper,api,opera,classical-music,fastapi,bachtrack
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastapi==0.104.1
+Requires-Dist: uvicorn[standard]==0.24.0
+Requires-Dist: pydantic==2.5.0
+Requires-Dist: pydantic-settings==2.1.0
+Requires-Dist: requests==2.31.0
+Requires-Dist: beautifulsoup4==4.12.2
+Requires-Dist: selenium==4.15.2
+Requires-Dist: webdriver-manager==4.0.1
+Requires-Dist: python-dotenv==1.0.0
+Provides-Extra: dev
+Requires-Dist: pytest==7.4.3; extra == "dev"
+Requires-Dist: pytest-asyncio==0.21.1; extra == "dev"
+Requires-Dist: black==23.12.0; extra == "dev"
+Requires-Dist: flake8==6.1.0; extra == "dev"
+Requires-Dist: mypy==1.7.0; extra == "dev"
+Dynamic: license-file
+Dynamic: requires-python
+
+# BachtrackAPI
+
+A Python web scraper and REST API for extracting classical music opera events from [Bachtrack.com](https://bachtrack.com/).
+
+## Overview
+
+BachtrackAPI provides two complementary ways to access opera event data:
+
+1. **Scraper Module** - Direct web scraping of Bachtrack opera listings
+2. **FastAPI Backend** - RESTful API endpoints for searching and filtering events
+
+Search by work ID (e.g., `12285` for Gianni Schicchi) or freetext (e.g., `"La Traviata"`).
+
+## Installation
+
+```bash
+pip install -r requirements.txt
+```
+
+## Quick Start
+
+### 1. Using the Scraper Directly
+
+```python
+from scraper.scraper import BachtrackScraper
+
+scraper = BachtrackScraper()
+
+# Search by work ID
+events = scraper.search_operas(12285)  # Gianni Schicchi
+print(f"Found {len(events)} events")
+
+# Search by freetext
+events = scraper.search_operas("La Traviata")
+for event in events:
+    print(f"{event['title']} - {event['city']} @ {event['venue']}")
+```
+
+**Output:**
+```
+Found 28 events
+Gianni Schicchi - Berlin @ Deutsche Oper
+Gianni Schicchi - Winterthur @ Stadttheater Winterthur
+...
+```
+
+### 2. Using the FastAPI Backend
+
+Start the server:
+```bash
+uvicorn api.main:app --reload
+```
+
+**Example API Requests:**
+
+```bash
+# Freetext search
+curl "http://localhost:8000/api/v1/events/get_operas?q=gianni%20schicchi"
+
+# Work ID search
+curl "http://localhost:8000/api/v1/events/get_operas?q=12285"
+
+# POST search
+curl -X POST "http://localhost:8000/api/v1/events/search" \
+  -H "Content-Type: application/json" \
+  -d '{"work_id": 12285}'
+```
+
+**Response:**
+```json
+{
+  "query": "12285",
+  "total_results": 28,
+  "results": [
+    {
+      "title": "Gianni Schicchi",
+      "city": "Berlin",
+      "date": "2026-04-05T00:00:00",
+      "venue": "Deutsche Oper",
+      "detail_url": "https://bachtrack.com/opera-event/..."
+    }
+  ]
+}
+```
+
+## Available Endpoints
+
+- `GET /api/v1/events/get_operas?q=<search>` - Raw scraper output
+- `GET /api/v1/events/search?work_id=<id>` - Search by work ID
+- `GET /api/v1/events/search?q=<term>` - Freetext search
+- `POST /api/v1/events/search` - JSON body search
+- `GET /docs` - Interactive API documentation
+- `GET /health` - Health check
+
+## Testing
+
+```bash
+# Run scraper tests
+python tests/test_scraper.py
+
+# Run full API integration tests
+pytest tests/test_api.py -v -s
+```
+
+## Project Structure
+
+```
+scraper/scraper.py           # Core scraping logic
+api/
+  ├── main.py                    # FastAPI app factory
+  ├── routes/events.py           # API endpoints
+  ├── models/event.py            # Pydantic models
+  └── services/opera_service.py  # Service layer
+tests/                           # Unit and integration tests
+```
+
+## License
+
+MIT License - see [LICENSE](LICENSE) file for details
+

bachtrackapi-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+api/__init__.py,sha256=JXZBmzqjHGf7CG-X_KWvZ7GTm3EHP7KQd4R9kdPE3t4,54
+api/main.py,sha256=ix_DYJjwo6AjBQKggpI6jYtHQx5ybXuSu4Gu4X8QzS0,842
+bachtrackapi-0.1.0.dist-info/licenses/LICENSE,sha256=PWqPgTDR0XxvjIt0t6OPvOVmJRV3TPYA8EQ6e01Zf1Y,1067
+scraper/__init__.py,sha256=w5P9XC4ieEl9eIwm0OSqKETDCeNoBK9KCsqVh8QkJFE,39
+scraper/scraper.py,sha256=2Aj4GoBFsie-LpNMzekiWuNEpyMQuzhoJ0arKOGBIMo,10762
+bachtrackapi-0.1.0.dist-info/METADATA,sha256=iaI9qk4VFc5PBfc-s5uQaeTxnscPgJGZLSSuVuKxlrQ,4572
+bachtrackapi-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+bachtrackapi-0.1.0.dist-info/top_level.txt,sha256=mepoNsBT0riUPSxOkrXxheORLHj-ayrWU2hFcrweb40,12
+bachtrackapi-0.1.0.dist-info/RECORD,,

bachtrackapi-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

bachtrackapi-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Clark Maio
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

bachtrackapi-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+api
+scraper

scraper/__init__.py

@@ -0,0 +1,3 @@
+
+
+from .scraper import BachtrackScraper

scraper/scraper.py

@@ -0,0 +1,297 @@
+"""Bachtrack.com scraper for opera events."""
+from typing import List, Dict, Union
+from datetime import datetime
+import requests
+from bs4 import BeautifulSoup
+from urllib.parse import quote
+import re
+
+
+class BachtrackScraper:
+    """Scraper for Bachtrack opera events."""
+
+    BASE_URL = "https://bachtrack.com"
+    
+    def __init__(self):
+        self.headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+        }
+
+    def search_operas(self, search_input: Union[int, str]) -> List[Dict]:
+        """
+        Search for opera events by work ID or freetext search.
+        
+        Args:
+            search_input: Either an integer work ID (e.g., 12285) or a string search term (e.g., "Il barbiere di Siviglia")
+            
+        Returns:
+            List of opera event dictionaries with city, date, venue, title
+        """
+        if isinstance(search_input, int):
+            # Search by work ID
+            search_url = f"{self.BASE_URL}/search-opera/work={search_input}"
+        else:
+            # Search by freetext
+            encoded_search = quote(search_input)
+            search_url = f"{self.BASE_URL}/search-opera/freetext={encoded_search}"
+        
+        try:
+            response = requests.get(search_url, headers=self.headers, timeout=10)
+            response.raise_for_status()
+        except requests.RequestException as e:
+            raise RuntimeError(f"Failed to fetch search results: {e}")
+
+        soup = BeautifulSoup(response.content, 'html.parser')
+        
+        # Extract opera events from listing
+        events = []
+        li_elements = soup.find_all('li', {'data-type': 'nothing'})
+        
+        for element in li_elements:
+            try:
+                event_list = self._parse_event_element(element)
+                events.extend(event_list)
+            except (AttributeError, ValueError) as e:
+                # Skip malformed elements
+                continue
+        
+        return events
+
+    def _parse_event_element(self, element) -> List[Dict]:
+        """
+        Parse individual event element and expand to multiple events for each date.
+        
+        Args:
+            element: BeautifulSoup element representing an event listing
+            
+        Returns:
+            List of dictionaries with event details, one per date
+        """
+        try:
+            city = element.find('div', {'class': 'listing-ms-city'}).text.strip()
+            date_str = element.find('div', {'class': 'listing-ms-dates'}).text.strip()
+            venue = element.find('div', {'class': 'listing-ms-venue'}).text.strip()
+            
+            # Extract title from listing-ms-main, removing Wish list button
+            main_div = element.find('div', {'class': 'listing-ms-main'})
+            title = main_div.text.strip()
+            # Remove the wish list placeholder text
+            title = title.replace('Wish list', '').strip()
+            
+            # Get detail page URL
+            detail_link = element.find('a', {'class': 'listing-ms-right'})
+            detail_url = None
+            if detail_link and detail_link.get('href'):
+                detail_url = f"{self.BASE_URL}{detail_link['href']}"
+            
+            # Parse dates and create one event per date
+            parsed_dates = self._parse_dates_list(date_str)
+            events = []
+            
+            for parsed_date in parsed_dates:
+                events.append({
+                    'title': title,
+                    'city': city,
+                    'date': parsed_date,
+                    'venue': venue,
+                    'detail_url': detail_url,
+                })
+            
+            return events
+        except (AttributeError, TypeError):
+            return []
+
+    def _parse_dates_list(self, date_str: str) -> List[datetime]:
+        """
+        Parse date string and return list of datetime objects.
+        
+        Handles formats like:
+        - "Apr 05, 10, 15, 17" (same month, same year - inferred as current/next year)
+        - "Sun 3 May at 14:00" (full date with time)
+        - "Feb 05, 07, 11, 13, 15 mat, 17, 19, 21" (with qualifiers like 'mat')
+        
+        Args:
+            date_str: Date string with comma-separated dates
+            
+        Returns:
+            List of datetime objects
+        """
+        # Clean up the date string
+        date_str = ' '.join(date_str.split())
+        date_parts = [d.strip() for d in date_str.split(',')]
+        
+        parsed_dates = []
+        month = None
+        year = None
+        
+        for part in date_parts:
+            try:
+                # Try to parse full date format: "Sun 3 May at 14:00"
+                if 'at' in part:
+                    dt = self._parse_full_date(part)
+                else:
+                    # Try abbreviated format like "May 03" or just "03"
+                    dt = self._parse_abbreviated_date(part, month, year)
+                    
+                if dt:
+                    parsed_dates.append(dt)
+                    # Remember the month and year for subsequent dates
+                    month = dt.month
+                    year = dt.year
+            except (ValueError, AttributeError):
+                # Skip dates that can't be parsed
+                continue
+        
+        return parsed_dates
+    
+    def _parse_full_date(self, date_str: str) -> datetime:
+        """
+        Parse full date format: "Sun 3 May at 14:00" or "Sunday 03 November 2024"
+        
+        Args:
+            date_str: Full date string
+            
+        Returns:
+            Parsed datetime object
+        """
+        # Remove qualifiers and extra whitespace
+        date_str = date_str.replace(' mat', '').replace(' at ', ' ').strip()
+        
+        # Try format with time: "Sun 3 May 14:00"
+        try:
+            dt = datetime.strptime(date_str, '%a %d %b %H:%M')
+            # Add current year
+            return dt.replace(year=datetime.now().year)
+        except ValueError:
+            pass
+        
+        # Try format with weekday and time but no leading zero on day: "Sun 3 May 14:00"
+        try:
+            # Handle single digit day
+            parts = date_str.split()
+            if len(parts) >= 3:
+                day = int(parts[1])
+                month_str = parts[2]
+                time_str = parts[3] if len(parts) > 3 else "00:00"
+                dt = datetime.strptime(f"{day} {month_str} {time_str}", '%d %b %H:%M')
+                return dt.replace(year=datetime.now().year)
+        except (ValueError, IndexError):
+            pass
+        
+        # Try format: "Sunday 03 November 2024"
+        try:
+            return datetime.strptime(date_str, '%A %d %B %Y')
+        except ValueError:
+            pass
+        
+        # Try format: "Sun 3 May" (no year, no time)
+        try:
+            dt = datetime.strptime(date_str, '%a %d %b')
+            # Use current year
+            return dt.replace(year=datetime.now().year)
+        except ValueError:
+            pass
+        
+        # Try format: "3 May" (no weekday, no year, no time)
+        try:
+            dt = datetime.strptime(date_str, '%d %b')
+            # Use current year
+            return dt.replace(year=datetime.now().year)
+        except ValueError:
+            pass
+        
+        raise ValueError(f"Could not parse date: {date_str}")
+    
+    def _parse_abbreviated_date(self, date_str: str, prev_month: int = None, prev_year: int = None) -> datetime:
+        """
+        Parse abbreviated date format like "05" (day only) or "May 03" (month and day)
+        
+        Args:
+            date_str: Abbreviated date string
+            prev_month: Month from previous date (for inferring month of day-only dates)
+            prev_year: Year from previous date (for inferring year)
+            
+        Returns:
+            Parsed datetime object
+        """
+        date_str = date_str.replace(' mat', '').strip()
+        
+        # Try "May 05" format
+        try:
+            dt = datetime.strptime(date_str, '%b %d')
+            return dt.replace(year=prev_year or datetime.now().year)
+        except ValueError:
+            pass
+        
+        # Try "May 5" format (no leading zero)
+        try:
+            dt = datetime.strptime(date_str, '%b %e').replace(day=int(date_str.split()[-1]))
+            return dt.replace(year=prev_year or datetime.now().year)
+        except (ValueError, IndexError):
+            pass
+        
+        # Try "05" or "5" format (day only) - use previous month/year
+        try:
+            day = int(date_str)
+            if prev_month and prev_year:
+                return datetime(prev_year, prev_month, day)
+            else:
+                # Fallback to current month/year
+                today = datetime.now()
+                return datetime(today.year, today.month, day)
+        except ValueError:
+            pass
+        
+        raise ValueError(f"Could not parse abbreviated date: {date_str}")
+
+    def _parse_date(self, date_str: str) -> datetime:
+        """
+        Parse date string format: "Sunday 03 November 2024" -> datetime object
+        
+        Args:
+            date_str: Date string in format "Day DD Month YYYY"
+            
+        Returns:
+            Parsed datetime object
+        """
+        # Handle multi-line date strings (strip extra whitespace)
+        date_str = ' '.join(date_str.split())
+        return datetime.strptime(date_str, '%A %d %B %Y')
+
+    def get_event_details(self, detail_url: str) -> Dict:
+        """
+        Fetch additional event details from event detail page.
+        
+        Args:
+            detail_url: URL of event detail page
+            
+        Returns:
+            Dictionary with address and additional metadata
+        """
+        try:
+            response = requests.get(detail_url, headers=self.headers, timeout=10)
+            response.raise_for_status()
+        except requests.RequestException as e:
+            raise RuntimeError(f"Failed to fetch event details: {e}")
+
+        soup = BeautifulSoup(response.content, 'html.parser')
+        
+        details = {}
+        
+        # Extract address
+        address_span = soup.find('span', {'class': 'listing-address'})
+        if address_span:
+            details['address'] = address_span.text.strip()
+        
+        # Extract table data if present
+        table_tbody = soup.find('tbody', {'class': 'plassmap_table'})
+        if table_tbody:
+            rows = table_tbody.find_all('tr')
+            for row in rows:
+                cells = row.find_all('td')
+                if len(cells) >= 2:
+                    key = cells[0].text.strip()
+                    value = cells[1].text.strip()
+                    details[key.lower()] = value
+        
+        return details