Net APItbca.net.br ↗

"""
TBCA Food Database API Client

Query Brazil's comprehensive food composition database including nutritional profiles,
statistical data, regional foods, and household measures.

Get your API key from: https://parse.bot/settings
"""

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


class ParseClient:
    """Client for interacting with the TBCA Food Database API via Parse."""

    def __init__(self, api_key: Optional[str] = None):
        """
        Initialize the Parse API client.

        Args:
            api_key: API key for authentication. If not provided, reads from PARSE_API_KEY env var.
        """
        self.base_url = "https://api.parse.bot"
        self.scraper_id = "f3f96c01-69e8-48d9-8e26-b6765980f9d6"
        self.api_key = api_key or os.getenv("PARSE_API_KEY")

        if not self.api_key:
            raise ValueError(
                "API key not provided. Set PARSE_API_KEY environment variable or pass api_key parameter."
            )

    def _call(
        self, endpoint: str, method: str = "POST", **params
    ) -> Dict[str, Any]:
        """
        Make a request to the Parse API.

        Args:
            endpoint: API endpoint name
            method: HTTP method (GET or POST)
            **params: Query parameters or request body

        Returns:
            Parsed JSON response
        """
        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:  # POST
            response = requests.post(url, headers=headers, json=params)

        response.raise_for_status()
        return response.json()

    def list_foods(
        self,
        query: str = "",
        group_id: str = "",
        food_type: str = "",
        page: int = 1,
    ) -> Dict[str, Any]:
        """
        Search for food items with filters and pagination.

        Args:
            query: Search query for food name or code
            group_id: Filter by food group ID
            food_type: Filter by food type ID
            page: Page number for pagination (1-based)

        Returns:
            Dict with foods list and total_pages
        """
        return self._call(
            "list_foods",
            method="GET",
            query=query,
            group_id=group_id,
            food_type=food_type,
            page=page,
        )

    def get_food_nutritional_profile(self, detail_id: str) -> Dict[str, Any]:
        """
        Get the full nutritional profile of a specific food item.

        Args:
            detail_id: The encrypted ID from list_foods results

        Returns:
            Dict with metadata and nutrients array
        """
        return self._call("get_food_nutritional_profile", method="GET", detail_id=detail_id)

    def get_food_statistical_info(self, detail_id: str) -> Dict[str, Any]:
        """
        Get statistical information for a food item.

        Args:
            detail_id: The encrypted ID from list_foods results

        Returns:
            Dict with metadata and statistical_data array
        """
        return self._call("get_food_statistical_info", method="GET", detail_id=detail_id)

    def search_by_component(
        self,
        component: str = "kJ|ENERGIA",
        group_id: str = "65",
        food_type: str = "70",
    ) -> Dict[str, Any]:
        """
        Search foods by nutritional component.

        Args:
            component: Nutrient component in 'unit|TAGNAME' format
            group_id: Food group ID
            food_type: Food type ID

        Returns:
            Dict with results array sorted by nutrient value
        """
        return self._call(
            "search_by_component",
            method="POST",
            component=component,
            group_id=group_id,
            food_type=food_type,
        )

    def get_food_composition_household_measures(self, food_code: str) -> Dict[str, Any]:
        """
        Get household measure definitions for a food code.

        Args:
            food_code: The food code from list_foods results

        Returns:
            Dict with measures containing medidas, sizeInputs, valoresMedidas, unidadesMedidas
        """
        return self._call(
            "get_food_composition_household_measures",
            method="GET",
            food_code=food_code,
        )

    def list_food_groups(self) -> Dict[str, Any]:
        """
        List all available food groups.

        Returns:
            Dict with groups array containing id and name
        """
        return self._call("list_food_groups", method="GET")

    def list_food_types(self) -> Dict[str, Any]:
        """
        List all available food types.

        Returns:
            Dict with types array containing id and name
        """
        return self._call("list_food_types", method="GET")

    def list_biodiversity_regional_foods(self) -> Dict[str, Any]:
        """
        List regional and biodiversity foods from the TBCA database.

        Returns:
            Dict with foods array
        """
        return self._call("list_biodiversity_regional_foods", method="GET")

    def list_institutional_foods(self) -> Dict[str, Any]:
        """
        List institutional foods from the TBCA database.

        Returns:
            Dict with foods array
        """
        return self._call("list_institutional_foods", method="GET")


def main():
    """
    Practical workflow: Find rice products, analyze their nutrition, and compare energy content.
    """
    client = ParseClient()

    print("=" * 70)
    print("TBCA Food Database - Nutritional Analysis Workflow")
    print("=" * 70)

    # Step 1: Get food groups to understand the database structure
    print("\n[1] Fetching available food groups...")
    groups_response = client.list_foods(query="arroz", page=1)
    foods = groups_response.get("data", {}).get("foods", [])
    
    if not foods:
        print("    No foods found. Please check your API key and try again.")
        return

    print(f"    ✓ Found {len(foods)} rice products in the database")

    # Step 2: Analyze each rice product's nutritional profile
    print("\n[2] Analyzing nutritional profiles for each rice product...")
    
    rice_analysis = []
    for idx, food in enumerate(foods[:3], 1):  # Analyze first 3 rice products
        food_name = food.get("name", "Unknown")
        food_code = food.get("code", "")
        detail_id = food.get("detail_id", "")

        print(f"\n    Rice Product {idx}: {food_name}")
        print(f"    Code: {food_code}")

        # Get nutritional profile
        if detail_id:
            try:
                nutrition = client.get_food_nutritional_profile(detail_id)
                nutrients = nutrition.get("data", {}).get("nutrients", [])

                # Extract key nutrients
                nutrition_data = {}
                for nutrient in nutrients:
                    component = nutrient.get("component", "")
                    value = nutrient.get("value_per_100g", "N/A")
                    units = nutrient.get("units", "")

                    if component in ["Energia", "Proteína", "Carboidrato", "Lipídeos"]:
                        nutrition_data[component] = f"{value} {units}"

                # Display nutrients
                for nutrient_name, nutrient_value in nutrition_data.items():
                    print(f"      • {nutrient_name}: {nutrient_value}")

                rice_analysis.append({
                    "name": food_name,
                    "code": food_code,
                    "detail_id": detail_id,
                    "nutrients": nutrition_data,
                })

            except Exception as e:
                print(f"      ⚠ Could not fetch profile: {str(e)}")

        # Get household measures
        if food_code:
            try:
                measures = client.get_food_composition_household_measures(food_code)
                medidas_list = measures.get("data", {}).get("medidas", [])
                valores = measures.get("data", {}).get("valoresMedidas", [])

                if medidas_list:
                    print(f"      Household measures:")
                    for medida, valor in zip(medidas_list[:2], valores[:2]):
                        print(f"        - {medida}: {valor}g")

            except Exception as e:
                print(f"      ⚠ Could not fetch measures: {str(e)}")

    # Step 3: Search for high-energy cereals
    print("\n[3] Searching for cereals by energy content...")
    energy_search = client.search_by_component(
        component="kJ|ENERGIA", group_id="65", food_type="70"
    )
    high_energy_foods = energy_search.get("data", {}).get("results", [])

    print(f"    ✓ Found {len(high_energy_foods)} cereals sorted by energy")
    print("\n    Top 3 highest energy cereals (per 100g):")
    for idx, food in enumerate(high_energy_foods[:3], 1):
        name = food.get("name", "Unknown")
        energy = food.get("value_per_100g", "N/A")
        units = food.get("units", "")
        print(f"      {idx}. {name}")
        print(f"         Energy: {energy} {units}")

    # Step 4: Get statistical information for comparison
    if rice_analysis:
        print(f"\n[4] Fetching statistical data for detailed analysis...")
        first_rice = rice_analysis[0]

        try:
            stats = client.get_food_statistical_info(first_rice["detail_id"])
            statistical_data = stats.get("data", {}).get("statistical_data", [])

            print(f"    Statistical analysis for: {first_rice['name']}")
            print("    Nutrient reliability metrics:")

            for stat in statistical_data[:3]:
                component = stat.get("componente", "")
                data_type = stat.get("tipo_de_dados", "")
                std_dev = stat.get("desvio_padrão", "-")

                if component:
                    print(f"      • {component}")
                    print(f"        Type: {data_type}, Std Dev: {std_dev}")

        except Exception as e:
            print(f"    ⚠ Could not fetch statistical data: {str(e)}")

    print("\n" + "=" * 70)
    print("✓ Nutritional analysis workflow completed successfully!")
    print("=" * 70)


if __name__ == "__main__":
    main()