pharmaradar 1.1.1__tar.gz

pharmaradar-1.1.1/.github/workflows/ci.yml

@@ -0,0 +1,232 @@
+# CI/CD Pipeline with Semantic Versioning
+#
+# This workflow automatically versions and publishes the package based on conventional commits:
+# - feat: adds new features → minor version bump (0.1.0 → 0.2.0)
+# - fix: bug fixes → patch version bump (0.1.0 → 0.1.1)  
+# - BREAKING CHANGE: in commit body → major version bump (0.1.0 → 1.0.0)
+#
+# The pipeline:
+# 1. Runs code quality checks (linting, formatting)
+# 2. Runs unit tests
+# 3. Analyzes commits and bumps version if needed (main branch only)
+# 4. Builds package
+# 5. Creates GitHub release (if version changed)
+# 6. Publishes to PyPI (if version changed and in release environment)
+#
+# Note: Workflow skips execution for semantic-release automated commits to prevent infinite loops
+
+name: CI/CD
+
+on:
+  push:
+    branches: [ main ]
+    # Don't run on tags created by semantic-release
+    tags-ignore: [ 'v*' ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  quality:
+    name: Code Quality
+    runs-on: ubuntu-latest
+    # Skip if this is a semantic-release commit
+    if: github.actor != 'github-actions[bot]' && !contains(github.event.head_commit.message, '[skip ci]')
+    
+    steps:
+    - uses: actions/checkout@v4
+    
+    - name: Set up Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: "3.13"
+    
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install -e ".[dev]"
+    
+    - name: Lint with flake8
+      run: |
+        flake8 src/ tests/ --count --select=E9,F63,F7,F82 --show-source --statistics
+        flake8 src/ tests/ --count --exit-zero --max-complexity=10 --max-line-length=120 --statistics
+    
+    - name: Check formatting with black
+      run: black --check --diff src/ tests/
+
+  test:
+    name: Test Suite
+    runs-on: ubuntu-latest
+    needs: quality
+    # Skip if this is a semantic-release commit
+    if: github.actor != 'github-actions[bot]' && !contains(github.event.head_commit.message, '[skip ci]')
+    strategy:
+      matrix:
+        python-version: ["3.13"]
+    
+    steps:
+    - uses: actions/checkout@v4
+    
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v4
+      with:
+        python-version: ${{ matrix.python-version }}
+    
+    - name: Install system dependencies
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y chromium-browser chromium-chromedriver
+    
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install -e ".[dev]"
+    
+    - name: Run tests
+      run: |
+        pytest tests/ --verbose --tb=short --junitxml=test-results.xml
+      env:
+        DISPLAY: :99
+    
+    - name: Upload test results
+      uses: actions/upload-artifact@v4
+      if: always()
+      with:
+        name: test-results-${{ matrix.python-version }}
+        path: test-results.xml
+
+  build:
+    name: Build Package
+    runs-on: ubuntu-latest
+    needs: [quality, test]
+    # Skip if this is a semantic-release commit, and only run on main branch pushes
+    if: github.event_name == 'push' && github.ref == 'refs/heads/main' && github.actor != 'github-actions[bot]' && !contains(github.event.head_commit.message, '[skip ci]')
+    outputs:
+      version-changed: ${{ steps.semantic.outputs.version-changed }}
+      old-version: ${{ steps.semantic.outputs.old-version }}
+      new-version: ${{ steps.semantic.outputs.new-version }}
+    
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        fetch-depth: 0  # Full history for semantic versioning
+        token: ${{ secrets.TOKEN }}
+    
+    - name: Set up Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: "3.13"
+    
+    - name: Install build dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install build twine python-semantic-release
+    
+    - name: Configure git for semantic release
+      run: |
+        git config user.name "github-actions[bot]"
+        git config user.email "github-actions[bot]@users.noreply.github.com"
+    
+    - name: Run semantic release
+      id: semantic
+      env:
+        GH_TOKEN: ${{ secrets.TOKEN }}
+      run: |
+        # Check if there are changes that warrant a new version
+        echo "🔍 Analyzing commits for version bump..."
+        
+        # Get current version before semantic release
+        OLD_VERSION=$(python -c "import tomllib; print(tomllib.load(open('pyproject.toml', 'rb'))['project']['version'])")
+        echo "old-version=$OLD_VERSION" >> $GITHUB_OUTPUT
+        echo "📋 Current version: $OLD_VERSION"
+        
+        # Run semantic release to bump version if needed
+        echo "🔄 Running semantic release..."
+        if semantic-release --noop version; then
+          echo "📦 Changes detected, proceeding with version bump"
+          semantic-release version
+        else
+          echo "ℹ️ No significant changes found, keeping current version"
+        fi
+        
+        # Get new version after semantic release
+        NEW_VERSION=$(python -c "import tomllib; print(tomllib.load(open('pyproject.toml', 'rb'))['project']['version'])")
+        echo "new-version=$NEW_VERSION" >> $GITHUB_OUTPUT
+        
+        # Check if version changed
+        if [ "$OLD_VERSION" != "$NEW_VERSION" ]; then
+          echo "version-changed=true" >> $GITHUB_OUTPUT
+          echo "✅ Version bumped from $OLD_VERSION to $NEW_VERSION"
+        else
+          echo "version-changed=false" >> $GITHUB_OUTPUT
+          echo "ℹ️ No version change needed (current: $NEW_VERSION)"
+        fi
+    
+    - name: Create GitHub Release
+      if: steps.semantic.outputs.version-changed == 'true'
+      env:
+        GH_TOKEN: ${{ secrets.TOKEN }}
+      run: |
+        NEW_VERSION="${{ steps.semantic.outputs.new-version }}"
+        echo "🚀 Preparing GitHub release for version $NEW_VERSION"
+        
+        # Create a git tag if it doesn't exist
+        if git tag -a "v$NEW_VERSION" -m "Release v$NEW_VERSION" 2>/dev/null; then
+          echo "✅ Created tag v$NEW_VERSION"
+          git push origin "v$NEW_VERSION" || echo "Tag already pushed"
+        else
+          echo "ℹ️ Tag v$NEW_VERSION already exists"
+        fi
+        
+        # Check if release already exists
+        if gh release view "v$NEW_VERSION" >/dev/null 2>&1; then
+          echo "ℹ️ Release v$NEW_VERSION already exists, skipping creation"
+        else
+          echo "📝 Creating GitHub release for v$NEW_VERSION"
+          gh release create "v$NEW_VERSION" \
+            --title "Release v$NEW_VERSION" \
+            --generate-notes \
+            --latest
+          echo "✅ GitHub release created successfully"
+        fi
+    
+    - name: Build package
+      run: python -m build
+    
+    - name: Check package
+      run: twine check dist/*
+    
+    - name: Summary
+      run: |
+        echo "📊 Build Summary:"
+        echo "Old version: ${{ steps.semantic.outputs.old-version }}"
+        echo "New version: ${{ steps.semantic.outputs.new-version }}"
+        echo "Version changed: ${{ steps.semantic.outputs.version-changed }}"
+        echo "Build artifacts:"
+        ls -la dist/
+
+    - name: Upload build artifacts
+      uses: actions/upload-artifact@v4
+      with:
+        name: dist
+        path: dist/
+        retention-days: 90
+
+  # publish:
+  #   name: Publish to PyPI
+  #   runs-on: ubuntu-latest
+  #   needs: build
+  #   if: github.event_name == 'push' && github.ref == 'refs/heads/main' && needs.build.outputs.version-changed == 'true'
+  #   environment: release
+    
+  #   steps:
+  #   - name: Download build artifacts
+  #     uses: actions/download-artifact@v4
+  #     with:
+  #       name: dist
+  #       path: dist/
+    
+  #   - name: Publish to PyPI
+  #     uses: pypa/gh-action-pypi-publish@release/v1
+  #     with:
+  #       password: ${{ secrets.PYPI_API_TOKEN }}
+  #       skip-existing: true  # Skip if version already exists

pharmaradar-1.1.1/.github/workflows/test.yml

@@ -0,0 +1,63 @@
+name: Unit Tests
+
+on:
+  push:
+    branches: [ main, develop ]
+  pull_request:
+    branches: [ main, develop ]
+
+jobs:
+  test:
+    name: Run Unit Tests
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.13"]
+
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+    
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v4
+      with:
+        python-version: ${{ matrix.python-version }}
+    
+    - name: Install system dependencies for Selenium
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y chromium-browser chromium-chromedriver xvfb
+    
+    - name: Cache pip dependencies
+      uses: actions/cache@v3
+      with:
+        path: ~/.cache/pip
+        key: ${{ runner.os }}-pip-${{ hashFiles('**/pyproject.toml') }}
+        restore-keys: |
+          ${{ runner.os }}-pip-
+    
+    - name: Install Python dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install -e ".[dev]"
+    
+    - name: Run unit tests
+      run: |
+        # Start virtual display for headless browser tests
+        export DISPLAY=:99
+        Xvfb :99 -screen 0 1024x768x24 > /dev/null 2>&1 &
+        
+        # Run tests with verbose output
+        pytest tests/ \
+          --verbose \
+          --tb=short \
+          --durations=10 \
+          --junitxml=test-results.xml
+    
+    - name: Upload test results
+      uses: actions/upload-artifact@v4
+      if: always()
+      with:
+        name: test-results-python-${{ matrix.python-version }}
+        path: test-results.xml
+        retention-days: 30

pharmaradar-1.1.1/.gitignore

@@ -0,0 +1,15 @@
+log/
+build/
+dist/
+*.egg-info/
+__pycache__
+*.pyc
+.pytest_cache
+.vscode
+.env
+.env.local
+.venv
+
+# Jenkins artifacts
+test-results.xml
+*.log

pharmaradar-1.1.1/CHANGELOG.md

@@ -0,0 +1,42 @@
+# CHANGELOG
+
+<!-- version list -->
+
+## v1.1.1 (2025-09-03)
+
+### Enhancement
+
+- Freeze build and twine packages
+  ([`f8c01af`](https://github.com/bartekmp/pharmaradar/commit/f8c01afffd2be7064cb366635d7bc80d3bdd7419))
+
+
+## v1.1.0 (2025-08-22)
+
+### Feature
+
+- Add selective fields update method
+  ([`55fe226`](https://github.com/bartekmp/pharmaradar/commit/55fe226d4aef26ecd6e9efe7d6231c32ff3c4fa2))
+
+
+## v1.0.2 (2025-08-20)
+
+### Enhancement
+
+- Update readme, remove unused file
+  ([`23f66fc`](https://github.com/bartekmp/pharmaradar/commit/23f66fcd73f83f3645962eb39279e18a92f7649f))
+
+
+## v1.0.1 (2025-08-19)
+
+### Bug Fixes
+
+- Don't run builds on tag releases
+  ([`a8b9e8e`](https://github.com/bartekmp/pharmaradar/commit/a8b9e8e7ad33ae38374e866600bde332d8348fbb))
+
+- Use right semver option
+  ([`10258b5`](https://github.com/bartekmp/pharmaradar/commit/10258b5dd97b9747cd480da60de48a5350f44f1a))
+
+
+## v1.0.0 (2025-08-19)
+
+- Initial Release

pharmaradar-1.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 bartekmp
+
+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.

pharmaradar-1.1.1/PKG-INFO

@@ -0,0 +1,256 @@
+Metadata-Version: 2.4
+Name: pharmaradar
+Version: 1.1.1
+Summary: Python scraping package for KtoMaLek.pl website to monitor drug availability.
+Author: bartekmp
+License-Expression: MIT
+Keywords: ktomalek,pharmaradar,web scraping,selenium
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: selenium>=4.15.0
+Requires-Dist: lxml>=5.0.0
+Provides-Extra: dev
+Requires-Dist: pytest==8.4.1; extra == "dev"
+Requires-Dist: pytest-mock==3.14.1; extra == "dev"
+Requires-Dist: black==25.1.0; extra == "dev"
+Requires-Dist: flake8==7.3.0; extra == "dev"
+Requires-Dist: isort==6.0.1; extra == "dev"
+Requires-Dist: python-semantic-release==10.2.0; extra == "dev"
+Requires-Dist: build==1.3.0; extra == "dev"
+Requires-Dist: twine==6.1.0; extra == "dev"
+Dynamic: license-file
+
+# PharmaRadar
+
+[![Unit Tests](https://github.com/bartekmp/pharmaradar/actions/workflows/test.yml/badge.svg)](https://github.com/bartekmp/pharmaradar/actions/workflows/test.yml)
+[![CI/CD](https://github.com/bartekmp/pharmaradar/actions/workflows/ci.yml/badge.svg)](https://github.com/bartekmp/pharmaradar/actions/workflows/ci.yml)
+
+Python package for searching and managing pharmacy medicine availability from [KtoMaLek.pl](https://ktomalek.pl).
+
+## Requirements
+Pharmaradar requires `chromium-browser`, `chromium-chromedriver` and `xvfb` to run, as the prerequisites for Selenium used to scrape the data from the KtoMaLek.pl page, as they do not provide an open API to get the data easily.
+
+## Installation
+
+```bash
+pip install pharmaradar
+```
+
+## Usage
+
+To work with searches use the `Medicine` object, which represents a search query including all required details about what you're looking for.
+If you'd like to find nearest pharmacies, that have at least low availability of Euthyrox N 50 medicine, nearby the location like Złota street in Warsaw and the max radius of 10 kilometers, create it like this:
+```python
+import pharmaradar
+
+medicine = pharmaradar.Medicine(
+        name="Euthyrox N 50",
+        dosage="50 mcg",
+        location="Warszawa, Złota",
+        radius_km=10.0,
+        min_availability=AvailabilityLevel.LOW,
+    )
+```
+
+Now create an instance of `MedicineFinder` class:
+```python
+finder = pharmaradar.MedicineFinder()
+```
+
+Then test if the connection to KtoMaLek.pl is possible and search for given medicine:
+```python
+if finder.test_connection():
+    pharmacies = finder.search_medicine(medicine)
+```
+
+If the search was successful, the `pharmacies` will contain a list of `PharmacyInfo` objects, with all important data found on the page:
+```python
+for pharmacy in pharmacies:
+    print(f"Pharmacy Name: {pharmacy.name}")
+    print(f"Address: {pharmacy.address}")
+    print(f"Availability: {pharmacy.availability}")
+    if pharmacy.price_full:
+        print(f"Price: {pharmacy.price_full} zł")
+    if pharmacy.distance_km:
+        print(f"Distance: {pharmacy.distance_km} km")
+    if pharmacy.reservation_url:
+        print(f"Reservation URL: {pharmacy.reservation_url}")
+```
+
+## Medicine watchdog
+
+`MedicineWatchdog` is a class useful in async and continuous tasks. It implements certain methods, like `add_medicine`, `update_medicine`, `remove_medicine`, `get_medicine`, etc. that interact with the database layer, which is responsible for operating on the actual database. It can be used to create an automated bot, which periodically will retrieve the medicine quieries using `get_all_medicines` method, and then will perform searching and notifying.
+```python
+import sqlite3
+from time import sleep
+
+sql_db_client = SqliteInterface("my_database.db")
+watchdog = pharmaradar.MedicineWatchdog(db_client)
+
+while True:
+
+    all_medicines: list[Medicine] = watchdog.get_all_medicines()
+    for medicine in all_medicines:
+
+        print(f"Medicine: {medicine.name}")
+
+        found_pharmacies_for_medicine: list[PharmacyInfo] = await watchdog.search_medicine(medicine)
+
+        if found_pharmacies_for_medicine:
+
+            print(f"Found {len(found_pharmacies_for_medicine)}")
+
+            for p in found_pharmacies_for_medicine:
+                print(str(p))
+        else:
+            print(f"Medicine not available in pharmacies located in {medicine.distance_km} kilometer distance")
+
+    sleep(60) # 1 minute
+```
+
+### Database interface
+The database interface instance passed to `MedicineWatchdog` must implement `MedicineDatabaseInterface`, which is basically a CRUD interface. The watchdog object will use this interface to interact with the data in the table. Example for an implementation for `sqlite` database:
+
+```python
+from pharmaradar import Medicine, MedicineDatabaseInterface
+
+class SqliteInterface(MedicineDatabaseInterface):
+    def __init__(self, db_file_path: str):
+        self.conn = sqlite3.connect(db_path)
+        self.cur = self.conn.cursor()
+
+    def _parse_row_to_medicine(self, row: tuple) -> Medicine:
+        """Convert a database row to a Medicine object."""
+        medicine_data = {
+            "id": row[0],
+            "name": row[1],
+            "dosage": row[2],
+            "amount": row[3],
+            "location": row[4],
+            "radius_km": row[5],
+            "max_price": row[6],
+            "min_availability": row[7],
+            "title": row[8],
+            "created_at": datetime.datetime.fromisoformat(row[9]) if row[9] else None,
+            "last_search_at": datetime.datetime.fromisoformat(row[10]) if row[10] else None,
+            "active": row[11],  # Default to True for existing records
+        }
+        return Medicine(**medicine_data)
+
+    def get_medicine(self, medicine_id: int) -> Medicine | None:
+        row = self.cur.execute("SELECT * FROM medicine WHERE id = ?", (medicine_id,)).fetchone()
+        if row is None:
+            return None
+        return self._parse_row_to_medicine(row)
+
+    def get_medicines(self) -> list[Medicine]:
+        rows = self.cur.execute("SELECT * FROM medicine").fetchall()
+        medicines = []
+        for medicine_row in res:
+            medicines.append(self._parse_row_to_medicine(medicine_row))
+        return medicines
+
+    def remove_medicine(self, medicine_id: int) -> bool:
+        with self.conn:
+            res = self.cur.execute("DELETE FROM medicine WHERE id = (?)", (medicine_id,))
+            return res.rowcount > 0
+
+    def save_medicine(self, medicine: Medicine) -> int:
+        with self.conn:
+            self.cur.execute(
+                    "INSERT INTO medicine VALUES (NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+                    (
+                        medicine.name,
+                        medicine.dosage,
+                        medicine.amount,
+                        medicine.location,
+                        medicine.radius_km,
+                        medicine.max_price,
+                        medicine.min_availability.value,
+                        medicine.title,
+                        medicine.created_at.isoformat() if medicine.created_at else None,
+                        medicine.last_search_at.isoformat() if medicine.last_search_at else None,
+                        medicine.active,
+                    ),
+                )
+                return self.cur.lastrowid or 0
+
+    def update_medicine(
+        self,
+        medicine_id: int,
+        *,
+        name: str | None = None,
+        dosage: str | None = None,
+        amount: str | None = None,
+        location: str | None = None,
+        radius_km: float | None = None,
+        max_price: float | None = None,
+        min_availability: str | None = None,
+        title: str | None = None,
+        last_search_at: datetime.datetime | None = None,
+        active: bool | None = None,
+    ) -> bool:
+        sql = []
+        values = []
+        if name is not None:
+            sql.append("name = ?")
+            values.append(name)
+        if dosage is not None:
+            sql.append("dosage = ?")
+            values.append(dosage)
+        if amount is not None:
+            sql.append("amount = ?")
+            values.append(amount)
+        if location is not None:
+            sql.append("location = ?")
+            values.append(location)
+        if radius_km is not None:
+            sql.append("radius_km = ?")
+            values.append(radius_km)
+        if max_price is not None:
+            sql.append("max_price = ?")
+            values.append(max_price)
+        if min_availability is not None:
+            sql.append("min_availability = ?")
+            values.append(min_availability)
+        if title is not None:
+            sql.append("title = ?")
+            values.append(title)
+        if last_search_at is not None:
+            sql.append("last_search_at = ?")
+            values.append(last_search_at.isoformat())
+        if active is not None:
+            sql.append("active = ?")
+            values.append(active)
+
+        values.append(medicine_id)
+        sql = f"UPDATE medicine SET {', '.join(sql)} WHERE id = ?"
+
+        with self.conn:
+            result = self.cur.execute(sql, values)
+            return result.rowcount > 0 
+    
+```
+
+Currently, the database itself must define the `medicine` table, declared as follows:
+```sql
+medicine(
+            id INTEGER PRIMARY KEY,
+            name TEXT NOT NULL,
+            dosage TEXT,
+            amount TEXT,
+            location TEXT NOT NULL,
+            radius_km REAL DEFAULT 10,
+            max_price REAL,
+            min_availability TEXT DEFAULT 'low',
+            title TEXT,
+            created_at TEXT,
+            last_search_at TEXT,
+            active BOOLEAN DEFAULT 1
+        )
+```
+
+## License
+
+MIT License