ia-tracker-qca 0.1.0__tar.gz

ia_tracker_qca-0.1.0/LICENCE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Elison Felipe Santos
+
+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.

ia_tracker_qca-0.1.0/MANIFEST.in

@@ -0,0 +1,4 @@
+include README.md
+include LICENSE
+include requirements.txt
+recursive-include src *.py

ia_tracker_qca-0.1.0/PKG-INFO

@@ -0,0 +1,140 @@
+Metadata-Version: 2.4
+Name: ia_tracker_qca
+Version: 0.1.0
+Summary: Biblioteca para rastreamento e auditoria de custos de APIs de IA
+Author-email: Sua Equipe <contato@suaempresa.com>
+License: MIT
+Project-URL: Homepage, https://github.com/suaempresa/ia-cost-tracker
+Project-URL: Documentation, https://github.com/suaempresa/ia-cost-tracker#readme
+Project-URL: Repository, https://github.com/suaempresa/ia-cost-tracker
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+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
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENCE
+Requires-Dist: psycopg2-binary>=2.9.0
+Requires-Dist: requests>=2.28.0
+Requires-Dist: python-dotenv>=0.19.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=3.0.0; extra == "dev"
+Requires-Dist: black>=22.0.0; extra == "dev"
+Requires-Dist: isort>=5.10.0; extra == "dev"
+Requires-Dist: flake8>=4.0.0; extra == "dev"
+Dynamic: license-file
+
+# IA Cost Tracker
+
+[![PyPI version](https://badge.fury.io/py/ia-cost-tracker.svg)](https://badge.fury.io/py/ia-cost-tracker)
+[![Python Versions](https://img.shields.io/pypi/pyversions/ia-cost-tracker.svg)](https://pypi.org/project/ia-cost-tracker/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Downloads](https://pepy.tech/badge/ia-cost-tracker)](https://pepy.tech/project/ia-cost-tracker)
+
+Rastreie custos de APIs de IA (Maritaca, Anthropic) automaticamente.
+
+Biblioteca Python para rastreamento e auditoria de custos de APIs de IA (Maritaca, Anthropic).
+
+## Instalação
+
+```bash
+pip install pip install ia_tracker_qca
+
+```
+
+Uso básico (não recomendado pois demora mais por causa que busca os valores atualizados na hora!):
+
+```python
+from ia_cost_tracker import IATracker
+
+# Inicializar
+tracker = IATracker(
+    db_connection_string="postgresql://user:pass@localhost/db",
+    maritaca_api_key="sua-chave",
+    anthropic_api_key="sua-chave"
+)
+
+# Sincronizar preços dos modelos
+tracker.sincronizar_precos_maritaca() #essa chamada a api demora uns 10segs as vezes.
+tracker.sincronizar_precos_anthropic()
+
+# Registrar uma chamada
+tracker.registrar_chamada(
+    provedor="maritaca",
+    modelo="sabia-2-medium",
+    tokens_input=150,
+    tokens_output=75,
+    aplicacao="meu-app",
+    tag_funcionalidade="chat",
+    usuario="usuario@email.com"
+)
+
+# Obter estatísticas
+stats = tracker.obter_estatisticas_aplicacao("meu-app")
+print(f"Custo total: R$ {stats['custo_total']}")
+print(f"Total de chamadas: {stats['total_chamadas']}")
+
+```
+
+
+Exemplo de uso em uma aplicação em produção:
+```python
+from ia_cost_tracker import IATracker
+
+tracker = IATracker(db_connection_string=os.getenv("DB_CONNECTION_STRING"))
+
+# Após chamar a IA
+tracker.registrar_chamada(
+    provedor="maritaca",  # ou "anthropic"
+    modelo="sabia-4",
+    tokens_input=150,
+    tokens_output=75,
+    aplicacao="meu-app",
+    tag_funcionalidade="chat",
+    usuario="user@email.com"  # opcional
+)
+```
+
+Desenvolvimento:
+
+```bash
+# Clonar repositório
+git clone https://github.com/suaempresa/ia-cost-tracker
+cd ia-cost-tracker
+
+# Instalar em modo desenvolvimento
+pip install -e ".[dev]"
+
+# Rodar testes
+pytest
+
+# Formatar código
+black src/
+isort src/
+```
+
+Consultar Custos:
+
+```python
+from datetime import datetime, timedelta
+
+# Últimos 7 dias
+data_inicio = datetime.now() - timedelta(days=7)
+stats = tracker.obter_estatisticas_aplicacao(
+    aplicacao="meu-app",
+    data_inicio=data_inicio
+)
+
+# Listar modelos disponíveis
+modelos = tracker.listar_modelos(provedor="maritaca")
+for modelo in modelos:
+    print(f"{modelo.nome_modelo}: "
+          f"R$ {modelo.custo_input_por_1k}/1k input, "
+          f"R$ {modelo.custo_output_por_1k}/1k output")
+
+```

ia_tracker_qca-0.1.0/README.md

@@ -0,0 +1,109 @@
+# IA Cost Tracker
+
+[![PyPI version](https://badge.fury.io/py/ia-cost-tracker.svg)](https://badge.fury.io/py/ia-cost-tracker)
+[![Python Versions](https://img.shields.io/pypi/pyversions/ia-cost-tracker.svg)](https://pypi.org/project/ia-cost-tracker/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Downloads](https://pepy.tech/badge/ia-cost-tracker)](https://pepy.tech/project/ia-cost-tracker)
+
+Rastreie custos de APIs de IA (Maritaca, Anthropic) automaticamente.
+
+Biblioteca Python para rastreamento e auditoria de custos de APIs de IA (Maritaca, Anthropic).
+
+## Instalação
+
+```bash
+pip install pip install ia_tracker_qca
+
+```
+
+Uso básico (não recomendado pois demora mais por causa que busca os valores atualizados na hora!):
+
+```python
+from ia_cost_tracker import IATracker
+
+# Inicializar
+tracker = IATracker(
+    db_connection_string="postgresql://user:pass@localhost/db",
+    maritaca_api_key="sua-chave",
+    anthropic_api_key="sua-chave"
+)
+
+# Sincronizar preços dos modelos
+tracker.sincronizar_precos_maritaca() #essa chamada a api demora uns 10segs as vezes.
+tracker.sincronizar_precos_anthropic()
+
+# Registrar uma chamada
+tracker.registrar_chamada(
+    provedor="maritaca",
+    modelo="sabia-2-medium",
+    tokens_input=150,
+    tokens_output=75,
+    aplicacao="meu-app",
+    tag_funcionalidade="chat",
+    usuario="usuario@email.com"
+)
+
+# Obter estatísticas
+stats = tracker.obter_estatisticas_aplicacao("meu-app")
+print(f"Custo total: R$ {stats['custo_total']}")
+print(f"Total de chamadas: {stats['total_chamadas']}")
+
+```
+
+
+Exemplo de uso em uma aplicação em produção:
+```python
+from ia_cost_tracker import IATracker
+
+tracker = IATracker(db_connection_string=os.getenv("DB_CONNECTION_STRING"))
+
+# Após chamar a IA
+tracker.registrar_chamada(
+    provedor="maritaca",  # ou "anthropic"
+    modelo="sabia-4",
+    tokens_input=150,
+    tokens_output=75,
+    aplicacao="meu-app",
+    tag_funcionalidade="chat",
+    usuario="user@email.com"  # opcional
+)
+```
+
+Desenvolvimento:
+
+```bash
+# Clonar repositório
+git clone https://github.com/suaempresa/ia-cost-tracker
+cd ia-cost-tracker
+
+# Instalar em modo desenvolvimento
+pip install -e ".[dev]"
+
+# Rodar testes
+pytest
+
+# Formatar código
+black src/
+isort src/
+```
+
+Consultar Custos:
+
+```python
+from datetime import datetime, timedelta
+
+# Últimos 7 dias
+data_inicio = datetime.now() - timedelta(days=7)
+stats = tracker.obter_estatisticas_aplicacao(
+    aplicacao="meu-app",
+    data_inicio=data_inicio
+)
+
+# Listar modelos disponíveis
+modelos = tracker.listar_modelos(provedor="maritaca")
+for modelo in modelos:
+    print(f"{modelo.nome_modelo}: "
+          f"R$ {modelo.custo_input_por_1k}/1k input, "
+          f"R$ {modelo.custo_output_por_1k}/1k output")
+
+```

ia_tracker_qca-0.1.0/pyproject.toml

@@ -0,0 +1,46 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ia_tracker_qca"
+version = "0.1.0"
+description = "Biblioteca para rastreamento e auditoria de custos de APIs de IA"
+readme = "README.md"
+authors = [
+    {name = "Sua Equipe", email = "contato@suaempresa.com"}
+]
+license = {text = "MIT"}
+requires-python = ">=3.8"
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+]
+dependencies = [
+    "psycopg2-binary>=2.9.0",
+    "requests>=2.28.0",
+    "python-dotenv>=0.19.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0.0",
+    "pytest-cov>=3.0.0",
+    "black>=22.0.0",
+    "isort>=5.10.0",
+    "flake8>=4.0.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/suaempresa/ia-cost-tracker"
+Documentation = "https://github.com/suaempresa/ia-cost-tracker#readme"
+Repository = "https://github.com/suaempresa/ia-cost-tracker"
+
+[tool.setuptools.packages.find]
+where = ["src"]

ia_tracker_qca-0.1.0/requirements.txt

@@ -0,0 +1,4 @@
+dotenv
+psycopg2-binary>=2.9.0
+requests>=2.28.0
+python-dotenv>=0.19.0

ia_tracker_qca-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

ia_tracker_qca-0.1.0/setup.py

@@ -0,0 +1,6 @@
+from setuptools import setup, find_packages
+
+setup(
+    packages=find_packages(where="src"),
+    package_dir={"": "src"},
+)

ia_tracker_qca-0.1.0/src/ia_cost_tracker/__init__.py

@@ -0,0 +1,27 @@
+"""
+IA Cost Tracker - Biblioteca para rastreamento de custos de APIs de IA.
+
+Esta biblioteca permite rastrear e auditar custos de chamadas a APIs de IA
+como Maritaca e Anthropic, salvando informações detalhadas em banco de dados.
+
+Para Maritaca: sincroniza preços via API
+Para Anthropic: usa preços mantidos no banco de dados
+"""
+
+__version__ = "0.1.0"
+
+from .tracker import IATracker
+from .exceptions import (
+    IATrackerError,
+    DatabaseError,
+    ProviderError,
+    ModelNotFoundError,
+)
+
+__all__ = [
+    "IATracker",
+    "IATrackerError",
+    "DatabaseError",
+    "ProviderError",
+    "ModelNotFoundError",
+]

ia_tracker_qca-0.1.0/src/ia_cost_tracker/database.py

@@ -0,0 +1,290 @@
+"""Gerenciador de conexões e operações com banco de dados."""
+
+import psycopg2
+from psycopg2.extras import RealDictCursor
+from typing import List, Optional, Dict, Any
+from contextlib import contextmanager
+from decimal import Decimal
+import logging
+
+from .models import ModeloIA, UsoToken
+from .exceptions import DatabaseError, ModelNotFoundError
+
+logger = logging.getLogger(__name__)
+
+
+class DatabaseManager:
+    """
+    Gerenciador de conexões e operações com PostgreSQL.
+    
+    Esta classe gerencia todas as interações com o banco de dados,
+    incluindo operações CRUD para modelos e registros de uso.
+    """
+    
+    def __init__(self, connection_string: str):
+        """
+        Inicializa o gerenciador de banco de dados.
+        
+        Args:
+            connection_string: String de conexão PostgreSQL
+                              (ex: "postgresql://user:pass@localhost/dbname")
+        
+        Raises:
+            DatabaseError: Se houver erro na conexão com o banco
+        """
+        self.connection_string = connection_string
+        self._test_connection()
+    
+    def _test_connection(self) -> None:
+        """Testa a conexão com o banco de dados."""
+        try:
+            with self._get_connection() as conn:
+                with conn.cursor() as cur:
+                    cur.execute("SELECT 1")
+        except Exception as e:
+            raise DatabaseError(f"Erro ao conectar ao banco de dados: {str(e)}")
+    
+    @contextmanager
+    def _get_connection(self):
+        """
+        Context manager para conexões com o banco.
+        
+        Yields:
+            psycopg2.connection: Conexão com o banco de dados
+        """
+        conn = None
+        try:
+            conn = psycopg2.connect(self.connection_string)
+            yield conn
+            conn.commit()
+        except Exception as e:
+            if conn:
+                conn.rollback()
+            raise DatabaseError(f"Erro na operação do banco: {str(e)}")
+        finally:
+            if conn:
+                conn.close()
+    
+    @staticmethod
+    def _convert_decimal_to_float(row_dict: Dict) -> Dict:
+        """
+        Converte valores Decimal para float no dicionário.
+        
+        Args:
+            row_dict: Dicionário com dados do banco
+        
+        Returns:
+            Dicionário com Decimals convertidos para float
+        """
+        converted = {}
+        for key, value in row_dict.items():
+            if isinstance(value, Decimal):
+                converted[key] = float(value)
+            else:
+                converted[key] = value
+        return converted
+    
+    def buscar_modelo(self, provedor: str, nome_modelo: str) -> Optional[ModeloIA]:
+        """
+        Busca um modelo específico no banco de dados.
+        
+        Args:
+            provedor: Nome do provedor (ex: 'maritaca', 'anthropic')
+            nome_modelo: Nome do modelo
+        
+        Returns:
+            ModeloIA se encontrado, None caso contrário
+        
+        Raises:
+            DatabaseError: Se houver erro na consulta
+        """
+        query = """
+            SELECT id_modelo, provedor, nome_modelo, custo_input_por_1k,
+                   custo_output_por_1k, ativo, criado_em
+            FROM dim_modelo_ia
+            WHERE provedor = %s AND nome_modelo = %s AND ativo = true
+        """
+        
+        with self._get_connection() as conn:
+            with conn.cursor(cursor_factory=RealDictCursor) as cur:
+                cur.execute(query, (provedor, nome_modelo))
+                row = cur.fetchone()
+                
+                if row:
+                    row_dict = self._convert_decimal_to_float(dict(row))
+                    return ModeloIA(**row_dict)
+                return None
+    
+    def listar_modelos(self, provedor: Optional[str] = None, 
+                      apenas_ativos: bool = True) -> List[ModeloIA]:
+        """
+        Lista modelos do banco de dados.
+        
+        Args:
+            provedor: Filtrar por provedor específico (opcional)
+            apenas_ativos: Se True, retorna apenas modelos ativos
+        
+        Returns:
+            Lista de ModeloIA
+        
+        Raises:
+            DatabaseError: Se houver erro na consulta
+        """
+        query = """
+            SELECT id_modelo, provedor, nome_modelo, custo_input_por_1k,
+                   custo_output_por_1k, ativo, criado_em
+            FROM dim_modelo_ia
+            WHERE 1=1
+        """
+        params = []
+        
+        if provedor:
+            query += " AND provedor = %s"
+            params.append(provedor)
+        
+        if apenas_ativos:
+            query += " AND ativo = true"
+        
+        query += " ORDER BY provedor, nome_modelo"
+        
+        with self._get_connection() as conn:
+            with conn.cursor(cursor_factory=RealDictCursor) as cur:
+                cur.execute(query, params)
+                rows = cur.fetchall()
+                modelos = []
+                for row in rows:
+                    row_dict = self._convert_decimal_to_float(dict(row))
+                    modelos.append(ModeloIA(**row_dict))
+                return modelos
+    
+    def inserir_ou_atualizar_modelo(self, modelo: ModeloIA) -> int:
+        """
+        Insere um novo modelo ou atualiza se já existir.
+        
+        Args:
+            modelo: Objeto ModeloIA a ser inserido/atualizado
+        
+        Returns:
+            ID do modelo inserido/atualizado
+        
+        Raises:
+            DatabaseError: Se houver erro na operação
+        """
+        query = """
+            INSERT INTO dim_modelo_ia 
+                (provedor, nome_modelo, custo_input_por_1k, custo_output_por_1k, ativo)
+            VALUES (%s, %s, %s, %s, %s)
+            ON CONFLICT (provedor, nome_modelo) 
+            DO UPDATE SET
+                custo_input_por_1k = EXCLUDED.custo_input_por_1k,
+                custo_output_por_1k = EXCLUDED.custo_output_por_1k,
+                ativo = EXCLUDED.ativo
+            RETURNING id_modelo
+        """
+        
+        with self._get_connection() as conn:
+            with conn.cursor() as cur:
+                cur.execute(query, (
+                    modelo.provedor,
+                    modelo.nome_modelo,
+                    modelo.custo_input_por_1k,
+                    modelo.custo_output_por_1k,
+                    modelo.ativo
+                ))
+                id_modelo = cur.fetchone()[0]
+                logger.info(f"Modelo {modelo.provedor}/{modelo.nome_modelo} "
+                          f"inserido/atualizado com ID {id_modelo}")
+                return id_modelo
+    
+    def registrar_uso(self, uso: UsoToken) -> int:
+        """
+        Registra um uso de tokens no banco de dados.
+        
+        Args:
+            uso: Objeto UsoToken com os dados do uso
+        
+        Returns:
+            ID do registro de uso criado
+        
+        Raises:
+            DatabaseError: Se houver erro na inserção
+        """
+        query = """
+            INSERT INTO fato_uso_tokens (
+                id_modelo, tokens_input, tokens_output,
+                custo_input, custo_output, tag_funcionalidade,
+                aplicacao, usuario, tempo_resposta_ms,
+                erro, mensagem_erro, timestamp_uso
+            ) VALUES (
+                %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s
+            ) RETURNING id_uso
+        """
+        
+        with self._get_connection() as conn:
+            with conn.cursor() as cur:
+                cur.execute(query, (
+                    uso.id_modelo,
+                    uso.tokens_input,
+                    uso.tokens_output,
+                    uso.custo_input,
+                    uso.custo_output,
+                    uso.tag_funcionalidade,
+                    uso.aplicacao,
+                    uso.usuario,
+                    uso.tempo_resposta_ms,
+                    uso.erro,
+                    uso.mensagem_erro,
+                    uso.timestamp_uso
+                ))
+                id_uso = cur.fetchone()[0]
+                logger.info(f"Uso registrado com ID {id_uso} - "
+                          f"Custo total: R$ {uso.custo_total:.6f}")
+                return id_uso
+    
+    def buscar_custos_por_aplicacao(self, aplicacao: str, 
+                                    data_inicio: Optional[Any] = None,
+                                    data_fim: Optional[Any] = None) -> Dict[str, Any]:
+        """
+        Busca estatísticas de custo para uma aplicação específica.
+        
+        Args:
+            aplicacao: Nome da aplicação
+            data_inicio: Data inicial do período (opcional)
+            data_fim: Data final do período (opcional)
+        
+        Returns:
+            Dicionário com estatísticas de uso e custo
+        
+        Raises:
+            DatabaseError: Se houver erro na consulta
+        """
+        query = """
+            SELECT 
+                COUNT(*) as total_chamadas,
+                SUM(tokens_input) as total_tokens_input,
+                SUM(tokens_output) as total_tokens_output,
+                SUM(tokens_total) as total_tokens,
+                SUM(custo_total) as custo_total,
+                AVG(custo_total) as custo_medio,
+                AVG(tempo_resposta_ms) as tempo_medio_resposta_ms,
+                SUM(CASE WHEN erro = true THEN 1 ELSE 0 END) as total_erros
+            FROM fato_uso_tokens
+            WHERE aplicacao = %s
+        """
+        params = [aplicacao]
+        
+        if data_inicio:
+            query += " AND timestamp_uso >= %s"
+            params.append(data_inicio)
+        
+        if data_fim:
+            query += " AND timestamp_uso <= %s"
+            params.append(data_fim)
+        
+        with self._get_connection() as conn:
+            with conn.cursor(cursor_factory=RealDictCursor) as cur:
+                cur.execute(query, params)
+                resultado = cur.fetchone()
+                if resultado:
+                    return self._convert_decimal_to_float(dict(resultado))
+                return {}

ia_tracker_qca-0.1.0/src/ia_cost_tracker/exceptions.py

@@ -0,0 +1,26 @@
+"""Exceções personalizadas para o IA Cost Tracker."""
+
+
+class IATrackerError(Exception):
+    """Exceção base para erros do IA Cost Tracker."""
+    pass
+
+
+class DatabaseError(IATrackerError):
+    """Exceção para erros relacionados ao banco de dados."""
+    pass
+
+
+class ProviderError(IATrackerError):
+    """Exceção para erros relacionados aos provedores de IA."""
+    pass
+
+
+class ModelNotFoundError(IATrackerError):
+    """Exceção quando um modelo não é encontrado no banco de dados."""
+    pass
+
+
+class ConfigurationError(IATrackerError):
+    """Exceção para erros de configuração."""
+    pass