Comportate como un gestor de servicios de datos en exploracion y produccion de

hidrocarburos y Usando el método ROCE (Rol, Objetivo, Contexto y

Estilo), escriba un prompt para Gemini para que le
genere un primer script en Python para esta clase.

Como gestor de servicios de datos en el área de Exploración y

Producción (E&P), entiendo que la integridad y la disponibilidad de la
información técnica (pozos, sísmica, producción) son el activo más
valioso de la organización. Un script inicial en Python debe enfocarse en
la robustez y la trazabilidad del dato.

Aquí tienes una propuesta de prompt estructurada bajo el método ROCE

para que obtengas un código profesional, escalable y alineado con los
estándares de la industria petrolera.

Estructura del Prompt (Método ROCE)

1. Rol

"Actúa como un Ingeniero de Datos Senior especializado en

Upstream (E&P), con amplia experiencia en la automatización de flujos
de trabajo para activos petroleros y gestión de bases de datos técnicas."

2. Objetivo

"Generar un script inicial en Python que permita cargar, limpiar y

realizar un análisis de calidad de datos (Data Quality Assessment) de un
archivo CSV que contiene registros históricos de producción diaria de
pozos (Well Production Data)."

3. Contexto

"El archivo contiene columnas críticas como: UWI (Identificador Único de

Pozo), Fecha, BOPD (Barriles de Petróleo por Día), BWPD (Agua) y
Presión_Cabezal. El script debe:

 Identificar y manejar valores nulos o negativos en variables físicas

imposibles.

 Asegurar que el formato de fecha sea estándar ISO-8601.

 Calcular el acumulado mensual por pozo.

 Generar un reporte básico de 'Salud del Dato' (porcentaje de

completitud por columna)."
4. Estilo

"El código debe ser modular (usando funciones), estar documentado

siguiendo las normas PEP 8, e incluir el uso de la librería pandas para el
manejo de datos y logging para el registro de errores, evitando
impresiones simples con print. El tono de los comentarios debe ser
técnico y profesional."

Cómo usar este prompt

Simplemente copia y pega el bloque anterior en un nuevo chat de

Gemini. Esto obligará al modelo a no darte un script genérico, sino uno
que incluya validaciones lógicas de ingeniería (como que la producción
no puede ser negativa) y estructuras de datos propias de nuestra
industria.

Ejemplo de lo que deberías recibir:

Un script bien estructurado incluirá validaciones como esta:

Python

import pandas as pd

import logging

def validar_fisica_datos(df):

"""

Valida que las variables de producción no tengan valores

físicamente imposibles (negativos).

"""

variables_criticas = ['BOPD', 'BWPD', 'Presión_Cabezal']

for var in variables_criticas:

conteo_errores = (df[var] < 0).sum()

if conteo_errores > 0:

[Link](f"Se detectaron {conteo_errores} valores

negativos en {var}.")
 return df

Este enfoque garantiza que, desde el primer script, la Gobernanza de

Datos esté integrada en el desarrollo.

1. Rol

"Actúa como un Ingeniero de Datos Senior especializado en Upstream

(E&P), con amplia experiencia en la automatización de flujos de trabajo
para activos petroleros y gestión de bases de datos técnicas."

2. Objetivo

"Generar un script inicial en Python que permita cargar, limpiar y realizar

un análisis de calidad de datos (Data Quality Assessment) de un archivo
CSV que contiene registros históricos de producción diaria de pozos (Well
Production Data)."

3. Contexto

"El archivo contiene columnas críticas como: UWI (Identificador Único de

Pozo), Fecha, BOPD (Barriles de Petróleo por Día), BWPD (Agua) y
Presión_Cabezal. El script debe:

Identificar y manejar valores nulos o negativos en variables físicas

imposibles.

Asegurar que el formato de fecha sea estándar ISO-8601.

Calcular el acumulado mensual por pozo.

Generar un reporte básico de 'Salud del Dato' (porcentaje de

completitud por columna)."

4. Estilo

"El código debe ser modular (usando funciones), estar documentado

siguiendo las normas PEP 8, e incluir el uso de la librería pandas para el
manejo de datos y logging para el registro de errores, evitando
impresiones simples con print. El tono de los comentarios debe ser
técnico y profesional."

Como Ingeniero de Datos Senior para Upstream, he diseñado este script

bajo un enfoque de Gobierno de Datos, asegurando que la limpieza de
los registros de producción sea auditable y robusta.

El código utiliza pandas para el procesamiento eficiente y logging para

capturar cualquier anomalía física (como presiones o caudales
negativos) que deba ser reportada al equipo de ingeniería de
yacimientos.

Python

import pandas as pd

import logging

import numpy as np

# Configuración del sistema de logging para trazabilidad técnica

[Link](

level=[Link],

format='%(asctime)s - %(levelname)s - [E&P Data Management] - %

(message)s'

)
def cargar_datos_produccion(ruta_archivo):

"""

Carga el archivo CSV y realiza la conversión inicial de tipos de datos.

"""

try:

df = pd.read_csv(ruta_archivo)

[Link](f"Archivo cargado exitosamente: {ruta_archivo}")

return df

except Exception as e:

[Link](f"Error crítico en la carga del archivo: {e}")

return None

def limpiar_y_validar_fisica(df):

"""

Aplica reglas de negocio de E&P para validar la integridad física de los

datos.

"""

# 1. Estandarización de Fechas (ISO-8601)

df['Fecha'] = pd.to_datetime(df['Fecha'], errors='coerce')

# 2. Manejo de valores nulos en columnas críticas

columnas_criticas = ['UWI', 'BOPD', 'BWPD', 'Presión_Cabezal']

# Reporte de completitud antes de la limpieza

for col in columnas_criticas:

completitud = (df[col].notnull().mean()) * 100

[Link](f"Salud del Dato - {col}: {completitud:.2f}% de

completitud.")
 # 3. Validación física: Los caudales y presiones no pueden ser
negativos

variables_numericas = ['BOPD', 'BWPD', 'Presión_Cabezal']

for var in variables_numericas:

invalidos = (df[var] < 0).sum()

if invalidos > 0:

[Link](f"Se detectaron {invalidos} registros con valores

negativos en {var}. Ajustando a NaN.")

[Link][df[var] < 0, var] = [Link]

# Eliminar filas sin UWI o Fecha (datos huérfanos)

df = [Link](subset=['UWI', 'Fecha'])

return df

def calcular_acumulados_mensuales(df):

"""

Realiza la agregación de producción por mes y pozo (UWI).

"""

# Extraer mes y año para la agrupación

df['Mes_Año'] = df['Fecha'].dt.to_period('M')

acumulados = [Link](['UWI', 'Mes_Año']).agg({

'BOPD': 'sum',

'BWPD': 'sum',

'Presión_Cabezal': 'mean' # Promedio de presión en el periodo

}).reset_index()
 [Link](columns={

'BOPD': 'Barriles_Mes',

'BWPD': 'Agua_Mes',

'Presión_Cabezal': 'Presión_Avg_Mes'

}, inplace=True)

[Link]("Cálculo de acumulados mensuales finalizado.")

return acumulados

def principal():

"""

Flujo de trabajo principal de automatización de datos.

"""

archivo_entrada = "datos_produccion_diaria.csv" # Reemplazar con la

ruta real

# Ejecución del pipeline

df_raw = cargar_datos_produccion(archivo_entrada)

if df_raw is not None:

df_limpio = limpiar_y_validar_fisica(df_raw)

df_reporte = calcular_acumulados_mensuales(df_limpio)

# Exportación del análisis de calidad y resultados

[Link]("Proceso completado. Listo para ingesta en Base de

Datos Técnica.")
 # print(df_reporte.head()) # Solo para verificación rápida en
consola

if __name__ == "__main__":

principal()

Aspectos Técnicos Destacados:

 Validación de Ingeniería: El script no solo busca errores de

código, sino errores de campo (como valores de BOPD negativos),
transformándolos en NaN para no sesgar los cálculos de
acumulados.

 Gestión de Salud del Dato: Antes de cualquier cálculo, el

sistema reporta automáticamente el porcentaje de completitud, lo
cual es fundamental para los KPIs de un gestor de datos.

 Escalabilidad: El uso de funciones modulares permite integrar

este script fácilmente en un orquestador como Airflow o Prefect.

Usando el método ROCE (Rol, Objetivo, Contexto y

Estilo), escriba un prompt que le

genere un primer script en Python

Para que este segundo prompt sea efectivo, vamos a elevar el nivel
técnico. Como gestor de datos en E&P, no solo necesitas "limpiar datos",
necesitas asegurar que el script sea el primer paso hacia una
Arquitectura de Datos sólida.

Aquí tienes la propuesta estructurada para obtener un script de nivel

profesional:

Estructura del Prompt (Método ROCE)

1. Rol

"Actúa como un Arquitecto de Datos especializado en el sector Oil

& Gas, experto en Python, con un enfoque estricto en Gobierno de
Datos y optimización de flujos de trabajo para activos de Exploración y
Producción."
2. Objetivo

"Generar un script robusto en Python para procesar un archivo fuente de

registros de pozos (Well Logs) o producción diaria, que realice una
validación técnica profunda, limpie inconsistencias físicas y prepare los
datos para una base de datos centralizada."

3. Contexto

"El dataset es un CSV con columnas como UWI (Unique Well Identifier),
Fecha, BOPD (Barriles de petróleo), BWPD (Barriles de agua) y
Presión_Cabezal.

El script debe cumplir con:

 Validación de Rangos: Marcar como erróneos valores de

producción negativos o presiones que excedan los límites técnicos
(ej. > 10,000 psi).

 Manejo de Outliers: Implementar un método básico (como

Desviación Estándar o Rango Intercuartílico) para identificar
registros sospechosos.

 Estandarización: Convertir todas las fechas a formato YYYY-MM-

DD.

 Enriquecimiento: Calcular el Corte de Agua (Water Cut)

diario: $WC = \frac{BWPD}{BOPD + BWPD}$.

 Trazabilidad: Crear un log que indique cuántas filas fueron

corregidas o eliminadas."

4. Estilo

"Escribe el código siguiendo el paradigma de Programación Orientada

a Objetos (OOP) para asegurar la reusabilidad. Utiliza pandas para el
procesamiento, numpy para cálculos vectorizados y la librería logging.
Incluye comentarios técnicos detallados en español (estilo docstrings) y
asegúrate de que el código sea limpio (PEP 8)."

¿Por qué este prompt es superior?

Al usar este prompt en Gemini, obtendrás un resultado que va más allá

de un simple tutorial:
 1. Enfoque en Calidad (QA/QC): Al mencionar "límites técnicos" y
"outliers", obligas a la IA a pensar como un ingeniero de petróleo,
no solo como un programador.

2. Cálculos de Ingeniería: La inclusión de fórmulas específicas

como el Water Cut ($WC$) hace que el script sea inmediatamente
útil para el análisis de yacimientos.

3. Modularidad (OOP): Al pedir Programación Orientada a Objetos,

el script que recibirás será una "clase" (ej. WellDataProcessor) que
podrás importar en otros proyectos futuros, lo cual es la base de
un buen gestor de servicios de datos.

¿Te gustaría que ajustemos algún parámetro específico de la

arquitectura, como la conexión a una base de datos SQL o el manejo de
archivos LAS (Well Logs)?

. Rol

"Actúa como un Arquitecto de Datos especializado en el sector Oil &

Gas, experto en Python, con un enfoque estricto en Gobierno de Datos y
optimización de flujos de trabajo para activos de Exploración y
Producción."

2. Objetivo

"Generar un script robusto en Python para procesar un archivo fuente de

registros de pozos (Well Logs) o producción diaria, que realice una
validación técnica profunda, limpie inconsistencias físicas y prepare los
datos para una base de datos centralizada."

3. Contexto

"El dataset es un CSV con columnas como UWI (Unique Well Identifier),
Fecha, BOPD (Barriles de petróleo), BWPD (Barriles de agua) y
Presión_Cabezal.

El script debe cumplir con:

Validación de Rangos: Marcar como erróneos valores de producción

negativos o presiones que excedan los límites técnicos (ej. > 10,000
psi).

Manejo de Outliers: Implementar un método básico (como Desviación

Estándar o Rango Intercuartílico) para identificar registros sospechosos.

Estandarización: Convertir todas las fechas a formato YYYY-MM-DD.

Enriquecimiento: Calcular el Corte de Agua (Water Cut) diario: $WC = \
frac{BWPD}{BOPD + BWPD}$.

Trazabilidad: Crear un log que indique cuántas filas fueron corregidas o

eliminadas."

4. Estilo

"Escribe el código siguiendo el paradigma de Programación Orientada a

Objetos (OOP) para asegurar la reusabilidad. Utiliza pandas para el
procesamiento, numpy para cálculos vectorizados y la librería logging.
Incluye comentarios técnicos detallados en español (estilo docstrings) y
asegúrate de que el código sea limpio (PEP 8)."

Como Arquitecto de Datos para Upstream, he estructurado esta solución bajo el paradigma
de Programación Orientada a Objetos (OOP). Esta arquitectura no solo procesa datos,
sino que encapsula las reglas de negocio de E&P (Exploración y Producción) en una clase
reutilizable, permitiendo que el proceso de QA/QC sea auditable y escalable hacia una base
de datos centralizada.

A continuación, presento el desarrollo del script siguiendo tus requerimientos técnicos:

Python
import pandas as pd
import numpy as np
import logging
from datetime import datetime

# Configuración del Logger para Trazabilidad de Gobierno de Datos

[Link](
level=[Link],
format='%(asctime)s - %(levelname)s - [E&P-ARCHITECT] - %(message)s'
)

class ProcesadorProduccionEP:
"""
Clase diseñada para el procesamiento, limpieza y enriquecimiento de
datos de producción de hidrocarburos bajo estándares de Gobierno de
Datos.
"""

def __init__(self, ruta_csv, limite_presion=10000):

"""
Inicializa el procesador con la ruta del archivo y parámetros
técnicos.

:param ruta_csv: str, ruta al archivo fuente.

:param limite_presion: float, límite máximo de presión de cabezal
permitido.
"""
self.ruta_csv = ruta_csv
 self.limite_presion = limite_presion
[Link] = None
self.log_metricas = {"filas_iniciales": 0, "outliers_detectados":
0, "nulos_eliminados": 0}

def cargar_datos(self):
"""Carga el dataset y registra el volumen inicial de datos."""
try:
[Link] = pd.read_csv(self.ruta_csv)
self.log_metricas["filas_iniciales"] = len([Link])
[Link](f"Carga exitosa. Registros iniciales:
{self.log_metricas['filas_iniciales']}")
except Exception as e:
[Link](f"Falla en la carga de datos: {e}")

def estandarizar_y_limpiar(self):
"""Realiza la limpieza física y estandarización de formatos."""
# Estandarización de Fechas (ISO-8601)
[Link]['Fecha'] = pd.to_datetime([Link]['Fecha'],
errors='coerce')

# Eliminación de registros críticos nulos (UWI o Fecha)

antes = len([Link])
[Link](subset=['UWI', 'Fecha'], inplace=True)
self.log_metricas["nulos_eliminados"] = antes - len([Link])

# Validación de Rangos Físicos

# 1. Producción no puede ser negativa
# 2. Presión de cabezal no debe exceder el límite técnico
condicion_fisica = (
([Link]['BOPD'] >= 0) &
([Link]['BWPD'] >= 0) &
([Link]['Presión_Cabezal'] <= self.limite_presion)
)

filas_invalidas = len([Link]) - condicion_fisica.sum()

if filas_invalidas > 0:
[Link](f"Detectadas {filas_invalidas} filas con
valores fuera de rango técnico. Filtrando...")
[Link] = [Link][condicion_fisica]

def detectar_outliers(self, columna='BOPD', umbral_z=3):

"""
Identifica registros sospechosos utilizando el método de Z-Score.

:param columna: str, columna a analizar (default BOPD).

:param umbral_z: int, desviaciones estándar para considerar un
dato como outlier.
"""
media = [Link][columna].mean()
desviacion = [Link][columna].std()

z_scores = ([Link][columna] - media) / desviacion

outliers = [Link][[Link](z_scores) > umbral_z]

self.log_metricas["outliers_detectados"] = len(outliers)
 [Link](f"Análisis de Calidad: {len(outliers)} outliers
detectados en {columna} (Z-Score > {umbral_z}).")

# En una arquitectura de producción, estos se suelen marcar, no

eliminar
[Link]['Flag_Outlier'] = [Link]([Link](z_scores) > umbral_z,
True, False)

def enriquecer_datos(self):
"""Calcula el Water Cut (WC) y otras métricas derivadas."""
# Evitar división por cero usando [Link]
total_fluidos = [Link]['BOPD'] + [Link]['BWPD']
[Link]['Water_Cut'] = [Link](
total_fluidos > 0,
([Link]['BWPD'] / total_fluidos),
0.0
)
[Link]("Enriquecimiento de datos completado (Cálculo de
Water Cut).")

def ejecutar_pipeline(self):
"""Orquestador del flujo de trabajo."""
self.cargar_datos()
if [Link] is not None:
self.estandarizar_y_limpiar()
self.detectar_outliers()
self.enriquecer_datos()

[Link]("=== RESUMEN DE TRAZABILIDAD ===")

[Link](f"Registros procesados con éxito:
{len([Link])}")
[Link](f"Registros eliminados (Nulos/Rango):
{self.log_metricas['nulos_eliminados']}")
return [Link]

# --- Punto de Entrada ---

if __name__ == "__main__":
# Simulación de uso en entorno local
procesador = ProcesadorProduccionEP("produccion_upstream.csv")
dataset_final = procesador.ejecutar_pipeline()

# En un escenario real, aquí se procedería a la carga en SQL/Data

Lake
# dataset_final.to_sql('produccion_diaria', conexion_engine)

Notas de la Arquitectura:

1. Validación Técnica de E&P: He incluido una lógica de filtrado que protege la

integridad de la base de datos al descartar presiones imposibles (ej. > 10,000 psi)
que podrían ser errores de sensor o de transcripción.
2. Cálculo Vectorizado: El cálculo del Water Cut se realiza mediante [Link],
lo cual es significativamente más rápido que usar ciclos for o apply en datasets de
miles de pozos.
3. Trazabilidad (Logs): Cada paso crítico (carga, limpieza, detección de outliers)
genera una entrada en el log. Esto es vital para cumplir con normativas de auditoría
de datos en empresas operadoras.
4. Flags de Calidad: En lugar de simplemente borrar los outliers, el script crea una
columna Flag_Outlier. Esto permite que el Ingeniero de Yacimientos decida
posteriormente si el dato es un error o un comportamiento real del pozo (ej. una
limpieza de pozo o un slug de gas).