diff --git "a/app.py" "b/app.py"
--- "a/app.py"
+++ "b/app.py"
@@ -1,36 +1,55 @@
-import streamlit as st
-import pandas as pd
-import json
+import streamlit as st
+import pandas as pd
+import base64
+import hashlib
+import hmac
+import json
+import time
import urllib.parse
import plotly.graph_objects as go
from tavily import TavilyClient
from email.message import EmailMessage
from datetime import datetime
-import requests
-import os
-import re
-import io
-from html import escape
-import crypto
-from dotenv import load_dotenv
-import database as db
+import requests
+import os
+try:
+ import truststore
+ truststore.inject_into_ssl()
+except Exception:
+ pass
+try:
+ import certifi
+ CERTIFI_CA_BUNDLE = certifi.where()
+ os.environ.setdefault("SSL_CERT_FILE", CERTIFI_CA_BUNDLE)
+ os.environ.setdefault("REQUESTS_CA_BUNDLE", CERTIFI_CA_BUNDLE)
+ os.environ.setdefault("GRPC_DEFAULT_SSL_ROOTS_FILE_PATH", CERTIFI_CA_BUNDLE)
+except Exception:
+ pass
+import re
+import io
+import unicodedata
+from html import escape, unescape
+import crypto
+from dotenv import load_dotenv
+import database as db
load_dotenv()
# --- 1. CONFIGURACIÓN INICIAL Y CIBERSEGURIDAD ---
st.set_page_config(page_title="Proyelec Sourcing Pro", layout="wide", page_icon="💎", initial_sidebar_state="expanded")
-# --- CACHE DE ESTILOS PARA EVITAR PARPADEO ---
-@st.cache_data
-def get_css():
- try:
- with open('style.css', 'r', encoding='utf-8') as f:
- return f''
- except:
- return ""
-
-st.markdown(get_css(), unsafe_allow_html=True)
+# --- CACHE DE ESTILOS PARA EVITAR PARPADEO ---
+@st.cache_data(show_spinner=False)
+def get_css(css_mtime=0):
+ try:
+ with open('style.css', 'r', encoding='utf-8') as f:
+ return f''
+ except:
+ return ""
+
+css_mtime = os.path.getmtime('style.css') if os.path.exists('style.css') else 0
+st.markdown(get_css(css_mtime), unsafe_allow_html=True)
@@ -63,10 +82,18 @@ def extraer_meta_nota(nota):
rev = rev_match.group(1).strip() if rev_match else None
return cierre, rev
-API_URL_BASE = os.getenv("API_URL_BASE", "http://localhost:8000/api/v1")
-API_HEADERS = {"X-Internal-Token": os.getenv("INTERNAL_API_TOKEN", "default-dev-token")}
-TIEMPO_BLOQUEO = 15 # minutos — debe coincidir con database.py
-MAPA_ESTADOS_SLI = {
+API_URL_BASE = os.getenv("API_URL_BASE", "http://localhost:8000/api/v1")
+API_HEADERS = {"X-Internal-Token": os.getenv("INTERNAL_API_TOKEN", "default-dev-token")}
+BRAVE_SEARCH_API_KEY = os.getenv("BRAVE_SEARCH_API_KEY", "").strip()
+TIEMPO_BLOQUEO = 15 # minutos — debe coincidir con database.py
+APP_SESSION_TTL_SECONDS = int(os.getenv("APP_SESSION_TTL_SECONDS", "43200"))
+SESSION_SECRET = (
+ os.getenv("SESSION_SECRET")
+ or os.getenv("ENCRYPTION_KEY")
+ or os.getenv("INTERNAL_API_TOKEN")
+ or "procura-dev-session"
+).encode("utf-8")
+MAPA_ESTADOS_SLI = {
"EVALUACIÓN": "En Evaluacion Economica",
"EVALUACION": "En Evaluacion Economica",
"ADJUDICADA": "Adjudicada",
@@ -77,30 +104,394 @@ MAPA_ESTADOS_SLI = {
}
-# --- 2. BASE DE DATOS LOCAL Y PERSISTENCIA ---
-def init_db():
- db.init_db()
-
-init_db()
+# --- 2. BASE DE DATOS LOCAL Y PERSISTENCIA ---
+@st.cache_resource(show_spinner=False)
+def init_db():
+ db.init_db()
+ return True
+
+init_db()
+
+@st.cache_data(ttl=300, show_spinner=False)
+def load_historical_prices():
+ df_historico = db.get_historical_prices_df()
+ return df_historico if not df_historico.empty else None
+
+@st.cache_data(ttl=300, show_spinner=False)
+def get_historico_anios_cached():
+ return db.get_historico_anios()
+
+@st.cache_data(ttl=60, show_spinner=False)
+def get_historico_count_cached():
+ return db.get_historico_count()
+
+@st.cache_data(ttl=120, show_spinner=False)
+def get_historico_licitaciones_cached(search="", anio="Todos", limit=1000):
+ return db.get_historico_licitaciones_df(limit=limit, search=search or None, anio=anio)
+
+def normalize_history_columns(df):
+ rename_map = {}
+ for col in df.columns:
+ col_norm = str(col).lower()
+ if "licitaci" in col_norm and "hist" in col_norm:
+ rename_map[col] = "licitacion_hist"
+ elif ("año" in col_norm or "anio" in col_norm) and "hist" in col_norm:
+ rename_map[col] = "anio_hist"
+ if rename_map:
+ df = df.rename(columns=rename_map)
+ return df
+
+def coerce_bool(value, default=False):
+ if isinstance(value, bool):
+ return value
+ if value is None or pd.isna(value):
+ return default
+ text = str(value).strip().lower()
+ if text in ["true", "si", "sí", "yes", "1", "y"]:
+ return True
+ if text in ["false", "no", "0", "n", "none", "null", "n/a", ""]:
+ return False
+ return default
+
+def coerce_optional_bool(value):
+ if isinstance(value, bool):
+ return value
+ if value is None or pd.isna(value):
+ return None
+ text = str(value).strip().lower()
+ if text in ["true", "si", "sí", "yes", "1", "y"]:
+ return True
+ if text in ["false", "no", "0", "n"]:
+ return False
+ return None
+
+def normalize_technical_fields(df):
+ defaults = {
+ "requiere_propuesta_tecnica": False,
+ "requiere_ficha_tecnica": False,
+ "marca_modelo_requerido": None,
+ "acepta_equivalente": None,
+ "posible_obsolescencia": False,
+ "evidencia_tecnica": "",
+ }
+ for col, default in defaults.items():
+ if col not in df.columns:
+ df[col] = default
+ for col in ["requiere_propuesta_tecnica", "requiere_ficha_tecnica", "posible_obsolescencia"]:
+ df[col] = df[col].apply(lambda value: coerce_bool(value, default=False))
+ df["acepta_equivalente"] = df["acepta_equivalente"].apply(coerce_optional_bool)
+ return df
+
+def is_meaningful_text(value):
+ if value is None:
+ return False
+ try:
+ if pd.isna(value):
+ return False
+ except (TypeError, ValueError):
+ pass
+ text = str(value).strip()
+ return bool(text) and text.lower() not in ["no", "n/a", "na", "nan", "none", "null", "sin restricciones", "no aplica"]
+
+def bool_label(value):
+ if value is True:
+ return "Sí"
+ if value is False:
+ return "No"
+ return "No determinado"
+
+NOT_SPECIFIED_DOC = "No especificado en los documentos adjuntos"
+ACP_CODE_RE = re.compile(r"\b([A-Z]{3})-([A-Z]{3})-(\d{5})\b", re.IGNORECASE)
+
+def clean_doc_value(value, default=NOT_SPECIFIED_DOC):
+ if value is None:
+ return default
+ try:
+ if pd.isna(value):
+ return default
+ except (TypeError, ValueError):
+ pass
+ text = str(value).strip()
+ if not text or text.lower() in ["n/a", "na", "nan", "none", "null", "no aplica", "no especificado"]:
+ return default
+ return text
+
+def normalize_acp_code(value):
+ text = clean_doc_value(value, default="")
+ if not text:
+ return ""
+ match = ACP_CODE_RE.search(text.upper())
+ if not match:
+ return ""
+ return f"{match.group(1).upper()}-{match.group(2).upper()}-{match.group(3)}"
+
+def acp_code_match(value):
+ code = normalize_acp_code(value)
+ if not ACP_CODE_RE.fullmatch(code or ""):
+ return ""
+ return "".join(ch for ch in code.upper() if ch.isascii() and ch.isalnum())
+
+def normalize_item_codes(df):
+ if "codigo_articulo" in df.columns:
+ df = df.copy()
+ df["codigo_articulo"] = df["codigo_articulo"].apply(normalize_acp_code)
+ return df
+
+def parse_rows_from_scope_text(value):
+ rows = set()
+ if value is None:
+ return rows, False
+ if isinstance(value, (list, tuple, set)):
+ all_rows = False
+ for item in value:
+ item_text = str(item or "").strip().lower()
+ if item_text in ["todos", "todas", "all"]:
+ all_rows = True
+ rows.update(re.findall(r"\d+", item_text))
+ return rows, all_rows
+
+ text = str(value or "").strip()
+ if not text:
+ return rows, False
+ if re.search(r"\b(todos|todas|global|all)\b", text, re.IGNORECASE):
+ return rows, True
+
+ scoped_matches = re.findall(
+ r"(?:l[ií]neas?|renglones?)\s+([0-9][0-9,\s\-yY]*)",
+ text,
+ flags=re.IGNORECASE,
+ )
+ for match in scoped_matches:
+ rows.update(re.findall(r"\d+", match))
+ return rows, False
+
+def apply_proposal_scope_from_cg(df, cg):
+ if df.empty or "requiere_propuesta_tecnica" not in df.columns:
+ return df, []
+ proposal_text = clean_doc_value(cg.get("propuesta_tecnica_requerida") if isinstance(cg, dict) else "", default="")
+ evidence_text = clean_doc_value(cg.get("evidencia_propuesta_tecnica") if isinstance(cg, dict) else "", default="")
+ applies_value = cg.get("propuesta_tecnica_aplica_renglones") if isinstance(cg, dict) else []
+
+ applies_rows, applies_all = parse_rows_from_scope_text(applies_value)
+ text_rows, text_all = parse_rows_from_scope_text(f"{proposal_text} {evidence_text}")
+ applies_rows.update(text_rows)
+ applies_all = applies_all or text_all
+
+ proposal_required = str(proposal_text).strip().lower().startswith(("si", "sí")) or bool(applies_rows) or applies_all
+ if not proposal_required:
+ return df, []
+
+ df = df.copy()
+ row_values = df["renglon"].astype(str).str.extract(r"(\d+)")[0].fillna("").astype(str) if "renglon" in df.columns else pd.Series("", index=df.index)
+ existing_rows = set(row_values[row_values != ""].tolist())
+
+ if applies_all or not applies_rows:
+ df["requiere_propuesta_tecnica"] = True
+ missing_rows = []
+ else:
+ df["requiere_propuesta_tecnica"] = row_values.isin(applies_rows)
+ missing_rows = sorted(applies_rows - existing_rows, key=lambda x: int(x) if x.isdigit() else x)
+
+ return df, missing_rows
+
+def strip_html_markup(value):
+ text = clean_doc_value(value, default="")
+ if not text:
+ return ""
+ text = unescape(text)
+ if re.search(r"", "\n", text, flags=re.IGNORECASE)
+ text = re.sub(r"]*>", "\n", text, flags=re.IGNORECASE)
+ text = re.sub(r"<[^>]+>", " ", text)
+ text = re.sub(r"[ \t]+", " ", text)
+ text = re.sub(r"\n\s*\n+", "\n", text)
+ return text.strip()
+
+def first_doc_value(source, keys, default=NOT_SPECIFIED_DOC):
+ if not isinstance(source, dict):
+ return default
+ for key in keys:
+ value = clean_doc_value(source.get(key), default="")
+ if value:
+ return value
+ return default
+
+def get_local_presence_decision(cg):
+ local_value = None
+ local_keys = [
+ "requiere_presencia_local",
+ "empresa_local_requerida",
+ "presencia_local_requerida",
+ "requiere_empresa_local",
+ "requiere_representante_local",
+ ]
+ if isinstance(cg, dict):
+ for key in local_keys:
+ if key in cg:
+ local_value = coerce_optional_bool(cg.get(key))
+ if local_value is not None:
+ break
+
+ if local_value is True:
+ return "Sí", "Participar con EP", "Requisito local detectado en el pliego.", "tone-green"
+ if local_value is False:
+ return "No", "Participar con Proyelec", "El pliego no exige presencia local.", "tone-blue"
+ return NOT_SPECIFIED_DOC, "Validar antes de decidir", "No se puede confirmar solo con el documento cargado.", "tone-amber"
+
+@st.cache_data(ttl=15, show_spinner=False)
+def get_api_health():
+ try:
+ r = requests.get(f"{API_URL_BASE.replace('/api/v1','')}/", timeout=2, headers=API_HEADERS)
+ return r.status_code == 200
+ except Exception:
+ return False
# Workspace multi
-def save_workspace_state(username, cg_dict, df):
- lic = cg_dict.get('numero_licitacion', 'Sin_Numero')
- db.save_workspace(username, str(lic), df.to_json(orient="records"), json.dumps(cg_dict))
-
-def load_workspace_state(username):
- row = db.load_workspace_state(username)
- if row and row[0] and row[1]:
- return pd.read_json(io.StringIO(row[0])), json.loads(row[1])
+def save_workspace_state(username, cg_dict, df):
+ lic = cg_dict.get('numero_licitacion', 'Sin_Numero')
+ db.save_workspace(username, str(lic), df.to_json(orient="records"), json.dumps(cg_dict))
+ get_all_workspaces_cached.clear()
+
+def load_workspace_state(username):
+ row = db.load_workspace_state(username)
+ if row and row[0] and row[1]:
+ return pd.read_json(io.StringIO(row[0])), json.loads(row[1])
return None, None
-def load_workspace_by_licitacion(username, licitacion):
- row = db.load_workspace(username, licitacion)
- if row and row[0] and row[1]:
- return pd.read_json(io.StringIO(row[0])), json.loads(row[1])
- return None, None
-
-def verify_login(username, password):
+def load_workspace_by_licitacion(username, licitacion):
+ row = db.load_workspace(username, licitacion)
+ if row and row[0] and row[1]:
+ return pd.read_json(io.StringIO(row[0])), json.loads(row[1])
+ return None, None
+
+def _b64url_encode(data):
+ return base64.urlsafe_b64encode(data).decode("utf-8").rstrip("=")
+
+def _b64url_decode(value):
+ padding = "=" * (-len(value) % 4)
+ return base64.urlsafe_b64decode(value + padding)
+
+def create_auth_token(username):
+ payload = {
+ "u": username,
+ "exp": int(time.time()) + APP_SESSION_TTL_SECONDS,
+ }
+ payload_raw = json.dumps(payload, separators=(",", ":"), sort_keys=True).encode("utf-8")
+ payload_b64 = _b64url_encode(payload_raw)
+ signature = hmac.new(SESSION_SECRET, payload_b64.encode("utf-8"), hashlib.sha256).hexdigest()
+ return f"{payload_b64}.{signature}"
+
+def parse_auth_token(token):
+ try:
+ payload_b64, signature = str(token).split(".", 1)
+ expected = hmac.new(SESSION_SECRET, payload_b64.encode("utf-8"), hashlib.sha256).hexdigest()
+ if not hmac.compare_digest(signature, expected):
+ return None
+ payload = json.loads(_b64url_decode(payload_b64).decode("utf-8"))
+ if int(payload.get("exp", 0)) < int(time.time()):
+ return None
+ username = str(payload.get("u", "")).strip()
+ return username or None
+ except Exception:
+ return None
+
+def get_query_param(name, default=""):
+ value = st.query_params.get(name, default)
+ if isinstance(value, list):
+ return value[0] if value else default
+ return value
+
+def clear_auth_query_param():
+ current_view = get_query_param("view", "")
+ st.query_params.clear()
+ if current_view:
+ st.query_params["view"] = current_view
+
+def get_shared_api_keys():
+ """Busca un par de API keys descifrable para analistas sin llaves propias."""
+ conn = db.get_connection()
+ c = conn.cursor()
+ c.execute("""
+ SELECT gemini_key, tavily_key
+ FROM users
+ WHERE role IN ('Gerencia', 'Supervisor', 'Admin')
+ AND (gemini_key != '' OR tavily_key != '')
+ ORDER BY
+ CASE role
+ WHEN 'Gerencia' THEN 1
+ WHEN 'Supervisor' THEN 2
+ ELSE 3
+ END,
+ username
+ """)
+ rows = c.fetchall()
+ conn.close()
+
+ for gemini_enc, tavily_enc in rows:
+ gemini = crypto.decrypt_data(gemini_enc) if gemini_enc else ""
+ tavily = crypto.decrypt_data(tavily_enc) if tavily_enc else ""
+ if gemini or tavily:
+ return gemini, tavily
+ return "", ""
+
+def hydrate_session_from_user_data(user_data, restore_workspace=True):
+ st.session_state.logged_in = True
+ st.session_state.username = user_data[0]
+ st.session_state.role = user_data[2] if user_data[2] else "Analista"
+ st.session_state.gemini_key = user_data[3] if user_data[3] else ""
+ st.session_state.tavily_key = user_data[4] if user_data[4] else ""
+ st.session_state.email_user = user_data[5] if user_data[5] else ""
+ st.session_state.email_pass = crypto.decrypt_data(user_data[6]) if len(user_data) > 6 and user_data[6] else ""
+
+ if restore_workspace:
+ df_saved, cg_saved = load_workspace_state(user_data[0])
+ if df_saved is not None:
+ st.session_state.df_exportar = df_saved
+ st.session_state.cg = cg_saved
+ st.session_state.procesado = True
+
+def get_user_profile_for_session(username):
+ conn = db.get_connection()
+ c = conn.cursor()
+ c.execute("SELECT * FROM users WHERE LOWER(username)=LOWER(%s)", (username,))
+ user_data = c.fetchone()
+ conn.close()
+
+ if not user_data:
+ return None
+
+ user_list = list(user_data)
+ user_list[3] = crypto.decrypt_data(user_list[3]) if user_list[3] else ""
+ user_list[4] = crypto.decrypt_data(user_list[4]) if user_list[4] else ""
+
+ if user_list[2] == "Analista":
+ shared_gemini, shared_tavily = get_shared_api_keys()
+ if not user_list[3]:
+ user_list[3] = shared_gemini
+ if not user_list[4]:
+ user_list[4] = shared_tavily
+
+ return tuple(user_list)
+
+def restore_persistent_session():
+ if st.session_state.logged_in:
+ return
+
+ token = get_query_param("auth", "")
+ username = parse_auth_token(token)
+ if not username:
+ return
+
+ user_data = get_user_profile_for_session(username)
+ if user_data:
+ hydrate_session_from_user_data(user_data)
+
+def logout_user():
+ clear_auth_query_param()
+ st.session_state.clear()
+ st.rerun()
+
+def verify_login(username, password):
# 1. Verificar bloqueo por intentos fallidos
bloqueado, segundos = db.esta_bloqueado(username)
if bloqueado:
@@ -115,19 +506,17 @@ def verify_login(username, password):
u_list = list(user_data)
role = u_list[2]
- # Analistas heredan solo gemini_key y tavily_key si no tienen las suyas
- # (NO heredan email corporativo de Gerencia — reduce superficie de ataque)
- if role == "Analista":
- conn = db.get_connection()
- c = conn.cursor()
- c.execute("SELECT gemini_key, tavily_key FROM users WHERE role='Gerencia' AND gemini_key != '' LIMIT 1")
- gerencia = c.fetchone()
- conn.close()
- if gerencia:
- if not u_list[3]: u_list[3] = crypto.decrypt_data(gerencia[0])
- if not u_list[4]: u_list[4] = crypto.decrypt_data(gerencia[1])
-
- return tuple(u_list)
+ # Analistas heredan solo gemini_key y tavily_key si no tienen las suyas
+ # o si sus llaves guardadas ya no se pueden descifrar.
+ # (NO heredan email corporativo — reduce superficie de ataque)
+ if role == "Analista":
+ shared_gemini, shared_tavily = get_shared_api_keys()
+ if not u_list[3]:
+ u_list[3] = shared_gemini
+ if not u_list[4]:
+ u_list[4] = shared_tavily
+
+ return tuple(u_list)
# Login fallido: registrar intento
db.registrar_intento_fallido(username)
@@ -137,19 +526,456 @@ def verify_login(username, password):
raise ValueError(f"Demasiados intentos fallidos. Cuenta bloqueada por {TIEMPO_BLOQUEO} minutos.")
return None
-def update_user_profile(username, gemini, tavily, email, raw_email_pass):
- # El cifrado de gemini, tavily y email_pass ocurre dentro de db.update_user_profile()
- enc_pass = crypto.encrypt_data(raw_email_pass) if raw_email_pass else ""
- db.update_user_profile(username, gemini, tavily, email, enc_pass)
-
-def save_history(username, licitacion, items_count):
- db.save_history(username, licitacion, items_count)
-
-def get_user_history(username):
- return db.get_user_history_df(username)
-
-def obtener_correos_licitacion(licitacion):
- return db.get_correos_licitacion_df(licitacion)
+def update_user_profile(username, gemini, tavily, email, raw_email_pass):
+ # El cifrado de gemini, tavily y email_pass ocurre dentro de db.update_user_profile()
+ enc_pass = crypto.encrypt_data(raw_email_pass) if raw_email_pass else ""
+ db.update_user_profile(username, gemini, tavily, email, enc_pass)
+ get_all_users_cached.clear()
+
+def save_history(username, licitacion, items_count):
+ db.save_history(username, licitacion, items_count)
+ get_user_history.clear()
+
+@st.cache_data(ttl=30, show_spinner=False)
+def get_user_history(username):
+ return db.get_user_history_df(username)
+
+@st.cache_data(ttl=30, show_spinner=False)
+def get_all_users_cached():
+ df = db.get_all_users()
+ if not df.empty:
+ if "Usuario" in df.columns and "username" not in df.columns:
+ df["username"] = df["Usuario"]
+ if "Nivel" in df.columns and "role" not in df.columns:
+ df["role"] = df["Nivel"]
+ return df
+
+@st.cache_data(ttl=30, show_spinner=False)
+def get_system_health_counts():
+ conn = db.get_connection()
+ try:
+ total_lic_monitor = pd.read_sql_query("SELECT COUNT(*) as c FROM seguimiento_licitaciones", conn).iloc[0]['c']
+ total_historial = pd.read_sql_query("SELECT COUNT(*) as c FROM history", conn).iloc[0]['c']
+ total_fichas = pd.read_sql_query("SELECT COUNT(*) as c FROM fichas_cache", conn).iloc[0]['c']
+ except Exception:
+ total_lic_monitor, total_historial, total_fichas = 0, 0, 0
+ conn.close()
+ return int(total_lic_monitor), int(total_historial), int(total_fichas)
+
+@st.cache_data(ttl=30, show_spinner=False)
+def get_usage_filter_options_cached(days):
+ return db.get_usage_filter_options(days=days)
+
+@st.cache_data(ttl=30, show_spinner=False)
+def get_usage_summary_cached(days, username, module):
+ return db.get_usage_summary(days=days, username=username, module=module)
+
+@st.cache_data(ttl=3600, show_spinner=False)
+def get_api_pricing_cached():
+ return db.get_api_pricing_df()
+
+@st.cache_data(ttl=20, show_spinner=False)
+def get_seguimientos_cached():
+ return db.get_seguimientos()
+
+@st.cache_data(ttl=20, show_spinner=False)
+def get_historial_seguimiento_cached(licitacion_id):
+ return db.get_historial_seguimiento(int(licitacion_id))
+
+@st.cache_data(ttl=30, show_spinner=False)
+def get_all_workspaces_cached(username, all_users=False):
+ return db.get_all_workspaces(username, all_users=all_users)
+
+@st.cache_data(ttl=30, show_spinner=False)
+def get_radar_cached(solo_nuevas=False, solo_hoy=False):
+ return db.get_licitaciones_radar(solo_nuevas=solo_nuevas, solo_hoy=solo_hoy)
+
+@st.cache_data(ttl=60, show_spinner=False)
+def get_radar_scans_cached(limit=10):
+ return db.get_ultimos_escaneos(limite=limit)
+
+@st.cache_data(ttl=300, show_spinner=False)
+def get_historico_radar_cached():
+ df = db.get_historico_licitaciones_df(limit=8000)
+ if df.empty:
+ return df
+ codigo_col = _hist_col(df, ["Código ACP", "Código ACP", "codigo_acp"])
+ obs_col = _hist_col(df, ["Observaciones", "observaciones"])
+ codigo_values = df[codigo_col].fillna("").astype(str) if codigo_col else ""
+ obs_values = df[obs_col].fillna("").astype(str) if obs_col else ""
+ df = df.copy()
+ df["_radar_codigo_norm"] = codigo_values.map(_radar_norm) if codigo_col else ""
+ df["_radar_haystack"] = (codigo_values + " " + obs_values).map(_radar_norm) if codigo_col or obs_col else ""
+ return df
+
+RADAR_HISTORICO_GRUPOS = {
+ "Electrico": {
+ "terms": ["electrico", "electricidad", "cable", "conductor", "breaker", "interruptor", "sensor", "luminaria", "transformador", "panel"],
+ "codes": ["ELT", "ELE", "CAB", "SEN", "LUM", "PWR", "SW", "BRK"],
+ },
+ "Hidraulico": {
+ "terms": ["hidraulico", "bomba", "valvula", "cilindro", "acumulador", "manguera", "manifold", "rexroth"],
+ "codes": ["HID", "HYD", "BOM", "PMP", "VAL", "CIL", "MAN"],
+ },
+ "Mecanico": {
+ "terms": ["mecanico", "motor", "rodamiento", "acople", "correa", "engranaje", "reductor", "sello", "resorte"],
+ "codes": ["MEC", "MOT", "ROD", "BRG", "ACO", "COR", "SEL"],
+ },
+ "Instrumentacion": {
+ "terms": ["instrumentacion", "transmisor", "medidor", "calibrador", "controlador", "plc", "modulo", "alarma"],
+ "codes": ["INS", "PLC", "MOD", "MET", "CTR", "CAL"],
+ },
+ "Refrigeracion": {
+ "terms": ["refrigeracion", "aire", "ventilador", "fan", "compresor", "evaporador", "condensador"],
+ "codes": ["REF", "HVAC", "FAN", "AIR", "CMP"],
+ },
+ "Ferreteria": {
+ "terms": ["materiales", "tornillo", "tuerca", "herramienta", "ferreteria", "zocalo", "vinilo", "aislar", "tuberia"],
+ "codes": ["HAR", "MAT", "FAB", "ALM", "TUB", "VIN"],
+ },
+}
+
+def _radar_norm(value):
+ text = "" if value is None else str(value)
+ text = unicodedata.normalize("NFKD", text).encode("ascii", "ignore").decode("ascii")
+ return re.sub(r"\s+", " ", text.lower()).strip()
+
+def _radar_has_term(text, term):
+ return _radar_has_norm_term(_radar_norm(text), term)
+
+def _radar_has_norm_term(norm_text, term):
+ norm_term = _radar_norm(term)
+ if not norm_term:
+ return False
+ if " " in norm_term:
+ return norm_term in norm_text
+ return re.search(rf"(? 0:
+ score += 2
+
+ if score <= 0:
+ continue
+
+ rows.append({
+ "score_hist": score,
+ "licitacion_hist": hist.get(lic_col, "") if lic_col else "",
+ "anio_hist": hist.get(anio_col, "") if anio_col else "",
+ "codigo_acp": codigo,
+ "precio_proyelec": hist.get(precio_col, "") if precio_col else "",
+ "adjudicada_proyelec": "Si" if win else "No/No especificado",
+ "evidencia": "; ".join(dict.fromkeys(reasons)),
+ "observaciones": obs,
+ })
+
+ if not rows:
+ return pd.DataFrame()
+ return pd.DataFrame(rows).sort_values(["score_hist", "anio_hist"], ascending=[False, False]).head(max_rows)
+
+def enrich_radar_with_history(radar_df, hist_df):
+ if radar_df is None or radar_df.empty:
+ return radar_df
+ enriched = radar_df.copy()
+ stats = []
+ for _, row in enriched.iterrows():
+ matches = build_historico_matches_for_radar(
+ row.get("objeto", ""),
+ row.get("categoria", ""),
+ hist_df,
+ max_rows=20,
+ )
+ total = len(matches)
+ wins = int((matches["adjudicada_proyelec"] == "Si").sum()) if total else 0
+ last_year = None
+ confidence = "Sin historial"
+ if total:
+ years = pd.to_numeric(matches["anio_hist"], errors="coerce").dropna()
+ last_year = int(years.max()) if not years.empty else None
+ top_score = float(matches["score_hist"].max())
+ confidence = "Alta" if top_score >= 8 else "Media" if top_score >= 4 else "Baja"
+ stats.append({
+ "hist_participaciones": total,
+ "hist_ganadas": wins,
+ "hist_ultimo_anio": last_year,
+ "hist_confianza": confidence,
+ })
+ return pd.concat([enriched.reset_index(drop=True), pd.DataFrame(stats)], axis=1)
+
+def parse_radar_datetime(value):
+ try:
+ from sli_scraper import parse_sli_datetime
+ return parse_sli_datetime(value)
+ except Exception:
+ return None
+
+def add_radar_date_columns(df):
+ if df is None or df.empty:
+ return df
+ enriched = df.copy()
+ cierre_values = enriched["fecha_cierre"].tolist() if "fecha_cierre" in enriched.columns else []
+ apertura_values = enriched["fecha_apertura"].tolist() if "fecha_apertura" in enriched.columns else []
+ enriched["_fecha_cierre_dt"] = pd.to_datetime([parse_radar_datetime(v) for v in cierre_values], errors="coerce") if cierre_values else pd.NaT
+ enriched["_fecha_apertura_dt"] = pd.to_datetime([parse_radar_datetime(v) for v in apertura_values], errors="coerce") if apertura_values else pd.NaT
+ enriched["_radar_vencida"] = enriched["_fecha_cierre_dt"].notna() & (enriched["_fecha_cierre_dt"] < pd.Timestamp(datetime.now()))
+ return enriched
+
+def sort_radar_by_dates(df):
+ if df is None or df.empty:
+ return df
+ sort_cols = [c for c in ["_radar_vencida", "_fecha_cierre_dt", "_fecha_apertura_dt", "numero_licitacion"] if c in df.columns]
+ if not sort_cols:
+ return df
+ return df.sort_values(sort_cols, ascending=True, na_position="last").reset_index(drop=True)
+
+def analyze_radar_opportunity(radar_row, matches_df=None, sli_data=None):
+ sli_data = sli_data or {}
+ matches_df = matches_df if matches_df is not None else pd.DataFrame()
+ objeto = str(
+ sli_data.get("descripcion")
+ or radar_row.get("objeto", "")
+ or ""
+ )
+ objeto_norm = _radar_norm(objeto)
+ cierre_txt = str(sli_data.get("fecha_cierre") or radar_row.get("fecha_cierre", "") or "")
+ cierre_dt = parse_radar_datetime(cierre_txt)
+ now = datetime.now()
+
+ score = 50
+ razones = []
+ riesgos = []
+ pasos = []
+
+ rubro_terms = [
+ "repuesto", "bomba", "motor", "cable", "electrico", "hidraulico",
+ "sensor", "valvula", "panel", "transformador", "breaker", "rodamiento",
+ "cilindro", "acumulador", "lubricante", "castrol", "instrumentacion",
+ ]
+ fuera_rubro_terms = [
+ "software", "licencia", "survey", "capacitacion", "alquiler", "grua",
+ "obra", "limpieza", "consultoria", "andamio", "puerta", "lona",
+ ]
+
+ rubro_hits = [term for term in rubro_terms if _radar_has_norm_term(objeto_norm, term)]
+ fuera_hits = [term for term in fuera_rubro_terms if _radar_has_norm_term(objeto_norm, term)]
+
+ if bool(radar_row.get("es_prioritaria", False)):
+ score += 10
+ razones.append("Marcada como prioritaria por palabras clave del rubro.")
+
+ if rubro_hits:
+ score += min(20, 8 + len(set(rubro_hits)) * 3)
+ razones.append("Objeto alineado al rubro Proyelec: " + ", ".join(sorted(set(rubro_hits))[:5]) + ".")
+ else:
+ score -= 8
+ riesgos.append("No se detectaron palabras fuertes del rubro Proyelec en el objeto.")
+
+ if fuera_hits:
+ score -= min(22, 8 + len(set(fuera_hits)) * 4)
+ riesgos.append("Puede estar fuera del foco comercial habitual: " + ", ".join(sorted(set(fuera_hits))[:5]) + ".")
+
+ hist_total = len(matches_df)
+ hist_wins = int((matches_df["adjudicada_proyelec"] == "Si").sum()) if hist_total and "adjudicada_proyelec" in matches_df.columns else 0
+ if hist_total:
+ score += min(18, 8 + hist_total)
+ razones.append(f"Hay {hist_total} participaciones historicas similares.")
+ if hist_wins:
+ score += min(12, hist_wins * 3)
+ razones.append(f"Proyelec ganó {hist_wins} registro(s) histórico(s) similar(es).")
+ else:
+ score -= 6
+ riesgos.append("No hay historial similar cargado; requiere validacion manual de precios y cumplimiento.")
+
+ if cierre_dt:
+ horas = (cierre_dt - now).total_seconds() / 3600
+ if horas < 0:
+ score -= 60
+ riesgos.append("La fecha de cierre ya paso; no conviene invertir tiempo salvo que el SLI muestre extension.")
+ elif horas <= 24:
+ score -= 18
+ riesgos.append("Cierra en menos de 24 horas; alto riesgo operativo para preparar oferta completa.")
+ elif horas <= 72:
+ score -= 6
+ riesgos.append("Cierra en menos de 3 días; validar capacidad de cotizar y subir documentos.")
+ elif horas <= 168:
+ score += 8
+ razones.append("Cierra esta semana; hay ventana razonable para evaluacion rapida.")
+ else:
+ score += 5
+ razones.append("Hay tiempo suficiente para revisar RFQ, proveedores y precios.")
+ else:
+ score -= 5
+ riesgos.append("No se pudo interpretar fecha de cierre; verificar manualmente en SLI.")
+
+ estatus = str(sli_data.get("estatus", "") or "").lower()
+ if estatus:
+ if "abierta" in estatus:
+ score += 5
+ razones.append("SLI confirma estatus abierto.")
+ elif "vencido" in estatus or "cancel" in estatus or "desierto" in estatus:
+ score -= 40
+ riesgos.append(f"SLI reporta estatus no participable: {sli_data.get('estatus')}.")
+ else:
+ riesgos.append(f"SLI reporta estatus: {sli_data.get('estatus')}.")
+
+ if (sli_data.get("resumen_acta") or {}).get("hallazgos"):
+ score -= 5
+ riesgos.append("El resumen SLI contiene observaciones; revisar antes de decidir.")
+
+ score = max(0, min(100, int(round(score))))
+ if score >= 75:
+ decision = "Participar"
+ color = "success"
+ pasos.extend([
+ "Pasar a seguimiento y asignar responsable.",
+ "Descargar/revisar RFQ y confirmar restricciones técnicas.",
+ "Cruzar renglones con histórico de precios y proveedores."
+ ])
+ elif score >= 50:
+ decision = "Revisar"
+ color = "warning"
+ pasos.extend([
+ "Revisar RFQ antes de comprometer recursos.",
+ "Confirmar disponibilidad de proveedores y documentos requeridos.",
+ "Validar si el objeto realmente pertenece al rubro Proyelec."
+ ])
+ else:
+ decision = "Descartar"
+ color = "error"
+ pasos.extend([
+ "No invertir tiempo comercial salvo instruccion del supervisor.",
+ "Guardar motivo de descarte si se decide cerrarla.",
+ ])
+
+ if not razones:
+ razones.append("La recomendación se basa en señales limitadas del Radar; requiere revisión del RFQ.")
+ if not riesgos:
+ riesgos.append("No se detectaron riesgos automaticos fuertes, pero falta revisar el RFQ completo.")
+
+ return {
+ "decision": decision,
+ "color": color,
+ "score": score,
+ "razones": razones[:6],
+ "riesgos": riesgos[:6],
+ "pasos": pasos[:5],
+ "sli": {
+ "estatus": sli_data.get("estatus", ""),
+ "descripcion": sli_data.get("descripcion", ""),
+ "fecha_cierre": sli_data.get("fecha_cierre", ""),
+ "fecha_publicacion": sli_data.get("fecha_publicacion", ""),
+ "url": sli_data.get("url", ""),
+ "error": sli_data.get("error", ""),
+ }
+ }
+
+def clear_monitor_cache():
+ get_seguimientos_cached.clear()
+ get_historial_seguimiento_cached.clear()
+ get_system_health_counts.clear()
+
+def clear_radar_cache():
+ get_radar_cached.clear()
+ get_radar_scans_cached.clear()
+ get_historico_radar_cached.clear()
+
+@st.cache_data(ttl=30, show_spinner=False)
+def obtener_correos_licitacion(licitacion):
+ return db.get_correos_licitacion_df(licitacion)
def activar_organizacion_imap():
try:
@@ -165,143 +991,331 @@ def activar_organizacion_imap():
return False, json_res.get("mensaje", "Error desconocido.")
else: return False, f"Error del servidor: {res.text}"
except Exception as e: return False, str(e)
-
-
-
-# --- 4. LOGIN CON IDENTIDAD PROYELEC ---
-if not st.session_state.logged_in:
- st.markdown("""
-
- """, unsafe_allow_html=True)
-
- col_logo = st.columns([1,3,1])[1]
- with col_logo:
- try:
- st.image("proyelec_logo.png", use_container_width=True)
- except Exception:
- st.markdown("⚡
", unsafe_allow_html=True)
-
- st.markdown("""
- PROYELEC
- Sourcing Intelligence Pro
- """, unsafe_allow_html=True)
-
- user_input = st.text_input("Usuario", placeholder="Usuario corporativo", label_visibility="collapsed")
- pass_input = st.text_input("Contraseña", type="password", placeholder="Contraseña", label_visibility="collapsed")
- st.write("")
- if st.button("Ingresar al Sistema", type="primary", use_container_width=True):
- try:
- user_data = verify_login(user_input, pass_input)
- if user_data:
- st.session_state.logged_in = True
- st.session_state.username = user_data[0]
- st.session_state.role = user_data[2] if user_data[2] else "Analista"
- st.session_state.gemini_key = user_data[3] if user_data[3] else ""
- st.session_state.tavily_key = user_data[4] if user_data[4] else ""
- st.session_state.email_user = user_data[5] if user_data[5] else ""
- st.session_state.email_pass = crypto.decrypt_data(user_data[6]) if user_data[6] else ""
- df_saved, cg_saved = load_workspace_state(user_data[0])
- if df_saved is not None:
- st.session_state.df_exportar = df_saved
- st.session_state.cg = cg_saved
- st.session_state.procesado = True
- st.rerun()
- else:
- st.error("❌ Credenciales incorrectas. Intenta de nuevo.")
- except ValueError as e:
- st.error(f"🔒 {e}")
-
- st.markdown('', unsafe_allow_html=True)
- st.stop()
-
-# --- NAVBAR RENDER ---
-st.markdown(f"""
-
-
💎 PROYELEC SOURCING PRO
-
Usuario: {st.session_state.username} {st.session_state.role} | {datetime.now().strftime("%d/%m/%Y")}
-
+
+
Procura AI beta interna
+
Sourcing operativo para licitaciones ACP
+
+ Analiza pliegos, compara histórico de precios, organiza proveedores y da seguimiento comercial desde un solo panel.
+
+
+
RFQ y renglones con evidencia técnica
+
Histórico Supabase para comparar precios
+
Radar SLI para supervisores
+
Seguimiento de licitaciones y comentarios
+
+
+
+
+
Ingresar al sistema
+
Usa tu usuario corporativo. El rol define los modulos disponibles dentro del sistema.
+
+
+
Administración Global
+
Panel de Control
+
Usuarios, roles, llaves, métricas y salud operativa del sistema.
+
+
Acceso Admin
+
➕ Nuevo Usuario
""", unsafe_allow_html=True)
new_u = st.text_input("Nombre de Usuario (Login)")
new_p = st.text_input("Contraseña Temporal", type="password")
- new_r = st.selectbox("Nivel de Acceso", ["Analista", "Gerencia"])
+ new_r = st.selectbox("Nivel de Acceso", ["Analista", "Supervisor", "Gerencia"])
if st.button("Crear Cuenta", use_container_width=True, type="primary"):
if new_u and new_p:
- if db.create_user(new_u, new_p, new_r):
- st.success(f"✅ Cuenta de {new_r} creada para '{new_u}'")
- st.rerun()
+ if db.create_user(new_u, new_p, new_r):
+ get_all_users_cached.clear()
+ st.success(f"✅ Cuenta de {new_r} creada para '{new_u}'")
+ st.rerun()
else:
st.error("⚠️ El usuario ya existe.")
else:
st.warning("Completa los campos.")
st.markdown("", unsafe_allow_html=True)
- st.markdown("
", unsafe_allow_html=True)
- with st.expander("🔑 Configurar API Keys por Usuario"):
- target_u = st.selectbox("Seleccionar Usuario", [""] + df_users['Usuario'].tolist())
+ st.markdown("
", unsafe_allow_html=True)
+ with st.expander("🔑 Configurar API Keys por Usuario"):
+ target_user_options = df_users["Usuario"].tolist() if "Usuario" in df_users.columns else df_users.get("username", pd.Series(dtype=str)).tolist()
+ target_u = st.selectbox("Seleccionar Usuario", [""] + target_user_options)
if target_u:
conn = db.get_connection()
c = conn.cursor()
@@ -319,98 +1333,280 @@ if st.session_state.username == "admin":
# email_pass: si se escribió algo lo ciframos, si no mantenemos el actual
final_p_enc = crypto.encrypt_data(new_p) if new_p else curr[3]
# gemini y tavily se cifran dentro de db.update_user_profile()
- db.update_user_profile(target_u, new_g, new_t, new_e, final_p_enc)
- st.success(f"Configuración guardada para {target_u}")
- st.rerun()
+ db.update_user_profile(target_u, new_g, new_t, new_e, final_p_enc)
+ get_all_users_cached.clear()
+ st.success(f"Configuración guardada para {target_u}")
+ st.rerun()
- with tab_stats:
+ if admin_view == "📊 Estadísticas del Sistema":
st.subheader("Salud del Sistema")
- conn = db.get_connection()
- try:
- total_lic_monitor = pd.read_sql_query("SELECT COUNT(*) as c FROM seguimiento_licitaciones", conn).iloc[0]['c']
- total_historial = pd.read_sql_query("SELECT COUNT(*) as c FROM history", conn).iloc[0]['c']
- total_fichas = pd.read_sql_query("SELECT COUNT(*) as c FROM fichas_cache", conn).iloc[0]['c']
- except Exception:
- total_lic_monitor, total_historial, total_fichas = 0, 0, 0
- conn.close()
+ total_lic_monitor, total_historial, total_fichas = get_system_health_counts()
s1, s2, s3 = st.columns(3)
- s1.metric("Licitaciones en Monitor ACP", total_lic_monitor)
- s2.metric("Pliegos Analizados (Histórico)", total_historial)
- s3.metric("Fichas Técnicas Generadas", total_fichas)
-
- st.markdown("---")
- if st.button("Cerrar Sesión Segura", type="primary", use_container_width=True):
- st.session_state.clear()
- st.rerun()
+ s1.metric("Licitaciones en Monitor ACP", total_lic_monitor)
+ s2.metric("Pliegos Analizados (Histórico)", total_historial)
+ s3.metric("Fichas Técnicas Generadas", total_fichas)
+
+ st.divider()
+ st.subheader("Analitica de Consumo y Costos")
+ try:
+ f1, f2, f3 = st.columns(3)
+ filter_options = get_usage_filter_options_cached(days=180)
+ with f1:
+ dias_metricas = st.selectbox("Periodo", [7, 30, 60, 90, 180], index=1, format_func=lambda d: f"Últimos {d} días")
+ with f2:
+ usuario_metricas = st.selectbox("Usuario", filter_options["users"])
+ with f3:
+ modulo_metricas = st.selectbox("Módulo", filter_options["modules"])
+
+ resumen = get_usage_summary_cached(days=dias_metricas, username=usuario_metricas, module=modulo_metricas)
+ m1, m2, m3, m4, m5, m6 = st.columns(6)
+ m1.metric("Eventos", f"{resumen['total_events']:,}")
+ m2.metric("Usuarios", resumen["active_users"])
+ m3.metric("Licitaciones", resumen["active_licitaciones"])
+ m4.metric("Tokens IA", f"{resumen['tokens_total']:,}")
+ m5.metric("Costo USD", f"${resumen['estimated_cost_usd']:.4f}")
+ m6.metric("Errores", resumen["errors"])
+ if resumen.get("uncosted_events", 0):
+ st.warning(f"{resumen['uncosted_events']} evento(s) IA antiguos no tienen input/output separados y no se incluyen en el costo.")
+
+ df_day = resumen["by_day"]
+ if not df_day.empty:
+ c1, c2 = st.columns(2)
+ with c1:
+ st.caption("Eventos por dia")
+ st.bar_chart(df_day.set_index("day")["eventos"])
+ with c2:
+ st.caption("Tokens por dia")
+ if df_day["tokens"].sum() > 0:
+ token_cols = [c for c in ["tokens_entrada", "tokens_salida"] if c in df_day.columns]
+ st.line_chart(df_day.set_index("day")[token_cols or ["tokens"]])
+ else:
+ st.info("Aun no hay tokens IA costeables en el periodo.")
+
+ with st.expander("Detalle y tarifas"):
+ st.caption("Consumo por modulo y funcion")
+ st.dataframe(resumen["by_module"], use_container_width=True, hide_index=True)
+ st.caption("Consumo por usuario")
+ st.dataframe(resumen["by_user"], use_container_width=True, hide_index=True)
+ st.caption("Tarifas usadas")
+ st.dataframe(get_api_pricing_cached(), use_container_width=True, hide_index=True)
+ except Exception as e:
+ st.error(f"Error cargando métricas: {e}")
+
+ st.markdown("---")
+ if st.button("Cerrar Sesión Segura", type="primary", use_container_width=True):
+ logout_user()
st.stop()
-# --- 5. SIDEBAR ---
-with st.sidebar:
- st.markdown("
", unsafe_allow_html=True)
-
- st.title("📄 1. Cargar Requerimiento")
- st.caption("Sube el pliego principal y los anexos técnicos en formato PDF.")
- archivos_pdf = st.file_uploader("", type=["pdf"], label_visibility="collapsed", accept_multiple_files=True)
-
- if st.button("🚀 Procesar con IA", type="primary", use_container_width=True):
+# --- 5. SIDEBAR ---
+def get_navigation_items():
+ items = [
+ {
+ "group": "Inicio",
+ "view": "🚀 Tablero de Operaciones",
+ "key": "inicio",
+ "label": "Inicio / RFQ",
+ "icon": "⌂",
+ "hint": "Dashboard, carga de RFQ y resultado activo",
+ "permission": "dashboard",
+ },
+ {
+ "group": "Sourcing",
+ "view": "🌐 Proveedores",
+ "key": "proveedores",
+ "label": "Proveedores",
+ "icon": "◎",
+ "hint": "Busqueda global de proveedores, precios y evidencia",
+ "permission": "providers",
+ },
+ {
+ "group": "Seguimiento",
+ "view": "🏛️ Monitor ACP",
+ "key": "licitaciones",
+ "label": "Licitaciones",
+ "icon": "□",
+ "hint": "Seguimiento, comentarios y estados de licitaciones",
+ "permission": "monitor",
+ },
+ {
+ "group": "Supervisión",
+ "view": "📡 Radar Supervisor",
+ "key": "radar",
+ "label": "Radar SLI",
+ "icon": "◇",
+ "hint": "Licitaciones abiertas, oportunidades y priorización",
+ "permission": "radar",
+ },
+ {
+ "group": "Datos",
+ "view": "📊 Historial Global",
+ "key": "historico",
+ "label": "Histórico",
+ "icon": "▦",
+ "hint": "Precios y licitaciones previas",
+ "permission": "historico",
+ },
+ {
+ "group": "Datos",
+ "view": "📚 Base de Conocimiento",
+ "key": "workspaces",
+ "label": "Workspaces",
+ "icon": "▤",
+ "hint": "Historial, fichas y recursos",
+ "permission": "workspaces",
+ },
+ ]
+ return [item for item in items if role_can(item["permission"])]
+
+navigation_items = get_navigation_items()
+valid_views = [item["view"] for item in navigation_items]
+nav_by_key = {item["key"]: item for item in navigation_items}
+requested_view = st.query_params.get("view", "")
+if isinstance(requested_view, list):
+ requested_view = requested_view[0] if requested_view else ""
+if requested_view in nav_by_key:
+ st.session_state.active_view = nav_by_key[requested_view]["view"]
+if st.session_state.get("active_view") not in valid_views:
+ st.session_state.active_view = valid_views[0]
+current_nav_item = next((item for item in navigation_items if item["view"] == st.session_state.active_view), navigation_items[0])
+
+with st.sidebar:
+ st.markdown("
", unsafe_allow_html=True)
+ st.markdown("""
+
+ """, unsafe_allow_html=True)
+ api_online_sidebar = get_api_health()
+ st.markdown(f"""
+
+ """, unsafe_allow_html=True)
+
+ role_profile = get_role_profile()
+ st.markdown(f"""
+
+ """, unsafe_allow_html=True)
+
+ st.markdown('', unsafe_allow_html=True)
+ last_group = None
+ for item in navigation_items:
+ if item["group"] != last_group:
+ st.markdown(f"{escape(item['group'])}
", unsafe_allow_html=True)
+ last_group = item["group"]
+ is_active = st.session_state.active_view == item["view"]
+ if st.button(
+ f"{item.get('icon', '•')} {item['label']}",
+ key=f"nav_{item['view']}",
+ use_container_width=True,
+ type="primary" if is_active else "secondary",
+ help=item["hint"],
+ ):
+ st.session_state.active_view = item["view"]
+ st.query_params["view"] = item["key"]
+ st.rerun()
+
+ st.divider()
+
+ st.markdown('', unsafe_allow_html=True)
+ st.markdown("""
+
+ """, unsafe_allow_html=True)
+ archivos_pdf = st.file_uploader("Archivos PDF", type=["pdf"], label_visibility="collapsed", accept_multiple_files=True)
+ if archivos_pdf:
+ st.caption(f"{len(archivos_pdf)} archivo(s) listo(s) para analizar")
+
+ if st.button("Procesar RFQ", type="primary", use_container_width=True):
if not st.session_state.gemini_key: st.error("⚠️ Verifica tus API Keys en la configuración.")
elif not archivos_pdf: st.error("⚠️ Falta subir al menos un documento.")
else:
with st.status("Conectando con Motor IA...", expanded=True) as status:
try:
archivos = [("archivos_pdf", (f.name, f.getvalue(), "application/pdf")) for f in archivos_pdf]
- datos_formulario = {"gemini_key": st.session_state.gemini_key}
+ datos_formulario = {
+ "gemini_key": st.session_state.gemini_key,
+ "username": st.session_state.username,
+ "role": st.session_state.role
+ }
respuesta_api = requests.post(f"{API_URL_BASE}/analizar-pliego", files=archivos, data=datos_formulario, headers=API_HEADERS)
if respuesta_api.status_code == 200:
- datos_crudos = respuesta_api.json()
- cg = datos_crudos.get("condiciones_generales", {})
- df_exportar = pd.DataFrame(datos_crudos.get("items", []))
-
- try:
- if not os.path.exists("ACP DATA LIC PASADAS v2_2.xlsx"):
- st.warning("⚠️ No se encontró el histórico 'ACP DATA LIC PASADAS v2_2.xlsx'. Procesando sin precios base.")
- else:
- df_historico = pd.read_excel("ACP DATA LIC PASADAS v2_2.xlsx", skiprows=8).rename(columns=lambda x: str(x).strip())
-
- # Limpiar códigos aislando solo el ID puro (Primera palabra, sin basura de la IA) y haciendo alfanumérico
- df_historico['codigo_match'] = df_historico['CODIGO ACP'].astype(str).str.replace(r'[^a-zA-Z0-9]', '', regex=True).str.upper()
- df_exportar['codigo_match'] = df_exportar['codigo_articulo'].astype(str).str.split().str[0].fillna("").astype(str).str.replace(r'[^a-zA-Z0-9]', '', regex=True).str.upper()
-
- df_cruzado = pd.merge(df_exportar, df_historico.drop_duplicates(subset=['codigo_match'])[['codigo_match', 'PRECIO COMPETENCIA', 'PRECIO PROYELEC']], left_on='codigo_match', right_on='codigo_match', how='left')
- df_cruzado = df_cruzado.drop(columns=['codigo_match']).rename(columns={'PRECIO COMPETENCIA': "precio_comp_hist", 'PRECIO PROYELEC': "precio_proy_hist"})
+ datos_crudos = respuesta_api.json()
+ cg = datos_crudos.get("condiciones_generales", {})
+ df_exportar = normalize_item_codes(normalize_technical_fields(pd.DataFrame(datos_crudos.get("items", []))))
+
+ try:
+ df_historico_match = load_historical_prices()
+ if df_historico_match is None:
+ st.warning("⚠️ El histórico de Supabase aún no tiene datos. Procesando sin precios base.")
+ else:
+ # El código ACP válido usa formato AAA-AAA-00000; se normaliza antes del cruce histórico.
+ df_exportar['codigo_match'] = df_exportar['codigo_articulo'].apply(acp_code_match)
+
+ df_cruzado = pd.merge(df_exportar, df_historico_match, left_on='codigo_match', right_on='codigo_match', how='left')
+ df_cruzado = df_cruzado.drop(columns=['codigo_match']).rename(columns={'PRECIO COMPETENCIA': "precio_comp_hist", 'PRECIO PROYELEC': "precio_proy_hist"})
- df_cruzado['precio_comp_hist'] = pd.to_numeric(df_cruzado['precio_comp_hist'], errors='coerce')
- df_cruzado['precio_proy_hist'] = pd.to_numeric(df_cruzado['precio_proy_hist'], errors='coerce')
- df_cruzado['margen_$'] = df_cruzado['precio_proy_hist'] - df_cruzado['precio_comp_hist']
- df_exportar = df_cruzado
- except Exception as excel_e:
- st.warning(f"⚠️ Error leyendo Excel histórico: {excel_e}")
+ df_cruzado['precio_comp_hist'] = pd.to_numeric(df_cruzado['precio_comp_hist'], errors='coerce')
+ df_cruzado['precio_proy_hist'] = pd.to_numeric(df_cruzado['precio_proy_hist'], errors='coerce')
+ df_cruzado['margen_$'] = df_cruzado['precio_proy_hist'] - df_cruzado['precio_comp_hist']
+ df_exportar = normalize_history_columns(df_cruzado)
+ except Exception as hist_e:
+ st.warning(f"⚠️ Error consultando histórico en Supabase: {hist_e}")
save_history(st.session_state.username, str(cg.get('numero_licitacion', 'Desconocida')), len(df_exportar))
save_workspace_state(st.session_state.username, cg, df_exportar)
- st.session_state.df_exportar, st.session_state.cg, st.session_state.procesado = df_exportar, cg, True
- status.update(label="✅ Análisis Completado", state="complete", expanded=False)
- st.rerun()
+ st.session_state.df_exportar, st.session_state.cg, st.session_state.procesado = df_exportar, cg, True
+ status.update(label="✅ Análisis Completado", state="complete", expanded=False)
+ st.toast("Analisis completado. Resultados listos.")
else: status.update(label=f"❌ Error en API: {respuesta_api.text}", state="error")
except Exception as e: status.update(label=f"❌ Error crítico: {e}", state="error")
st.divider()
- st.caption("Opciones del Sistema")
-
- # Indicador de estado de la API
- try:
- _r = requests.get(f"{API_URL_BASE.replace('/api/v1','')}/", timeout=2, headers=API_HEADERS)
- if _r.status_code == 200:
- st.markdown("🟢 Motor IA Activo
", unsafe_allow_html=True)
- else:
- st.markdown("🔴 Motor IA Sin respuesta
", unsafe_allow_html=True)
- except Exception:
- st.markdown("🔴 Motor IA Apagado — Ejecuta run.bat
", unsafe_allow_html=True)
+ st.markdown('', unsafe_allow_html=True)
+ st.markdown(f"""
+
+ """, unsafe_allow_html=True)
if st.session_state.role == "Gerencia":
with st.expander("⚙️ Configuración y Llaves", expanded=False):
@@ -426,70 +1622,14 @@ with st.sidebar:
st.toast("✅ Configuración guardada.")
else:
st.markdown("""
-
- ⚙️ Configuración administrada por Gerencia
-
- """, unsafe_allow_html=True)
-
- # --- PANEL DE ADMINISTRACIÓN (solo Gerencia) ---
- if st.session_state.role == "Gerencia":
- with st.expander("👥 Gestión de Usuarios", expanded=False):
- st.caption("Panel exclusivo de Gerencia")
-
- df_users = db.get_all_users()
- if not df_users.empty:
- for _, u in df_users.iterrows():
- u_col1, u_col2, u_col3 = st.columns([0.45, 0.3, 0.25])
- with u_col1:
- st.markdown(f"{u['username']}
", unsafe_allow_html=True)
- with u_col2:
- roles_opt = ["Gerencia", "Analista"]
- idx = roles_opt.index(u['role']) if u['role'] in roles_opt else 1
- nuevo_rol = st.selectbox("", roles_opt, index=idx, key=f"rol_{u['username']}", label_visibility="collapsed")
- if nuevo_rol != u['role']:
- db.update_user_role(u['username'], nuevo_rol)
- st.toast(f"Rol de {u['username']} actualizado.")
- st.rerun()
- with u_col3:
- if u['username'] != st.session_state.username:
- if st.button("🗑️", key=f"del_{u['username']}", help=f"Eliminar {u['username']}"):
- db.delete_user(u['username'])
- st.toast(f"Usuario {u['username']} eliminado.")
- st.rerun()
-
- st.divider()
- st.caption("Crear nuevo usuario")
- new_u = st.text_input("Username", key="new_username", placeholder="ej: analista2")
- new_p = st.text_input("Contraseña", key="new_password", type="password", placeholder="mínimo 6 caracteres")
- new_r = st.selectbox("Rol", ["Analista", "Gerencia"], key="new_role")
- if st.button("➕ Crear Usuario", use_container_width=True):
- if new_u and new_p and len(new_p) >= 6:
- ok = db.create_user(new_u, new_p, new_r)
- if ok:
- st.toast(f"✅ Usuario '{new_u}' creado con rol {new_r}.")
- st.rerun()
- else:
- st.error(f"El usuario '{new_u}' ya existe.")
- else:
- st.warning("Username y contraseña (mín. 6 chars) son requeridos.")
+
+ ⚙️ Configuración administrada por el equipo autorizado
+
+ """, unsafe_allow_html=True)
- st.divider()
- st.caption("Resetear contraseña")
- reset_u = st.selectbox("Usuario", df_users['username'].tolist() if not df_users.empty else [], key="reset_user")
- reset_p = st.text_input("Nueva contraseña", key="reset_pass", type="password")
- if st.button("🔑 Resetear", use_container_width=True):
- if reset_u and reset_p and len(reset_p) >= 6:
- db.reset_user_password(reset_u, reset_p)
- st.toast(f"✅ Contraseña de '{reset_u}' actualizada.")
- else:
- st.warning("Selecciona usuario y escribe la nueva contraseña.")
-
- if st.button("🚪 Cerrar Sesión", use_container_width=True):
- st.session_state.logged_in = False
- st.session_state.procesado = False
- st.session_state.role = ""
- st.rerun()
+ if st.button("🚪 Cerrar Sesión", use_container_width=True):
+ logout_user()
# --- 7. RENDERIZADO VISUAL PRINCIPAL ---
# Colores y emojis por estado ACP
@@ -516,29 +1656,1286 @@ ESTADO_CONFIG.update({
"Desierta": ("", "#171C24", "#748091"),
})
-tab_main, tab_hist, tab_acp = st.tabs([
- "🚀 Tablero de Operaciones",
- "📚 Base de Conocimiento",
- "🏛️ Monitor ACP"
-])
-
-with tab_acp:
- st.markdown("Monitor ACP
", unsafe_allow_html=True)
- st.markdown("Seguimiento de licitaciones, estados SLI y alertas de evaluacion.
", unsafe_allow_html=True)
- seg_df = db.get_seguimientos()
-
- # --- KPIs del monitor ---
- total_seg = len(seg_df)
- adjudicadas = len(seg_df[seg_df['estado'] == 'Adjudicada']) if not seg_df.empty else 0
+active_view = st.session_state.active_view
+
+def render_page_header(eyebrow, title, subtitle, meta_items=None):
+ meta_html = ""
+ if meta_items:
+ meta_html = "" + "".join(
+ f"{escape(str(item))}" for item in meta_items if item is not None
+ ) + "
"
+ st.markdown(f"""
+
+ """, unsafe_allow_html=True)
+
+def render_summary_strip(items):
+ if not items:
+ return
+ cols = st.columns(len(items))
+ for col, item in zip(cols, items):
+ label = escape(str(item.get("label", "")))
+ value = escape(str(item.get("value", "")))
+ tone = escape(str(item.get("tone", "blue")))
+ with col:
+ st.markdown(f"""
+
+ """, unsafe_allow_html=True)
+
+def render_empty_state(title, body):
+ st.markdown(f"""
+
+
{escape(str(title))}
+
{escape(str(body))}
+
+
{escape(str(title))}
+
{escape(str(body))}
+
" + "".join(
+ f"{escape(str(item))}" for item in meta_items if item is not None
+ ) + "
"
+ st.markdown(f"""
+
+ """, unsafe_allow_html=True)
+
+def render_access_snapshot():
+ items = [
+ ("RFQ", role_can("rfq_upload")),
+ ("Proveedores", role_can("providers")),
+ ("Histórico", role_can("historico")),
+ ("Seguimiento", role_can("monitor")),
+ ("Radar SLI", role_can("radar")),
+ ("Admin", role_can("admin")),
+ ]
+ items_html = "".join(
+ f"{escape(label)}{'Activo' if enabled else 'No asignado'}
"
+ for label, enabled in items
+ )
+ st.markdown(f"""
+
+ {items_html}
+
+ """, unsafe_allow_html=True)
+
+def build_checklist_html(items):
+ rows = []
+ for item in items:
+ label = escape(str(item.get("label", "")))
+ value = escape(str(item.get("value", "")))
+ state = escape(str(item.get("state", "neutral")))
+ rows.append(
+ f''
+ )
+ return "" + "".join(rows) + "
"
+
+def render_analysis_state(cg, df, missing_rows, role_mode):
+ total_rows = len(df)
+ valid_codes = int(df["codigo_articulo"].apply(lambda value: bool(ACP_CODE_RE.fullmatch(str(value or "")))).sum()) if "codigo_articulo" in df.columns and total_rows else 0
+ proposal_count = int(df["requiere_propuesta_tecnica"].fillna(False).sum()) if "requiere_propuesta_tecnica" in df.columns else 0
+ attachment_count = int(df["requiere_ficha_tecnica"].fillna(False).sum()) if "requiere_ficha_tecnica" in df.columns else 0
+ has_history = bool(
+ ("precio_comp_hist" in df.columns and df["precio_comp_hist"].notna().any())
+ or ("precio_proy_hist" in df.columns and df["precio_proy_hist"].notna().any())
+ )
+ contact_parts = [
+ first_doc_value(cg, ["persona_encargada_licitacion", "persona_encargada", "agente_de_compras"], default=""),
+ first_doc_value(cg, ["correo_encargado_licitacion", "correo_encargado", "correo_contacto"], default=""),
+ first_doc_value(cg, ["telefono_encargado_licitacion", "telefono_encargado", "telefono_contacto"], default=""),
+ ]
+ contact_count = sum(1 for part in contact_parts if is_meaningful_text(part))
+ _, participation, _, _ = get_local_presence_decision(cg)
+ role_summary = {
+ "Analista": "RFQ, proveedores, histórico y seguimiento",
+ "Supervisor": "Analista + Radar SLI y seguimiento operativo",
+ "Gerencia": "Supervisor + vista gerencial e histórico corporativo",
+ "Admin": "Usuarios, roles, métricas y salud del sistema",
+ }.get(role_mode, "Flujo operativo")
+
+ state_items = [
+ {
+ "label": "Pliego leído",
+ "value": first_doc_value(cg, ["numero_licitacion"], default="Número no especificado"),
+ "state": "ok" if is_meaningful_text(first_doc_value(cg, ["numero_licitacion"], default="")) else "warn",
+ },
+ {
+ "label": "Códigos ACP",
+ "value": f"{valid_codes}/{total_rows} validados" if total_rows else "Sin renglones",
+ "state": "ok" if total_rows and valid_codes == total_rows else "warn",
+ },
+ {
+ "label": "Histórico consultado",
+ "value": "Con referencia de costos" if has_history else "Sin match histórico",
+ "state": "ok" if has_history else "neutral",
+ },
+ {
+ "label": "Propuesta técnica",
+ "value": f"Requerida en {proposal_count} renglón(es)" if proposal_count else "No detectada por renglón",
+ "state": "ok" if proposal_count else "neutral",
+ },
+ {
+ "label": "Ficha/catálogo adjunto",
+ "value": f"Pedido en {attachment_count} renglón(es)" if attachment_count else "No pedido aparte",
+ "state": "warn" if attachment_count else "neutral",
+ },
+ {
+ "label": "Contacto ACP",
+ "value": f"{contact_count}/3 datos detectados",
+ "state": "ok" if contact_count >= 2 else "warn",
+ },
+ {
+ "label": "Empresa sugerida",
+ "value": participation,
+ "state": "ok" if "Participar" in participation else "warn",
+ },
+ {
+ "label": f"Vista {role_mode}",
+ "value": role_summary,
+ "state": "ok",
+ },
+ ]
+ if missing_rows:
+ state_items.append({
+ "label": "Renglón faltante",
+ "value": f"Evidencia menciona línea(s) {', '.join(missing_rows)}",
+ "state": "warn",
+ })
+
+ render_table_toolbar(
+ "Estado del análisis",
+ "Checklist operativo para analista, supervisor y gerencia antes de cotizar o dar seguimiento.",
+ [role_mode, "Beta Etapa 1"],
+ )
+ st.markdown(f"{build_checklist_html(state_items)}
", unsafe_allow_html=True)
+
+def spec_text_to_checklist_html(text, max_items=14):
+ raw_text = strip_html_markup(text)
+ if not raw_text:
+ return build_checklist_html([{"label": "Especificación", "value": "Sin descripción técnica detectada.", "state": "neutral"}])
+
+ lines = []
+ for raw_line in raw_text.replace("\r", "\n").split("\n"):
+ line = raw_line.strip()
+ line = re.sub(r"^[-*•\s]+", "", line).strip()
+ line = line.replace("[ ]", "").replace("[x]", "").replace("[X]", "").replace("☐", "").replace("☑", "").strip()
+ if line and line.lower() not in ["sin descripcion", "sin descripción"]:
+ lines.append(line)
+
+ if not lines:
+ lines = [raw_text]
+
+ items = []
+ for line in lines[:max_items]:
+ label, value = "Requisito", line
+ if ":" in line and len(line.split(":", 1)[0]) <= 48:
+ label, value = line.split(":", 1)
+ label = label.strip() or "Requisito"
+ value = value.strip() or "No especificado"
+ items.append({"label": label, "value": value, "state": "neutral"})
+
+ if len(lines) > max_items:
+ items.append({"label": "Detalle adicional", "value": f"{len(lines) - max_items} puntos mas en el texto original.", "state": "neutral"})
+ return build_checklist_html(items)
+
+def build_rfq_email_html(subject, body, meta):
+ meta_rows = "".join(
+ f"""
+
+ | {escape(str(label))} |
+ {escape(str(value or 'N/A'))} |
+
+ """
+ for label, value in meta
+ )
+ body_safe = escape(str(body or ""))
+ return f"""
+
+
+
+
+
+
+
+ |
+ Proyelec International
+ Request for Quotation
+ {escape(str(subject or 'Request for Quotation'))}
+ |
+
+
+
+
+ {body_safe}
+ |
+
+
+ |
+ Generated by Procura AI. Please validate technical compliance, lead time, payment terms and supplier reliability before issuing a purchase decision.
+ |
+
+
+ |
+
+
+
+"""
+
+def render_rfq_email_preview(subject, body, meta):
+ meta_html = "".join(
+ f"{escape(str(label))}{escape(str(value or 'N/A'))}
"
+ for label, value in meta
+ )
+ body_preview = escape(str(body or "RFQ pendiente")).replace("\n", "
")
+ st.markdown(f"""
+
+
+
{meta_html}
+
{body_preview}
+
'
+ f'
{escape(source.get("short", source["name"]))}{caption}
'
+ f'
{escape(source.get("kind", ""))}" + "".join(cards) + "
"
+
+def provider_query_variants(base_query, extra_terms="", region="Global", qty=1):
+ base = str(base_query or "").strip()
+ extras = str(extra_terms or "").strip()
+ region_txt = "" if region == "Global" else str(region)
+ qty_txt = f"quantity {qty}" if qty else ""
+ if not base:
+ return []
+ raw_variants = [
+ ("Compatibilidad técnica", f"{base} datasheet specifications manufacturer part number {extras}"),
+ ("Precio y stock", f"{base} price stock availability distributor {region_txt} {qty_txt} {extras}"),
+ ("Distribuidor autorizado", f"{base} authorized distributor supplier industrial {region_txt} {extras}"),
+ ("Proveedor alternativo", f"{base} equivalent replacement supplier global {extras}"),
+ ]
+ variants = []
+ seen = set()
+ for label, query in raw_variants:
+ clean = re.sub(r"\s+", " ", query).strip()
+ if clean and clean.lower() not in seen:
+ seen.add(clean.lower())
+ variants.append({"label": label, "query": clean})
+ return variants
+
+def search_brave_providers(query, count=8):
+ if not BRAVE_SEARCH_API_KEY:
+ return []
+ try:
+ response = requests.get(
+ "https://api.search.brave.com/res/v1/web/search",
+ headers={"X-Subscription-Token": BRAVE_SEARCH_API_KEY},
+ params={"q": query, "count": count, "search_lang": "en"},
+ timeout=15,
+ )
+ response.raise_for_status()
+ data = response.json()
+ web_results = data.get("web", {}).get("results", [])
+ return [
+ {
+ "title": item.get("title", ""),
+ "content": item.get("description", ""),
+ "url": item.get("url", ""),
+ }
+ for item in web_results
+ ]
+ except Exception as exc:
+ st.warning(f"Brave Search no respondio: {exc}")
+ return []
+
+def score_provider_result(result, query):
+ title = str(result.get("title", "") or "")
+ content = str(result.get("content", "") or "")
+ url = str(result.get("url", "") or "")
+ haystack = _radar_norm(f"{title} {content} {url}")
+ query_tokens = _radar_object_tokens(query)
+
+ score = 45
+ reasons = []
+ positive_terms = {
+ "supplier": 8,
+ "distributor": 8,
+ "manufacturer": 7,
+ "authorized": 8,
+ "stock": 6,
+ "price": 6,
+ "pricing": 6,
+ "datasheet": 7,
+ "catalog": 5,
+ "industrial": 4,
+ "quote": 4,
+ }
+ risk_terms = {
+ "used": 8,
+ "refurbished": 8,
+ "surplus": 6,
+ "ebay": 6,
+ "blog": 5,
+ "forum": 5,
+ "pdf": 2,
+ }
+
+ for term, weight in positive_terms.items():
+ if _radar_has_norm_term(haystack, term):
+ score += weight
+ reasons.append(term)
+ matched_tokens = [token for token in query_tokens if _radar_has_norm_term(haystack, token)]
+ if matched_tokens:
+ score += min(18, len(set(matched_tokens)) * 4)
+ reasons.append("match tecnico")
+ for term, weight in risk_terms.items():
+ if _radar_has_norm_term(haystack, term):
+ score -= weight
+
+ score = max(0, min(100, score))
+ if score >= 78:
+ risk = "Bajo"
+ elif score >= 58:
+ risk = "Medio"
+ else:
+ risk = "Alto"
+ return score, risk, ", ".join(dict.fromkeys(reasons)) or "Evidencia limitada"
+
+def build_provider_results_table(results, query, source_name):
+ rows = []
+ for result in results or []:
+ score, risk, evidence = score_provider_result(result, query)
+ rows.append({
+ "Score": score,
+ "Riesgo": risk,
+ "Fuente": source_name,
+ "Proveedor / resultado": result.get("title", "Proveedor"),
+ "Evidencia": evidence,
+ "Resumen": result.get("content", ""),
+ "URL": result.get("url", ""),
+ "Precio": "Requiere confirmacion",
+ })
+ if not rows:
+ return pd.DataFrame()
+ return pd.DataFrame(rows).sort_values(["Score"], ascending=False)
+
+def merge_provider_result_tables(tables):
+ frames = [df for df in tables if df is not None and not df.empty]
+ if not frames:
+ return pd.DataFrame()
+ merged = pd.concat(frames, ignore_index=True)
+ if "URL" in merged.columns:
+ merged = merged.sort_values("Score", ascending=False).drop_duplicates(subset=["URL"], keep="first")
+ return merged.sort_values(["Score", "Riesgo"], ascending=[False, True]).reset_index(drop=True)
+
+def radar_urgency_label(value):
+ if pd.isna(value):
+ return "Sin fecha"
+ try:
+ delta_days = int((pd.Timestamp(value).normalize() - pd.Timestamp(datetime.now()).normalize()).days)
+ except Exception:
+ return "Sin fecha"
+ if delta_days < 0:
+ return "Vencida"
+ if delta_days == 0:
+ return "Hoy"
+ if delta_days == 1:
+ return "Mañana"
+ if delta_days <= 7:
+ return f"{delta_days} días"
+ return f"{delta_days} días"
+
+def build_radar_table_view(radar_df):
+ view = pd.DataFrame(index=radar_df.index)
+ view["RFQ"] = radar_df["numero_licitacion"].astype(str) if "numero_licitacion" in radar_df.columns else ""
+ view["Objeto"] = radar_df["objeto"].astype(str) if "objeto" in radar_df.columns else ""
+ view["Cierre"] = radar_df["fecha_cierre"].fillna("").astype(str) if "fecha_cierre" in radar_df.columns else ""
+ view["Urgencia"] = radar_df["_fecha_cierre_dt"].apply(radar_urgency_label) if "_fecha_cierre_dt" in radar_df.columns else "Sin fecha"
+ view["Prioridad"] = radar_df["es_prioritaria"].fillna(False).apply(lambda v: "Alta" if bool(v) else "Normal") if "es_prioritaria" in radar_df.columns else "Normal"
+ view["Historial"] = radar_df["hist_participaciones"].fillna(0).astype(int) if "hist_participaciones" in radar_df.columns else 0
+ view["Ganadas"] = radar_df["hist_ganadas"].fillna(0).astype(int) if "hist_ganadas" in radar_df.columns else 0
+ view["Score"] = radar_df["score_interes"].fillna(0).astype(int) if "score_interes" in radar_df.columns else 0
+ view["Estado"] = radar_df["estado_radar"].fillna("").astype(str) if "estado_radar" in radar_df.columns else ""
+ return view
+
+if active_view == "🌐 Proveedores":
+ render_page_header(
+ "Sourcing global",
+ "Proveedores",
+ "Búsqueda de proveedores reales, técnicamente compatibles y con señales de precio.",
+ ["Free-tier primero", "Precios con evidencia", "Beta interna"]
+ )
+
+ rfq_loaded = st.session_state.df_exportar is not None and not st.session_state.df_exportar.empty
+ tavily_ready = bool(st.session_state.get("tavily_key"))
+ brave_ready = bool(BRAVE_SEARCH_API_KEY)
+ active_source_count = int(tavily_ready) + int(brave_ready)
+ render_summary_strip([
+ {"label": "Motores activos", "value": active_source_count, "tone": "green" if active_source_count else "orange"},
+ {"label": "Catálogos gratis", "value": "Mouser/DigiKey/Octopart", "tone": "green"},
+ {"label": "Rutas de precio", "value": "Shopping + catálogos", "tone": "amber"},
+ {"label": "RFQ cargado", "value": "Si" if rfq_loaded else "No", "tone": "green" if rfq_loaded else "orange"},
+ ])
+
+ st.markdown("""
+
+
Estrategia beta free-tier
+
+ El motor separa la búsqueda en rutas de compatibilidad técnica, precio/stock,
+ distribuidores autorizados y proveedores alternativos. Así reducimos resultados bonitos pero poco útiles.
+
+
+
Búsqueda sugerida por el RFQ
+
{escape(selected_query or 'Sin término detectado')}
+
+ Código ACP {escape(str(selected_code))}
+ Marca/modelo {escape(str(selected_brand))}
+ Cantidad {escape(str(selected_qty))}
+
+
+
Consulta preparada
+
{escape(base_query or 'Sin búsqueda')}
+
{escape(selected_row_label)}
{escape(final_query or 'Completa una búsqueda para continuar.')}
+
{chips_html}
", unsafe_allow_html=True)
+
+ button_label = "Generar ranking automático" if selected_api_sources else "Preparar links de búsqueda"
+ run_search = st.button(button_label, type="primary", use_container_width=True)
+
+ with right_col:
+ render_table_toolbar(
+ "Links de verificación manual",
+ "Accesos rápidos para validar precio, stock, datasheets y evidencia sin consumir API.",
+ ["Free-tier", "Catálogos", "Web"],
+ )
+ links_query = manual_query.strip() or selected_query.strip()
+ sources = provider_source_catalog(links_query)
+ selected_names_for_cards = set(locals().get("selected_source_names", []))
+ if selected_names_for_cards:
+ sources = [source for source in sources if source.get("name") in selected_names_for_cards]
+ sources = [source for source in sources if source.get("url")]
+ if links_query:
+ source_cards = []
+ for source in sources:
+ source_url = source.get("url", "")
+ action_html = f"Consultar"
+ source_initial = escape(str(source.get("name", "F"))[:2].upper())
+ source_cards.append(
+ f''
+ f'
{source_initial}
'
+ f'
{escape(source.get("name", "Fuente"))}
'
+ f'
{escape(source.get("kind", ""))}
'
+ f'
{escape(source.get("status", ""))}
'
+ f'
{escape(source.get("detail", ""))}
'
+ f'
{action_html}
{''.join(source_cards)}
", unsafe_allow_html=True)
+ else:
+ render_empty_state("Sin links manuales seleccionados", "Selecciona Google, catálogos o directorios para abrir búsquedas externas sin consumir API.")
+ else:
+ render_empty_state("Sin búsqueda", "Selecciona un renglón o escribe un producto para activar las fuentes.")
+
+ with st.expander("Opciones pagas para la propuesta"):
+ render_notice_panel(
+ "Motores recomendados cuando la empresa apruebe presupuesto",
+ "SerpApi/DataForSEO para precios web y APIs oficiales de Mouser, DigiKey y Nexar/Octopart para stock, datasheets y distribuidores verificables.",
+ "blue",
+ )
+
+ if run_search:
+ if not base_query:
+ st.error("Escribe una búsqueda o selecciona un renglón con descripción.")
+ elif not selected_search_sources:
+ st.error("Selecciona al menos una fuente de búsqueda.")
+ elif not selected_api_sources:
+ st.info("Listo: usa los links de verificación manual para revisar proveedores, precios, stock y datasheets. Para ranking automático, activa Tavily o Brave Search.")
+ else:
+ with st.status("Buscando proveedores con fuentes free-tier...", expanded=True):
+ try:
+ result_tables = []
+ for variant in query_variants:
+ st.write(f"Ruta: {variant['label']}")
+ if "Tavily" in selected_api_sources:
+ t_client = TavilyClient(api_key=st.session_state.tavily_key)
+ res_tavily = t_client.search(
+ query=variant["query"],
+ search_depth="advanced" if depth_label == "Avanzada" else "basic",
+ max_results=4,
+ )
+ result_tables.append(build_provider_results_table(res_tavily.get("results", []), base_query, f"Tavily - {variant['label']}"))
+ if "Brave Search" in selected_api_sources:
+ brave_results = search_brave_providers(variant["query"], count=4)
+ result_tables.append(build_provider_results_table(brave_results, base_query, f"Brave - {variant['label']}"))
+ provider_results = merge_provider_result_tables(result_tables)
+ st.session_state.provider_results = provider_results
+ st.session_state.provider_last_query = base_query
+ st.toast("Búsqueda de proveedores completada", icon="🔎")
+ except Exception as e:
+ st.session_state.provider_results = pd.DataFrame()
+ st.error(f"No se pudo completar la búsqueda: {e}")
+
+ provider_results = st.session_state.get("provider_results", pd.DataFrame())
+ if provider_results is not None and not provider_results.empty:
+ render_table_toolbar(
+ "Ranking preliminar de proveedores",
+ "Candidatos organizados por score, riesgo y evidencia encontrada.",
+ [f"{len(provider_results)} resultados", st.session_state.get("provider_last_query", "Búsqueda")],
+ )
+ st.dataframe(
+ provider_results,
+ column_config={
+ "Score": st.column_config.ProgressColumn("Score", min_value=0, max_value=100),
+ "Riesgo": st.column_config.TextColumn("Riesgo", width="small"),
+ "Fuente": st.column_config.TextColumn("Fuente", width="small"),
+ "Proveedor / resultado": st.column_config.TextColumn("Proveedor / resultado", width="large"),
+ "Evidencia": st.column_config.TextColumn("Evidencia", width="medium"),
+ "Resumen": st.column_config.TextColumn("Resumen", width="large"),
+ "URL": st.column_config.LinkColumn("URL"),
+ "Precio": st.column_config.TextColumn("Precio", width="medium"),
+ },
+ use_container_width=True,
+ hide_index=True,
+ )
+
+ top_rows = provider_results.head(3)
+ card_cols = st.columns(min(3, len(top_rows)))
+ for idx, (_, result_row) in enumerate(top_rows.iterrows()):
+ with card_cols[idx]:
+ st.markdown(
+ f''
+ f'
{escape(str(result_row.get("Proveedor / resultado", "Proveedor"))[:80])}
'
+ f'
Score: {escape(str(result_row.get("Score", "")))} | Riesgo: {escape(str(result_row.get("Riesgo", "")))}
'
+ f'
{escape(str(result_row.get("Resumen", ""))[:180])}
'
+ f'
Revisar evidencia'
+ f'
+
Licitacion seleccionada
+
{escape(numero_radar)}
+
{escape(objeto_radar)}
+
-
🏛️
-
Sin licitaciones registradas
-
Usa el formulario para registrar la primera licitación ACP en seguimiento.
-
-
📂
-
Sin registros aun
-
Procesa tu primer pliego para comenzar a construir el historial.
-
", unsafe_allow_html=True)
- if st.button("🗑️ Eliminar este Registro", key=f"del_hist_{lic_sel}", use_container_width=True):
- db.delete_history_entry(st.session_state.username, lic_sel)
- st.toast(f"Registro {lic_sel} eliminado.", icon="🗑️")
- st.rerun()
+ if st.button("🗑️ Eliminar este Registro", key=f"del_hist_{lic_sel}", use_container_width=True):
+ db.delete_history_entry(st.session_state.username, lic_sel)
+ get_user_history.clear()
+ st.toast(f"Registro {lic_sel} eliminado.", icon="🗑️")
+ st.rerun()
st.divider()
# Exportar historial completo
@@ -1116,194 +3524,462 @@ with tab_hist:
mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
use_container_width=True)
with col_del:
- if st.button("⚠️ Borrar Todo", use_container_width=True, type="secondary"):
- db.clear_all_history(st.session_state.username)
- st.toast("Historial borrado completamente.", icon="✅")
- st.rerun()
-
-with tab_main:
- if not st.session_state.procesado:
- # --- KPIs REALES DEL SISTEMA ---
- df_hist_kpi = get_user_history(st.session_state.username)
- total_lic = len(df_hist_kpi)
- total_reng = int(df_hist_kpi['Renglones'].sum()) if not df_hist_kpi.empty and 'Renglones' in df_hist_kpi.columns else 0
- ultima_act = df_hist_kpi['Fecha Proceso'].iloc[0][:10] if not df_hist_kpi.empty else "Sin actividad"
-
- st.markdown("
", unsafe_allow_html=True)
- st.markdown(f"""
-
- Centro de Mando
-
- Bienvenido, {st.session_state.username}
- Sistema de Inteligencia de Sourcing — Proyelec
- """, unsafe_allow_html=True)
-
- k1, k2, k3, k4 = st.columns(4)
- k1.metric("Licitaciones Procesadas", total_lic)
- k2.metric("Renglones Analizados", total_reng)
- k3.metric("Ultima Actividad", ultima_act)
- k4.metric("Motor IA", "Gemini 2.5 Flash")
-
- st.markdown("
", unsafe_allow_html=True)
- st.markdown("Para comenzar, sube el pliego en el panel izquierdo y presiona Procesar con IA
", unsafe_allow_html=True)
-
- c1, c2, c3 = st.columns(3)
- with c1:
- st.markdown("""
-
-
📄
-
1. Carga el Pliego
-
Sube el PDF oficial de la licitacion. Soporta pliego principal y anexos tecnicos simultaneamente.
-
-
🧠
-
2. Analisis con IA
-
Gemini extrae renglones, codigos, cantidades y cruza automaticamente con el historico de precios.
-
-
🎯
-
3. Sourcing Global
-
Busca los mejores proveedores, genera RFQs y organiza cotizaciones en tu bandeja inteligente.
-
-
-
Nº Licitación
-
{cg_render.get('numero_licitacion', 'N/A')}
-
-
-
Lugar Entrega
-
{cg_render.get('lugar_de_entrega', 'N/A')}
-
-
-
Tiempo Entrega
-
{cg_render.get('tiempo_de_entrega_global', 'N/A')}
-
-
-
Garantía
-
{cg_render.get('garantia_exigida', 'N/A')}
-
-
-
Req. Prop. Técnica
-
{cg_render.get('propuesta_tecnica_requerida', 'N/A')}
-
-
-
Validez de Oferta
-
{cg_render.get('validez_de_la_oferta', 'N/A')}
-
-
{escape(str(label))}{escape(str(value))}
"
+ for label, value in hero_rows
+ )
+ st.markdown(f"""
+
+
+
{escape(role_profile["title"])}
+
Procura operativa
+
Hola {escape(st.session_state.username)}. {escape(role_profile["scope"])}
+
+ Rol: {escape(current_role_mode())}
+ Última actividad: {escape(str(ultima_act))}
+ Motor IA {'activo' if api_online_now else 'apagado'}
+
+
+
+ {hero_rows_html}
+
+
Rutas de trabajo
", unsafe_allow_html=True)
+ route_cards = [
+ ("Analizar RFQ", "Carga de pliego y anexos desde el panel lateral.", "Listo", None),
+ ("Proveedores", "Sourcing por renglón con evidencia y señales de precio.", "Abrir", "🌐 Proveedores"),
+ ("Seguimiento", "Estados, comentarios y trazabilidad de participación.", "Abrir", "🏛️ Monitor ACP"),
+ ("Workspaces", "Recuperar análisis guardados y actividad reciente.", "Abrir", "📚 Base de Conocimiento"),
+ ]
+ if role_can("radar"):
+ route_cards.insert(3, ("Radar SLI", "Licitaciones abiertas, prioridad y acción sugerida.", "Abrir", "📡 Radar Supervisor"))
+ if role_can("historico"):
+ route_cards.append(("Histórico", "Base corporativa de precios y licitaciones previas.", "Abrir", "📊 Historial Global"))
+
+ for start in range(0, len(route_cards), 3):
+ route_cols = st.columns(min(3, len(route_cards) - start))
+ for col, (title, body, action, target_view) in zip(route_cols, route_cards[start:start + 3]):
+ with col:
+ st.markdown(f"""
+
+
{escape(title)}
+
{escape(body)}
+
Lectura rápida
", unsafe_allow_html=True)
+ d1, d2 = st.columns([0.55, 0.45])
+ with d1:
+ st.markdown(f"""
+
+
Prioridad recomendada
+
RFQ → Proveedores → Seguimiento
+
El flujo operativo queda separado por módulos para que cada cargo vea solo las decisiones que le corresponden.
+
+
Estado operativo
+
Licitaciones prioritarias{radar_prioritarias if role_can("radar") else "N/A"}
+
Monitor activo{en_eval_kpi}
+
Alcance{escape(role_profile["badge"])}
+
Acceso del rol actual
", unsafe_allow_html=True)
+ render_access_snapshot()
+
+ if not df_hist_kpi.empty:
+ st.markdown("Actividad reciente
", unsafe_allow_html=True)
+ render_table_toolbar("Actividad reciente", "Últimos análisis procesados por el usuario activo.", [st.session_state.username, "Historial"])
+ st.dataframe(df_hist_kpi.head(8), use_container_width=True, hide_index=True)
+ else:
+ render_empty_state("Sin actividad reciente", "Cuando proceses un RFQ, aparecera aqui como acceso rapido.")
+
+ else:
+ df_render = normalize_item_codes(normalize_technical_fields(normalize_history_columns(st.session_state.df_exportar)))
+ cg_render = st.session_state.cg if isinstance(st.session_state.cg, dict) else {}
+ df_render, missing_proposal_rows = apply_proposal_scope_from_cg(df_render, cg_render)
+ if "acepta_equivalente" in df_render.columns:
+ df_render["equivalente_txt"] = df_render["acepta_equivalente"].apply(bool_label)
+
+ result_view = st.radio(
+ "Vista de licitacion",
+ ["📋 1. Matriz de Productos", "📨 2. Emisión de RFQs", "🤖 3. Centro de Mando AI", "📈 4. Análisis de Costos"],
+ horizontal=True,
+ label_visibility="collapsed",
+ key="result_view",
+ )
+
+ if result_view == "📋 1. Matriz de Productos":
+ numero_licitacion = first_doc_value(cg_render, ["numero_licitacion", "licitacion", "numero_de_licitacion"])
+ lugar_entrega = first_doc_value(cg_render, ["lugar_de_entrega", "lugar_entrega", "sitio_entrega"])
+ tiempo_entrega = first_doc_value(cg_render, ["tiempo_de_entrega_global", "tiempo_entrega", "plazo_entrega"])
+ garantia_exigida = first_doc_value(cg_render, ["garantia_exigida", "garantia", "garantias"])
+ propuesta_tecnica = first_doc_value(cg_render, ["propuesta_tecnica_requerida"])
+ validez_oferta = first_doc_value(cg_render, ["validez_de_la_oferta", "validez_oferta"])
+ encargado_licitacion = first_doc_value(cg_render, [
+ "persona_encargada_licitacion",
+ "persona_encargada",
+ "agente_de_compras",
+ "comprador",
+ "responsable_licitacion",
+ ])
+ correo_encargado = first_doc_value(cg_render, [
+ "correo_encargado_licitacion",
+ "email_encargado_licitacion",
+ "correo_encargado",
+ "correo_contacto",
+ "email",
+ ])
+ telefono_encargado = first_doc_value(cg_render, [
+ "telefono_encargado_licitacion",
+ "telefono_encargado",
+ "telefono_contacto",
+ "telefono",
+ ])
+ presencia_local, participacion_sugerida, presencia_nota, presencia_tone = get_local_presence_decision(cg_render)
+ evidencia_presencia = first_doc_value(cg_render, ["evidencia_presencia_local"], default="")
+ evidencia_presencia_html = (
+ f"{escape(evidencia_presencia)}" if evidencia_presencia else ""
+ )
+
+ render_table_toolbar(
+ "Información de la licitación",
+ "Datos críticos extraídos del pliego para ordenar la evaluación antes de cotizar.",
+ ["Pliego", "Contacto ACP", participacion_sugerida],
+ )
+ st.markdown(f"""
+
+
+
+ Nº Licitación
+ {escape(numero_licitacion)}
+
+
+ Garantía
+ {escape(garantia_exigida)}
+
+
+ Lugar Entrega
+ {escape(lugar_entrega)}
+
+
+ Tiempo Entrega
+ {escape(tiempo_entrega)}
+
+
+ Req. Prop. Técnica
+ {escape(propuesta_tecnica)}
+
+
+ Validez de Oferta
+ {escape(validez_oferta)}
+
+
+
+
-
Renglón {fila.get('renglon', '-')} | Cód: {fila.get('codigo_articulo', 'N/A')}
-
{texto_ficha}
-
-
-
{res.get('title', 'Supplier')}
-
{res.get('content', '')[:120]}...
-
Visitar Website ↗
-
", unsafe_allow_html=True)
- st.markdown(data_ficha.get("datasheet_md", ""))
- st.markdown("
", unsafe_allow_html=True)
- else:
- st.error("Error al generar ficha: " + res_ficha.text)
- except Exception as e:
- st.error(f"Fallo en generación: {e}")
-
- with t2:
+ st.dataframe(df_items_view, column_config=col_config, use_container_width=True, hide_index=True)
+
+ def row_detail_label(row_idx):
+ row = df_render.loc[row_idx]
+ renglon = clean_doc_value(row.get("renglon", ""), default="-")
+ codigo = clean_doc_value(row.get("codigo_articulo", ""), default="S/C")
+ term = clean_doc_value(row.get("termino_de_busqueda_corto", ""), default="Sin descripción")
+ term = term if len(term) <= 88 else f"{term[:85]}..."
+ prop = "Prop. técnica" if coerce_bool(row.get("requiere_propuesta_tecnica", False), default=False) else "Sin prop. técnica"
+ return f"Renglón {renglon} | {codigo} | {prop} | {term}"
+
+ selected_row_idx = None
+ if not df_render.empty:
+ render_table_toolbar(
+ "Detalle del renglón",
+ "Elige el renglón a revisar. La tabla superior queda como vista general.",
+ ["Checklist", "Evidencia", "Proveedores"],
+ )
+ row_options = list(df_render.index)
+ selected_row_idx = st.selectbox(
+ "Ver detalle del renglón",
+ row_options,
+ format_func=row_detail_label,
+ key="matrix_detail_row_idx",
+ label_visibility="collapsed",
+ )
+
+ if selected_row_idx is not None:
+ fila = df_render.loc[selected_row_idx]
+ lic_hist = fila.get("licitacion_hist", "")
+ anio_hist = fila.get("anio_hist", "")
+ precio_comp = fila.get("precio_comp_hist", None)
+ precio_proy = fila.get("precio_proy_hist", None)
+ hist_source = "Sin referencia histórica en Supabase"
+ if pd.notna(precio_comp) or pd.notna(precio_proy):
+ try:
+ anio_hist_txt = str(int(float(anio_hist)))
+ except Exception:
+ anio_hist_txt = "Año N/A"
+ hist_source = f"Histórico Supabase: licitación {lic_hist or 'N/A'} ({anio_hist_txt})"
+
+ requiere_prop = coerce_bool(fila.get("requiere_propuesta_tecnica", False), default=False)
+ requiere_ficha = coerce_bool(fila.get("requiere_ficha_tecnica", False), default=False)
+ marca_modelo = fila.get("marca_modelo_requerido", None)
+ acepta_equiv = coerce_optional_bool(fila.get("acepta_equivalente", None))
+ posible_obsol = coerce_bool(fila.get("posible_obsolescencia", False), default=False)
+ evidencia_item = fila.get("evidencia_tecnica", "")
+ row_flags = []
+ if requiere_prop:
+ row_flags.append("Requiere propuesta técnica")
+ if requiere_ficha:
+ row_flags.append("Requiere ficha/catálogo adjunto")
+ if is_meaningful_text(marca_modelo):
+ row_flags.append(f"Marca/modelo: {marca_modelo}")
+ if acepta_equiv is False:
+ row_flags.append("No acepta equivalente")
+ elif acepta_equiv is True:
+ row_flags.append("Acepta equivalente")
+ if posible_obsol:
+ row_flags.append("Posible obsolescencia/actualización")
+ row_flags_text = " | ".join(row_flags) if row_flags else "Sin alertas técnicas por renglón"
+
+ texto_ficha = strip_html_markup(fila.get('ficha_tecnica_completa', 'Sin descripción')) or "Sin descripción"
+ texto_ficha_html = escape(texto_ficha).replace("\n", "
")
+ status_checklist = build_checklist_html([
+ {
+ "label": "Cantidad solicitada",
+ "value": str(fila.get('cantidad', 'N/A')),
+ "state": "neutral",
+ },
+ {
+ "label": "Propuesta técnica",
+ "value": "Requerida" if requiere_prop else "No requerida en este renglón",
+ "state": "ok" if requiere_prop else "neutral",
+ },
+ {
+ "label": "Ficha/catálogo adjunto",
+ "value": "Requerido" if requiere_ficha else "No pedido aparte",
+ "state": "warn" if requiere_ficha else "neutral",
+ },
+ {
+ "label": "Marca / proveedor",
+ "value": str(marca_modelo) if is_meaningful_text(marca_modelo) else "No especificado",
+ "state": "warn" if is_meaningful_text(marca_modelo) else "neutral",
+ },
+ {
+ "label": "Equivalentes",
+ "value": bool_label(acepta_equiv),
+ "state": "ok" if acepta_equiv is True else ("warn" if acepta_equiv is False else "neutral"),
+ },
+ {
+ "label": "Obsolescencia",
+ "value": "Revisar actualización de parte" if posible_obsol else "Sin alerta detectada",
+ "state": "warn" if posible_obsol else "neutral",
+ },
+ ])
+ spec_checklist = spec_text_to_checklist_html(texto_ficha)
+ provider_query = provider_query_from_row(fila)
+
+ st.markdown(f"""
+
+
+
+
Renglón seleccionado
+
Renglón {escape(str(fila.get('renglon', '-')))} | {escape(str(fila.get('codigo_articulo', 'N/A')))}
+
{escape(hist_source)}
+
+
+
Checklist del renglón
+ {status_checklist}
+
{escape(row_flags_text)}
+
Especificaciones detectadas
+
{spec_checklist}
+
Texto técnico completo del renglón
+
{texto_ficha_html}
+
+ Fichas técnicas: pendiente para la próxima fase, conectada a búsqueda de datasheets, validación técnica y generación controlada.
+
+
@@ -1564,7 +4301,7 @@ Use professional business English/Spanish. Format tables using plain text dashes
with st.spinner("🎓 El Asesor Senior está analizando tu situación..."):
try:
import google.generativeai as genai
- genai.configure(api_key=st.session_state.gemini_key)
+ genai.configure(api_key=st.session_state.gemini_key, transport="rest")
modelo_neg = genai.GenerativeModel('gemini-2.5-flash')
cg_ctx = st.session_state.get('cg', {})
@@ -1651,7 +4388,7 @@ Responde con el siguiente formato estructurado en Markdown:
# ──────────────────────────────────────────────
# 💬 PROCURA COPILOT
# ──────────────────────────────────────────────
- with tab_cop:
+ if ai_view == "💬 Procura Copilot":
st.markdown("""
Hazle preguntas en lenguaje natural al Copilot sobre la licitación activa, los renglones
@@ -1690,7 +4427,7 @@ Responde con el siguiente formato estructurado en Markdown:
with st.spinner("Analizando..."):
try:
import google.generativeai as genai
- genai.configure(api_key=st.session_state.gemini_key)
+ genai.configure(api_key=st.session_state.gemini_key, transport="rest")
modelo_cop = genai.GenerativeModel('gemini-2.5-flash')
# Construir contexto de la licitación activa
@@ -1740,16 +4477,70 @@ Responde de forma clara y profesional. Si puedes dar un número o dato exacto de
- with t4:
- st.markdown("### 📈 Visualización de Costos")
- if 'precio_comp_hist' in df_render.columns and not df_render['precio_comp_hist'].isna().all():
- fig = go.Figure()
- fig.add_trace(go.Bar(x=df_render['renglon'], y=df_render['precio_comp_hist'], name='Competencia', marker_color='#30363D'))
- fig.add_trace(go.Bar(x=df_render['renglon'], y=df_render['precio_proy_hist'], name='Proyelec', marker_color='#58A6FF'))
- fig.update_layout(template="plotly_dark", title="Análisis de Competitividad Histórica", barmode='group', plot_bgcolor='rgba(0,0,0,0)', paper_bgcolor='rgba(0,0,0,0)')
- st.plotly_chart(fig, use_container_width=True)
- else:
- st.info("📊 **Sin Historial de Costos**\n\nNo se encontraron registros de precios anteriores para los códigos de esta licitación en la base de datos histórica. Los artículos parecen ser nuevos o no han sido cotizados previamente.")
+ if result_view == "📈 4. Análisis de Costos":
+ st.markdown("### 📈 Visualización de Costos")
+ if 'precio_comp_hist' in df_render.columns and not df_render['precio_comp_hist'].isna().all():
+ df_cost = df_render.copy()
+ for col in ["cantidad", "precio_comp_hist", "precio_proy_hist", "margen_$"]:
+ if col in df_cost.columns:
+ df_cost[col] = pd.to_numeric(df_cost[col], errors="coerce")
+ df_cost["valor_comp_hist"] = df_cost["cantidad"].fillna(0) * df_cost["precio_comp_hist"].fillna(0)
+ df_cost["valor_proy_hist"] = df_cost["cantidad"].fillna(0) * df_cost["precio_proy_hist"].fillna(0)
+ df_cost["diferencia_total_hist"] = df_cost["valor_proy_hist"] - df_cost["valor_comp_hist"]
+
+ total_comp_hist = float(df_cost["valor_comp_hist"].sum())
+ total_proy_hist = float(df_cost["valor_proy_hist"].sum())
+ total_diff_hist = float(df_cost["diferencia_total_hist"].sum())
+ matched_hist = int(df_cost["precio_comp_hist"].notna().sum())
+ total_rows = len(df_cost)
+
+ ck1, ck2, ck3, ck4 = st.columns(4)
+ ck1.metric("Cobertura histórica", f"{matched_hist}/{total_rows}")
+ ck2.metric("Base competencia", f"$ {total_comp_hist:,.2f}")
+ ck3.metric("Base Proyelec", f"$ {total_proy_hist:,.2f}")
+ ck4.metric("Diferencia hist.", f"$ {total_diff_hist:,.2f}")
+
+ fig = go.Figure()
+ fig.add_trace(go.Bar(x=df_cost['renglon'], y=df_cost['precio_comp_hist'], name='Competencia', marker_color='#30363D'))
+ fig.add_trace(go.Bar(x=df_cost['renglon'], y=df_cost['precio_proy_hist'], name='Proyelec', marker_color='#58A6FF'))
+ fig.update_layout(template="plotly_dark", title="Análisis de Competitividad Histórica", barmode='group', plot_bgcolor='rgba(0,0,0,0)', paper_bgcolor='rgba(0,0,0,0)')
+ st.plotly_chart(fig, use_container_width=True)
+
+ cost_cols = [
+ "renglon", "codigo_articulo", "cantidad", "licitacion_hist", "anio_hist",
+ "precio_comp_hist", "precio_proy_hist", "margen_$",
+ "valor_comp_hist", "valor_proy_hist", "diferencia_total_hist",
+ ]
+ cost_cols = [c for c in cost_cols if c in df_cost.columns]
+ st.caption("Trazabilidad del precio histórico usado para cada renglón")
+ st.dataframe(
+ df_cost[cost_cols],
+ use_container_width=True,
+ hide_index=True,
+ column_config={
+ "renglon": st.column_config.TextColumn("Renglón", width="small"),
+ "codigo_articulo": st.column_config.TextColumn("Código ACP"),
+ "licitacion_hist": st.column_config.TextColumn("Lic. Hist.", width="small"),
+ "anio_hist": st.column_config.NumberColumn("Año Hist.", format="%d", width="small"),
+ "precio_comp_hist": st.column_config.NumberColumn("Precio Comp.", format="$ %.2f"),
+ "precio_proy_hist": st.column_config.NumberColumn("Precio Proyelec", format="$ %.2f"),
+ "margen_$": st.column_config.NumberColumn("Margen Unit.", format="$ %.2f"),
+ "valor_comp_hist": st.column_config.NumberColumn("Valor Comp.", format="$ %.2f"),
+ "valor_proy_hist": st.column_config.NumberColumn("Valor Proyelec", format="$ %.2f"),
+ "diferencia_total_hist": st.column_config.NumberColumn("Dif. Total", format="$ %.2f"),
+ },
+ )
+
+ if "anio_hist" in df_cost.columns and df_cost["anio_hist"].notna().any():
+ df_year = df_cost.dropna(subset=["anio_hist"]).copy()
+ df_year["anio_hist"] = pd.to_numeric(df_year["anio_hist"], errors="coerce")
+ df_year = df_year.dropna(subset=["anio_hist"])
+ if not df_year.empty:
+ year_counts = df_year.groupby("anio_hist").size().reset_index(name="renglones")
+ st.caption("Origen de referencias por año histórico")
+ st.bar_chart(year_counts.set_index("anio_hist")["renglones"])
+ else:
+ st.info("📊 **Sin Historial de Costos**\n\nNo se encontraron registros de precios anteriores para los códigos de esta licitación en la base de datos histórica. Los artículos parecen ser nuevos o no han sido cotizados previamente.")
st.markdown("#### Volumen Solicitado por Renglón")
fig = go.Figure(data=[go.Bar(x=df_render['renglon'], y=df_render['cantidad'], marker_color='#238636')])