Gov APInaac.gov.in ↗

"""
NAAC Accreditation API Client
Access India's National Assessment and Accreditation Council data.
Get your API key from: https://parse.bot/settings
"""

import os
import sys
import requests
from typing import Any, Dict, List, Optional


class ParseClient:
    """Client for NAAC Accreditation API."""

    def __init__(self, api_key: Optional[str] = None):
        """Initialize the Parse client.
        
        Args:
            api_key: API key for authentication. If not provided, uses PARSE_API_KEY env var.
        """
        self.base_url = "https://api.parse.bot"
        self.scraper_id = "9c2b7795-187c-495f-ade4-81fde136d50d"
        self.api_key = api_key or os.getenv("PARSE_API_KEY")
        
        if not self.api_key:
            raise ValueError("API key not provided and PARSE_API_KEY env var not set")

    def _call(self, endpoint: str, method: str = "POST", **params) -> Dict[str, Any]:
        """Make an API call to the Parse Bot scraper.
        
        Args:
            endpoint: The endpoint name (e.g., 'search_accredited_institutions')
            method: HTTP method - 'GET' or 'POST'
            **params: Query/body parameters
            
        Returns:
            Response JSON as dictionary
        """
        url = f"{self.base_url}/scraper/{self.scraper_id}/{endpoint}"
        headers = {
            "X-API-Key": self.api_key,
            "Content-Type": "application/json"
        }
        
        if method.upper() == "GET":
            response = requests.get(url, headers=headers, params=params)
        else:
            response = requests.post(url, headers=headers, json=params)
        
        response.raise_for_status()
        return response.json()

    def search_accredited_institutions(
        self,
        inst_name: Optional[str] = None,
        inst_type: int = 0,
        state: int = 0,
        start: int = 0,
        limit: int = 10
    ) -> Dict[str, Any]:
        """Search for NAAC accredited institutions.
        
        Args:
            inst_name: Institution name or partial name
            inst_type: 0=All, 1=College, 2=University
            state: State ID (use get_states() to get available IDs)
            start: Pagination start offset
            limit: Number of results (max 100)
            
        Returns:
            Dictionary with institutions list and total records count
        """
        params = {
            "inst_name": inst_name,
            "inst_type": inst_type,
            "state": state,
            "start": start,
            "limit": limit
        }
        # Remove None values
        params = {k: v for k, v in params.items() if v is not None or k in ["inst_type", "state", "start", "limit"]}
        
        return self._call("search_accredited_institutions", method="GET", **params)

    def get_institution_details(self, assessment_id: int) -> Dict[str, Any]:
        """Get detailed accreditation information for a specific institution.
        
        Args:
            assessment_id: The HEI assessment ID from search results
            
        Returns:
            Dictionary with institution details and report links
        """
        return self._call("get_institution_details", method="GET", assessment_id=assessment_id)

    def get_states(self) -> Dict[str, str]:
        """Get mapping of state names to their IDs.
        
        Returns:
            Dictionary mapping state names to state IDs
        """
        return self._call("get_states", method="GET")

    def get_latest_results(self) -> Dict[str, List[Dict[str, str]]]:
        """Get links to latest NAAC accreditation results PDF reports.
        
        Returns:
            Dictionary with latest_pdf_results array
        """
        return self._call("get_latest_results", method="GET")


def main():
    """Practical workflow example showing chained API calls."""
    # Initialize client
    client = ParseClient()
    
    print("=" * 70)
    print("NAAC ACCREDITATION API - PRACTICAL WORKFLOW EXAMPLE")
    print("=" * 70)
    
    # Step 1: Get available states
    print("\n1. Fetching available states...")
    states_data = client.get_states()
    print(f"   Found {len(states_data)} states")
    
    # Find Telangana's state ID
    telangana_id = None
    for state_name, state_id in states_data.items():
        if "Telangana" in state_name:
            telangana_id = int(state_id)
            print(f"   Telangana ID: {telangana_id}")
            break
    
    # Step 2: Search for universities in Telangana
    print("\n2. Searching for universities in Telangana...")
    search_results = client.search_accredited_institutions(
        inst_type=2,  # Universities only
        state=telangana_id,
        limit=5
    )
    
    institutions = search_results.get("institutions", [])
    total = search_results.get("filtered_records", 0)
    print(f"   Found {total} universities in Telangana")
    
    # Step 3: Display search results and get details for each
    print("\n3. Retrieving detailed information for each university...")
    print("-" * 70)
    
    for idx, inst in enumerate(institutions, 1):
        inst_name = inst.get("hei_name", "Unknown")
        assessment_id = inst.get("hei_assessment_id")
        grade = inst.get("grade", "N/A")
        status = inst.get("status", "N/A")
        valid_till = inst.get("accreditation_valid_till", "N/A")
        
        print(f"\n   Institution {idx}: {inst_name}")
        print(f"   Grade: {grade} | Status: {status}")
        print(f"   Valid Till: {valid_till}")
        
        # Get detailed information including reports
        if assessment_id:
            try:
                details = client.get_institution_details(assessment_id)
                
                # Display status information
                iiqa_status = details.get("iiqa_status", "N/A")
                ssr_status = details.get("ssr_status", "N/A")
                print(f"   IIQA Status: {iiqa_status}")
                print(f"   SSR Status: {ssr_status}")
                
                # List available reports
                reports = details.get("reports", [])
                if reports:
                    print(f"   Available Reports: {len(reports)}")
                    for report in reports[:2]:  # Show first 2 reports
                        label = report.get("label", "Unknown")
                        print(f"     - {label}")
                    if len(reports) > 2:
                        print(f"     ... and {len(reports) - 2} more")
            except Exception as e:
                print(f"   Error fetching details: {str(e)}")
    
    # Step 4: Get latest PDF results
    print("\n" + "-" * 70)
    print("\n4. Fetching latest accreditation results PDFs...")
    latest_results = client.get_latest_results()
    pdfs = latest_results.get("latest_pdf_results", [])
    
    if pdfs:
        print(f"   Found {len(pdfs)} PDF reports:")
        for pdf in pdfs[:3]:  # Show first 3
            title = pdf.get("title", "Unknown")
            url = pdf.get("url", "N/A")
            print(f"     - {title}: {url[:50]}..." if len(url) > 50 else f"     - {title}: {url}")
    
    print("\n" + "=" * 70)
    print("Workflow completed successfully!")
    print("=" * 70)


if __name__ == "__main__":
    try:
        main()
    except KeyError as e:
        print(f"Error: API key not found. Please set PARSE_API_KEY environment variable.", file=sys.stderr)
        sys.exit(1)
    except requests.exceptions.RequestException as e:
        print(f"API request error: {e}", file=sys.stderr)
        sys.exit(1)