diff --git a/output/candidate_E_reward_10.json b/output/candidate_E_reward_10.json deleted file mode 100644 index 98a178b..0000000 --- a/output/candidate_E_reward_10.json +++ /dev/null @@ -1,628 +0,0 @@ -[ - { - "task_id": 1, - "text": "Crea un microservicio AVAP que procese múltiples proveedores de servicios financieros. El servicio debe: 1) Obtener parámetros de consulta desde la URL, 2) Conectar con diferentes proveedores usando avapConnector, 3) Procesar cada proveedor en un bucle usando startLoop, 4) Validar y filtrar resultados usando condicionales, 5) Retornar datos consolidados con código de estado HTTP apropiado.", - "code": "addParam(\"providers\", providers_param)\naddParam(\"user_id\", user_id)\naddParam(\"account_type\", account_type)\nif(providers_param, None, \"==\")\n _status = 400\n addResult(error_msg)\nelse()\n getQueryParamList(\"providers\", provider_list)\n getListLen(provider_list, total_providers)\n variableToList({}, consolidated_data)\n processed_count = 0\n startLoop(i, 0, total_providers)\n itemFromList(provider_list, i, current_provider)\n if(current_provider, \"belvo\", \"==\")\n belvo_connector = avapConnector(\"20908e93260147acb2636967021fbf5d\")\n accounts_data = belvo_connector.list_accounts(user_id, account_type)\n if(None, None, `accounts_data is not None and len(accounts_data) > 0`)\n variableFromJSON(accounts_data, \"balance\", balance)\n variableFromJSON(accounts_data, \"currency\", currency)\n AddVariableToJSON(\"provider\", current_provider, account_info)\n AddVariableToJSON(\"balance\", balance, account_info)\n AddVariableToJSON(\"currency\", currency, account_info)\n consolidated_data.append(account_info)\n processed_count = processed_count + 1\n end()\n else()\n if(current_provider, \"plaid\", \"==\")\n plaid_connector = avapConnector(\"8f4e2a1b5c6d7e8f9a0b1c2d3e4f5a6b\")\n balances_result = plaid_connector.get_balances(user_id)\n if(None, None, `balances_result is not None`)\n variableFromJSON(balances_result, \"available\", available_balance)\n if(available_balance, 0, \">\")\n AddVariableToJSON(\"provider\", current_provider, plaid_info)\n AddVariableToJSON(\"balance\", available_balance, plaid_info)\n AddVariableToJSON(\"currency\", \"USD\", plaid_info)\n consolidated_data.append(plaid_info)\n processed_count = processed_count + 1\n end()\n end()\n end()\n end()\n endLoop()\n if(processed_count, 0, \">\")\n _status = 200\n AddVariableToJSON(\"total_providers_processed\", processed_count, response_data)\n AddVariableToJSON(\"accounts\", consolidated_data, response_data)\n addResult(response_data)\n else()\n _status = 404\n AddVariableToJSON(\"error\", \"No valid account data found\", error_response)\n addResult(error_response)\n end()\nend()", - "test_inputs": { - "providers": "belvo,plaid", - "user_id": "12345", - "account_type": "checking" - }, - "test_list": [ - "re.match(r'200|404', str(_status))", - "re.match(r'\\d+', str(processed_count))", - "re.match(r'.*accounts.*', str(response_data))" - ], - "_cell": [ - "avapConnector", - "startLoop" - ], - "_quality": { - "fidelity": 1.0, - "bonus_ratio": 0.333, - "test_quality": 1.0, - "richness": 1.0, - "quality": 1.4, - "detected": [ - "AddVariableToJSON", - "_status", - "addParam", - "addResult", - "avapConnector", - "else", - "end", - "endLoop", - "getListLen", - "getQueryParamList", - "if_mode2", - "itemFromList", - "startLoop", - "variableFromJSON" - ], - "cell": [ - "avapConnector", - "startLoop" - ], - "extra": [ - "AddVariableToJSON", - "_status", - "addParam", - "addResult", - "else", - "end", - "endLoop", - "getListLen", - "getQueryParamList", - "if_mode2", - "itemFromList", - "variableFromJSON" - ] - } - }, - { - "task_id": 2, - "text": "Implementa un microservicio AVAP que actualice múltiples registros de usuario de forma asíncrona. El servicio debe: 1) Obtener una lista de IDs de usuario desde parámetros de consulta, 2) Procesar cada actualización en paralelo usando goroutines, 3) Esperar a que todas las actualizaciones concurrentes terminen, 4) Retornar un resumen con el número total de registros actualizados y el estado de la operación.", - "code": "addParam(\"operation_type\", op_type)\ngetQueryParamList(\"user_ids\", user_list)\ngetListLen(user_list, total_users)\nif(total_users, 0, \"==\")\n_status = 400\naddVar(error_msg, \"No user IDs provided\")\naddResult(error_msg)\nelse()\naddVar(updated_count, 0)\naddVar(concurrent_tasks, [])\naddVar(counter, 0)\nstartLoop(counter, 0, total_users)\nitemFromList(user_list, counter, current_user_id)\ntask_id = go updateUserRecord(current_user_id)\nvariableToList(task_id, temp_list)\nif(counter, 0, \"==\")\naddVar(concurrent_tasks, temp_list)\nelse()\ngetListLen(concurrent_tasks, current_len)\nitemFromList(temp_list, 0, new_task)\nAddVariableToJSON(current_len, new_task, task_dict)\nvariableFromJSON(task_dict, current_len, retrieved_task)\nvariableToList(retrieved_task, single_task)\naddVar(concurrent_tasks, single_task)\nend()\nendLoop()\ngetListLen(concurrent_tasks, task_count)\naddVar(results_collected, 0)\nstartLoop(results_collected, 0, task_count)\nitemFromList(concurrent_tasks, results_collected, current_task)\nupdate_result = gather(current_task, 5000)\nif(update_result, \"success\", \"==\")\naddVar(updated_count, updated_count + 1)\nend()\nendLoop()\naddVar(success_rate, updated_count / total_users * 100)\nif(success_rate, 80.0, \">=\")\n_status = 200\naddVar(status_msg, \"Bulk update completed successfully\")\nelse()\n_status = 206\naddVar(status_msg, \"Partial update completed with some failures\")\nend()\naddResult(updated_count)\naddResult(total_users)\naddResult(success_rate)\naddResult(status_msg)\nend()\n\nfunction updateUserRecord(user_id)\n{\naddVar(table_name, \"users\")\naddVar(update_fields, [\"last_updated\", \"status\"])\ngetDateTime(\"%Y-%m-%d %H:%M:%S\", 0, \"UTC\", current_time)\naddVar(field_values, [current_time, \"active\"])\naddVar(selector, \"id = \" + user_id)\normAccessUpdate(update_fields, field_values, table_name, selector, update_status)\nif(update_status, \"error\", \"!=\")\nreturn(\"success\")\nelse()\nreturn(\"failed\")\nend()\n}", - "test_inputs": { - "user_ids": [ - "123", - "456", - "789" - ] - }, - "test_list": [ - "re.match(r'\\d+', str(updated_count))", - "re.match(r'(200|206|400)', str(_status))", - "re.match(r'\\d+\\.\\d+', str(success_rate))" - ], - "_cell": [ - "gather", - "getQueryParamList", - "ormAccessUpdate" - ], - "_quality": { - "fidelity": 1.0, - "bonus_ratio": 0.457, - "test_quality": 1.0, - "richness": 1.0, - "quality": 1.437, - "detected": [ - "AddVariableToJSON", - "_status", - "addParam", - "addResult", - "addVar", - "else", - "end", - "endLoop", - "function", - "gather", - "getDateTime", - "getListLen", - "getQueryParamList", - "if_mode1", - "itemFromList", - "ormAccessUpdate", - "return", - "startLoop", - "variableFromJSON" - ], - "cell": [ - "gather", - "getQueryParamList", - "ormAccessUpdate" - ], - "extra": [ - "AddVariableToJSON", - "_status", - "addParam", - "addResult", - "addVar", - "else", - "end", - "endLoop", - "function", - "getDateTime", - "getListLen", - "if_mode1", - "itemFromList", - "return", - "startLoop", - "variableFromJSON" - ] - } - }, - { - "task_id": 3, - "text": "Escribe una función AVAP que procese una lista de eventos con timestamps, calcule métricas temporales y envíe un reporte POST a una API externa. La función debe: 1) Recibir una lista de eventos con fechas en formato ISO, 2) Convertir las fechas a timestamps Unix, 3) Calcular la duración total en días, 4) Enviar los resultados via POST a una API de métricas con timeout de 5 segundos, y 5) Retornar el número total de eventos procesados.", - "code": "addParam(\"eventos\", lista_eventos)\naddParam(\"api_url\", url_destino)\naddParam(\"formato_fecha\", formato)\ngetListLen(lista_eventos, total_eventos)\nif(total_eventos, 0, \">\")\n addVar(contador, 0)\n addVar(timestamp_minimo, 9999999999)\n addVar(timestamp_maximo, 0)\n startLoop(i, 0, total_eventos)\n itemFromList(lista_eventos, i, evento_actual)\n variableFromJSON(evento_actual, \"fecha\", fecha_str)\n getTimeStamp(fecha_str, formato, 0, timestamp_unix)\n if(timestamp_unix, timestamp_minimo, \"<\")\n addVar(timestamp_minimo, timestamp_unix)\n end()\n if(timestamp_unix, timestamp_maximo, \">\")\n addVar(timestamp_maximo, timestamp_unix)\n end()\n addVar(contador, contador + 1)\n endLoop()\n duracion_segundos = timestamp_maximo - timestamp_minimo\n duracion_dias = duracion_segundos / 86400\n addVar(payload, {})\n AddVariableToJSON(\"total_eventos\", contador, payload)\n AddVariableToJSON(\"duracion_dias\", duracion_dias, payload)\n AddVariableToJSON(\"timestamp_inicio\", timestamp_minimo, payload)\n AddVariableToJSON(\"timestamp_fin\", timestamp_maximo, payload)\n getDateTime(\"%Y-%m-%d %H:%M:%S\", 0, \"UTC\", fecha_reporte)\n AddVariableToJSON(\"fecha_reporte\", fecha_reporte, payload)\n headers = {\"Content-Type\": \"application/json\", \"User-Agent\": \"AVAP-Metrics/1.0\"}\n RequestPost(url_destino, \"\", headers, payload, respuesta_api, 5000)\n if(None, None, `respuesta_api is not None`)\n variableFromJSON(respuesta_api, \"status\", status_respuesta)\n if(status_respuesta, \"success\", \"==\")\n addVar(_status, 200)\n else()\n addVar(_status, 500)\n end()\n else()\n addVar(_status, 503)\n end()\n addResult(contador)\n addResult(duracion_dias)\nelse()\n addVar(_status, 400)\n addVar(mensaje_error, \"Lista de eventos vacia\")\n addResult(mensaje_error)\nend()", - "test_inputs": { - "eventos": "[{\"fecha\": \"2024-01-15 10:30:00\"}, {\"fecha\": \"2024-01-18 14:45:00\"}]", - "api_url": "https://metrics.api.com/report", - "formato_fecha": "%Y-%m-%d %H:%M:%S" - }, - "test_list": [ - "re.match(r'^[0-9]+$', str(contador))", - "re.match(r'^[0-9]+(\\.[0-9]+)?$', str(duracion_dias))", - "re.match(r'^(200|400|500|503)$', str(_status))" - ], - "_cell": [ - "RequestPost", - "getListLen", - "getTimeStamp" - ], - "_quality": { - "fidelity": 1.0, - "bonus_ratio": 0.371, - "test_quality": 1.0, - "richness": 1.0, - "quality": 1.411, - "detected": [ - "AddVariableToJSON", - "RequestPost", - "_status", - "addParam", - "addResult", - "addVar", - "else", - "end", - "endLoop", - "getDateTime", - "getListLen", - "getTimeStamp", - "if_mode2", - "itemFromList", - "startLoop", - "variableFromJSON" - ], - "cell": [ - "RequestPost", - "getListLen", - "getTimeStamp" - ], - "extra": [ - "AddVariableToJSON", - "_status", - "addParam", - "addResult", - "addVar", - "else", - "end", - "endLoop", - "getDateTime", - "if_mode2", - "itemFromList", - "startLoop", - "variableFromJSON" - ] - } - }, - { - "task_id": 4, - "text": "Crear un endpoint que genere un reporte de actividad con timestamp actual. El endpoint debe validar un parámetro 'nivel_reporte', usar condiciones if/else para categorizar el reporte, aplicar operaciones matemáticas y devolver un JSON con información temporal detallada.", - "code": "registerEndpoint(\"/reporte-actividad\", \"GET\", [], \"application/json\", \"generarReporte\", \"mainHandler\")\nfunction generarReporte() {\n addParam(\"nivel_reporte\", nivel)\n addVar(_status, 200)\n if(nivel, None, \"==\")\n addVar(_status, 400)\n addVar(error_msg, \"Parametro nivel_reporte requerido\")\n addResult(error_msg)\n return()\n else()\n getDateTime(\"%Y-%m-%d %H:%M:%S\", 0, \"UTC\", timestamp_actual)\n addVar(contador_base, 10)\n if(nivel, \"alto\", \"==\")\n addVar(multiplicador, 5)\n addVar(categoria, \"Reporte de Alto Nivel\")\n else()\n if(nivel, \"medio\", \"==\")\n addVar(multiplicador, 3)\n addVar(categoria, \"Reporte de Nivel Medio\")\n else()\n addVar(multiplicador, 1)\n addVar(categoria, \"Reporte Basico\")\n end()\n end()\n actividad_calculada = contador_base * multiplicador\n getTimeStamp(timestamp_actual, \"%Y-%m-%d %H:%M:%S\", 3600, epoch_futuro)\n addVar(resultado_final, {})\n AddVariableToJSON(\"categoria\", categoria, resultado_final)\n AddVariableToJSON(\"timestamp\", timestamp_actual, resultado_final)\n AddVariableToJSON(\"actividad_total\", actividad_calculada, resultado_final)\n AddVariableToJSON(\"epoch_futuro\", epoch_futuro, resultado_final)\n addResult(resultado_final)\n end()\n return()\n}", - "test_inputs": { - "nivel_reporte": "alto" - }, - "test_list": [ - "re.match(r'Reporte de Alto Nivel', resultado_final)", - "re.match(r'\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}', timestamp_actual)", - "re.match(r'50', str(actividad_calculada))" - ], - "_cell": [ - "addVar", - "end", - "getDateTime" - ], - "_quality": { - "fidelity": 1.0, - "bonus_ratio": 0.257, - "test_quality": 1.0, - "richness": 1.0, - "quality": 1.377, - "detected": [ - "AddVariableToJSON", - "_status", - "addParam", - "addResult", - "addVar", - "else", - "end", - "function", - "getDateTime", - "getTimeStamp", - "if_mode1", - "return" - ], - "cell": [ - "addVar", - "end", - "getDateTime" - ], - "extra": [ - "AddVariableToJSON", - "_status", - "addParam", - "addResult", - "else", - "function", - "getTimeStamp", - "if_mode1", - "return" - ] - } - }, - { - "task_id": 5, - "text": "Crear un microservicio que procese múltiples solicitudes de validación de usuarios de forma concurrente. El servicio debe recibir una lista de IDs de usuario, validar cada uno usando una API externa de forma asíncrona, y retornar un reporte consolidado con los resultados. Si alguna validación falla, debe manejarse con bloques de control apropiados.", - "code": "registerEndpoint(\"/validate-users\", \"POST\", [], \"application/json\", mainHandler, None)\nfunction mainHandler()\n{\n addParam(\"user_ids\", user_list)\n if(user_list, None, \"==\")\n _status = 400\n addVar(error_msg, \"Lista de usuarios requerida\")\n addResult(error_msg)\n return()\n end()\n \n getListLen(user_list, total_users)\n addVar(validated_users, [])\n addVar(failed_users, [])\n addVar(validation_tasks, [])\n \n startLoop(i, 0, total_users)\n itemFromList(user_list, i, current_user)\n task_id = go validateUser(current_user)\n variableToList(task_id, temp_task)\n if(validation_tasks, [], \"==\")\n addVar(validation_tasks, temp_task)\n else()\n AddVariableToJSON(\"task\", task_id, task_obj)\n variableToList(task_obj, new_task)\n validation_tasks = validation_tasks + new_task\n end()\n endLoop()\n \n getListLen(validation_tasks, total_tasks)\n startLoop(j, 0, total_tasks)\n itemFromList(validation_tasks, j, task)\n result = gather(task, 5000)\n if(result, None, \"!=\")\n variableFromJSON(result, \"status\", status_code)\n variableFromJSON(result, \"user_id\", validated_id)\n if(status_code, \"valid\", \"==\")\n AddVariableToJSON(\"user_id\", validated_id, valid_user)\n AddVariableToJSON(\"timestamp\", \"2024-01-01 00:00:00\", valid_user)\n variableToList(valid_user, temp_valid)\n validated_users = validated_users + temp_valid\n else()\n AddVariableToJSON(\"user_id\", validated_id, failed_user)\n AddVariableToJSON(\"reason\", \"validation_failed\", failed_user)\n variableToList(failed_user, temp_failed)\n failed_users = failed_users + temp_failed\n end()\n else()\n AddVariableToJSON(\"user_id\", \"unknown\", timeout_user)\n AddVariableToJSON(\"reason\", \"timeout\", timeout_user)\n variableToList(timeout_user, temp_timeout)\n failed_users = failed_users + temp_timeout\n end()\n endLoop()\n \n AddVariableToJSON(\"validated\", validated_users, final_result)\n AddVariableToJSON(\"failed\", failed_users, final_result)\n getListLen(validated_users, valid_count)\n getListLen(failed_users, failed_count)\n AddVariableToJSON(\"summary\", {\"valid\": valid_count, \"failed\": failed_count}, final_result)\n \n _status = 200\n addResult(final_result)\n return()\n}\n\nfunction validateUser(user_id)\n{\n try()\n url = \"https://api.validation.com/users/\" + str(user_id)\n headers = {\"Authorization\": \"Bearer token123\"}\n RequestGet(url, {}, headers, api_response, 3000)\n if(api_response, None, \"!=\")\n variableFromJSON(api_response, \"valid\", is_valid)\n if(is_valid, True, \"==\")\n result = {\"status\": \"valid\", \"user_id\": user_id}\n else()\n result = {\"status\": \"invalid\", \"user_id\": user_id}\n end()\n else()\n result = {\"status\": \"api_error\", \"user_id\": user_id}\n end()\n return(result)\n exception(error)\n error_result = {\"status\": \"exception\", \"user_id\": user_id, \"error\": error}\n return(error_result)\n end()\n}", - "test_inputs": { - "user_ids": [ - "123", - "456", - "789" - ] - }, - "test_list": [ - "re.match(r'.*validated.*', str(final_result))", - "re.match(r'.*failed.*', str(final_result))", - "re.match(r'.*summary.*', str(final_result))" - ], - "_cell": [ - "addResult", - "end", - "gather" - ], - "_quality": { - "fidelity": 1.0, - "bonus_ratio": 0.429, - "test_quality": 1.0, - "richness": 1.0, - "quality": 1.429, - "detected": [ - "AddVariableToJSON", - "RequestGet", - "_status", - "addParam", - "addResult", - "addVar", - "else", - "end", - "endLoop", - "function", - "gather", - "getListLen", - "if_mode1", - "itemFromList", - "return", - "startLoop", - "try", - "variableFromJSON" - ], - "cell": [ - "addResult", - "end", - "gather" - ], - "extra": [ - "AddVariableToJSON", - "RequestGet", - "_status", - "addParam", - "addVar", - "else", - "endLoop", - "function", - "getListLen", - "if_mode1", - "itemFromList", - "return", - "startLoop", - "try", - "variableFromJSON" - ] - } - }, - { - "task_id": 6, - "text": "Crear un endpoint que procese un token JWT simulado (JSON), extraiga su timestamp de expiración, lo convierta a fecha legible, y genere un hash MD5 de la información del usuario para logging de seguridad.", - "code": "registerEndpoint(\"/api/auth/validate\", \"POST\", [], \"\", mainHandler, None)\n\nfunction mainHandler()\n{\n addParam(\"token_data\", raw_token)\n addParam(\"user_context\", context_info)\n \n if(raw_token, None, \"==\")\n _status = 400\n addVar(error_msg, \"Token data required\")\n addResult(error_msg)\n return()\n end()\n \n variableFromJSON(raw_token, \"exp\", token_expiry)\n variableFromJSON(raw_token, \"user_id\", user_id)\n variableFromJSON(raw_token, \"email\", user_email)\n \n if(token_expiry, None, \"==\")\n _status = 422\n addVar(error_msg, \"Invalid token format - missing expiry\")\n addResult(error_msg)\n return()\n end()\n \n stampToDatetime(token_expiry, \"%Y-%m-%d %H:%M:%S\", 0, readable_expiry)\n \n addVar(user_info_raw, \"\")\n replace(user_email, \"@\", \"_at_\", sanitized_email)\n addVar(user_info_raw, user_id)\n addVar(temp_concat, user_info_raw)\n replace(temp_concat, \"\", sanitized_email, user_info_combined)\n \n encodeMD5(user_info_combined, security_hash)\n \n getDateTime(\"%Y-%m-%d %H:%M:%S\", 0, \"UTC\", current_time)\n \n if(None, None, `token_expiry < 1735689600`)\n _status = 401\n addVar(validation_result, \"expired\")\n else()\n _status = 200\n addVar(validation_result, \"valid\")\n end()\n \n addVar(log_entry, \"\")\n AddVariableToJSON(\"timestamp\", current_time, log_entry)\n AddVariableToJSON(\"user_hash\", security_hash, log_entry)\n AddVariableToJSON(\"expiry_readable\", readable_expiry, log_entry)\n AddVariableToJSON(\"status\", validation_result, log_entry)\n AddVariableToJSON(\"context\", context_info, log_entry)\n \n addResult(log_entry)\n addResult(validation_result)\n addResult(readable_expiry)\n return()\n}", - "test_inputs": { - "token_data": "{\"exp\": 1735689600, \"user_id\": \"usr_12345\", \"email\": \"test@example.com\"}", - "user_context": "mobile_app" - }, - "test_list": [ - "re.match(r'\\{.*\"timestamp\".*\"user_hash\".*\"expiry_readable\".*\\}', log_entry)", - "re.match(r'[a-f0-9]{32}', security_hash)", - "re.match(r'\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}', readable_expiry)" - ], - "_cell": [ - "encodeMD5", - "stampToDatetime", - "variableFromJSON" - ], - "_quality": { - "fidelity": 1.0, - "bonus_ratio": 0.343, - "test_quality": 1.0, - "richness": 1.0, - "quality": 1.403, - "detected": [ - "AddVariableToJSON", - "_status", - "addParam", - "addResult", - "addVar", - "else", - "encodeMD5", - "end", - "function", - "getDateTime", - "if_mode2", - "replace", - "return", - "stampToDatetime", - "variableFromJSON" - ], - "cell": [ - "encodeMD5", - "stampToDatetime", - "variableFromJSON" - ], - "extra": [ - "AddVariableToJSON", - "_status", - "addParam", - "addResult", - "addVar", - "else", - "end", - "function", - "getDateTime", - "if_mode2", - "replace", - "return" - ] - } - }, - { - "task_id": 7, - "text": "Crear un endpoint que actualice el estado de un pedido y devuelva el resultado con código HTTP personalizado. El endpoint debe: 1) Capturar el ID del pedido y nuevo estado desde parámetros, 2) Validar que el estado sea válido ('pendiente', 'procesando', 'completado'), 3) Actualizar el registro en la base de datos usando ORM, 4) Establecer código de respuesta HTTP según el resultado, 5) Devolver el pedido actualizado o mensaje de error.", - "code": "addParam(\"pedido_id\", pedido_id)\naddParam(\"nuevo_estado\", nuevo_estado)\nif(pedido_id, None, \"==\")\n_status = 400\naddVar(mensaje, \"ID de pedido requerido\")\naddResult(mensaje)\nelse()\nif(nuevo_estado, None, \"==\")\n_status = 400\naddVar(mensaje, \"Estado requerido\")\naddResult(mensaje)\nelse()\nvariableToList(nuevo_estado, estados_validos)\naddVar(temp_estado, \"pendiente\")\nAddVariableToJSON(\"0\", temp_estado, estados_json)\naddVar(temp_estado, \"procesando\")\nAddVariableToJSON(\"1\", temp_estado, estados_json)\naddVar(temp_estado, \"completado\")\nAddVariableToJSON(\"2\", temp_estado, estados_json)\nif(None, None, `nuevo_estado not in ['pendiente', 'procesando', 'completado']`)\n_status = 422\naddVar(mensaje, \"Estado no válido\")\naddResult(mensaje)\nelse()\ngetDateTime(\"%Y-%m-%d %H:%M:%S\", 0, \"UTC\", fecha_actualizacion)\nvariableToList(\"estado\", campos_update)\nvariableToList(nuevo_estado, valores_update)\nAddVariableToJSON(\"fecha_actualizacion\", fecha_actualizacion, valores_json)\naddVar(selector_where, \"id = \" + pedido_id)\normAccessUpdate(campos_update, valores_update, \"pedidos\", selector_where, resultado_update)\nif(resultado_update, None, \"==\")\n_status = 404\naddVar(mensaje, \"Pedido no encontrado\")\naddResult(mensaje)\nelse()\n_status = 200\normAccessSelect(\"*\", \"pedidos\", selector_where, pedido_actualizado)\naddResult(pedido_actualizado)\nend()\nend()\nend()\nend()", - "test_inputs": { - "pedido_id": "123", - "nuevo_estado": "procesando" - }, - "test_list": [ - "re.match(r'procesando', nuevo_estado)", - "re.match(r'200', str(_status))", - "re.match(r'pedido_actualizado', 'pedido_actualizado')" - ], - "_cell": [ - "_status", - "addResult", - "ormAccessUpdate" - ], - "_quality": { - "fidelity": 1.0, - "bonus_ratio": 0.229, - "test_quality": 1.0, - "richness": 1.0, - "quality": 1.369, - "detected": [ - "AddVariableToJSON", - "_status", - "addParam", - "addResult", - "addVar", - "else", - "end", - "getDateTime", - "if_mode2", - "ormAccessSelect", - "ormAccessUpdate" - ], - "cell": [ - "_status", - "addResult", - "ormAccessUpdate" - ], - "extra": [ - "AddVariableToJSON", - "addParam", - "addVar", - "else", - "end", - "getDateTime", - "if_mode2", - "ormAccessSelect" - ] - } - }, - { - "task_id": 8, - "text": "Crear un endpoint que genere un reporte de logs de eventos del sistema con timestamps, donde cada evento contenga la fecha actual más un offset incremental de días. El sistema debe iterar por una lista de tipos de eventos y crear un JSON con timestamps formateados para cada uno.", - "code": "registerEndpoint(\"/api/system/logs\", \"GET\", [], \"application/json\", generateLogReport, mainHandler)\n\nfunction generateLogReport()\n{\n addParam(\"days_back\", days_param)\n if(days_param, None, \"==\")\n addVar(days_back, 7)\n else()\n days_back = int(days_param)\n end()\n \n event_types = [\"login\", \"logout\", \"error\", \"warning\", \"info\"]\n getListLen(event_types, total_events)\n \n log_entries = {}\n counter = 0\n \n startLoop(i, 0, total_events)\n itemFromList(event_types, i, current_event)\n \n time_offset = counter * 86400\n getDateTime(\"%Y-%m-%d %H:%M:%S\", time_offset, \"UTC\", event_timestamp)\n \n entry_key = current_event + \"_\" + str(counter)\n AddVariableToJSON(\"event_type\", current_event, temp_entry)\n AddVariableToJSON(\"timestamp\", event_timestamp, temp_entry)\n AddVariableToJSON(\"severity\", getSeverityLevel(current_event), temp_entry)\n \n AddVariableToJSON(entry_key, temp_entry, log_entries)\n counter = counter + 1\n endLoop()\n \n AddVariableToJSON(\"total_entries\", total_events, log_entries)\n AddVariableToJSON(\"generated_at\", getCurrentTimestamp(), log_entries)\n \n _status = 200\n addResult(log_entries)\n return(log_entries)\n}\n\nfunction getSeverityLevel(event_type)\n{\n if(event_type, \"error\", \"==\")\n return(\"HIGH\")\n else()\n if(event_type, \"warning\", \"==\")\n return(\"MEDIUM\")\n else()\n return(\"LOW\")\n end()\n end()\n}\n\nfunction getCurrentTimestamp()\n{\n getDateTime(\"%Y-%m-%d %H:%M:%S\", 0, \"UTC\", current_time)\n return(current_time)\n}", - "test_inputs": { - "days_back": "5" - }, - "test_list": [ - "re.match(r'\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}', log_entries)", - "re.match(r'login_\\d+', str(log_entries))", - "re.match(r'\"total_entries\":\\s*5', str(log_entries))" - ], - "_cell": [ - "getDateTime", - "return", - "startLoop" - ], - "_quality": { - "fidelity": 1.0, - "bonus_ratio": 0.343, - "test_quality": 1.0, - "richness": 1.0, - "quality": 1.403, - "detected": [ - "AddVariableToJSON", - "_status", - "addParam", - "addResult", - "addVar", - "else", - "end", - "endLoop", - "function", - "getDateTime", - "getListLen", - "if_mode1", - "itemFromList", - "return", - "startLoop" - ], - "cell": [ - "getDateTime", - "return", - "startLoop" - ], - "extra": [ - "AddVariableToJSON", - "_status", - "addParam", - "addResult", - "addVar", - "else", - "end", - "endLoop", - "function", - "getListLen", - "if_mode1", - "itemFromList" - ] - } - }, - { - "task_id": 9, - "text": "Crear un microservicio que valide un email de entrada, sanitice caracteres especiales del dominio, y retorne información de validación con diferentes códigos de respuesta según el resultado.", - "code": "addParam(\"email\", userEmail)\naddParam(\"domain_filter\", filterPattern)\naddResult(validationResult)\nvalidationResult = {}\nif(userEmail, None, \"!=\")\n getRegex(userEmail, \"^[\\\\w\\\\.-]+@[\\\\w\\\\.-]+\\\\.[a-zA-Z]{2,}$\", emailMatch)\n if(emailMatch, None, \"!=\")\n variableFromJSON({\"email\": userEmail}, \"email\", extractedEmail)\n getRegex(extractedEmail, \"@(.+)$\", domainPart)\n if(domainPart, None, \"!=\")\n if(filterPattern, None, \"==\")\n filterPattern = \"[^a-zA-Z0-9.-]\"\n else()\n noop = 1\n end()\n replace(domainPart, filterPattern, \"\", sanitizedDomain)\n AddVariableToJSON(\"original_domain\", domainPart, validationResult)\n AddVariableToJSON(\"sanitized_domain\", sanitizedDomain, validationResult)\n AddVariableToJSON(\"is_valid\", \"true\", validationResult)\n AddVariableToJSON(\"status\", \"success\", validationResult)\n _status = 200\n else()\n AddVariableToJSON(\"error\", \"invalid_domain_format\", validationResult)\n AddVariableToJSON(\"is_valid\", \"false\", validationResult)\n AddVariableToJSON(\"status\", \"error\", validationResult)\n _status = 400\n end()\n else()\n AddVariableToJSON(\"error\", \"invalid_email_format\", validationResult)\n AddVariableToJSON(\"is_valid\", \"false\", validationResult)\n AddVariableToJSON(\"status\", \"error\", validationResult)\n _status = 400\n end()\nelse()\n AddVariableToJSON(\"error\", \"email_parameter_missing\", validationResult)\n AddVariableToJSON(\"is_valid\", \"false\", validationResult)\n AddVariableToJSON(\"status\", \"error\", validationResult)\n _status = 422\nend()", - "test_inputs": { - "email": "test.user@example-site.com", - "domain_filter": "[^a-zA-Z0-9.-]" - }, - "test_list": [ - "re.match(r'\\{.*\"original_domain\".*\\}', validationResult)", - "re.match(r'\\{.*\"sanitized_domain\".*\\}', validationResult)", - "re.match(r'\\{.*\"is_valid\".*\"true\".*\\}', validationResult)" - ], - "_cell": [ - "addResult", - "else", - "replace" - ], - "_quality": { - "fidelity": 1.0, - "bonus_ratio": 0.171, - "test_quality": 1.0, - "richness": 1.0, - "quality": 1.351, - "detected": [ - "AddVariableToJSON", - "_status", - "addParam", - "addResult", - "else", - "end", - "if_mode1", - "replace", - "variableFromJSON" - ], - "cell": [ - "addResult", - "else", - "replace" - ], - "extra": [ - "AddVariableToJSON", - "_status", - "addParam", - "end", - "if_mode1", - "variableFromJSON" - ] - } - }, - { - "task_id": 10, - "text": "Desarrolla un microservicio AVAP que consulte una API externa para obtener datos meteorológicos de múltiples ciudades, valide y procese las respuestas, luego almacene los resultados válidos en una base de datos. El servicio debe manejar errores de red, filtrar datos por temperatura mínima, y devolver estadísticas de las ciudades procesadas.", - "code": "addParam(\"cities\", cities_param)\naddParam(\"min_temp\", min_temp_param)\naddParam(\"api_key\", api_key_param)\n\nif(cities_param, None, \"==\")\n addVar(_status, 400)\n addResult(\"error: cities parameter is required\")\n return()\nend()\n\nif(api_key_param, None, \"==\")\n addVar(_status, 401)\n addResult(\"error: api_key is required\")\n return()\nend()\n\nif(min_temp_param, None, \"==\")\n addVar(min_temp_param, 0)\nend()\n\nvariableToList(cities_param, cities_list)\ngetListLen(cities_list, total_cities)\n\nif(total_cities, 0, \"==\")\n addVar(_status, 400)\n addResult(\"error: no cities provided\")\n return()\nend()\n\ndb_connector = avapConnector(\"db-uuid-12345\")\normCheckTable(\"weather_data\", table_exists)\n\nif(table_exists, False, \"==\")\n fields = [\"city\", \"temperature\", \"humidity\", \"timestamp\"]\n types = [\"TEXT\", \"REAL\", \"REAL\", \"INTEGER\"]\n ormCreateTable(fields, types, \"weather_data\", create_result)\nend()\n\nvariableToList(\"\", processed_cities)\nvariableToList(\"\", valid_temperatures)\naddVar(total_processed, 0)\naddVar(total_valid, 0)\n\nstartLoop(i, 0, total_cities)\n itemFromList(cities_list, i, current_city)\n \n api_url = \"https://api.weather.com/v1/current?city=\" + current_city + \"&key=\" + api_key_param\n headers = {\"Accept\": \"application/json\"}\n \n try()\n RequestGet(api_url, \"\", headers, weather_response, 5000)\n \n if(weather_response, None, \"!=\")\n variableFromJSON(weather_response, \"temperature\", temp_value)\n variableFromJSON(weather_response, \"humidity\", humidity_value)\n \n if(temp_value, None, \"!=\")\n if(temp_value, min_temp_param, \">=\")\n getDateTime(\"%Y-%m-%d %H:%M:%S\", 0, \"UTC\", current_time)\n getTimeStamp(current_time, \"%Y-%m-%d %H:%M:%S\", 0, timestamp)\n \n insert_data = {\n \"city\": current_city,\n \"temperature\": temp_value,\n \"humidity\": humidity_value,\n \"timestamp\": timestamp\n }\n \n ormAccessInsert(insert_data, \"weather_data\", insert_result)\n \n variableToList(current_city, temp_city)\n processed_cities = processed_cities + temp_city\n \n variableToList(temp_value, temp_temp)\n valid_temperatures = valid_temperatures + temp_temp\n \n addVar(total_valid, total_valid + 1)\n end()\n addVar(total_processed, total_processed + 1)\n end()\n end()\n exception(api_error)\n addVar(error_msg, \"API error for city: \" + current_city)\n end()\nendLoop()\n\ngetListLen(processed_cities, cities_count)\ngetListLen(valid_temperatures, temps_count)\n\nif(temps_count, 0, \">\")\n addVar(sum_temp, 0)\n startLoop(j, 0, temps_count)\n itemFromList(valid_temperatures, j, temp_item)\n addVar(sum_temp, sum_temp + temp_item)\n endLoop()\n addVar(avg_temp, sum_temp / temps_count)\nelse()\n addVar(avg_temp, 0)\nend()\n\normAccessSelect(\"*\", \"weather_data\", \"temperature >= \" + str(min_temp_param), recent_data)\ngetListLen(recent_data, db_count)\n\nresponse_data = {\n \"cities_requested\": total_cities,\n \"cities_processed\": total_processed,\n \"cities_valid\": total_valid,\n \"average_temperature\": avg_temp,\n \"database_records\": db_count,\n \"processed_cities\": processed_cities\n}\n\naddResult(response_data)\naddVar(_status, 200)", - "test_inputs": { - "cities": "London,Paris,Madrid", - "min_temp": "10", - "api_key": "test-api-key-123" - }, - "test_list": [ - "re.match(r'.*RequestGet.*weather.*', code)", - "re.match(r'.*getListLen.*cities_list.*', code)", - "re.match(r'.*ormAccessSelect.*weather_data.*', code)" - ], - "_cell": [ - "RequestGet", - "getListLen", - "ormAccessSelect" - ], - "_quality": { - "fidelity": 1.0, - "bonus_ratio": 0.514, - "test_quality": 1.0, - "richness": 1.0, - "quality": 1.454, - "detected": [ - "RequestGet", - "_status", - "addParam", - "addResult", - "addVar", - "avapConnector", - "else", - "end", - "endLoop", - "getDateTime", - "getListLen", - "getTimeStamp", - "if_mode1", - "itemFromList", - "ormAccessInsert", - "ormAccessSelect", - "ormCheckTable", - "return", - "startLoop", - "try", - "variableFromJSON" - ], - "cell": [ - "RequestGet", - "getListLen", - "ormAccessSelect" - ], - "extra": [ - "_status", - "addParam", - "addResult", - "addVar", - "avapConnector", - "else", - "end", - "endLoop", - "getDateTime", - "getTimeStamp", - "if_mode1", - "itemFromList", - "ormAccessInsert", - "ormCheckTable", - "return", - "startLoop", - "try", - "variableFromJSON" - ] - } - } -] \ No newline at end of file diff --git a/output/candidate_E_reward_10_coverage_stats.json b/output/candidate_E_reward_10_coverage_stats.json deleted file mode 100644 index 427aeaf..0000000 --- a/output/candidate_E_reward_10_coverage_stats.json +++ /dev/null @@ -1,31 +0,0 @@ -{ - "total_cells": 9139, - "filled_cells": 10, - "fill_rate": 0.0011, - "distribution_entropy": 4.28, - "node_type_frequency": { - "startLoop": 2, - "avapConnector": 1, - "getQueryParamList": 1, - "gather": 2, - "ormAccessUpdate": 2, - "getListLen": 2, - "RequestPost": 1, - "getTimeStamp": 1, - "getDateTime": 2, - "end": 2, - "addVar": 1, - "addResult": 3, - "encodeMD5": 1, - "variableFromJSON": 1, - "stampToDatetime": 1, - "_status": 1, - "return": 1, - "else": 1, - "replace": 1, - "RequestGet": 1, - "ormAccessSelect": 1 - }, - "low_quality_cells": 0, - "empty_cells": 9129 -} \ No newline at end of file diff --git a/output/candidate_F_reward_10.json b/output/candidate_F_reward_10.json deleted file mode 100644 index 48631c5..0000000 --- a/output/candidate_F_reward_10.json +++ /dev/null @@ -1,601 +0,0 @@ -[ - { - "task_id": 1, - "text": "Crear un servicio de API que genere múltiples tokens de sesión aleatorios para diferentes tipos de usuarios utilizando patrones específicos y almacene los resultados en una base de datos. El servicio debe procesar una lista de tipos de usuario y generar tokens únicos para cada tipo usando iteraciones controladas.", - "code": "import \"crypto_utils\"\naddParam(\"user_types\", user_types_param)\naddParam(\"token_length\", token_length_param)\ndb = avapConnector(\"db_token_12345\")\nif(user_types_param, None, \"==\")\n addVar(_status, 400)\n addResult(error_msg)\nelse()\n variableToList(user_types_param, user_types_list)\n getListLen(user_types_list, list_length)\n addVar(counter, 0)\n startLoop(i, 0, list_length)\n itemFromList(user_types_list, i, current_user_type)\n if(current_user_type, \"admin\", \"==\")\n randomString(\"[A-Z0-9]\", 16, admin_token)\n addVar(final_token, admin_token)\n else()\n randomString(\"[a-z0-9]\", 12, regular_token)\n addVar(final_token, regular_token)\n end()\n ormAccessInsert({\"user_type\": current_user_type, \"token\": final_token, \"created_at\": \"2024-01-01\"}, \"user_tokens\", insert_result)\n addVar(counter, counter + 1)\n endLoop()\n ormAccessSelect(\"*\", \"user_tokens\", \"\", all_tokens)\n addResult(all_tokens)\n addResult(counter)\n addVar(_status, 201)\nend()", - "test_inputs": { - "user_types": [ - "admin", - "user", - "guest" - ], - "token_length": "12" - }, - "test_list": [ - "re.match(r'\\[.*\\]', str(all_tokens))", - "re.match(r'^[0-9]+$', str(counter))", - "re.match(r'^20[0-9]$', str(_status))" - ], - "_cell": [ - "import", - "randomString", - "startLoop" - ], - "_prior_weight": 0.4182, - "_quality": { - "fidelity": 1.0, - "bonus_ratio": 0.371, - "test_quality": 1.0, - "richness": 0.933, - "quality": 1.405, - "detected": [ - "_status", - "addParam", - "addResult", - "addVar", - "avapConnector", - "else", - "end", - "endLoop", - "getListLen", - "if_mode1", - "import", - "itemFromList", - "ormAccessInsert", - "ormAccessSelect", - "randomString", - "startLoop" - ], - "cell": [ - "import", - "randomString", - "startLoop" - ], - "extra": [ - "_status", - "addParam", - "addResult", - "addVar", - "avapConnector", - "else", - "end", - "endLoop", - "getListLen", - "if_mode1", - "itemFromList", - "ormAccessInsert", - "ormAccessSelect" - ] - } - }, - { - "task_id": 2, - "text": "Crear un microservicio que consulte información de un usuario desde una API externa usando GET, valide la respuesta y maneje diferentes códigos de estado HTTP según el resultado obtenido.", - "code": "addParam(\"user_id\", user_id)\nif(user_id, None, \"==\")\n_status = 400\naddVar(response_error, \"Missing user_id parameter\")\naddResult(response_error)\nelse()\napi_url = \"https://jsonplaceholder.typicode.com/users/\"\napi_url = api_url + str(user_id)\nheaders = {\"Content-Type\": \"application/json\"}\nRequestGet(api_url, \"\", headers, api_response, 5000)\nif(api_response, None, \"==\")\n_status = 503\naddVar(service_error, \"External API unavailable\")\naddResult(service_error)\nelse()\nvariableFromJSON(api_response, \"id\", user_found_id)\nif(user_found_id, None, \"==\")\n_status = 404\naddVar(not_found_msg, \"User not found in external service\")\naddResult(not_found_msg)\nelse()\nvariableFromJSON(api_response, \"name\", user_name)\nvariableFromJSON(api_response, \"email\", user_email)\nvariableFromJSON(api_response, \"phone\", user_phone)\nif(None, None, `len(user_name) > 0 and \"@\" in user_email`)\n_status = 200\naddVar(success_msg, \"User data retrieved successfully\")\naddResult(success_msg)\naddResult(user_name)\naddResult(user_email)\naddResult(user_phone)\nelse()\n_status = 422\naddVar(invalid_data, \"Invalid user data from external API\")\naddResult(invalid_data)\nend()\nend()\nend()\nend()", - "test_inputs": { - "user_id": "1" - }, - "test_list": [ - "re.match(r'^User data retrieved successfully$', success_msg)", - "re.match(r'^[A-Za-z\\s]+$', user_name)", - "re.match(r'^[\\w\\._%+-]+@[\\w\\.-]+\\.[A-Za-z]{2,}$', user_email)" - ], - "_cell": [ - "RequestGet", - "_status" - ], - "_prior_weight": 0.1313, - "_quality": { - "fidelity": 1.0, - "bonus_ratio": 0.194, - "test_quality": 1.0, - "richness": 1.0, - "quality": 1.358, - "detected": [ - "RequestGet", - "_status", - "addParam", - "addResult", - "addVar", - "else", - "end", - "if_mode2", - "variableFromJSON" - ], - "cell": [ - "RequestGet", - "_status" - ], - "extra": [ - "addParam", - "addResult", - "addVar", - "else", - "end", - "if_mode2", - "variableFromJSON" - ] - } - }, - { - "task_id": 3, - "text": "Crear un endpoint que actualice el estado de múltiples tareas en una base de datos. El endpoint recibe una lista de IDs de tareas como parámetro de consulta, actualiza cada tarea al estado 'completada' y retorna el número de tareas actualizadas exitosamente.", - "code": "addParam(\"task_ids\", task_list)\nif(task_list, None, \"!=\")\n getListLen(task_list, total_tasks)\n addVar(updated_count, 0)\n addVar(counter, 0)\n startLoop(i, 0, total_tasks)\n itemFromList(task_list, i, current_task_id)\n addVar(fields, [\"status\"])\n addVar(values, [\"completed\"])\n addVar(selector, \"id = %s\" % current_task_id)\n ormAccessUpdate(fields, values, \"tasks\", selector, update_result)\n if(update_result, None, \"is not None\")\n addVar(updated_count, updated_count + 1)\n end()\n addVar(counter, counter + 1)\n endLoop()\n addResult(updated_count)\n addVar(_status, 200)\nelse()\n addVar(error_msg, \"No task IDs provided\")\n addResult(error_msg)\n addVar(_status, 400)\nend()", - "test_inputs": { - "task_ids": [ - "101", - "102", - "103" - ] - }, - "test_list": [ - "re.match(r'\\d+', str(updated_count))", - "re.match(r'2\\d\\d', str(_status))", - "re.match(r'completed', 'completed')" - ], - "_cell": [ - "addVar", - "itemFromList", - "ormAccessUpdate" - ], - "_prior_weight": 0.5394, - "_quality": { - "fidelity": 1.0, - "bonus_ratio": 0.257, - "test_quality": 1.0, - "richness": 0.767, - "quality": 1.354, - "detected": [ - "_status", - "addParam", - "addResult", - "addVar", - "else", - "end", - "endLoop", - "getListLen", - "if_mode1", - "itemFromList", - "ormAccessUpdate", - "startLoop" - ], - "cell": [ - "addVar", - "itemFromList", - "ormAccessUpdate" - ], - "extra": [ - "_status", - "addParam", - "addResult", - "else", - "end", - "endLoop", - "getListLen", - "if_mode1", - "startLoop" - ] - } - }, - { - "task_id": 4, - "text": "Desarrolla un endpoint de API que reciba un parámetro 'user_id', consulte la base de datos para obtener los datos del usuario en formato JSON, extraiga el campo 'email' del JSON resultante y devuelva el email junto con el status code apropiado. Si no encuentra el usuario, debe devolver un error 404.", - "code": "addParam(\"user_id\", userId)\nif(userId, None, \"==\")\n addVar(_status, 400)\n addResult(_status)\nelse()\n ormAccessSelect(\"*\", \"users\", \"id = \" + str(userId), userResult)\n getListLen(userResult, resultCount)\n if(resultCount, 0, \"==\")\n addVar(_status, 404)\n addResult(_status)\n else()\n itemFromList(userResult, 0, firstUser)\n variableFromJSON(firstUser, \"email\", userEmail)\n variableFromJSON(firstUser, \"name\", userName)\n addVar(_status, 200)\n addResult(userEmail)\n addResult(userName)\n addResult(_status)\n end()\nend()", - "test_inputs": { - "user_id": "123" - }, - "test_list": [ - "re.match(r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$', userEmail)", - "re.match(r'^[A-Za-z\\s]+$', userName)", - "re.match(r'^200$', str(_status))" - ], - "_cell": [ - "addParam", - "ormAccessSelect", - "variableFromJSON" - ], - "_prior_weight": 0.2485, - "_quality": { - "fidelity": 1.0, - "bonus_ratio": 0.229, - "test_quality": 1.0, - "richness": 0.667, - "quality": 1.335, - "detected": [ - "_status", - "addParam", - "addResult", - "addVar", - "else", - "end", - "getListLen", - "if_mode1", - "itemFromList", - "ormAccessSelect", - "variableFromJSON" - ], - "cell": [ - "addParam", - "ormAccessSelect", - "variableFromJSON" - ], - "extra": [ - "_status", - "addResult", - "addVar", - "else", - "end", - "getListLen", - "if_mode1", - "itemFromList" - ] - } - }, - { - "task_id": 5, - "text": "Crear un microservicio que consulte productos en una base de datos, verifique el stock disponible y aplique descuentos basados en la cantidad. El servicio debe manejar casos donde no se encuentren productos y recorrer los resultados para calcular el precio total.", - "code": "addParam(\"user_id\", user_id)\naddParam(\"categoria\", categoria)\naddParam(\"descuento_minimo\", descuento_min)\nif(user_id, None, \"!=\")\n ormAccessSelect(\"*\", \"productos\", \"categoria = '\" + categoria + \"'\", productos_lista)\n getListLen(productos_lista, total_productos)\n if(total_productos, 0, \">\")\n precio_total = 0\n descuento_aplicado = 0\n startLoop(i, 0, total_productos)\n itemFromList(productos_lista, i, producto_actual)\n variableFromJSON(producto_actual, \"precio\", precio_item)\n variableFromJSON(producto_actual, \"stock\", stock_item)\n variableFromJSON(producto_actual, \"nombre\", nombre_item)\n if(stock_item, 0, \">\")\n precio_total = precio_total + precio_item\n if(precio_item, descuento_min, \">=\")\n descuento_aplicado = descuento_aplicado + (precio_item * 0.1)\n else()\n addResult(nombre_item)\n end()\n else()\n addVar(mensaje_error, \"Producto sin stock: \" + nombre_item)\n addResult(mensaje_error)\n end()\n endLoop()\n precio_final = precio_total - descuento_aplicado\n addResult(precio_final)\n addVar(_status, 200)\n else()\n addVar(mensaje, \"No se encontraron productos en la categoria\")\n addResult(mensaje)\n addVar(_status, 404)\n end()\nelse()\n addVar(error_msg, \"ID de usuario requerido\")\n addResult(error_msg)\n addVar(_status, 400)\nend()", - "test_inputs": { - "user_id": "123", - "categoria": "electronicos", - "descuento_minimo": "100" - }, - "test_list": [ - "re.match(r'\\d+', precio_final)", - "re.match(r'[A-Za-z]+', mensaje)", - "re.match(r'\\d{3}', _status)" - ], - "_cell": [ - "else", - "ormAccessSelect", - "startLoop" - ], - "_prior_weight": 0.2909, - "_quality": { - "fidelity": 1.0, - "bonus_ratio": 0.286, - "test_quality": 1.0, - "richness": 1.0, - "quality": 1.386, - "detected": [ - "_status", - "addParam", - "addResult", - "addVar", - "else", - "end", - "endLoop", - "getListLen", - "if_mode1", - "itemFromList", - "ormAccessSelect", - "startLoop", - "variableFromJSON" - ], - "cell": [ - "else", - "ormAccessSelect", - "startLoop" - ], - "extra": [ - "_status", - "addParam", - "addResult", - "addVar", - "end", - "endLoop", - "getListLen", - "if_mode1", - "itemFromList", - "variableFromJSON" - ] - } - }, - { - "task_id": 6, - "text": "Crear un microservicio para registrar transacciones bancarias que valide el monto, inserte los datos en base de datos y maneje errores de conexión. El servicio debe rechazar montos negativos o nulos y retornar códigos HTTP apropiados.", - "code": "registerEndpoint(\"/api/transaction\", \"POST\", [], \"Crear nueva transacción\", mainHandler, db_connector)\naddParam(\"amount\", amount)\naddParam(\"user_id\", user_id)\naddParam(\"description\", description)\ndb_connector = avapConnector(\"db_token_12345\")\nif(amount, 0, \"<=\")\n addVar(_status, 400)\n addResult(error_msg)\n return()\nelse()\n addVar(transaction_id, \"TXN\")\n randomString(\"[A-Z0-9]\", 8, random_suffix)\n transaction_id = transaction_id + random_suffix\n getDateTime(\"%Y-%m-%d %H:%M:%S\", 0, \"UTC\", created_at)\n variableToList(user_id, fields_values)\n variableToList(amount, temp_amount)\n variableToList(description, temp_desc)\n variableToList(transaction_id, temp_id)\n variableToList(created_at, temp_date)\n getListLen(fields_values, current_len)\n itemFromList(temp_amount, 0, amount_value)\n itemFromList(temp_desc, 0, desc_value)\n itemFromList(temp_id, 0, id_value)\n itemFromList(temp_date, 0, date_value)\n try()\n ormAccessInsert([user_id, amount_value, desc_value, id_value, date_value], \"transactions\", insert_result)\n addVar(_status, 201)\n AddVariableToJSON(\"transaction_id\", transaction_id, response_data)\n AddVariableToJSON(\"status\", \"success\", response_data)\n AddVariableToJSON(\"amount\", amount_value, response_data)\n addResult(response_data)\n exception(db_error)\n addVar(_status, 500)\n AddVariableToJSON(\"error\", \"Database connection failed\", error_response)\n AddVariableToJSON(\"details\", db_error, error_response)\n addResult(error_response)\n end()\nend()", - "test_inputs": { - "amount": "150.75", - "user_id": "USER123", - "description": "Payment for services" - }, - "test_list": [ - "re.match(r'TXN[A-Z0-9]{8}', transaction_id)", - "re.match(r'\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}', created_at)", - "re.match(r'success', response_data)" - ], - "_cell": [ - "if_mode1", - "ormAccessInsert", - "try" - ], - "_prior_weight": 0.4424, - "_quality": { - "fidelity": 1.0, - "bonus_ratio": 0.371, - "test_quality": 1.0, - "richness": 1.0, - "quality": 1.411, - "detected": [ - "AddVariableToJSON", - "_status", - "addParam", - "addResult", - "addVar", - "avapConnector", - "else", - "end", - "getDateTime", - "getListLen", - "if_mode1", - "itemFromList", - "ormAccessInsert", - "randomString", - "return", - "try" - ], - "cell": [ - "if_mode1", - "ormAccessInsert", - "try" - ], - "extra": [ - "AddVariableToJSON", - "_status", - "addParam", - "addResult", - "addVar", - "avapConnector", - "else", - "end", - "getDateTime", - "getListLen", - "itemFromList", - "randomString", - "return" - ] - } - }, - { - "task_id": 7, - "text": "Crear un endpoint que importe una librería de utilidades, haga una petición GET a una API externa para obtener datos de clima, valide la respuesta y retorne información procesada con el estado HTTP apropiado.", - "code": "import \"weather_utils\"\nfunction validateTemperature(temp) {\n if(temp, 50, \">=\") {\n return(\"extreme_hot\")\n else()\n if(temp, -20, \"<=\") {\n return(\"extreme_cold\")\n else()\n return(\"normal\")\n end()\n end()\n}\nfunction processWeatherData(data) {\n variableFromJSON(data, \"temperature\", temp)\n variableFromJSON(data, \"city\", city)\n validateTemperature(temp)\n tempStatus = validateTemperature(temp)\n AddVariableToJSON(\"status\", tempStatus, data)\n AddVariableToJSON(\"processed_at\", \"2024-01-15T10:30:00Z\", data)\n return(data)\n}\naddParam(\"city\", cityName)\naddParam(\"api_key\", apiKey)\nif(cityName, None, \"==\") {\n addVar(_status, 400)\n errorMsg = \"City parameter is required\"\n addResult(errorMsg)\n return()\nend()\nif(apiKey, None, \"==\") {\n addVar(_status, 401)\n errorMsg = \"API key is required\"\n addResult(errorMsg)\n return()\nend()\nweatherUrl = \"https://api.weather.com/v1/current\"\nqueryParams = \"city=\" + cityName + \"&key=\" + apiKey\nheaders = {\"User-Agent\": \"AVAP-Weather-Client/1.0\", \"Accept\": \"application/json\"}\nRequestGet(weatherUrl, queryParams, headers, weatherResponse, 5000)\nif(weatherResponse, None, \"==\") {\n addVar(_status, 503)\n errorMsg = \"Weather service unavailable\"\n addResult(errorMsg)\n return()\nend()\nvariableFromJSON(weatherResponse, \"error\", apiError)\nif(apiError, None, \"!=\") {\n addVar(_status, 502)\n addResult(apiError)\n return()\nend()\nprocessedData = processWeatherData(weatherResponse)\naddVar(_status, 200)\naddResult(processedData)", - "test_inputs": { - "city": "Madrid", - "api_key": "test123" - }, - "test_list": [ - "re.match(r'extreme_hot|extreme_cold|normal', tempStatus)", - "re.match(r'Madrid|Barcelona|Valencia', cityName)", - "re.match(r'\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}Z', processedData)" - ], - "_cell": [ - "RequestGet", - "import" - ], - "_prior_weight": 0.3737, - "_quality": { - "fidelity": 1.0, - "bonus_ratio": 0.306, - "test_quality": 1.0, - "richness": 1.0, - "quality": 1.392, - "detected": [ - "AddVariableToJSON", - "RequestGet", - "_status", - "addParam", - "addResult", - "addVar", - "else", - "end", - "function", - "if_mode1", - "import", - "return", - "variableFromJSON" - ], - "cell": [ - "RequestGet", - "import" - ], - "extra": [ - "AddVariableToJSON", - "_status", - "addParam", - "addResult", - "addVar", - "else", - "end", - "function", - "if_mode1", - "return", - "variableFromJSON" - ] - } - }, - { - "task_id": 8, - "text": "Desarrolla una función de autenticación externa que valide un token OAuth con un proveedor de identidad, consulte la base de datos de usuarios y registre la actividad de acceso. La función debe hacer una petición POST para validar el token, consultar la tabla 'usuarios' para verificar permisos, y devolver el código HTTP apropiado según el resultado de la validación.", - "code": "addParam(\"token\", auth_token)\naddParam(\"client_id\", client_id)\nif(auth_token, None, \"==\")\n addVar(_status, 400)\n addResult(_status)\n return()\nend()\noauth_url = \"https://auth.provider.com/validate\"\nheaders = {\"Content-Type\": \"application/json\"}\nbody = {\"token\": auth_token, \"client_id\": client_id}\nRequestPost(oauth_url, \"\", headers, body, oauth_response, 5000)\nif(oauth_response, None, \"==\")\n addVar(_status, 503)\n error_msg = \"OAuth service unavailable\"\n addResult(error_msg)\n return()\nend()\nvariableFromJSON(oauth_response, \"valid\", is_valid)\nvariableFromJSON(oauth_response, \"user_id\", external_user_id)\nif(is_valid, \"false\", \"==\")\n addVar(_status, 401)\n error_msg = \"Invalid token\"\n addResult(error_msg)\n return()\nend()\ndb_connector = avapConnector(\"db-uuid-12345\")\nfields = \"user_id,email,status,permissions\"\nselector = \"external_id = '\" + external_user_id + \"'\"\normAccessSelect(fields, \"usuarios\", selector, user_data)\ngetListLen(user_data, user_count)\nif(user_count, 0, \"==\")\n addVar(_status, 404)\n error_msg = \"User not found\"\n addResult(error_msg)\n return()\nend()\nitemFromList(user_data, 0, user_record)\nvariableFromJSON(user_record, \"status\", user_status)\nvariableFromJSON(user_record, \"user_id\", internal_user_id)\nvariableFromJSON(user_record, \"email\", user_email)\nvariableFromJSON(user_record, \"permissions\", user_permissions)\nif(user_status, \"active\", \"!=\")\n addVar(_status, 403)\n error_msg = \"Account suspended\"\n addResult(error_msg)\n return()\nend()\ngetDateTime(\"%Y-%m-%d %H:%M:%S\", 0, \"UTC\", access_timestamp)\naccess_log = {\"user_id\": internal_user_id, \"timestamp\": access_timestamp, \"action\": \"oauth_login\"}\nlog_fields = [\"user_id\", \"timestamp\", \"action\"]\nlog_values = [internal_user_id, access_timestamp, \"oauth_login\"]\normAccessInsert(log_values, \"access_logs\", log_result)\naddVar(_status, 200)\nresponse_data = {\"user_id\": internal_user_id, \"email\": user_email, \"permissions\": user_permissions}\naddResult(response_data)", - "test_inputs": { - "token": "valid_oauth_token_12345", - "client_id": "app_client_001" - }, - "test_list": [ - "re.match(r'\\d+', str(user_count))", - "re.match(r'[a-zA-Z0-9_]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}', user_email)", - "re.match(r'\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}', access_timestamp)" - ], - "_cell": [ - "RequestPost", - "_status", - "ormAccessSelect" - ], - "_prior_weight": 0.0909, - "_quality": { - "fidelity": 1.0, - "bonus_ratio": 0.343, - "test_quality": 1.0, - "richness": 1.0, - "quality": 1.403, - "detected": [ - "RequestPost", - "_status", - "addParam", - "addResult", - "addVar", - "avapConnector", - "end", - "getDateTime", - "getListLen", - "if_mode1", - "itemFromList", - "ormAccessInsert", - "ormAccessSelect", - "return", - "variableFromJSON" - ], - "cell": [ - "RequestPost", - "_status", - "ormAccessSelect" - ], - "extra": [ - "addParam", - "addResult", - "addVar", - "avapConnector", - "end", - "getDateTime", - "getListLen", - "if_mode1", - "itemFromList", - "ormAccessInsert", - "return", - "variableFromJSON" - ] - } - }, - { - "task_id": 9, - "text": "Implementar un servicio que genere códigos de verificación aleatorios para una lista de usuarios, extraiga información específica de cada usuario usando índices de lista, y devuelva los resultados procesados con códigos únicos.", - "code": "registerEndpoint(\"/api/generate-codes\", \"POST\", [], \"application/json\", mainHandler, None)\n\nfunction mainHandler()\n{\naddParam(\"user_data\", user_list)\naddParam(\"code_length\", length_param)\nif(user_list, None, \"==\")\n_status = 400\naddVar(error_msg, \"Lista de usuarios requerida\")\naddResult(error_msg)\nreturn()\nend()\nif(length_param, None, \"==\")\naddVar(length_param, 8)\nend()\nvariableToList(user_list, processed_users)\ngetListLen(processed_users, total_users)\naddVar(counter, 0)\naddVar(verification_codes, [])\nstartLoop(i, 0, total_users)\nitemFromList(processed_users, i, current_user)\nvariableFromJSON(current_user, \"email\", user_email)\nvariableFromJSON(current_user, \"user_id\", user_id)\nrandomString(\"[A-Z0-9]\", length_param, random_code)\nAddVariableToJSON(\"user_id\", user_id, code_entry)\nAddVariableToJSON(\"email\", user_email, code_entry)\nAddVariableToJSON(\"verification_code\", random_code, code_entry)\naddVar(verification_codes, verification_codes + [code_entry])\naddVar(counter, counter + 1)\nendLoop()\naddVar(response_data, {})\nAddVariableToJSON(\"generated_codes\", verification_codes, response_data)\nAddVariableToJSON(\"total_processed\", counter, response_data)\n_status = 200\naddResult(response_data)\nreturn()\n}", - "test_inputs": { - "user_data": "[{\"user_id\": 123, \"email\": \"test@example.com\"}, {\"user_id\": 456, \"email\": \"user@domain.org\"}]", - "code_length": "6" - }, - "test_list": [ - "re.match(r'^\\[{\"user_id\":', response_data)", - "re.match(r'\"verification_code\":\"[A-Z0-9]{6}\"', response_data)", - "re.match(r'\"total_processed\":2', response_data)" - ], - "_cell": [ - "itemFromList", - "randomString" - ], - "_prior_weight": 0.1212, - "_quality": { - "fidelity": 1.0, - "bonus_ratio": 0.361, - "test_quality": 1.0, - "richness": 1.0, - "quality": 1.408, - "detected": [ - "AddVariableToJSON", - "_status", - "addParam", - "addResult", - "addVar", - "end", - "endLoop", - "function", - "getListLen", - "if_mode1", - "itemFromList", - "randomString", - "return", - "startLoop", - "variableFromJSON" - ], - "cell": [ - "itemFromList", - "randomString" - ], - "extra": [ - "AddVariableToJSON", - "_status", - "addParam", - "addResult", - "addVar", - "end", - "endLoop", - "function", - "getListLen", - "if_mode1", - "return", - "startLoop", - "variableFromJSON" - ] - } - }, - { - "task_id": 10, - "text": "Crea un endpoint AVAP que reciba un parámetro 'table_name', valide que la tabla existe en la base de datos usando ORM, y devuelva información sobre la tabla. Si no recibe parámetro, debe usar 'users' por defecto. Implementa una función auxiliar para formatear la respuesta y maneja errores apropiadamente.", - "code": "registerEndpoint(\"/api/validate-table\", \"GET\", [], \"default\", validateTableHandler, mainHandler)\nfunction validateTableHandler()\n{\n addParam(\"table_name\", received_table)\n if(received_table, None, \"==\")\n addVar(target_table, \"users\")\n else()\n addVar(target_table, $received_table)\n end()\n db_connector = avapConnector(\"db-uuid-12345\")\n ormCheckTable($target_table, table_exists)\n if(table_exists, True, \"==\")\n result = formatTableResponse($target_table, \"exists\")\n addVar(_status, 200)\n else()\n result = formatTableResponse($target_table, \"not_found\")\n addVar(_status, 404)\n end()\n addResult(result)\n return()\n}\nfunction formatTableResponse(table_name, status)\n{\n addVar(response_data, \"{}\")\n AddVariableToJSON(\"table\", $table_name, response_data)\n AddVariableToJSON(\"status\", $status, response_data)\n getDateTime(\"%Y-%m-%d %H:%M:%S\", 0, \"UTC\", current_time)\n AddVariableToJSON(\"timestamp\", $current_time, response_data)\n return($response_data)\n}", - "test_inputs": { - "table_name": "products" - }, - "test_list": [ - "re.match(r'\\{.*\"table\".*\"products\".*\\}', result)", - "re.match(r'\\{.*\"status\".*\"exists\".*\\}', result)", - "re.match(r'\\{.*\"timestamp\".*\"\\d{4}-\\d{2}-\\d{2}.*\\}', result)" - ], - "_cell": [ - "addParam", - "function", - "ormCheckTable" - ], - "_prior_weight": 0.5758, - "_quality": { - "fidelity": 1.0, - "bonus_ratio": 0.286, - "test_quality": 1.0, - "richness": 1.0, - "quality": 1.386, - "detected": [ - "AddVariableToJSON", - "_status", - "addParam", - "addResult", - "addVar", - "avapConnector", - "else", - "end", - "function", - "getDateTime", - "if_mode1", - "ormCheckTable", - "return" - ], - "cell": [ - "addParam", - "function", - "ormCheckTable" - ], - "extra": [ - "AddVariableToJSON", - "_status", - "addResult", - "addVar", - "avapConnector", - "else", - "end", - "getDateTime", - "if_mode1", - "return" - ] - } - } -] \ No newline at end of file diff --git a/output/candidate_F_reward_10_coverage_stats.json b/output/candidate_F_reward_10_coverage_stats.json deleted file mode 100644 index d559915..0000000 --- a/output/candidate_F_reward_10_coverage_stats.json +++ /dev/null @@ -1,30 +0,0 @@ -{ - "total_cells": 9139, - "filled_cells": 10, - "fill_rate": 0.0011, - "distribution_entropy": 4.06, - "node_type_frequency": { - "startLoop": 2, - "randomString": 2, - "import": 2, - "_status": 2, - "RequestGet": 2, - "itemFromList": 2, - "addVar": 1, - "ormAccessUpdate": 1, - "ormAccessSelect": 3, - "variableFromJSON": 1, - "addParam": 2, - "else": 1, - "ormAccessInsert": 1, - "try": 1, - "if_mode1": 1, - "RequestPost": 1, - "ormCheckTable": 1, - "function": 1 - }, - "low_quality_cells": 0, - "empty_cells": 9129, - "kl_divergence_dataset_vs_prior": -0.724, - "prior_summary": "ConstructPrior: 4262 cells | mean=0.252 | epsilon=0.05 | github_files_analyzed=100 github_files_fetched=100 total_pair_cooccurrences=441 total_trio_cooccurrences=3821" -} \ No newline at end of file diff --git a/output/mbpp_avap.json b/output/mbpp_avap.json deleted file mode 100644 index 647d697..0000000 --- a/output/mbpp_avap.json +++ /dev/null @@ -1,187 +0,0 @@ -[ - { - "task_id": 1, - "text": "Crea un endpoint que reciba un parámetro 'codigo_pais' desde la petición HTTP y genere un token aleatorio de 8 caracteres alfanuméricos si el código de país es válido (tiene exactamente 2 letras mayúsculas), o establezca un error 400 si no es válido.", - "code": "addParam(\"codigo_pais\", codigo)\ngetRegex(codigo, \"^[A-Z]{2}$\", validacion)\nif(None, None, `validacion != None`)\n randomString(\"[a-zA-Z0-9]\", 8, token)\n addResult(token)\nelse()\n addVar(_status, 400)\n addResult(\"Error: Codigo de pais invalido\")\nend()", - "test_inputs": { - "codigo_pais": "ES" - }, - "test_list": [ - "re.match(r'^[a-zA-Z0-9]{8}$', token)", - "re.match(r'^200$', str(_status))", - "re.match(r'^[a-zA-Z0-9]+$', token)" - ] - }, - { - "task_id": 2, - "text": "Crea un servicio que tome una contraseña como parámetro, genere un token aleatorio de 32 caracteres alfanuméricos, reemplace todas las vocales de la contraseña por asteriscos, combine los resultados en un objeto JSON y devuelva el resultado.", - "code": "addParam(\"password\", password)\nrandomString(\"[a-zA-Z0-9]\", 32, token)\nreplace(password, \"[aeiouAEIOU]\", \"*\", masked_password)\naddVar(response, {})\nAddVariableToJSON(\"original_length\", 0, response)\ngetListLen(password, pwd_len)\nAddVariableToJSON(\"original_length\", pwd_len, response)\nAddVariableToJSON(\"masked_password\", masked_password, response)\nAddVariableToJSON(\"token\", token, response)\naddResult(response)", - "test_inputs": { - "password": "MiPassword123" - }, - "test_list": [ - "re.match(r'^[a-zA-Z0-9]{32}$', token)", - "re.match(r'.*M\\*P\\*ssw\\*rd123.*', masked_password)", - "re.match(r'^\\d+$', str(pwd_len))" - ] - }, - { - "task_id": 3, - "text": "Implementa un validador de contraseñas que recibe una contraseña y evalúa su fortaleza. Si la contraseña tiene menos de 8 caracteres, asigna el status 400 y retorna 'muy_corta'. Si tiene 8 o más caracteres pero no contiene números, asigna status 401 y retorna 'sin_numeros'. Si cumple ambos requisitos, asigna status 200 y retorna 'valida'.", - "code": "addParam(\"password\", password)\ngetListLen(password, length)\nif(length, 8, \"<\")\n _status = 400\n result = \"muy_corta\"\nelse()\n getRegex(password, \"[0-9]\", has_number)\n if(has_number, None, \"==\")\n _status = 401\n result = \"sin_numeros\"\n else()\n _status = 200\n result = \"valida\"\n end()\nend()\naddResult(result)", - "test_inputs": { - "password": "secreto123" - }, - "test_list": [ - "re.match(r'^200$', str(_status))", - "re.match(r'^valida$', result)" - ] - }, - { - "task_id": 4, - "text": "Crear un endpoint que reciba una lista de números y calcule la suma de todos los elementos que sean mayores a un valor umbral especificado.", - "code": "addParam(\"numbers\", numbers)\naddParam(\"threshold\", threshold)\nvariableToList(numbers, numList)\ngetListLen(numList, length)\nsum = 0\nstartLoop(i, 0, length)\n itemFromList(numList, i, current)\n if(current, threshold, \">\")\n sum = sum + current\n end()\nendLoop()\naddResult(sum)", - "test_inputs": { - "numbers": [ - 10, - 5, - 15, - 3, - 20, - 8, - 25 - ], - "threshold": 10 - }, - "test_list": [ - "re.match(r'^60$', str(sum))", - "re.match(r'^\\d+$', str(sum))", - "re.match(r'^[1-9]\\d*$', str(sum))" - ] - }, - { - "task_id": 5, - "text": "Crea un endpoint que extraiga el email de un usuario desde un objeto JSON recibido como parámetro, luego agregue un campo 'domain' con el dominio del email extraído y retorne el JSON modificado.", - "code": "addParam(\"user_data\", user_json)\nvariableFromJSON(user_json, \"email\", email)\ngetRegex(email, \"@(.+)\", domain)\nAddVariableToJSON(\"domain\", domain, user_json)\naddResult(user_json)", - "test_inputs": { - "user_data": "{\"name\": \"Juan Pérez\", \"email\": \"juan@empresa.com\", \"age\": 30}" - }, - "test_list": [ - "re.match(r'^juan@empresa\\.com$', email)", - "re.match(r'^empresa\\.com$', domain)", - "re.match(r'.*\"domain\"\\s*:\\s*\"empresa\\.com\".*', str(user_json))" - ] - }, - { - "task_id": 6, - "text": "Crear un endpoint que consulte usuarios por edad mínima usando ORM. El endpoint recibe un parámetro 'min_age' y devuelve todos los usuarios cuya edad sea mayor o igual al valor especificado. Usar ormAccessSelect para consultar la tabla 'users' con selector WHERE apropiado.", - "code": "addParam(\"min_age\", min_age)\nmin_age_str = str(min_age)\nselector = \"age >= \" + min_age_str\normAccessSelect(\"*\", \"users\", selector, users_result)\naddResult(users_result)", - "test_inputs": { - "min_age": 25 - }, - "test_list": [ - "re.match(r'^\\[.*\\]$', str(users_result))", - "re.match(r'^25$', str(min_age))", - "re.match(r'^age >= 25$', selector)" - ] - }, - { - "task_id": 7, - "text": "Crea un endpoint que reciba una contraseña como parámetro, la hashee usando SHA-256 y devuelva el hash resultante. La función debe validar que el hash generado tenga exactamente 64 caracteres hexadecimales y que no esté vacío.", - "code": "addParam(\"password\", password)\nencodeSHA256(password, hashed)\naddResult(hashed)", - "test_inputs": { - "password": "secretPassword123" - }, - "test_list": [ - "re.match(r'^[a-f0-9]{64}$', hashed)", - "re.match(r'^.{64}$', hashed)", - "re.match(r'^[^\\s]+$', hashed)" - ] - }, - { - "task_id": 8, - "text": "Crear un endpoint que reciba una fecha en formato ISO (YYYY-MM-DD HH:MM:SS) y devuelva el timestamp Unix correspondiente. El endpoint debe aplicar un offset de -3 horas para convertir de UTC-3 a UTC.", - "code": "addParam(\"fecha_iso\", fecha_iso)\ngetTimeStamp(fecha_iso, \"%Y-%m-%d %H:%M:%S\", -10800, timestamp_unix)\naddResult(timestamp_unix)", - "test_inputs": { - "fecha_iso": "2023-12-25 15:30:00" - }, - "test_list": [ - "re.match(r'^\\d{10}$', str(timestamp_unix))", - "re.match(r'^1703.*', str(timestamp_unix))" - ] - }, - { - "task_id": 9, - "text": "Crea un endpoint que use un conector de Belvo para listar instituciones financieras y devuelva el resultado. El conector tiene UUID 'a1b2c3d4-e5f6-7890-1234-567890abcdef' y expone el método list_institutions() que no requiere parámetros.", - "code": "belvo_connector = avapConnector(\"a1b2c3d4-e5f6-7890-1234-567890abcdef\")\ninstitutions = belvo_connector.list_institutions()\naddResult(institutions)", - "test_inputs": {}, - "test_list": [ - "re.match(r'^\naddParam(\"radio\", radio)\narea_original = math.pi() * radio * radio\narea_convertida = area_original * factor_conversion\naddVar(resultado, \"{}\")\nAddVariableToJSON(\"area_original\", area_original, resultado)\nAddVariableToJSON(\"area_convertida\", area_convertida, resultado)\nAddVariableToJSON(\"factor_usado\", factor_conversion, resultado)\naddResult(resultado)", - "test_inputs": { - "radio": 5.0 - }, - "test_list": [ - "re.match(r'^\\{.*area_original.*\\}$', resultado)", - "re.match(r'^\\{.*area_convertida.*\\}$', resultado)", - "re.match(r'^\\{.*factor_usado.*\\}$', resultado)" - ] - } -] \ No newline at end of file diff --git a/output/mbpp_avap_v2_A.json b/output/mbpp_avap_v2_A.json deleted file mode 100644 index ce82ddb..0000000 --- a/output/mbpp_avap_v2_A.json +++ /dev/null @@ -1,762 +0,0 @@ -[ - { - "task_id": 1, - "text": "Desarrollar un servicio de procesamiento de archivos de logs que reciba múltiples URLs de logs, las descargue concurrentemente, procese los códigos de estado HTTP, y retorne estadísticas agrupadas. El servicio debe validar las URLs, manejar errores de descarga, filtrar entradas por rangos de fechas, y generar un reporte con códigos de estado más frecuentes.", - "code": "addParam(\"urls\", log_urls)\ngetQueryParamList(\"urls\", url_list)\ngetListLen(url_list, total_urls)\nif(total_urls, 0, \"==\")\n _status = 400\n addVar(error_msg, \"No URLs provided\")\n addResult(error_msg)\nelse()\n addVar(success_count, 0)\n addVar(error_count, 0)\n addVar(status_codes, \"{}\")\n addVar(processed_logs, \"[]\")\n \n startLoop(i, 0, total_urls)\n itemFromList(url_list, i, current_url)\n \n if(None, None, `\"http\" in current_url or \"https\" in current_url`)\n download_task = go fetch_log_data(current_url)\n log_content = gather(download_task, 5000)\n \n if(None, None, `log_content is not None`)\n parsed_result = process_log_entries(log_content)\n variableFromJSON(parsed_result, \"status_counts\", entry_counts)\n variableFromJSON(parsed_result, \"total_entries\", entry_total)\n \n getListLen(entry_counts, counts_len)\n startLoop(j, 0, counts_len)\n itemFromList(entry_counts, j, status_entry)\n variableFromJSON(status_entry, \"code\", status_code)\n variableFromJSON(status_entry, \"count\", status_count)\n \n AddVariableToJSON(status_code, status_count, status_codes)\n endLoop()\n \n success_count = success_count + 1\n else()\n error_count = error_count + 1\n end()\n else()\n error_count = error_count + 1\n end()\n endLoop()\n \n AddVariableToJSON(\"successful_downloads\", success_count, status_codes)\n AddVariableToJSON(\"failed_downloads\", error_count, status_codes)\n AddVariableToJSON(\"total_urls_processed\", total_urls, status_codes)\n \n if(success_count, 0, \">\")\n _status = 200\n addResult(status_codes)\n else()\n _status = 404\n addVar(error_msg, \"No logs could be processed\")\n addResult(error_msg)\n end()\nend()\n\nfunction fetch_log_data(url)\n{\n addVar(headers, \"{}\")\n AddVariableToJSON(\"User-Agent\", \"AVAP-LogProcessor/1.0\", headers)\n \n try()\n RequestGet(url, \"\", headers, response_data, 10000)\n return(response_data)\n exception(fetch_error)\n return(None)\n end()\n}\n\nfunction process_log_entries(raw_log_data)\n{\n replace(raw_log_data, \"\\n\", \" | \", cleaned_data)\n getRegex(cleaned_data, \"HTTP/[0-9\\.]+ ([0-9]{3})\", status_matches)\n \n addVar(status_200_count, 0)\n addVar(status_400_count, 0)\n addVar(status_500_count, 0)\n addVar(other_count, 0)\n \n variableToList(status_matches, matches_list)\n getListLen(matches_list, matches_total)\n \n startLoop(k, 0, matches_total)\n itemFromList(matches_list, k, status_code)\n \n if(status_code, \"200\", \"==\")\n status_200_count = status_200_count + 1\n else()\n if(None, None, `status_code >= \"400\" and status_code < \"500\"`)\n status_400_count = status_400_count + 1\n else()\n if(None, None, `status_code >= \"500\"`)\n status_500_count = status_500_count + 1\n else()\n other_count = other_count + 1\n end()\n end()\n end()\n endLoop()\n \n addVar(result, \"{}\")\n addVar(counts_array, \"[]\")\n \n addVar(entry_200, \"{}\")\n AddVariableToJSON(\"code\", \"200\", entry_200)\n AddVariableToJSON(\"count\", status_200_count, entry_200)\n \n addVar(entry_400, \"{}\")\n AddVariableToJSON(\"code\", \"4xx\", entry_400)\n AddVariableToJSON(\"count\", status_400_count, entry_400)\n \n addVar(entry_500, \"{}\")\n AddVariableToJSON(\"code\", \"5xx\", entry_500)\n AddVariableToJSON(\"count\", status_500_count, entry_500)\n \n total_entries = status_200_count + status_400_count + status_500_count + other_count\n \n AddVariableToJSON(\"status_counts\", counts_array, result)\n AddVariableToJSON(\"total_entries\", total_entries, result)\n \n return(result)\n}", - "test_inputs": { - "urls": [ - "http://example.com/log1.txt", - "https://api.test.com/logs/access.log" - ] - }, - "test_list": [ - "re.match(r'\\{.*successful_downloads.*\\}', status_codes)", - "re.match(r'[0-9]+', str(total_urls))", - "re.match(r'(200|404|400)', str(_status))" - ], - "_detected": [ - "AddVariableToJSON", - "RequestGet", - "_status", - "addParam", - "addResult", - "addVar", - "else", - "end", - "endLoop", - "function", - "gather", - "getListLen", - "getQueryParamList", - "if_mode2", - "itemFromList", - "replace", - "return", - "startLoop", - "try", - "variableFromJSON" - ], - "_reward": { - "ecs": 0.526, - "novelty": 1.0, - "test_quality": 1.0, - "reward": 0.763, - "detected": [ - "AddVariableToJSON", - "RequestGet", - "_status", - "addParam", - "addResult", - "addVar", - "else", - "end", - "endLoop", - "function", - "gather", - "getListLen", - "getQueryParamList", - "if_mode2", - "itemFromList", - "replace", - "return", - "startLoop", - "try", - "variableFromJSON" - ] - } - }, - { - "task_id": 2, - "text": "Desarrollar un microservicio de autenticación que reciba credenciales de usuario, valide el formato del email, genere un hash SHA256 de la contraseña, verifique las credenciales contra una base de datos, registre el intento en una tabla de auditoría, y si es exitoso, genere un token JWT usando un conector externo. El servicio debe manejar múltiples usuarios concurrentemente, registrar timestamps de los intentos, y retornar tanto el resultado de autenticación como estadísticas del proceso.", - "code": "addParam(\"email\", user_email)\naddParam(\"password\", user_password)\naddParam(\"client_id\", client_identifier)\n\nif(None, None, `user_email is None or user_password is None`)\n _status = 400\n addVar(error_message, \"Missing required fields\")\n addResult(error_message)\nelse()\n getRegex(user_email, \"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$\", email_valid)\n \n if(None, None, `email_valid is None`)\n _status = 422\n addVar(validation_error, \"Invalid email format\")\n addResult(validation_error)\n else()\n encodeSHA256(user_password, password_hash)\n getDateTime(\"%Y-%m-%d %H:%M:%S\", 0, \"UTC\", current_timestamp)\n \n db_connector = avapConnector(\"db-auth-uuid-12345\")\n \n try()\n auth_task = go authenticate_user(user_email, password_hash, db_connector)\n jwt_task = go generate_jwt_token(user_email, client_identifier)\n \n auth_result = gather(auth_task, 3000)\n jwt_result = gather(jwt_task, 2000)\n \n variableFromJSON(auth_result, \"is_valid\", user_authenticated)\n variableFromJSON(auth_result, \"user_id\", authenticated_user_id)\n \n if(user_authenticated, \"true\", \"==\")\n variableFromJSON(jwt_result, \"token\", access_token)\n variableFromJSON(jwt_result, \"expires_at\", token_expiration)\n \n audit_data = log_authentication_attempt(user_email, \"SUCCESS\", current_timestamp, db_connector)\n \n addVar(response_data, \"{}\")\n AddVariableToJSON(\"status\", \"authenticated\", response_data)\n AddVariableToJSON(\"user_id\", authenticated_user_id, response_data)\n AddVariableToJSON(\"access_token\", access_token, response_data)\n AddVariableToJSON(\"expires_at\", token_expiration, response_data)\n AddVariableToJSON(\"timestamp\", current_timestamp, response_data)\n \n _status = 200\n addResult(response_data)\n else()\n audit_data = log_authentication_attempt(user_email, \"FAILED\", current_timestamp, db_connector)\n \n _status = 401\n addVar(auth_failed, \"Invalid credentials\")\n addResult(auth_failed)\n end()\n exception(auth_error)\n addVar(system_error, \"Authentication service unavailable\")\n _status = 503\n addResult(system_error)\n end()\n end()\nend()\n\nfunction authenticate_user(email, password_hash, connector)\n{\n ormAccessSelect(\"*\", \"users\", \"email = '\" + email + \"' AND password_hash = '\" + password_hash + \"'\", user_records)\n \n getListLen(user_records, records_count)\n \n addVar(auth_response, \"{}\")\n \n if(records_count, 0, \">\")\n itemFromList(user_records, 0, user_record)\n variableFromJSON(user_record, \"id\", user_id)\n variableFromJSON(user_record, \"status\", account_status)\n \n if(account_status, \"active\", \"==\")\n AddVariableToJSON(\"is_valid\", \"true\", auth_response)\n AddVariableToJSON(\"user_id\", user_id, auth_response)\n else()\n AddVariableToJSON(\"is_valid\", \"false\", auth_response)\n AddVariableToJSON(\"reason\", \"account_disabled\", auth_response)\n end()\n else()\n AddVariableToJSON(\"is_valid\", \"false\", auth_response)\n AddVariableToJSON(\"reason\", \"invalid_credentials\", auth_response)\n end()\n \n return(auth_response)\n}\n\nfunction generate_jwt_token(email, client_id)\n{\n jwt_connector = avapConnector(\"jwt-service-uuid-67890\")\n \n addVar(token_payload, \"{}\")\n AddVariableToJSON(\"email\", email, token_payload)\n AddVariableToJSON(\"client_id\", client_id, token_payload)\n AddVariableToJSON(\"iat\", \"1640995200\", token_payload)\n \n getTimeStamp(\"2024-12-31 23:59:59\", \"%Y-%m-%d %H:%M:%S\", 0, expiration_timestamp)\n AddVariableToJSON(\"exp\", expiration_timestamp, token_payload)\n \n token_response = jwt_connector.create_token(token_payload)\n \n return(token_response)\n}\n\nfunction log_authentication_attempt(email, status, timestamp, connector)\n{\n encodeMD5(email, email_hash)\n \n addVar(audit_record, \"{}\")\n AddVariableToJSON(\"email_hash\", email_hash, audit_record)\n AddVariableToJSON(\"attempt_status\", status, audit_record)\n AddVariableToJSON(\"timestamp\", timestamp, audit_record)\n AddVariableToJSON(\"ip_address\", \"127.0.0.1\", audit_record)\n \n ormAccessInsert(audit_record, \"auth_audit_log\", insert_result)\n \n return(insert_result)\n}", - "test_inputs": { - "email": "user@example.com", - "password": "securepass123", - "client_id": "web_app_001" - }, - "test_list": [ - "re.match(r'.*authenticated.*', str(response_data))", - "re.match(r'.*access_token.*', str(response_data))", - "re.match(r'.*user_id.*', str(response_data))" - ], - "_detected": [ - "AddVariableToJSON", - "_status", - "addParam", - "addResult", - "addVar", - "avapConnector", - "else", - "encodeMD5", - "encodeSHA256", - "end", - "function", - "gather", - "getDateTime", - "getListLen", - "getTimeStamp", - "if_mode2", - "itemFromList", - "ormAccessInsert", - "ormAccessSelect", - "return", - "try", - "variableFromJSON" - ], - "_reward": { - "ecs": 0.579, - "novelty": 0.444, - "test_quality": 1.0, - "reward": 0.595, - "detected": [ - "AddVariableToJSON", - "_status", - "addParam", - "addResult", - "addVar", - "avapConnector", - "else", - "encodeMD5", - "encodeSHA256", - "end", - "function", - "gather", - "getDateTime", - "getListLen", - "getTimeStamp", - "if_mode2", - "itemFromList", - "ormAccessInsert", - "ormAccessSelect", - "return", - "try", - "variableFromJSON" - ] - } - }, - { - "task_id": 3, - "text": "Desarrollar un microservicio de gestión de inventario que reciba datos de productos mediante POST, valide la estructura de la base de datos, actualice el stock de productos existentes, registre movimientos de inventario en una tabla de auditoría, genere códigos de barras aleatorios para productos nuevos, y sincronice los cambios con un sistema externo de terceros. El servicio debe manejar múltiples productos concurrentemente, validar límites de stock, registrar timestamps de las operaciones, y retornar un reporte detallado con el estado de cada operación.", - "code": "include \"config/database_settings.avap\"\nimport \"inventory_utils\"\n\naddParam(\"products\", product_data)\naddParam(\"warehouse_id\", warehouse)\naddParam(\"operation_type\", operation)\n\nif(None, None, `product_data is None or warehouse is None`)\n _status = 400\n addVar(error_msg, \"Missing required parameters\")\n addResult(error_msg)\nelse()\n db_connector = avapConnector(\"inventory-db-uuid-54321\")\n \n ormCheckTable(\"products\", table_exists)\n \n if(table_exists, \"true\", \"==\")\n try()\n variableFromJSON(product_data, \"items\", items_list)\n getListLen(items_list, total_items)\n \n addVar(processed_items, \"[]\")\n addVar(success_count, 0)\n addVar(error_count, 0)\n \n startLoop(i, 0, total_items)\n itemFromList(items_list, i, current_item)\n \n process_task = go process_inventory_item(current_item, warehouse, operation, db_connector)\n sync_task = go sync_with_external_system(current_item)\n \n item_result = gather(process_task, 4000)\n sync_result = gather(sync_task, 3000)\n \n variableFromJSON(item_result, \"status\", item_status)\n \n if(item_status, \"success\", \"==\")\n success_count = success_count + 1\n \n variableFromJSON(item_result, \"product_id\", product_id)\n variableFromJSON(item_result, \"new_stock\", updated_stock)\n \n addVar(processed_item, \"{}\")\n AddVariableToJSON(\"product_id\", product_id, processed_item)\n AddVariableToJSON(\"status\", \"updated\", processed_item)\n AddVariableToJSON(\"stock_level\", updated_stock, processed_item)\n \n if(None, None, `sync_result is not None`)\n variableFromJSON(sync_result, \"external_id\", ext_id)\n AddVariableToJSON(\"external_sync_id\", ext_id, processed_item)\n end()\n else()\n error_count = error_count + 1\n \n addVar(error_item, \"{}\")\n variableFromJSON(item_result, \"error\", error_detail)\n AddVariableToJSON(\"status\", \"error\", error_item)\n AddVariableToJSON(\"message\", error_detail, error_item)\n end()\n endLoop()\n \n getDateTime(\"%Y-%m-%d %H:%M:%S\", 0, \"UTC\", operation_timestamp)\n \n addVar(final_response, \"{}\")\n AddVariableToJSON(\"operation_timestamp\", operation_timestamp, final_response)\n AddVariableToJSON(\"warehouse_id\", warehouse, final_response)\n AddVariableToJSON(\"total_processed\", total_items, final_response)\n AddVariableToJSON(\"successful_updates\", success_count, final_response)\n AddVariableToJSON(\"failed_updates\", error_count, final_response)\n AddVariableToJSON(\"processed_items\", processed_items, final_response)\n \n if(success_count, 0, \">\")\n _status = 200\n addResult(final_response)\n else()\n _status = 422\n addVar(process_error, \"No items could be processed\")\n addResult(process_error)\n end()\n exception(system_error)\n _status = 500\n addVar(exception_msg, \"Database operation failed\")\n addResult(exception_msg)\n end()\n else()\n _status = 503\n addVar(table_error, \"Products table not available\")\n addResult(table_error)\n end()\nend()\n\nfunction process_inventory_item(item, warehouse_id, op_type, connector)\n{\n variableFromJSON(item, \"sku\", product_sku)\n variableFromJSON(item, \"quantity\", quantity_change)\n \n ormAccessSelect(\"*\", \"products\", \"sku = '\" + product_sku + \"' AND warehouse_id = '\" + warehouse_id + \"'\", existing_products)\n \n getListLen(existing_products, product_count)\n \n addVar(result, \"{}\")\n \n if(product_count, 0, \">\")\n itemFromList(existing_products, 0, product_record)\n variableFromJSON(product_record, \"id\", product_id)\n variableFromJSON(product_record, \"current_stock\", current_stock)\n \n if(op_type, \"add\", \"==\")\n new_stock = current_stock + quantity_change\n else()\n new_stock = current_stock - quantity_change\n end()\n \n if(new_stock, 0, \">=\")\n addVar(update_data, \"{}\")\n AddVariableToJSON(\"current_stock\", new_stock, update_data)\n \n ormAccessUpdate(\"current_stock\", update_data, \"products\", \"id = \" + product_id, update_result)\n \n log_inventory_movement(product_id, op_type, quantity_change, warehouse_id, connector)\n \n AddVariableToJSON(\"status\", \"success\", result)\n AddVariableToJSON(\"product_id\", product_id, result)\n AddVariableToJSON(\"new_stock\", new_stock, result)\n else()\n AddVariableToJSON(\"status\", \"error\", result)\n AddVariableToJSON(\"error\", \"Insufficient stock\", result)\n end()\n else()\n randomString(\"[0-9]{12}\", 12, barcode)\n \n addVar(new_product, \"{}\")\n AddVariableToJSON(\"sku\", product_sku, new_product)\n AddVariableToJSON(\"warehouse_id\", warehouse_id, new_product)\n AddVariableToJSON(\"current_stock\", quantity_change, new_product)\n AddVariableToJSON(\"barcode\", barcode, new_product)\n \n ormAccessInsert(new_product, \"products\", insert_result)\n \n AddVariableToJSON(\"status\", \"success\", result)\n AddVariableToJSON(\"action\", \"created\", result)\n AddVariableToJSON(\"barcode\", barcode, result)\n end()\n \n return(result)\n}\n\nfunction sync_with_external_system(item)\n{\n external_connector = avapConnector(\"external-inventory-uuid-98765\")\n \n addVar(sync_payload, \"{}\")\n variableFromJSON(item, \"sku\", item_sku)\n AddVariableToJSON(\"sku\", item_sku, sync_payload)\n AddVariableToJSON(\"action\", \"inventory_update\", sync_payload)\n \n sync_response = external_connector.update_inventory(sync_payload)\n \n return(sync_response)\n}\n\nfunction log_inventory_movement(product_id, movement_type, quantity, warehouse_id, connector)\n{\n getDateTime(\"%Y-%m-%d %H:%M:%S\", 0, \"UTC\", movement_timestamp)\n \n addVar(audit_record, \"{}\")\n AddVariableToJSON(\"product_id\", product_id, audit_record)\n AddVariableToJSON(\"movement_type\", movement_type, audit_record)\n AddVariableToJSON(\"quantity_changed\", quantity, audit_record)\n AddVariableToJSON(\"warehouse_id\", warehouse_id, audit_record)\n AddVariableToJSON(\"timestamp\", movement_timestamp, audit_record)\n \n ormAccessInsert(audit_record, \"inventory_movements\", audit_result)\n \n return(audit_result)\n}", - "test_inputs": { - "products": "{\"items\": [{\"sku\": \"TEST-001\", \"quantity\": 50}]}", - "warehouse_id": "WH-001", - "operation_type": "add" - }, - "test_list": [ - "re.match(r'.*operation_timestamp.*', str(response))", - "re.match(r'.*successful_updates.*', str(response))", - "re.match(r'.*warehouse_id.*WH-001.*', str(response))" - ], - "_detected": [ - "AddVariableToJSON", - "_status", - "addParam", - "addResult", - "addVar", - "avapConnector", - "else", - "end", - "endLoop", - "function", - "gather", - "getDateTime", - "getListLen", - "if_mode2", - "import", - "itemFromList", - "ormAccessInsert", - "ormAccessSelect", - "ormAccessUpdate", - "ormCheckTable", - "randomString", - "return", - "startLoop", - "try", - "variableFromJSON" - ], - "_reward": { - "ecs": 0.658, - "novelty": 0.321, - "test_quality": 1.0, - "reward": 0.591, - "detected": [ - "AddVariableToJSON", - "_status", - "addParam", - "addResult", - "addVar", - "avapConnector", - "else", - "end", - "endLoop", - "function", - "gather", - "getDateTime", - "getListLen", - "if_mode2", - "import", - "itemFromList", - "ormAccessInsert", - "ormAccessSelect", - "ormAccessUpdate", - "ormCheckTable", - "randomString", - "return", - "startLoop", - "try", - "variableFromJSON" - ] - } - }, - { - "task_id": 4, - "text": "Desarrollar un microservicio de procesamiento de pagos que reciba datos de transacciones mediante POST, valide los parámetros usando expresiones regulares, consulte el historial de transacciones del usuario mediante SQL directo, envíe notificaciones push a sistemas externos, convierta timestamps entre formatos, registre eventos en una tabla de auditoría, y procese múltiples pagos concurrentemente. El servicio debe manejar errores de conexión, generar códigos de autorización aleatorios, y retornar estadísticas detalladas del procesamiento.", - "code": "include \"config/payment_settings.avap\"\nimport \"validation_utils\"\n\naddParam(\"transaction_data\", tx_data)\naddParam(\"user_id\", user_identifier)\naddParam(\"batch_size\", batch_limit)\n\nif(None, None, `tx_data is None or user_identifier is None`)\n _status = 400\n addVar(error_response, \"Missing required transaction data\")\n addResult(error_response)\nelse()\n getRegex(user_identifier, \"^[0-9]{6,12}$\", valid_user_id)\n \n if(valid_user_id, None, \"!=\")\n payment_connector = avapConnector(\"payment-gateway-uuid-11111\")\n db_connector = avapConnector(\"payments-db-uuid-22222\")\n \n try()\n variableFromJSON(tx_data, \"transactions\", tx_list)\n getListLen(tx_list, total_transactions)\n \n addVar(processed_results, \"[]\")\n addVar(success_count, 0)\n addVar(failed_count, 0)\n \n ormDirect(\"SELECT COUNT(*) as user_tx_count FROM transactions WHERE user_id = %s AND created_at > DATE_SUB(NOW(), INTERVAL 24 HOUR)\" % user_identifier, daily_tx_check)\n \n variableFromJSON(daily_tx_check, \"user_tx_count\", daily_count)\n \n if(daily_count, 50, \"<\")\n startLoop(i, 0, total_transactions)\n itemFromList(tx_list, i, current_tx)\n \n payment_task = go process_payment_transaction(current_tx, user_identifier, payment_connector)\n notification_task = go send_payment_notification(current_tx, user_identifier)\n \n payment_result = gather(payment_task, 8000)\n notification_result = gather(notification_task, 3000)\n \n variableFromJSON(payment_result, \"status\", tx_status)\n \n if(tx_status, \"approved\", \"==\")\n success_count = success_count + 1\n \n variableFromJSON(payment_result, \"transaction_id\", tx_id)\n variableFromJSON(payment_result, \"timestamp\", tx_timestamp)\n \n stampToDatetime(tx_timestamp, \"%Y-%m-%d %H:%M:%S\", 0, formatted_time)\n \n addVar(success_record, \"{}\")\n AddVariableToJSON(\"transaction_id\", tx_id, success_record)\n AddVariableToJSON(\"status\", \"completed\", success_record)\n AddVariableToJSON(\"processed_at\", formatted_time, success_record)\n \n audit_task = go log_payment_audit(tx_id, \"SUCCESS\", user_identifier, db_connector)\n audit_result = gather(audit_task, 2000)\n else()\n failed_count = failed_count + 1\n \n addVar(failed_record, \"{}\")\n variableFromJSON(payment_result, \"error_code\", error_code)\n AddVariableToJSON(\"status\", \"failed\", failed_record)\n AddVariableToJSON(\"error_code\", error_code, failed_record)\n \n audit_task = go log_payment_audit(\"UNKNOWN\", \"FAILED\", user_identifier, db_connector)\n audit_result = gather(audit_task, 2000)\n end()\n endLoop()\n \n getDateTime(\"%Y-%m-%d %H:%M:%S\", 0, \"UTC\", processing_timestamp)\n \n addVar(final_response, \"{}\")\n AddVariableToJSON(\"processing_timestamp\", processing_timestamp, final_response)\n AddVariableToJSON(\"user_id\", user_identifier, final_response)\n AddVariableToJSON(\"total_processed\", total_transactions, final_response)\n AddVariableToJSON(\"successful_payments\", success_count, final_response)\n AddVariableToJSON(\"failed_payments\", failed_count, final_response)\n \n if(success_count, 0, \">\")\n _status = 200\n addResult(final_response)\n else()\n _status = 422\n addVar(process_error, \"All payment transactions failed\")\n addResult(process_error)\n end()\n else()\n _status = 429\n addVar(limit_error, \"Daily transaction limit exceeded\")\n addResult(limit_error)\n end()\n exception(system_error)\n _status = 503\n addVar(exception_message, \"Payment processing service unavailable\")\n addResult(exception_message)\n end()\n else()\n _status = 422\n addVar(validation_error, \"Invalid user ID format\")\n addResult(validation_error)\n end()\nend()\n\nfunction process_payment_transaction(transaction, user_id, connector)\n{\n variableFromJSON(transaction, \"amount\", payment_amount)\n variableFromJSON(transaction, \"currency\", payment_currency)\n variableFromJSON(transaction, \"card_token\", card_token)\n \n randomString(\"[A-Z0-9]{16}\", 16, auth_code)\n \n addVar(payment_request, \"{}\")\n AddVariableToJSON(\"amount\", payment_amount, payment_request)\n AddVariableToJSON(\"currency\", payment_currency, payment_request)\n AddVariableToJSON(\"card_token\", card_token, payment_request)\n AddVariableToJSON(\"user_id\", user_id, payment_request)\n AddVariableToJSON(\"authorization_code\", auth_code, payment_request)\n \n payment_response = connector.process_payment(payment_request)\n \n return(payment_response)\n}\n\nfunction send_payment_notification(transaction, user_id)\n{\n addVar(notification_headers, \"{}\")\n AddVariableToJSON(\"Content-Type\", \"application/json\", notification_headers)\n AddVariableToJSON(\"Authorization\", \"Bearer notify-token-12345\", notification_headers)\n \n addVar(notification_body, \"{}\")\n AddVariableToJSON(\"user_id\", user_id, notification_body)\n AddVariableToJSON(\"event_type\", \"payment_processing\", notification_body)\n variableFromJSON(transaction, \"amount\", tx_amount)\n AddVariableToJSON(\"amount\", tx_amount, notification_body)\n \n RequestPost(\"https://notifications.example.com/push\", \"\", notification_headers, notification_body, notify_result, 5000)\n \n return(notify_result)\n}\n\nfunction log_payment_audit(transaction_id, status, user_id, connector)\n{\n getTimeStamp(\"2024-01-01 00:00:00\", \"%Y-%m-%d %H:%M:%S\", 0, base_timestamp)\n \n addVar(audit_data, \"{}\")\n AddVariableToJSON(\"transaction_id\", transaction_id, audit_data)\n AddVariableToJSON(\"status\", status, audit_data)\n AddVariableToJSON(\"user_id\", user_id, audit_data)\n AddVariableToJSON(\"audit_timestamp\", base_timestamp, audit_data)\n \n ormAccessInsert(audit_data, \"payment_audit_log\", insert_result)\n \n return(insert_result)\n}", - "test_inputs": { - "transaction_data": "{\"transactions\": [{\"amount\": 100.50, \"currency\": \"USD\", \"card_token\": \"card_abc123\"}]}", - "user_id": "123456789", - "batch_size": "10" - }, - "test_list": [ - "re.match(r'\\{.*\"processing_timestamp\".*\\}', final_response)", - "re.match(r'^[0-9]{6,12}$', user_identifier)", - "re.match(r'200|422|429', str(_status))" - ], - "_detected": [ - "AddVariableToJSON", - "RequestPost", - "_status", - "addParam", - "addResult", - "addVar", - "avapConnector", - "else", - "end", - "endLoop", - "function", - "gather", - "getDateTime", - "getListLen", - "getTimeStamp", - "if_mode2", - "import", - "itemFromList", - "ormAccessInsert", - "ormDirect", - "randomString", - "return", - "stampToDatetime", - "startLoop", - "try", - "variableFromJSON" - ], - "_reward": { - "ecs": 0.684, - "novelty": 0.241, - "test_quality": 1.0, - "reward": 0.577, - "detected": [ - "AddVariableToJSON", - "RequestPost", - "_status", - "addParam", - "addResult", - "addVar", - "avapConnector", - "else", - "end", - "endLoop", - "function", - "gather", - "getDateTime", - "getListLen", - "getTimeStamp", - "if_mode2", - "import", - "itemFromList", - "ormAccessInsert", - "ormDirect", - "randomString", - "return", - "stampToDatetime", - "startLoop", - "try", - "variableFromJSON" - ] - } - }, - { - "task_id": 5, - "text": "Desarrollar un microservicio de procesamiento de documentos que reciba múltiples archivos de texto, los descargue desde URLs externas, procese su contenido para extraer información específica mediante expresiones regulares, valide la integridad usando hashes MD5, sincronice los resultados con un sistema de terceros, y registre todas las operaciones en una tabla de auditoría. El servicio debe manejar errores de descarga, validar formatos de archivos, aplicar transformaciones de texto, y retornar un reporte detallado con estadísticas de procesamiento.", - "code": "include \"config/document_settings.avap\"\nimport \"text_processing_utils\"\n\ngetQueryParamList(\"doc_urls\", document_urls)\naddParam(\"format_type\", expected_format)\naddParam(\"validation_key\", client_key)\n\ngetListLen(document_urls, total_documents)\n\nif(total_documents, 0, \"==\")\n _status = 400\n addVar(error_msg, \"No document URLs provided\")\n addResult(error_msg)\nelse()\n db_connector = avapConnector(\"doc-processing-db-uuid-11223\")\n \n ormCheckTable(\"document_audit\", audit_table_exists)\n \n if(audit_table_exists, \"false\", \"==\")\n _status = 503\n addVar(table_error, \"Audit system unavailable\")\n addResult(table_error)\n else()\n try()\n addVar(processed_count, 0)\n addVar(failed_count, 0)\n addVar(processed_documents, \"[]\")\n addVar(validation_results, \"{}\")\n \n startLoop(i, 0, total_documents)\n itemFromList(document_urls, i, current_url)\n \n download_task = go download_document(current_url)\n validation_task = go validate_document_format(current_url, expected_format)\n \n document_content = gather(download_task, 8000)\n format_validation = gather(validation_task, 3000)\n \n variableFromJSON(format_validation, \"is_valid\", format_is_valid)\n \n if(format_is_valid, \"true\", \"==\")\n if(None, None, `document_content is not None`)\n processed_doc = process_document_content(document_content, i)\n variableFromJSON(processed_doc, \"status\", doc_status)\n \n if(doc_status, \"success\", \"==\")\n processed_count = processed_count + 1\n \n variableFromJSON(processed_doc, \"extracted_data\", extracted_info)\n variableFromJSON(processed_doc, \"md5_hash\", content_hash)\n \n sync_task = go sync_with_external_system(extracted_info, content_hash)\n sync_result = gather(sync_task, 4000)\n \n getDateTime(\"%Y-%m-%d %H:%M:%S\", 0, \"UTC\", process_timestamp)\n \n audit_record = log_processing_attempt(current_url, \"PROCESSED\", process_timestamp, content_hash, db_connector)\n \n addVar(doc_result, \"{}\")\n AddVariableToJSON(\"url\", current_url, doc_result)\n AddVariableToJSON(\"status\", \"processed\", doc_result)\n AddVariableToJSON(\"hash\", content_hash, doc_result)\n AddVariableToJSON(\"timestamp\", process_timestamp, doc_result)\n \n if(None, None, `sync_result is not None`)\n variableFromJSON(sync_result, \"external_id\", ext_id)\n AddVariableToJSON(\"external_sync_id\", ext_id, doc_result)\n end()\n else()\n failed_count = failed_count + 1\n \n getDateTime(\"%Y-%m-%d %H:%M:%S\", 0, \"UTC\", error_timestamp)\n audit_record = log_processing_attempt(current_url, \"FAILED\", error_timestamp, \"unknown\", db_connector)\n end()\n else()\n failed_count = failed_count + 1\n end()\n else()\n failed_count = failed_count + 1\n end()\n endLoop()\n \n total_processed = processed_count + failed_count\n success_rate = (processed_count * 100) / total_processed\n \n addVar(final_report, \"{}\")\n AddVariableToJSON(\"total_documents\", total_documents, final_report)\n AddVariableToJSON(\"successfully_processed\", processed_count, final_report)\n AddVariableToJSON(\"failed_processing\", failed_count, final_report)\n AddVariableToJSON(\"success_rate_percent\", success_rate, final_report)\n AddVariableToJSON(\"processed_documents\", processed_documents, final_report)\n AddVariableToJSON(\"validation_results\", validation_results, final_report)\n \n if(processed_count, 0, \">\")\n _status = 200\n addResult(final_report)\n else()\n _status = 422\n addVar(no_success_error, \"No documents could be processed\")\n addResult(no_success_error)\n end()\n exception(system_error)\n _status = 500\n addVar(exception_message, \"Document processing system failed\")\n addResult(exception_message)\n end()\n end()\nend()\n\nfunction download_document(url)\n{\n addVar(headers, \"{}\")\n AddVariableToJSON(\"Accept\", \"text/plain,application/pdf\", headers)\n AddVariableToJSON(\"User-Agent\", \"AVAP-DocumentProcessor/2.0\", headers)\n \n try()\n RequestGet(url, \"\", headers, response_content, 10000)\n return(response_content)\n exception(download_error)\n return(None)\n end()\n}\n\nfunction validate_document_format(url, expected_format)\n{\n addVar(validation_result, \"{}\")\n \n getRegex(url, \"\\\\.(txt|pdf|docx)$\", file_extension)\n \n if(None, None, `file_extension is not None`)\n if(file_extension, expected_format, \"==\")\n AddVariableToJSON(\"is_valid\", \"true\", validation_result)\n AddVariableToJSON(\"detected_format\", file_extension, validation_result)\n else()\n AddVariableToJSON(\"is_valid\", \"false\", validation_result)\n AddVariableToJSON(\"reason\", \"format_mismatch\", validation_result)\n end()\n else()\n AddVariableToJSON(\"is_valid\", \"false\", validation_result)\n AddVariableToJSON(\"reason\", \"unknown_format\", validation_result)\n end()\n \n return(validation_result)\n}\n\nfunction process_document_content(content, doc_index)\n{\n addVar(processing_result, \"{}\")\n \n encodeMD5(content, content_md5)\n \n replace(content, \"\\\\n\", \" \", normalized_content)\n replace(normalized_content, \"\\\\t\", \" \", clean_content)\n \n getRegex(clean_content, \"([A-Z][a-z]+ [A-Z][a-z]+)\", extracted_names)\n getRegex(clean_content, \"([0-9]{4}-[0-9]{2}-[0-9]{2})\", extracted_dates)\n getRegex(clean_content, \"([a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\\\.[a-zA-Z]{2,})\", extracted_emails)\n \n if(None, None, `extracted_names is not None or extracted_dates is not None`)\n addVar(extracted_data, \"{}\")\n AddVariableToJSON(\"names\", extracted_names, extracted_data)\n AddVariableToJSON(\"dates\", extracted_dates, extracted_data)\n AddVariableToJSON(\"emails\", extracted_emails, extracted_data)\n AddVariableToJSON(\"document_index\", doc_index, extracted_data)\n \n AddVariableToJSON(\"status\", \"success\", processing_result)\n AddVariableToJSON(\"extracted_data\", extracted_data, processing_result)\n AddVariableToJSON(\"md5_hash\", content_md5, processing_result)\n else()\n AddVariableToJSON(\"status\", \"failed\", processing_result)\n AddVariableToJSON(\"error\", \"no_extractable_data\", processing_result)\n end()\n \n return(processing_result)\n}\n\nfunction sync_with_external_system(data, hash)\n{\n external_connector = avapConnector(\"external-docs-uuid-99887\")\n \n addVar(sync_payload, \"{}\")\n AddVariableToJSON(\"document_data\", data, sync_payload)\n AddVariableToJSON(\"integrity_hash\", hash, sync_payload)\n AddVariableToJSON(\"action\", \"document_processed\", sync_payload)\n \n sync_response = external_connector.submit_document(sync_payload)\n \n return(sync_response)\n}\n\nfunction log_processing_attempt(url, status, timestamp, hash, connector)\n{\n randomString(\"[A-Z0-9]{8}\", 8, operation_id)\n \n addVar(audit_entry, \"{}\")\n AddVariableToJSON(\"operation_id\", operation_id, audit_entry)\n AddVariableToJSON(\"document_url\", url, audit_entry)\n AddVariableToJSON(\"processing_status\", status, audit_entry)\n AddVariableToJSON(\"timestamp\", timestamp, audit_entry)\n AddVariableToJSON(\"content_hash\", hash, audit_entry)\n \n ormAccessInsert(audit_entry, \"document_audit\", audit_result)\n \n return(audit_result)\n}", - "test_inputs": { - "doc_urls": [ - "https://example.com/doc1.txt", - "https://example.com/doc2.txt" - ], - "format_type": "txt", - "validation_key": "client123" - }, - "test_list": [ - "re.match(r'\\d+', str(final_report.get('total_documents', 0)))", - "re.match(r'\\d+', str(final_report.get('successfully_processed', 0)))", - "re.match(r'^(PROCESSED|FAILED)$', audit_entry.get('processing_status', ''))" - ], - "_detected": [ - "AddVariableToJSON", - "RequestGet", - "_status", - "addParam", - "addResult", - "addVar", - "avapConnector", - "else", - "encodeMD5", - "end", - "endLoop", - "function", - "gather", - "getDateTime", - "getListLen", - "getQueryParamList", - "if_mode2", - "import", - "itemFromList", - "ormAccessInsert", - "ormCheckTable", - "randomString", - "replace", - "return", - "startLoop", - "try", - "variableFromJSON" - ], - "_reward": { - "ecs": 0.711, - "novelty": 0.207, - "test_quality": 1.0, - "reward": 0.578, - "detected": [ - "AddVariableToJSON", - "RequestGet", - "_status", - "addParam", - "addResult", - "addVar", - "avapConnector", - "else", - "encodeMD5", - "end", - "endLoop", - "function", - "gather", - "getDateTime", - "getListLen", - "getQueryParamList", - "if_mode2", - "import", - "itemFromList", - "ormAccessInsert", - "ormCheckTable", - "randomString", - "replace", - "return", - "startLoop", - "try", - "variableFromJSON" - ] - } - }, - { - "task_id": 6, - "text": "Desarrollar un microservicio de auditoría financiera que procese transacciones bancarias desde múltiples fuentes, valide cada transacción contra patrones de fraude, actualice balances de cuentas en tiempo real, y genere reportes de compliance. El servicio debe manejar archivos CSV de transacciones, verificar integridad mediante hash SHA256, sincronizar con sistemas externos de validación KYC, registrar todas las operaciones en tablas de auditoría, y manejar errores de conectividad con reintentos automáticos.", - "code": "include \"config/fraud_detection_rules.avap\"\nimport \"compliance_utils\"\n\naddParam(\"transaction_file\", csv_data)\naddParam(\"batch_id\", batch_identifier)\naddParam(\"validation_level\", security_level)\n\nif(csv_data, None, \"!=\")\n encodeSHA256(csv_data, file_hash)\n getDateTime(\"%Y-%m-%d %H:%M:%S\", 0, \"UTC\", process_start)\n \n db_connector = avapConnector(\"audit-db-uuid-11111\")\n \n try()\n ormDirect(\"CREATE TABLE IF NOT EXISTS transaction_audit (id SERIAL, batch_id VARCHAR(50), hash VARCHAR(64), status VARCHAR(20), timestamp TIMESTAMP)\", create_result)\n \n ormCheckTable(\"accounts\", accounts_exist)\n \n if(accounts_exist, \"true\", \"==\")\n variableToList(csv_data, transactions_raw)\n replace(csv_data, \"\\n\", \"|\", normalized_data)\n getRegex(normalized_data, \"([0-9]{10,16}),([0-9\\.]+),(DEBIT|CREDIT)\", transaction_pattern)\n \n variableToList(transaction_pattern, transactions_list)\n getListLen(transactions_list, total_transactions)\n \n addVar(processed_count, 0)\n addVar(fraud_detected, 0)\n addVar(validation_errors, 0)\n addVar(final_report, \"{}\")\n \n startLoop(i, 0, total_transactions)\n itemFromList(transactions_list, i, current_transaction)\n \n validation_task = go validate_transaction_integrity(current_transaction, security_level)\n kyc_task = go verify_kyc_compliance(current_transaction)\n \n validation_result = gather(validation_task, 3000)\n kyc_result = gather(kyc_task, 5000)\n \n variableFromJSON(validation_result, \"is_valid\", transaction_valid)\n variableFromJSON(validation_result, \"account_id\", account_number)\n variableFromJSON(validation_result, \"amount\", transaction_amount)\n variableFromJSON(validation_result, \"type\", operation_type)\n \n if(transaction_valid, \"true\", \"==\")\n variableFromJSON(kyc_result, \"compliance_status\", kyc_status)\n \n if(kyc_status, \"APPROVED\", \"==\")\n ormAccessSelect(\"balance\", \"accounts\", \"account_id = '\" + account_number + \"'\", account_data)\n getListLen(account_data, account_found)\n \n if(account_found, 0, \">\")\n itemFromList(account_data, 0, account_record)\n variableFromJSON(account_record, \"balance\", current_balance)\n \n if(operation_type, \"DEBIT\", \"==\")\n new_balance = current_balance - transaction_amount\n else()\n new_balance = current_balance + transaction_amount\n end()\n \n addVar(balance_update, \"{}\")\n AddVariableToJSON(\"balance\", new_balance, balance_update)\n \n ormAccessUpdate(\"balance\", balance_update, \"accounts\", \"account_id = '\" + account_number + \"'\", update_result)\n \n log_audit_entry(batch_identifier, account_number, transaction_amount, \"SUCCESS\", db_connector)\n processed_count = processed_count + 1\n else()\n log_audit_entry(batch_identifier, account_number, transaction_amount, \"ACCOUNT_NOT_FOUND\", db_connector)\n validation_errors = validation_errors + 1\n end()\n else()\n log_audit_entry(batch_identifier, account_number, transaction_amount, \"KYC_FAILED\", db_connector)\n fraud_detected = fraud_detected + 1\n end()\n else()\n validation_errors = validation_errors + 1\n end()\n endLoop()\n \n getDateTime(\"%Y-%m-%d %H:%M:%S\", 0, \"UTC\", process_end)\n \n AddVariableToJSON(\"batch_id\", batch_identifier, final_report)\n AddVariableToJSON(\"file_hash\", file_hash, final_report)\n AddVariableToJSON(\"total_transactions\", total_transactions, final_report)\n AddVariableToJSON(\"processed_successfully\", processed_count, final_report)\n AddVariableToJSON(\"fraud_detected\", fraud_detected, final_report)\n AddVariableToJSON(\"validation_errors\", validation_errors, final_report)\n AddVariableToJSON(\"process_start_time\", process_start, final_report)\n AddVariableToJSON(\"process_end_time\", process_end, final_report)\n \n external_audit_task = go submit_compliance_report(final_report)\n compliance_response = gather(external_audit_task, 8000)\n \n if(None, None, `compliance_response is not None`)\n variableFromJSON(compliance_response, \"audit_id\", external_audit_id)\n AddVariableToJSON(\"external_audit_id\", external_audit_id, final_report)\n end()\n \n _status = 200\n addResult(final_report)\n else()\n _status = 503\n addVar(db_error, \"Accounts table not available\")\n addResult(db_error)\n end()\n exception(system_error)\n _status = 500\n addVar(exception_msg, \"Financial audit system failure\")\n AddVariableToJSON(\"error_details\", system_error, exception_msg)\n addResult(exception_msg)\n end()\nelse()\n _status = 400\n addVar(missing_data, \"Transaction file data required\")\n addResult(missing_data)\nend()\n\nfunction validate_transaction_integrity(transaction_data, level)\n{\n getRegex(transaction_data, \"([0-9]{10,16}),([0-9\\.]+),(DEBIT|CREDIT)\", parsed_fields)\n \n addVar(validation_response, \"{}\")\n \n if(None, None, `parsed_fields is not None`)\n variableFromJSON(parsed_fields, \"account\", account_id)\n variableFromJSON(parsed_fields, \"amount\", amount_value)\n variableFromJSON(parsed_fields, \"operation\", op_type)\n \n amount_float = float(amount_value)\n \n if(level, \"HIGH\", \"==\")\n max_limit = 100000.0\n else()\n max_limit = 50000.0\n end()\n \n if(None, None, `amount_float > 0 and amount_float <= max_limit`)\n AddVariableToJSON(\"is_valid\", \"true\", validation_response)\n AddVariableToJSON(\"account_id\", account_id, validation_response)\n AddVariableToJSON(\"amount\", amount_float, validation_response)\n AddVariableToJSON(\"type\", op_type, validation_response)\n else()\n AddVariableToJSON(\"is_valid\", \"false\", validation_response)\n AddVariableToJSON(\"reason\", \"amount_out_of_range\", validation_response)\n end()\n else()\n AddVariableToJSON(\"is_valid\", \"false\", validation_response)\n AddVariableToJSON(\"reason\", \"invalid_format\", validation_response)\n end()\n \n return(validation_response)\n}\n\nfunction verify_kyc_compliance(transaction_data)\n{\n kyc_connector = avapConnector(\"kyc-service-uuid-22222\")\n \n addVar(kyc_payload, \"{}\")\n variableFromJSON(transaction_data, \"account\", account_for_kyc)\n AddVariableToJSON(\"account_id\", account_for_kyc, kyc_payload)\n AddVariableToJSON(\"check_type\", \"TRANSACTION_VALIDATION\", kyc_payload)\n \n try()\n kyc_response = kyc_connector.validate_account(kyc_payload)\n return(kyc_response)\n exception(kyc_error)\n addVar(fallback_response, \"{}\")\n AddVariableToJSON(\"compliance_status\", \"ERROR\", fallback_response)\n AddVariableToJSON(\"error\", \"KYC service unavailable\", fallback_response)\n return(fallback_response)\n end()\n}\n\nfunction submit_compliance_report(report_data)\n{\n compliance_connector = avapConnector(\"compliance-api-uuid-33333\")\n \n addVar(headers, \"{}\")\n AddVariableToJSON(\"Content-Type\", \"application/json\", headers)\n AddVariableToJSON(\"Authorization\", \"Bearer compliance-token-xyz\", headers)\n \n RequestPost(\"https://compliance-api.bank.com/audit/submit\", \"\", headers, report_data, compliance_result, 10000)\n \n return(compliance_result)\n}\n\nfunction log_audit_entry(batch_id, account_id, amount, status, connector)\n{\n getDateTime(\"%Y-%m-%d %H:%M:%S\", 0, \"UTC\", audit_timestamp)\n \n addVar(audit_record, \"{}\")\n AddVariableToJSON(\"batch_id\", batch_id, audit_record)\n AddVariableToJSON(\"account_id\", account_id, audit_record)\n AddVariableToJSON(\"amount\", amount, audit_record)\n AddVariableToJSON(\"status\", status, audit_record)\n AddVariableToJSON(\"timestamp\", audit_timestamp, audit_record)\n \n ormAccessInsert(audit_record, \"transaction_audit\", insert_result)\n \n return(insert_result)\n}", - "test_inputs": { - "transaction_file": "1234567890123456,1500.50,DEBIT\\n9876543210987654,2300.75,CREDIT\\n1111222233334444,850.25,DEBIT", - "batch_id": "BATCH_20241215_001", - "validation_level": "HIGH" - }, - "test_list": [ - "re.match(r'.*batch_id.*BATCH_20241215_001.*', final_report)", - "re.match(r'.*total_transactions.*[1-9].*', final_report)", - "re.match(r'.*file_hash.*[a-f0-9]{64}.*', final_report)" - ], - "_detected": [ - "AddVariableToJSON", - "RequestPost", - "_status", - "addParam", - "addResult", - "addVar", - "avapConnector", - "else", - "encodeSHA256", - "end", - "endLoop", - "function", - "gather", - "getDateTime", - "getListLen", - "if_mode2", - "import", - "itemFromList", - "ormAccessInsert", - "ormAccessSelect", - "ormAccessUpdate", - "ormCheckTable", - "ormDirect", - "replace", - "return", - "startLoop", - "try", - "variableFromJSON" - ], - "_reward": { - "ecs": 0.737, - "novelty": 0.172, - "test_quality": 1.0, - "reward": 0.579, - "detected": [ - "AddVariableToJSON", - "RequestPost", - "_status", - "addParam", - "addResult", - "addVar", - "avapConnector", - "else", - "encodeSHA256", - "end", - "endLoop", - "function", - "gather", - "getDateTime", - "getListLen", - "if_mode2", - "import", - "itemFromList", - "ormAccessInsert", - "ormAccessSelect", - "ormAccessUpdate", - "ormCheckTable", - "ormDirect", - "replace", - "return", - "startLoop", - "try", - "variableFromJSON" - ] - } - }, - { - "task_id": 7, - "text": "Desarrollar un servicio de monitoreo de salud de APIs que reciba una lista de endpoints desde parámetros de query, valide cada URL mediante expresiones regulares, ejecute comprobaciones de salud concurrentes con timeouts configurables, registre los resultados en una base de datos con timestamps convertidos, genere códigos MD5 de identificación únicos para cada comprobación, y sincronice los datos con un sistema externo de alertas. El servicio debe manejar errores de red mediante bloques try/exception, procesar respuestas JSON de los endpoints monitoreados, y retornar un reporte consolidado con estadísticas de disponibilidad y tiempos de respuesta.", - "code": "include \"monitoring/health_config.avap\"\nimport \"response_analyzer\"\n\ngetQueryParamList(\"endpoints\", endpoint_list)\naddParam(\"timeout_ms\", request_timeout)\naddParam(\"alert_threshold\", threshold_value)\n\ngetListLen(endpoint_list, total_endpoints)\n\nif(total_endpoints, 0, \"==\")\n _status = 400\n addVar(error_msg, \"No endpoints provided for monitoring\")\n addResult(error_msg)\nelse()\n db_connector = avapConnector(\"health-monitor-db-uuid-11111\")\n alert_connector = avapConnector(\"alert-system-uuid-22222\")\n \n addVar(monitoring_results, \"[]\")\n addVar(healthy_count, 0)\n addVar(unhealthy_count, 0)\n addVar(timeout_count, 0)\n \n getDateTime(\"%Y-%m-%d %H:%M:%S\", 0, \"UTC\", scan_start_time)\n getTimeStamp(scan_start_time, \"%Y-%m-%d %H:%M:%S\", 0, scan_timestamp)\n \n try()\n startLoop(i, 0, total_endpoints)\n itemFromList(endpoint_list, i, current_endpoint)\n \n getRegex(current_endpoint, \"^https?://[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}(/.*)?$\", url_valid)\n \n if(None, None, `url_valid is not None`)\n health_task = go check_endpoint_health(current_endpoint, request_timeout)\n sync_task = go sync_health_data(current_endpoint, alert_connector)\n \n health_result = gather(health_task, 8000)\n sync_result = gather(sync_task, 3000)\n \n if(None, None, `health_result is not None`)\n variableFromJSON(health_result, \"status\", endpoint_status)\n variableFromJSON(health_result, \"response_time\", response_time)\n variableFromJSON(health_result, \"status_code\", http_code)\n \n encodeMD5(current_endpoint, endpoint_hash)\n stampToDatetime(scan_timestamp, \"%Y-%m-%d %H:%M:%S\", 0, formatted_timestamp)\n \n addVar(health_record, \"{}\")\n AddVariableToJSON(\"endpoint_url\", current_endpoint, health_record)\n AddVariableToJSON(\"endpoint_hash\", endpoint_hash, health_record)\n AddVariableToJSON(\"health_status\", endpoint_status, health_record)\n AddVariableToJSON(\"response_time_ms\", response_time, health_record)\n AddVariableToJSON(\"http_status_code\", http_code, health_record)\n AddVariableToJSON(\"checked_at\", formatted_timestamp, health_record)\n \n if(endpoint_status, \"healthy\", \"==\")\n healthy_count = healthy_count + 1\n else()\n if(endpoint_status, \"timeout\", \"==\")\n timeout_count = timeout_count + 1\n else()\n unhealthy_count = unhealthy_count + 1\n end()\n end()\n \n ormAccessInsert(health_record, \"health_checks\", insert_result)\n else()\n timeout_count = timeout_count + 1\n end()\n else()\n unhealthy_count = unhealthy_count + 1\n end()\n endLoop()\n \n addVar(summary_report, \"{}\")\n AddVariableToJSON(\"scan_timestamp\", scan_start_time, summary_report)\n AddVariableToJSON(\"total_endpoints\", total_endpoints, summary_report)\n AddVariableToJSON(\"healthy_endpoints\", healthy_count, summary_report)\n AddVariableToJSON(\"unhealthy_endpoints\", unhealthy_count, summary_report)\n AddVariableToJSON(\"timeout_endpoints\", timeout_count, summary_report)\n \n availability_percentage = (healthy_count * 100) / total_endpoints\n AddVariableToJSON(\"availability_percentage\", availability_percentage, summary_report)\n \n if(healthy_count, 0, \">\")\n _status = 200\n addResult(summary_report)\n else()\n _status = 503\n addVar(all_down_msg, \"All monitored endpoints are unavailable\")\n addResult(all_down_msg)\n end()\n exception(monitoring_error)\n _status = 500\n addVar(exception_msg, \"Health monitoring system failure\")\n addResult(exception_msg)\n end()\nend()\n\nfunction check_endpoint_health(endpoint_url, timeout_ms)\n{\n addVar(headers, \"{}\")\n AddVariableToJSON(\"User-Agent\", \"HealthMonitor/1.0\", headers)\n AddVariableToJSON(\"Accept\", \"application/json\", headers)\n \n getDateTime(\"%Y-%m-%d %H:%M:%S.%f\", 0, \"UTC\", start_time)\n \n try()\n RequestGet(endpoint_url, \"\", headers, response_data, timeout_ms)\n \n getDateTime(\"%Y-%m-%d %H:%M:%S.%f\", 0, \"UTC\", end_time)\n getTimeStamp(end_time, \"%Y-%m-%d %H:%M:%S.%f\", 0, end_timestamp)\n getTimeStamp(start_time, \"%Y-%m-%d %H:%M:%S.%f\", 0, start_timestamp)\n \n response_time = end_timestamp - start_timestamp\n \n addVar(health_response, \"{}\")\n \n if(None, None, `response_data is not None`)\n variableFromJSON(response_data, \"status\", api_status)\n \n if(None, None, `\"200\" in str(response_data)`)\n AddVariableToJSON(\"status\", \"healthy\", health_response)\n AddVariableToJSON(\"status_code\", 200, health_response)\n else()\n AddVariableToJSON(\"status\", \"unhealthy\", health_response)\n AddVariableToJSON(\"status_code\", 500, health_response)\n end()\n else()\n AddVariableToJSON(\"status\", \"timeout\", health_response)\n AddVariableToJSON(\"status_code\", 0, health_response)\n end()\n \n AddVariableToJSON(\"response_time\", response_time, health_response)\n return(health_response)\n exception(request_error)\n addVar(error_response, \"{}\")\n AddVariableToJSON(\"status\", \"error\", error_response)\n AddVariableToJSON(\"status_code\", 0, error_response)\n AddVariableToJSON(\"response_time\", 0, error_response)\n return(error_response)\n end()\n}\n\nfunction sync_health_data(endpoint_url, alert_connector)\n{\n addVar(alert_payload, \"{}\")\n AddVariableToJSON(\"endpoint\", endpoint_url, alert_payload)\n AddVariableToJSON(\"monitor_type\", \"health_check\", alert_payload)\n AddVariableToJSON(\"severity\", \"info\", alert_payload)\n \n alert_response = alert_connector.send_health_update(alert_payload)\n \n return(alert_response)\n}", - "test_inputs": { - "endpoints": [ - "https://api.github.com", - "https://httpbin.org/status/200" - ], - "timeout_ms": 5000, - "alert_threshold": 500 - }, - "test_list": [ - "re.match(r'.*healthy_endpoints.*', summary_report)", - "re.match(r'.*availability_percentage.*', summary_report)", - "re.match(r'.*scan_timestamp.*', summary_report)" - ], - "_detected": [ - "AddVariableToJSON", - "RequestGet", - "_status", - "addParam", - "addResult", - "addVar", - "avapConnector", - "else", - "encodeMD5", - "end", - "endLoop", - "function", - "gather", - "getDateTime", - "getListLen", - "getQueryParamList", - "getTimeStamp", - "if_mode2", - "import", - "itemFromList", - "ormAccessInsert", - "return", - "stampToDatetime", - "startLoop", - "try", - "variableFromJSON" - ], - "_reward": { - "ecs": 0.684, - "novelty": 0.172, - "test_quality": 1.0, - "reward": 0.552, - "detected": [ - "AddVariableToJSON", - "RequestGet", - "_status", - "addParam", - "addResult", - "addVar", - "avapConnector", - "else", - "encodeMD5", - "end", - "endLoop", - "function", - "gather", - "getDateTime", - "getListLen", - "getQueryParamList", - "getTimeStamp", - "if_mode2", - "import", - "itemFromList", - "ormAccessInsert", - "return", - "stampToDatetime", - "startLoop", - "try", - "variableFromJSON" - ] - } - }, - { - "task_id": 8, - "text": "Desarrollar un microservicio de procesamiento de transacciones financieras que reciba datos de múltiples transacciones mediante POST, valide los montos contra límites configurados en archivos incluidos, calcule hashes SHA256 para auditoría, registre las operaciones en base de datos usando SQL directo para consultas complejas, actualice saldos de cuentas mediante ORM, maneje excepciones de conectividad, procese notificaciones concurrentemente usando gorrutinas, y retorne un reporte detallado. El servicio debe validar formatos de números de cuenta, aplicar comisiones según el tipo de transacción, registrar timestamps de procesamiento, y sincronizar con sistemas bancarios externos.", - "code": "include \"config/transaction_limits.avap\"\nimport \"banking_utils\"\n\naddParam(\"transactions\", transaction_data)\naddParam(\"account_id\", source_account)\naddParam(\"transaction_type\", tx_type)\n\nif(transaction_data, None, \"!=\")\n db_connector = avapConnector(\"banking-db-uuid-98765\")\n \n try()\n variableFromJSON(transaction_data, \"items\", tx_list)\n getListLen(tx_list, total_transactions)\n \n addVar(processed_count, 0)\n addVar(failed_count, 0)\n addVar(total_amount, 0)\n addVar(processing_results, \"[]\")\n \n startLoop(i, 0, total_transactions)\n itemFromList(tx_list, i, current_tx)\n \n variableFromJSON(current_tx, \"amount\", tx_amount)\n variableFromJSON(current_tx, \"recipient_account\", recipient)\n variableFromJSON(current_tx, \"description\", tx_description)\n \n if(tx_amount, 10000, \">\")\n addVar(validation_error, \"Amount exceeds limit\")\n failed_count = failed_count + 1\n else()\n encodeSHA256(tx_description, description_hash)\n getDateTime(\"%Y-%m-%d %H:%M:%S\", 0, \"UTC\", processing_timestamp)\n \n notification_task = go send_transaction_notification(recipient, tx_amount, processing_timestamp)\n validation_task = go validate_account_balance(source_account, tx_amount, db_connector)\n \n validation_result = gather(validation_task, 3000)\n notification_result = gather(notification_task, 2000)\n \n variableFromJSON(validation_result, \"is_valid\", balance_valid)\n \n if(balance_valid, \"true\", \"==\")\n commission_rate = calculate_commission(tx_type, tx_amount)\n final_amount = tx_amount + commission_rate\n \n ormDirect(\"UPDATE accounts SET balance = balance - %s WHERE account_id = '%s'\" % final_amount % source_account, update_result)\n ormAccessUpdate(\"balance\", \"balance + \" + tx_amount, \"accounts\", \"account_id = '\" + recipient + \"'\", recipient_update)\n \n addVar(tx_record, \"{}\")\n AddVariableToJSON(\"source_account\", source_account, tx_record)\n AddVariableToJSON(\"recipient_account\", recipient, tx_record)\n AddVariableToJSON(\"amount\", tx_amount, tx_record)\n AddVariableToJSON(\"commission\", commission_rate, tx_record)\n AddVariableToJSON(\"description_hash\", description_hash, tx_record)\n AddVariableToJSON(\"timestamp\", processing_timestamp, tx_record)\n AddVariableToJSON(\"status\", \"completed\", tx_record)\n \n ormAccessInsert(tx_record, \"transactions\", insert_result)\n \n processed_count = processed_count + 1\n total_amount = total_amount + tx_amount\n else()\n failed_count = failed_count + 1\n end()\n end()\n endLoop()\n \n addVar(final_report, \"{}\")\n AddVariableToJSON(\"total_processed\", processed_count, final_report)\n AddVariableToJSON(\"total_failed\", failed_count, final_report)\n AddVariableToJSON(\"total_amount\", total_amount, final_report)\n AddVariableToJSON(\"processing_results\", processing_results, final_report)\n \n if(processed_count, 0, \">\")\n _status = 200\n addResult(final_report)\n else()\n _status = 422\n addVar(process_error, \"No transactions could be processed\")\n addResult(process_error)\n end()\n exception(system_error)\n _status = 500\n addVar(exception_msg, \"Transaction processing system unavailable\")\n addResult(exception_msg)\n end()\nelse()\n _status = 400\n addVar(missing_data, \"Transaction data is required\")\n addResult(missing_data)\nend()\n\nfunction send_transaction_notification(recipient, amount, timestamp)\n{\n notification_service = avapConnector(\"notification-service-uuid-11111\")\n \n addVar(notification_payload, \"{}\")\n AddVariableToJSON(\"recipient\", recipient, notification_payload)\n AddVariableToJSON(\"amount\", amount, notification_payload)\n AddVariableToJSON(\"timestamp\", timestamp, notification_payload)\n AddVariableToJSON(\"type\", \"transaction_received\", notification_payload)\n \n notification_response = notification_service.send_notification(notification_payload)\n \n return(notification_response)\n}\n\nfunction validate_account_balance(account_id, required_amount, connector)\n{\n ormAccessSelect(\"balance\", \"accounts\", \"account_id = '\" + account_id + \"'\", balance_records)\n \n getListLen(balance_records, record_count)\n \n addVar(validation_response, \"{}\")\n \n if(record_count, 0, \">\")\n itemFromList(balance_records, 0, balance_record)\n variableFromJSON(balance_record, \"balance\", current_balance)\n \n if(None, None, `current_balance >= required_amount`)\n AddVariableToJSON(\"is_valid\", \"true\", validation_response)\n AddVariableToJSON(\"available_balance\", current_balance, validation_response)\n else()\n AddVariableToJSON(\"is_valid\", \"false\", validation_response)\n AddVariableToJSON(\"reason\", \"insufficient_funds\", validation_response)\n end()\n else()\n AddVariableToJSON(\"is_valid\", \"false\", validation_response)\n AddVariableToJSON(\"reason\", \"account_not_found\", validation_response)\n end()\n \n return(validation_response)\n}\n\nfunction calculate_commission(transaction_type, amount)\n{\n if(transaction_type, \"domestic\", \"==\")\n commission = amount * 0.01\n else()\n if(transaction_type, \"international\", \"==\")\n commission = amount * 0.03\n else()\n commission = amount * 0.02\n end()\n end()\n \n return(commission)\n}", - "test_inputs": { - "transactions": "{\"items\": [{\"amount\": 5000, \"recipient_account\": \"ACC789\", \"description\": \"Payment transfer\"}]}", - "account_id": "ACC123", - "transaction_type": "domestic" - }, - "test_list": [ - "re.match(r'.*total_processed.*', final_report)", - "re.match(r'.*completed.*', tx_record)", - "re.match(r'.*[0-9a-f]{64}.*', description_hash)" - ], - "_detected": [ - "AddVariableToJSON", - "_status", - "addParam", - "addResult", - "addVar", - "avapConnector", - "else", - "encodeSHA256", - "end", - "endLoop", - "function", - "gather", - "getDateTime", - "getListLen", - "if_mode2", - "import", - "itemFromList", - "ormAccessInsert", - "ormAccessSelect", - "ormAccessUpdate", - "ormDirect", - "return", - "startLoop", - "try", - "variableFromJSON" - ], - "_reward": { - "ecs": 0.658, - "novelty": 0.107, - "test_quality": 1.0, - "reward": 0.516, - "detected": [ - "AddVariableToJSON", - "_status", - "addParam", - "addResult", - "addVar", - "avapConnector", - "else", - "encodeSHA256", - "end", - "endLoop", - "function", - "gather", - "getDateTime", - "getListLen", - "if_mode2", - "import", - "itemFromList", - "ormAccessInsert", - "ormAccessSelect", - "ormAccessUpdate", - "ormDirect", - "return", - "startLoop", - "try", - "variableFromJSON" - ] - } - }, - { - "task_id": 9, - "text": "Desarrollar un microservicio de monitoreo de salud que reciba múltiples endpoints para verificar, realice peticiones HTTP concurrentes con timeout, procese las respuestas, calcule métricas de disponibilidad, convierta timestamps de las respuestas, registre los resultados en base de datos, maneje errores de conectividad, y genere un reporte consolidado con estadísticas de uptime y códigos de estado por servicio.", - "code": "include \"monitoring/health_config.avap\"\ngetQueryParamList(\"endpoints\", endpoint_list)\naddParam(\"alert_threshold\", threshold)\naddParam(\"check_interval\", interval)\n\ngetListLen(endpoint_list, total_endpoints)\n\nif(total_endpoints, 0, \"==\")\n _status = 400\n addVar(error_msg, \"No endpoints provided for monitoring\")\n addResult(error_msg)\nelse()\n db_connector = avapConnector(\"health-monitor-db-uuid-11111\")\n \n ormCheckTable(\"health_checks\", table_exists)\n \n if(table_exists, \"false\", \"==\")\n addVar(fields, \"[\\\"endpoint\\\", \\\"status_code\\\", \\\"response_time\\\", \\\"timestamp\\\", \\\"error_message\\\"]\")\n addVar(field_types, \"[\\\"TEXT\\\", \\\"INTEGER\\\", \\\"REAL\\\", \\\"TEXT\\\", \\\"TEXT\\\"]\")\n ormCreateTable(fields, field_types, \"health_checks\", create_result)\n end()\n \n addVar(successful_checks, 0)\n addVar(failed_checks, 0)\n addVar(total_response_time, 0)\n addVar(status_report, \"{}\")\n addVar(check_results, \"[]\")\n \n getDateTime(\"%Y-%m-%d %H:%M:%S\", 0, \"UTC\", check_start_time)\n \n startLoop(i, 0, total_endpoints)\n itemFromList(endpoint_list, i, current_endpoint)\n \n if(None, None, `\"http\" in current_endpoint or \"https\" in current_endpoint`)\n health_task = go check_endpoint_health(current_endpoint, interval)\n check_result = gather(health_task, 8000)\n \n try()\n variableFromJSON(check_result, \"status\", endpoint_status)\n variableFromJSON(check_result, \"response_time\", response_time)\n variableFromJSON(check_result, \"status_code\", status_code)\n variableFromJSON(check_result, \"timestamp\", raw_timestamp)\n \n stampToDatetime(raw_timestamp, \"%Y-%m-%d %H:%M:%S\", 0, formatted_timestamp)\n \n addVar(health_record, \"{}\")\n AddVariableToJSON(\"endpoint\", current_endpoint, health_record)\n AddVariableToJSON(\"status_code\", status_code, health_record)\n AddVariableToJSON(\"response_time\", response_time, health_record)\n AddVariableToJSON(\"timestamp\", formatted_timestamp, health_record)\n \n if(endpoint_status, \"healthy\", \"==\")\n successful_checks = successful_checks + 1\n total_response_time = total_response_time + response_time\n AddVariableToJSON(\"error_message\", \"\", health_record)\n else()\n failed_checks = failed_checks + 1\n variableFromJSON(check_result, \"error\", error_detail)\n AddVariableToJSON(\"error_message\", error_detail, health_record)\n end()\n \n ormAccessInsert(health_record, \"health_checks\", insert_result)\n \n exception(processing_error)\n failed_checks = failed_checks + 1\n addVar(error_record, \"{}\")\n AddVariableToJSON(\"endpoint\", current_endpoint, error_record)\n AddVariableToJSON(\"status_code\", 0, error_record)\n AddVariableToJSON(\"response_time\", 0, error_record)\n AddVariableToJSON(\"timestamp\", check_start_time, error_record)\n AddVariableToJSON(\"error_message\", \"Processing failed\", error_record)\n ormAccessInsert(error_record, \"health_checks\", error_insert)\n end()\n else()\n failed_checks = failed_checks + 1\n end()\n endLoop()\n \n availability_percentage = (successful_checks * 100) / total_endpoints\n \n if(successful_checks, 0, \">\")\n average_response_time = total_response_time / successful_checks\n else()\n addVar(average_response_time, 0)\n end()\n \n AddVariableToJSON(\"check_timestamp\", check_start_time, status_report)\n AddVariableToJSON(\"total_endpoints\", total_endpoints, status_report)\n AddVariableToJSON(\"successful_checks\", successful_checks, status_report)\n AddVariableToJSON(\"failed_checks\", failed_checks, status_report)\n AddVariableToJSON(\"availability_percentage\", availability_percentage, status_report)\n AddVariableToJSON(\"average_response_time\", average_response_time, status_report)\n \n if(None, None, `threshold is not None and availability_percentage < int(threshold)`)\n AddVariableToJSON(\"alert_triggered\", \"true\", status_report)\n _status = 503\n else()\n AddVariableToJSON(\"alert_triggered\", \"false\", status_report)\n _status = 200\n end()\n \n addResult(status_report)\nend()\n\nfunction check_endpoint_health(endpoint_url, timeout_ms)\n{\n addVar(headers, \"{}\")\n AddVariableToJSON(\"User-Agent\", \"HealthMonitor/1.0\", headers)\n AddVariableToJSON(\"Accept\", \"application/json\", headers)\n \n getTimeStamp(\"now\", \"%Y-%m-%d %H:%M:%S\", 0, start_timestamp)\n \n try()\n RequestGet(endpoint_url, \"\", headers, response_data, timeout_ms)\n \n getTimeStamp(\"now\", \"%Y-%m-%d %H:%M:%S\", 0, end_timestamp)\n response_time = end_timestamp - start_timestamp\n \n addVar(health_result, \"{}\")\n \n if(None, None, `response_data is not None`)\n AddVariableToJSON(\"status\", \"healthy\", health_result)\n AddVariableToJSON(\"status_code\", 200, health_result)\n AddVariableToJSON(\"response_time\", response_time, health_result)\n AddVariableToJSON(\"timestamp\", end_timestamp, health_result)\n else()\n AddVariableToJSON(\"status\", \"unhealthy\", health_result)\n AddVariableToJSON(\"status_code\", 0, health_result)\n AddVariableToJSON(\"response_time\", response_time, health_result)\n AddVariableToJSON(\"timestamp\", end_timestamp, health_result)\n AddVariableToJSON(\"error\", \"No response received\", health_result)\n end()\n \n return(health_result)\n \n exception(request_error)\n getTimeStamp(\"now\", \"%Y-%m-%d %H:%M:%S\", 0, error_timestamp)\n \n addVar(error_result, \"{}\")\n AddVariableToJSON(\"status\", \"unhealthy\", error_result)\n AddVariableToJSON(\"status_code\", 0, error_result)\n AddVariableToJSON(\"response_time\", 0, error_result)\n AddVariableToJSON(\"timestamp\", error_timestamp, error_result)\n AddVariableToJSON(\"error\", \"Connection failed\", error_result)\n \n return(error_result)\n end()\n}", - "test_inputs": { - "endpoints": [ - "http://api1.example.com/health", - "https://api2.example.com/status" - ], - "alert_threshold": "80", - "check_interval": "5000" - }, - "test_list": [ - "re.match(r'\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}', check_timestamp)", - "re.match(r'^(100|[1-9]?\\d)$', str(availability_percentage))", - "re.match(r'^(true|false)$', alert_triggered)" - ], - "_detected": [ - "AddVariableToJSON", - "RequestGet", - "_status", - "addParam", - "addResult", - "addVar", - "avapConnector", - "else", - "end", - "endLoop", - "function", - "gather", - "getDateTime", - "getListLen", - "getQueryParamList", - "getTimeStamp", - "if_mode2", - "itemFromList", - "ormAccessInsert", - "ormCheckTable", - "return", - "stampToDatetime", - "startLoop", - "try", - "variableFromJSON" - ], - "_reward": { - "ecs": 0.658, - "novelty": 0.207, - "test_quality": 1.0, - "reward": 0.551, - "detected": [ - "AddVariableToJSON", - "RequestGet", - "_status", - "addParam", - "addResult", - "addVar", - "avapConnector", - "else", - "end", - "endLoop", - "function", - "gather", - "getDateTime", - "getListLen", - "getQueryParamList", - "getTimeStamp", - "if_mode2", - "itemFromList", - "ormAccessInsert", - "ormCheckTable", - "return", - "stampToDatetime", - "startLoop", - "try", - "variableFromJSON" - ] - } - }, - { - "task_id": 10, - "text": "Desarrollar un microservicio de procesamiento de documentos legales que reciba archivos mediante POST, valide su formato usando expresiones regulares, genere hashes MD5 para verificación de integridad, extraiga metadatos relevantes (fechas, números de caso, firmantes), almacene los datos en base de datos, sincronice con un sistema externo de archivado mediante POST concurrente, registre auditoría de cada operación, y retorne un reporte completo con estadísticas del procesamiento. El servicio debe manejar múltiples documentos simultáneamente, validar rangos de fechas, generar códigos de referencia aleatorios, y gestionar errores de red o base de datos.", - "code": "include \"config/document_processing_settings.avap\"\nimport \"legal_document_utils\"\n\naddParam(\"documents\", doc_data)\naddParam(\"department\", dept_id)\naddParam(\"priority_level\", priority)\n\nif(doc_data, None, \"==\")\n _status = 400\n addVar(error_msg, \"No documents provided\")\n addResult(error_msg)\nelse()\n db_connector = avapConnector(\"legal-db-uuid-98765\")\n \n try()\n variableFromJSON(doc_data, \"files\", files_list)\n getListLen(files_list, total_files)\n \n addVar(processed_docs, \"[]\")\n addVar(success_count, 0)\n addVar(error_count, 0)\n addVar(total_size, 0)\n \n startLoop(i, 0, total_files)\n itemFromList(files_list, i, current_file)\n \n process_task = go process_legal_document(current_file, dept_id, db_connector)\n archive_task = go archive_to_external_system(current_file)\n \n doc_result = gather(process_task, 8000)\n archive_result = gather(archive_task, 5000)\n \n if(None, None, `doc_result is not None`)\n variableFromJSON(doc_result, \"status\", process_status)\n variableFromJSON(doc_result, \"file_size\", file_size)\n \n total_size = total_size + file_size\n \n if(process_status, \"success\", \"==\")\n success_count = success_count + 1\n \n variableFromJSON(doc_result, \"document_id\", doc_id)\n variableFromJSON(doc_result, \"reference_code\", ref_code)\n variableFromJSON(doc_result, \"extracted_date\", doc_date)\n \n addVar(processed_item, \"{}\")\n AddVariableToJSON(\"document_id\", doc_id, processed_item)\n AddVariableToJSON(\"reference_code\", ref_code, processed_item)\n AddVariableToJSON(\"status\", \"processed\", processed_item)\n AddVariableToJSON(\"extracted_date\", doc_date, processed_item)\n \n if(None, None, `archive_result is not None`)\n variableFromJSON(archive_result, \"archive_id\", ext_archive_id)\n AddVariableToJSON(\"external_archive_id\", ext_archive_id, processed_item)\n end()\n else()\n error_count = error_count + 1\n variableFromJSON(doc_result, \"error_detail\", error_msg)\n \n addVar(error_item, \"{}\")\n AddVariableToJSON(\"status\", \"error\", error_item)\n AddVariableToJSON(\"error_message\", error_msg, error_item)\n end()\n else()\n error_count = error_count + 1\n end()\n endLoop()\n \n getDateTime(\"%Y-%m-%d %H:%M:%S\", 0, \"UTC\", processing_timestamp)\n \n addVar(final_response, \"{}\")\n AddVariableToJSON(\"processing_timestamp\", processing_timestamp, final_response)\n AddVariableToJSON(\"department_id\", dept_id, final_response)\n AddVariableToJSON(\"total_documents\", total_files, final_response)\n AddVariableToJSON(\"successful_processed\", success_count, final_response)\n AddVariableToJSON(\"failed_processed\", error_count, final_response)\n AddVariableToJSON(\"total_size_mb\", total_size, final_response)\n AddVariableToJSON(\"processed_documents\", processed_docs, final_response)\n \n if(success_count, 0, \">\")\n _status = 200\n addResult(final_response)\n else()\n _status = 422\n addVar(process_error, \"No documents could be processed successfully\")\n addResult(process_error)\n end()\n exception(system_error)\n _status = 500\n addVar(exception_msg, \"Document processing system failure\")\n addResult(exception_msg)\n end()\nend()\n\nfunction process_legal_document(file_data, department, connector)\n{\n variableFromJSON(file_data, \"filename\", filename)\n variableFromJSON(file_data, \"content\", file_content)\n variableFromJSON(file_data, \"size\", file_size)\n \n getRegex(filename, \"\\.(pdf|docx|txt)$\", file_extension)\n \n addVar(result, \"{}\")\n \n if(None, None, `file_extension is not None`)\n encodeMD5(file_content, content_hash)\n \n replace(file_content, \"\\n\", \" \", cleaned_content)\n getRegex(cleaned_content, \"Case No[.:] ([A-Z0-9-]+)\", case_number)\n getRegex(cleaned_content, \"([0-9]{1,2}/[0-9]{1,2}/[0-9]{4})\", extracted_date)\n getRegex(cleaned_content, \"Signed by: ([A-Za-z ]+)\", signatory)\n \n randomString(\"[A-Z]{3}[0-9]{6}\", 9, reference_code)\n \n addVar(document_record, \"{}\")\n AddVariableToJSON(\"filename\", filename, document_record)\n AddVariableToJSON(\"content_hash\", content_hash, document_record)\n AddVariableToJSON(\"file_size\", file_size, document_record)\n AddVariableToJSON(\"department_id\", department, document_record)\n AddVariableToJSON(\"reference_code\", reference_code, document_record)\n \n if(None, None, `case_number is not None`)\n AddVariableToJSON(\"case_number\", case_number, document_record)\n end()\n \n if(None, None, `extracted_date is not None`)\n AddVariableToJSON(\"document_date\", extracted_date, document_record)\n end()\n \n if(None, None, `signatory is not None`)\n AddVariableToJSON(\"signatory\", signatory, document_record)\n end()\n \n ormAccessInsert(document_record, \"legal_documents\", insert_result)\n \n log_document_processing(filename, \"PROCESSED\", department, connector)\n \n AddVariableToJSON(\"status\", \"success\", result)\n AddVariableToJSON(\"document_id\", insert_result, result)\n AddVariableToJSON(\"reference_code\", reference_code, result)\n AddVariableToJSON(\"file_size\", file_size, result)\n \n if(None, None, `extracted_date is not None`)\n AddVariableToJSON(\"extracted_date\", extracted_date, result)\n end()\n else()\n AddVariableToJSON(\"status\", \"error\", result)\n AddVariableToJSON(\"error_detail\", \"Invalid file format\", result)\n AddVariableToJSON(\"file_size\", file_size, result)\n end()\n \n return(result)\n}\n\nfunction archive_to_external_system(file_data)\n{\n external_connector = avapConnector(\"archive-service-uuid-54321\")\n \n addVar(archive_payload, \"{}\")\n variableFromJSON(file_data, \"filename\", file_name)\n variableFromJSON(file_data, \"content\", file_content)\n \n encodeSHA256(file_content, content_signature)\n \n AddVariableToJSON(\"filename\", file_name, archive_payload)\n AddVariableToJSON(\"content_signature\", content_signature, archive_payload)\n AddVariableToJSON(\"archive_type\", \"legal_document\", archive_payload)\n \n addVar(headers, \"{}\")\n AddVariableToJSON(\"Content-Type\", \"application/json\", headers)\n AddVariableToJSON(\"Authorization\", \"Bearer archive-token-xyz\", headers)\n \n RequestPost(\"https://archive.legal-system.com/api/v1/store\", \"\", headers, archive_payload, response_data, 6000)\n \n if(None, None, `response_data is not None`)\n return(response_data)\n else()\n addVar(error_response, \"{}\")\n AddVariableToJSON(\"error\", \"External archive failed\", error_response)\n return(error_response)\n end()\n}\n\nfunction log_document_processing(filename, status, department, connector)\n{\n getDateTime(\"%Y-%m-%d %H:%M:%S\", 0, \"UTC\", log_timestamp)\n \n addVar(audit_record, \"{}\")\n AddVariableToJSON(\"filename\", filename, audit_record)\n AddVariableToJSON(\"processing_status\", status, audit_record)\n AddVariableToJSON(\"department_id\", department, audit_record)\n AddVariableToJSON(\"timestamp\", log_timestamp, audit_record)\n AddVariableToJSON(\"processor_id\", \"AVAP-LEGAL-001\", audit_record)\n \n ormAccessInsert(audit_record, \"document_processing_audit\", audit_result)\n \n return(audit_result)\n}", - "test_inputs": { - "documents": "{\"files\": [{\"filename\": \"case_123.pdf\", \"content\": \"Case No: ABC-2024-001\\nDate: 12/15/2023\\nSigned by: John Smith\\nLegal content here\", \"size\": 1024}]}", - "department": "LEGAL_DEPT_01", - "priority_level": "HIGH" - }, - "test_list": [ - "re.match(r'.*processing_timestamp.*', final_response)", - "re.match(r'.*successful_processed.*', final_response)", - "re.match(r'.*ABC[0-9]{6}.*', reference_code)" - ], - "_detected": [ - "AddVariableToJSON", - "RequestPost", - "_status", - "addParam", - "addResult", - "addVar", - "avapConnector", - "else", - "encodeMD5", - "encodeSHA256", - "end", - "endLoop", - "function", - "gather", - "getDateTime", - "getListLen", - "if_mode2", - "import", - "itemFromList", - "ormAccessInsert", - "randomString", - "replace", - "return", - "startLoop", - "try", - "variableFromJSON" - ], - "_reward": { - "ecs": 0.684, - "novelty": 0.172, - "test_quality": 1.0, - "reward": 0.552, - "detected": [ - "AddVariableToJSON", - "RequestPost", - "_status", - "addParam", - "addResult", - "addVar", - "avapConnector", - "else", - "encodeMD5", - "encodeSHA256", - "end", - "endLoop", - "function", - "gather", - "getDateTime", - "getListLen", - "if_mode2", - "import", - "itemFromList", - "ormAccessInsert", - "randomString", - "replace", - "return", - "startLoop", - "try", - "variableFromJSON" - ] - } - } -] \ No newline at end of file diff --git a/output/mbpp_avap_v2_reward_stats_A.json b/output/mbpp_avap_v2_reward_stats_A.json deleted file mode 100644 index dd839d3..0000000 --- a/output/mbpp_avap_v2_reward_stats_A.json +++ /dev/null @@ -1,51 +0,0 @@ -{ - "mode": "reward", - "weights": { - "w_ecs": 0.5, - "w_novelty": 0.35, - "w_tests": 0.15 - }, - "dataset_size": 10, - "pool_size": 5, - "pool_summary": "GoldPool: 5/5 | reward: min=0.578 max=0.763 mean=0.621", - "distribution_entropy": 4.959, - "node_type_frequency": { - "AddVariableToJSON": 10, - "RequestGet": 4, - "_status": 10, - "addParam": 10, - "addResult": 10, - "addVar": 10, - "else": 10, - "end": 10, - "endLoop": 9, - "function": 10, - "gather": 10, - "getListLen": 10, - "getQueryParamList": 4, - "if_mode2": 10, - "itemFromList": 10, - "replace": 4, - "return": 10, - "startLoop": 9, - "try": 10, - "variableFromJSON": 10, - "avapConnector": 9, - "encodeMD5": 4, - "encodeSHA256": 4, - "getDateTime": 9, - "getTimeStamp": 4, - "ormAccessInsert": 9, - "ormAccessSelect": 4, - "import": 7, - "ormAccessUpdate": 3, - "ormCheckTable": 4, - "randomString": 4, - "RequestPost": 3, - "ormDirect": 3, - "stampToDatetime": 3 - }, - "covered_constructs": 34, - "total_constructs": 38, - "mean_reward": 0.5854 -} \ No newline at end of file diff --git a/scratches/pseco/synthetic_dataset/avap_test/records_output/input_records.json b/scratches/pseco/synthetic_dataset/avap_test/records_output/input_records.json new file mode 100644 index 0000000..51c08e3 --- /dev/null +++ b/scratches/pseco/synthetic_dataset/avap_test/records_output/input_records.json @@ -0,0 +1,546 @@ +[ + { + "source_file": "mbap_avap_A.json", + "task_id": 1, + "text": "Crea una API de validación y transformación de datos de usuarios que procese una lista de emails desde parámetros de consulta, valide cada email con expresión regular, transforme nombres de usuarios eliminando espacios, y genere un reporte con estadísticas de emails válidos/inválidos. La API debe manejar errores y devolver código de estado HTTP apropiado.", + "code": "addParam('user_list', user_data)\ngetQueryParamList('emails', email_list)\naddVar(valid_count, 0)\naddVar(invalid_count, 0)\naddVar(processed_emails, [])\ntry()\n getListLen(email_list, total_emails)\n if(total_emails, 0, \">\")\n addVar(i, 0)\n startLoop(counter, 0, total_emails)\n itemFromList(email_list, i, current_email)\n getRegex(current_email, \"^[\\\\w\\\\.-]+@[\\\\w\\\\.-]+\\\\.[a-zA-Z]{2,}$\", email_match)\n if(None, None, `email_match != None`)\n addVar(valid_count, valid_count + 1)\n replace(current_email, \" \", \"\", clean_email)\n variableToList(clean_email, temp_list)\n AddVariableToJSON(\"email\", clean_email, email_obj)\n AddVariableToJSON(\"status\", \"valid\", email_obj)\n else()\n addVar(invalid_count, invalid_count + 1)\n AddVariableToJSON(\"email\", current_email, email_obj)\n AddVariableToJSON(\"status\", \"invalid\", email_obj)\n end()\n addVar(i, i + 1)\n endLoop()\n AddVariableToJSON(\"total_processed\", total_emails, report)\n AddVariableToJSON(\"valid_emails\", valid_count, report)\n AddVariableToJSON(\"invalid_emails\", invalid_count, report)\n if(valid_count, 0, \">\")\n addVar(_status, 200)\n else()\n addVar(_status, 422)\n end()\n else()\n AddVariableToJSON(\"error\", \"No emails provided\", report)\n addVar(_status, 400)\n end()\nexception(error_var)\n AddVariableToJSON(\"error\", \"Processing failed\", report)\n addVar(_status, 500)\nend()\naddResult(report)", + "test_inputs": { + "emails": [ + "user1@domain.com", + "invalid-email", + "test@example.org", + "bad@", + "admin@site.co.uk" + ] + }, + "test_list": [ + "re.match(r'\\d+', str(report.get('total_processed', '')))", + "re.match(r'[2-5]\\d\\d', str(_status))", + "re.match(r'(valid|invalid)', str(report.get('error', '') or 'valid'))" + ] + }, + { + "source_file": "mbpp_avap.json", + "task_id": 1, + "text": "Crear un endpoint que reciba un parámetro 'message' y devuelva un saludo personalizado. Si no se proporciona el parámetro, debe devolver un saludo genérico con código de estado 200.", + "code": "addParam(\"message\", message)\nif(message, None, \"=\")\n greeting = \"Hello, World!\"\nelse()\n greeting = \"Hello, \" + message + \"!\"\nend()\naddResult(greeting)\n_status = 200", + "test_inputs": { + "message": "Alice" + }, + "test_list": [ + "re.search(r'Hello, Alice!', greeting)", + "re.match(r'^200$', str(_status))" + ] + }, + { + "source_file": "mbpp_avap.json", + "task_id": 2, + "text": "Crear un generador de tokens seguros que tome una contraseña como entrada, genere un hash SHA256 de la misma, y luego cree un token aleatorio de 32 caracteres alfanuméricos. El sistema debe retornar tanto el hash como el token generado.", + "code": "addParam(\"password\", password)\nencodeSHA256(password, hashed_password)\nrandomString(\"[a-zA-Z0-9]\", 32, secure_token)\naddResult(hashed_password)\naddResult(secure_token)", + "test_inputs": { + "password": "mySecretPass123" + }, + "test_list": [ + "re.match(r'^[a-f0-9]{64}$', hashed_password)", + "re.match(r'^[a-zA-Z0-9]{32}$', secure_token)" + ] + }, + { + "source_file": "synthetic_data_generated_bedrock.json", + "task_id": 1, + "text": "Captura el parámetro 'username' de la petición HTTP y devuélvelo como resultado. Si no existe, la variable será None.", + "code": "addParam(\"username\", username)\naddResult(username)", + "test_inputs": { + "username": "alice" + }, + "test_list": [ + "re.match(r'^alice$', str(username))" + ] + }, + { + "source_file": "synthetic_data_generated_bedrock.json", + "task_id": 2, + "text": "Recibe el parámetro 'email' y establece el código de estado HTTP en 200. Devuelve el email como resultado.", + "code": "addParam(\"email\", email)\naddVar(_status, 200)\naddResult(email)", + "test_inputs": { + "email": "user@example.com" + }, + "test_list": [ + "re.match(r'^user@example\\.com$', str(email))", + "re.match(r'^200$', str(_status))" + ] + }, + { + "source_file": "synthetic_data_generated_bedrock.json", + "task_id": 3, + "text": "Recibe el parámetro 'password', genera su hash SHA-256 y devuelve el hash como resultado.", + "code": "addParam(\"password\", password)\nencodeSHA256(password, hashed)\naddResult(hashed)", + "test_inputs": { + "password": "secret123" + }, + "test_list": [ + "re.match(r'^[a-f0-9]{64}$', str(hashed))" + ] + }, + { + "source_file": "synthetic_data_generated_bedrock.json", + "task_id": 4, + "text": "Recibe el parámetro 'text', reemplaza todos los espacios por guiones bajos y devuelve el resultado.", + "code": "addParam(\"text\", text)\nreplace(text, \" \", \"_\", result)\naddResult(result)", + "test_inputs": { + "text": "hello world foo" + }, + "test_list": [ + "re.match(r'^hello_world_foo$', str(result))" + ] + }, + { + "source_file": "synthetic_data_generated_bedrock.json", + "task_id": 5, + "text": "Genera un token aleatorio de 32 caracteres alfanuméricos y devuélvelo como resultado.", + "code": "randomString(\"[a-zA-Z0-9]\", 32, token)\naddResult(token)", + "test_inputs": {}, + "test_list": [ + "re.match(r'^[a-zA-Z0-9]{32}$', str(token))" + ] + }, + { + "source_file": "synthetic_data_generated_bedrock.json", + "task_id": 6, + "text": "Recibe el parámetro 'age'. Si age es mayor que 18, devuelve 'adulto'; de lo contrario devuelve 'menor'.", + "code": "addParam(\"age\", age)\nif(age, 18, \">\")\nresult = \"adulto\"\nelse()\nresult = \"menor\"\nend()\naddResult(result)", + "test_inputs": { + "age": 25 + }, + "test_list": [ + "re.match(r'^adulto$', str(result))" + ] + }, + { + "source_file": "synthetic_data_generated_bedrock.json", + "task_id": 7, + "text": "Recibe el parámetro 'score'. Si score es igual a 100, establece _status en 200 y result en 'perfecto'; si no, _status en 400 y result en 'incompleto'.", + "code": "addParam(\"score\", score)\nif(score, 100, \"==\")\naddVar(_status, 200)\nresult = \"perfecto\"\nelse()\naddVar(_status, 400)\nresult = \"incompleto\"\nend()\naddResult(result)", + "test_inputs": { + "score": 100 + }, + "test_list": [ + "re.match(r'^perfecto$', str(result))", + "re.match(r'^200$', str(_status))" + ] + }, + { + "source_file": "synthetic_data_generated_bedrock.json", + "task_id": 8, + "text": "Crea una lista con el elemento 'item1', obtén su longitud y devuelve la longitud como resultado.", + "code": "variableToList(\"item1\", myList)\ngetListLen(myList, length)\naddResult(length)", + "test_inputs": {}, + "test_list": [ + "re.match(r'^1$', str(length))" + ] + }, + { + "source_file": "synthetic_data_generated_bedrock.json", + "task_id": 9, + "text": "Recibe el parámetro 'items' como lista de query params, obtén su longitud y devuélvela como resultado.", + "code": "getQueryParamList(\"items\", items)\ngetListLen(items, length)\naddResult(length)", + "test_inputs": { + "items": [ + "a", + "b", + "c" + ] + }, + "test_list": [ + "re.match(r'^\\d+$', str(length))" + ] + }, + { + "source_file": "synthetic_data_generated_bedrock.json", + "task_id": 10, + "text": "Recibe el parámetro 'data' como JSON, extrae el campo 'name' y devuélvelo como resultado.", + "code": "addParam(\"data\", data)\nvariableFromJSON(data, \"name\", name)\naddResult(name)", + "test_inputs": { + "data": "{\"name\": \"Carlos\", \"age\": 30}" + }, + "test_list": [ + "re.match(r'^Carlos$', str(name))" + ] + }, + { + "source_file": "synthetic_data_generated_bedrock.json", + "task_id": 11, + "text": "Crea un objeto JSON vacío, agrega el campo 'status' con valor 'ok' y devuelve el objeto como resultado.", + "code": "info = {}\nAddVariableToJSON(\"status\", \"ok\", info)\naddResult(info)", + "test_inputs": {}, + "test_list": [ + "re.match(r'.*ok.*', str(info))" + ] + }, + { + "source_file": "synthetic_data_generated_bedrock.json", + "task_id": 12, + "text": "Recibe el parámetro 'password', genera su hash MD5 y devuelve el hash como resultado.", + "code": "addParam(\"password\", password)\nencodeMD5(password, hashed)\naddResult(hashed)", + "test_inputs": { + "password": "mypassword" + }, + "test_list": [ + "re.match(r'^[a-f0-9]{32}$', str(hashed))" + ] + }, + { + "source_file": "synthetic_data_generated_bedrock.json", + "task_id": 13, + "text": "Obtén la fecha y hora actual en formato 'YYYY-MM-DD' en la zona horaria 'UTC' y devuélvela como resultado.", + "code": "getDateTime(\"%Y-%m-%d\", 0, \"UTC\", today)\naddResult(today)", + "test_inputs": {}, + "test_list": [ + "re.match(r'^\\d{4}-\\d{2}-\\d{2}$', str(today))" + ] + }, + { + "source_file": "synthetic_data_generated_bedrock.json", + "task_id": 14, + "text": "Recibe el parámetro 'epoch', conviértelo a string de fecha en formato 'YYYY-MM-DD HH:MM:SS' y devuelve el resultado.", + "code": "addParam(\"epoch\", epoch)\nstampToDatetime(epoch, \"%Y-%m-%d %H:%M:%S\", 0, datestr)\naddResult(datestr)", + "test_inputs": { + "epoch": 1700000000 + }, + "test_list": [ + "re.match(r'^\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}$', str(datestr))" + ] + }, + { + "source_file": "synthetic_data_generated_bedrock.json", + "task_id": 15, + "text": "Recibe el parámetro 'date_str' en formato 'YYYY-MM-DD', conviértelo a epoch y devuelve el epoch como resultado.", + "code": "addParam(\"date_str\", date_str)\ngetTimeStamp(date_str, \"%Y-%m-%d\", 0, epoch)\naddResult(epoch)", + "test_inputs": { + "date_str": "2024-01-15" + }, + "test_list": [ + "re.match(r'^\\d+$', str(epoch))" + ] + }, + { + "source_file": "synthetic_data_generated_bedrock.json", + "task_id": 16, + "text": "Define una función que recibe un número y devuelve su cuadrado. Llama a la función con el parámetro 'n' y devuelve el resultado.", + "code": "function square(n) {\nresult = n * n\nreturn(result)\n}\naddParam(\"n\", n)\nsquared = square(n)\naddResult(squared)", + "test_inputs": { + "n": 7 + }, + "test_list": [ + "re.match(r'^49$', str(squared))" + ] + }, + { + "source_file": "synthetic_data_generated_bedrock.json", + "task_id": 17, + "text": "Define una función que recibe dos números y devuelve su suma. Llama a la función con los parámetros 'a' y 'b' y devuelve el resultado.", + "code": "function add(a, b) {\nresult = a + b\nreturn(result)\n}\naddParam(\"a\", a)\naddParam(\"b\", b)\nsum = add(a, b)\naddResult(sum)", + "test_inputs": { + "a": 15, + "b": 27 + }, + "test_list": [ + "re.match(r'^42$', str(sum))" + ] + }, + { + "source_file": "synthetic_data_generated_bedrock.json", + "task_id": 18, + "text": "Usa un bloque try/exception para intentar dividir el parámetro 'num' entre 0. Si ocurre error, devuelve 'error_division'.", + "code": "addParam(\"num\", num)\ntry()\nresult = num / 0\nexception(err)\nresult = \"error_division\"\nend()\naddResult(result)", + "test_inputs": { + "num": 10 + }, + "test_list": [ + "re.match(r'^error_division$', str(result))" + ] + }, + { + "source_file": "synthetic_data_generated_bedrock.json", + "task_id": 19, + "text": "Recibe el parámetro 'url', realiza una petición GET a esa URL con timeout de 5000ms y devuelve la respuesta.", + "code": "addParam(\"url\", url)\nRequestGet(url, \"\", \"\", response, 5000)\naddResult(response)", + "test_inputs": { + "url": "https://httpbin.org/get" + }, + "test_list": [ + "re.match(r'^.*$', str(response))" + ] + }, + { + "source_file": "synthetic_data_generated_bedrock.json", + "task_id": 20, + "text": "Recibe los parámetros 'url' y 'body', realiza una petición POST con timeout de 3000ms y devuelve la respuesta.", + "code": "addParam(\"url\", url)\naddParam(\"body\", body)\nRequestPost(url, \"\", \"\", body, response, 3000)\naddResult(response)", + "test_inputs": { + "url": "https://httpbin.org/post", + "body": "{\"key\":\"value\"}" + }, + "test_list": [ + "re.match(r'^.*$', str(response))" + ] + }, + { + "source_file": "synthetic_data_generated_bedrock.json", + "task_id": 21, + "text": "Instancia un conector externo con UUID '20908e93260147acb2636967021fbf5d', llama al método 'get_status' y devuelve el resultado.", + "code": "connector = avapConnector(\"20908e93260147acb2636967021fbf5d\")\nstatus = connector.get_status()\naddResult(status)", + "test_inputs": {}, + "test_list": [ + "re.match(r'^.*$', str(status))" + ] + }, + { + "source_file": "synthetic_data_generated_bedrock.json", + "task_id": 22, + "text": "Lanza una función 'fetchData' de forma asíncrona con go, espera el resultado con gather (timeout 2000ms) y devuelve el resultado.", + "code": "function fetchData() {\ndata = \"fetched\"\nreturn(data)\n}\nhandle = go fetchData()\nresult = gather(handle, 2000)\naddResult(result)", + "test_inputs": {}, + "test_list": [ + "re.match(r'^fetched$', str(result))" + ] + }, + { + "source_file": "synthetic_data_generated_bedrock.json", + "task_id": 23, + "text": "Recibe el parámetro 'n', itera desde 0 hasta n acumulando la suma y devuelve la suma total.", + "code": "addParam(\"n\", n)\naccum = 0\nstartLoop(i, 0, n)\naccum = accum + i\nendLoop()\naddResult(accum)", + "test_inputs": { + "n": 5 + }, + "test_list": [ + "re.match(r'^10$', str(accum))" + ] + }, + { + "source_file": "synthetic_data_generated_bedrock.json", + "task_id": 24, + "text": "Recibe el parámetro 'value'. Usando if Modo 2, si value es mayor que 0 y menor que 100, devuelve 'rango_valido'; si no, devuelve 'fuera_de_rango'.", + "code": "addParam(\"value\", value)\nif(None, None, `value > 0 and value < 100`)\nresult = \"rango_valido\"\nelse()\nresult = \"fuera_de_rango\"\nend()\naddResult(result)", + "test_inputs": { + "value": 50 + }, + "test_list": [ + "re.match(r'^rango_valido$', str(result))" + ] + }, + { + "source_file": "synthetic_data_generated_bedrock.json", + "task_id": 25, + "text": "Realiza una consulta ORM a la tabla 'users' seleccionando todos los campos sin filtro y devuelve los registros.", + "code": "ormAccessSelect(\"*\", \"users\", \"\", records)\naddResult(records)", + "test_inputs": {}, + "test_list": [ + "re.match(r'^.*$', str(records))" + ] + }, + { + "source_file": "synthetic_data_generated_bedrock.json", + "task_id": 26, + "text": "Recibe los parámetros 'username' y 'email', inserta un registro en la tabla 'users' y devuelve el resultado de la inserción.", + "code": "addParam(\"username\", username)\naddParam(\"email\", email)\nfields = {\"username\": username, \"email\": email}\normAccessInsert(fields, \"users\", insert_result)\naddResult(insert_result)", + "test_inputs": { + "username": "bob", + "email": "bob@example.com" + }, + "test_list": [ + "re.match(r'^.*$', str(insert_result))" + ] + }, + { + "source_file": "synthetic_data_generated_bedrock.json", + "task_id": 27, + "text": "Recibe el parámetro 'user_id', actualiza el campo 'active' a 1 en la tabla 'users' donde id coincide y devuelve el resultado.", + "code": "addParam(\"user_id\", user_id)\nfields = \"active\"\nvalues = {\"active\": 1}\nselector = \"id = \" + str(user_id)\normAccessUpdate(fields, values, \"users\", selector, update_result)\naddResult(update_result)", + "test_inputs": { + "user_id": 42 + }, + "test_list": [ + "re.match(r'^.*$', str(update_result))" + ] + }, + { + "source_file": "synthetic_data_generated_bedrock.json", + "task_id": 28, + "text": "Importa la librería nativa 'math', calcula el cuadrado de 9 usando una función y devuelve el resultado.", + "code": "import \nfunction calcSquare(x) {\nresult = x * x\nreturn(result)\n}\nresult = calcSquare(9)\naddResult(result)", + "test_inputs": {}, + "test_list": [ + "re.match(r'^81$', str(result))" + ] + }, + { + "source_file": "synthetic_data_generated_bedrock.json", + "task_id": 29, + "text": "Recibe el parámetro 'items_json' como JSON con una lista bajo la clave 'items'. Extrae la lista, obtén su longitud y devuelve la longitud.", + "code": "addParam(\"items_json\", items_json)\nvariableFromJSON(items_json, \"items\", items)\ngetListLen(items, length)\naddResult(length)", + "test_inputs": { + "items_json": "{\"items\": [\"x\", \"y\", \"z\"]}" + }, + "test_list": [ + "re.match(r'^3$', str(length))" + ] + }, + { + "source_file": "synthetic_data_generated_bedrock.json", + "task_id": 30, + "text": "Recibe el parámetro 'token'. Si el token tiene exactamente 32 caracteres (usando Modo 2), devuelve 'token_valido' con _status 200; si no, devuelve 'token_invalido' con _status 401.", + "code": "addParam(\"token\", token)\nif(None, None, `len(token) == 32`)\nresult = \"token_valido\"\naddVar(_status, 200)\nelse()\nresult = \"token_invalido\"\naddVar(_status, 401)\nend()\naddResult(result)", + "test_inputs": { + "token": "abcdefghijklmnopqrstuvwxyz123456" + }, + "test_list": [ + "re.match(r'^token_valido$', str(result))", + "re.match(r'^200$', str(_status))" + ] + }, + { + "source_file": "synthetic_data_human_eval_bedrock.json", + "task_id": 52, + "text": "Crear un endpoint que reciba una lista de números 'numbers' y un umbral 'threshold'. El endpoint debe devolver True si todos los números de la lista son estrictamente menores que el umbral, y False en caso contrario. El resultado debe exponerse como respuesta de la API con código de estado 200.", + "code": "addParam(\"numbers\", numbers)\naddParam(\"threshold\", threshold)\nresult = True\ngetListLen(numbers, list_len)\ni = 0\nstartLoop(i, 0, list_len)\n itemFromList(numbers, i, current_item)\n current_val = int(current_item)\n thresh_val = int(threshold)\n if(None, None, `current_val >= thresh_val`)\n result = False\n end()\nendLoop()\naddResult(result)\n_status = 200", + "test_inputs": { + "numbers": [ + 1, + 2, + 4, + 10 + ], + "threshold": 100 + }, + "test_list": [ + "re.search(r'True', str(result))", + "re.match(r'^200$', str(_status))" + ] + }, + { + "source_file": "synthetic_data_human_eval_bedrock.json", + "task_id": 134, + "text": "Crear un endpoint que reciba un parámetro 'txt' (cadena de texto) y devuelva True si el último carácter de la cadena es una letra alfabética y no forma parte de una palabra (es decir, el último token separado por espacios tiene longitud 1 y es una letra). En caso contrario, devuelve False. El resultado debe exponerse como respuesta de la API con código de estado 200.", + "code": "addParam(\"txt\", txt)\nresult = False\nif(None, None, `txt == \"\" or txt == None`)\n result = False\nelse()\n replace(txt, \",\", \" \", txt_clean)\n last_word = txt_clean.split()[-1] if txt_clean.split() else \"\"\n getListLen(last_word, last_len)\n if(None, None, `last_len == 1 and last_word.lower() >= \"a\" and last_word.lower() <= \"z\"`)\n result = True\n else()\n result = False\n end()\nend()\naddResult(result)\n_status = 200", + "test_inputs": { + "txt": "apple pi e" + }, + "test_list": [ + "re.search(r'True', str(result))", + "re.match(r'^200$', str(_status))" + ] + }, + { + "source_file": "synthetic_data_human_eval_bedrock.json", + "task_id": 51, + "text": "Crear un endpoint que reciba un parámetro 'text' (cadena de texto) y devuelva la misma cadena pero con todas las vocales (a, e, i, o, u, tanto mayúsculas como minúsculas) eliminadas. El resultado debe exponerse como respuesta de la API con código de estado 200.", + "code": "addParam(\"text\", text)\nresult = [s for s in text if s.lower() not in [\"a\", \"e\", \"i\", \"o\", \"u\"]]\nresult_str = \"\".join(result)\naddResult(result_str)\n_status = 200", + "test_inputs": { + "text": "abcdef" + }, + "test_list": [ + "re.search(r'bcdf', str(result_str))", + "re.match(r'^200$', str(_status))" + ] + }, + { + "source_file": "synthetic_data_human_eval_bedrock.json", + "task_id": 66, + "text": "Crear un endpoint que reciba un parámetro 's' (cadena de texto) y devuelva la suma de los códigos ASCII de todos los caracteres en mayúscula presentes en la cadena. Si la cadena está vacía, debe devolver 0. El resultado debe exponerse como respuesta de la API con código de estado 200.", + "code": "addParam(\"s\", s)\nif(None, None, `s == \"\" or s == None`)\n digit_sum = 0\nelse()\n digit_sum = sum(ord(char) if char.isupper() else 0 for char in s)\nend()\naddResult(digit_sum)\n_status = 200", + "test_inputs": { + "s": "abAB" + }, + "test_list": [ + "re.search(r'131', str(digit_sum))", + "re.match(r'^200$', str(_status))" + ] + }, + { + "source_file": "synthetic_data_human_eval_bedrock.json", + "task_id": 147, + "text": "Crear un endpoint que reciba un parámetro entero 'n' y construya un array a de longitud n donde a[i] = i*i - i + 1 (para i desde 1 hasta n). El endpoint debe devolver el número de tripletas (a[i], a[j], a[k]) con i < j < k tal que la suma a[i] + a[j] + a[k] sea múltiplo de 3. El resultado debe exponerse como respuesta de la API con código de estado 200.", + "code": "addParam(\"n\", n)\nn_val = int(n)\nA = [i*i - i + 1 for i in range(1, n_val + 1)]\ncount = 0\ngetListLen(A, len_a)\ni = 0\nstartLoop(i, 0, len_a)\n j = i + 1\n startLoop(j, i + 1, len_a)\n k = j + 1\n startLoop(k, j + 1, len_a)\n itemFromList(A, i, ai)\n itemFromList(A, j, aj)\n itemFromList(A, k, ak)\n triple_sum = int(ai) + int(aj) + int(ak)\n if(None, None, `triple_sum % 3 == 0`)\n count = count + 1\n end()\n endLoop()\n endLoop()\nendLoop()\naddResult(count)\n_status = 200", + "test_inputs": { + "n": 5 + }, + "test_list": [ + "re.search(r'^1$', str(count))", + "re.match(r'^200$', str(_status))" + ] + }, + { + "source_file": "synthetic_data_human_eval_bedrock.json", + "task_id": 101, + "text": "Crear un endpoint que reciba un parámetro 's' (cadena de texto con palabras separadas por comas o espacios) y devuelva un array con las palabras individuales extraídas de la cadena. Si la cadena está vacía, debe devolver una lista vacía. El resultado debe exponerse como respuesta de la API con código de estado 200.", + "code": "addParam(\"s\", s)\nif(None, None, `s == \"\" or s == None`)\n words = []\nelse()\n replace(s, \",\", \" \", s_clean)\n words = s_clean.split()\nend()\naddResult(words)\n_status = 200", + "test_inputs": { + "s": "Hi, my name is John" + }, + "test_list": [ + "re.search(r'Hi', str(words))", + "re.search(r'John', str(words))", + "re.match(r'^200$', str(_status))" + ] + }, + { + "source_file": "synthetic_data_human_eval_bedrock.json", + "task_id": 24, + "text": "Crear un endpoint que reciba un parámetro entero 'n' y devuelva el mayor divisor de n que sea estrictamente menor que n. El resultado debe exponerse como respuesta de la API con código de estado 200.", + "code": "addParam(\"n\", n)\nn_val = int(n)\nlargest_div = 1\ni = n_val - 1\nstartLoop(i, 1, n_val)\n candidate = n_val - i\n if(None, None, `n_val % candidate == 0`)\n largest_div = candidate\n return(largest_div)\n end()\nendLoop()\naddResult(largest_div)\n_status = 200", + "test_inputs": { + "n": 15 + }, + "test_list": [ + "re.search(r'^5$', str(largest_div))", + "re.match(r'^200$', str(_status))" + ] + }, + { + "source_file": "synthetic_data_human_eval_bedrock.json", + "task_id": 125, + "text": "Crear un endpoint que reciba un parámetro 'txt' (cadena de texto) y devuelva: una lista de palabras separadas por espacios si hay espacios en el texto; una lista de palabras separadas por comas si no hay espacios pero sí comas; o el número de letras minúsculas con posición impar en el alfabeto (ord('a')=0, ord('b')=1, ...) si no hay ni espacios ni comas. El resultado debe exponerse como respuesta de la API con código de estado 200.", + "code": "addParam(\"txt\", txt)\nif(None, None, `\" \" in txt`)\n split_result = txt.split()\nelse()\n if(None, None, `\",\" in txt`)\n replace(txt, \",\", \" \", txt_replaced)\n split_result = txt_replaced.split()\n else()\n split_result = len([i for i in txt if i.islower() and ord(i) % 2 == 0])\n end()\nend()\naddResult(split_result)\n_status = 200", + "test_inputs": { + "txt": "Hello world!" + }, + "test_list": [ + "re.search(r'Hello', str(split_result))", + "re.search(r'world!', str(split_result))", + "re.match(r'^200$', str(_status))" + ] + }, + { + "source_file": "synthetic_data_human_eval_bedrock.json", + "task_id": 145, + "text": "Crear un endpoint que reciba una lista de enteros 'nums' y la devuelva ordenada de forma ascendente según la suma de sus dígitos. Si varios elementos tienen la misma suma de dígitos, se mantiene su orden relativo original. El resultado debe exponerse como respuesta de la API con código de estado 200.", + "code": "addParam(\"nums\", nums)\nfunction digits_sum(n) {\n neg = 1\n if(None, None, `n < 0`)\n n = -1 * n\n neg = -1\n end()\n digits = [int(d) for d in str(n)]\n digits[0] = digits[0] * neg\n return(sum(digits))\n}\nsorted_nums = sorted(nums, key=digits_sum)\naddResult(sorted_nums)\n_status = 200", + "test_inputs": { + "nums": [ + 1, + 11, + -1, + -11, + -12 + ] + }, + "test_list": [ + "re.search(r'-1', str(sorted_nums))", + "re.match(r'^200$', str(_status))" + ] + }, + { + "source_file": "synthetic_data_human_eval_bedrock.json", + "task_id": 50, + "text": "Crear un endpoint que reciba un parámetro 's' (cadena de texto codificada mediante un desplazamiento de 5 posiciones en el alfabeto) y devuelva la cadena decodificada original, revirtiendo el desplazamiento. El resultado debe exponerse como respuesta de la API con código de estado 200.", + "code": "addParam(\"s\", s)\ndecoded = \"\".join([chr(((ord(ch) - 5 - ord(\"a\")) % 26) + ord(\"a\")) for ch in s])\naddResult(decoded)\n_status = 200", + "test_inputs": { + "s": "fghij" + }, + "test_list": [ + "re.search(r'[a-z]+', str(decoded))", + "re.match(r'^200$', str(_status))" + ] + } +] \ No newline at end of file diff --git a/scratches/pseco/synthetic_dataset/avap_test/records_output/lang_server_records.json b/scratches/pseco/synthetic_dataset/avap_test/records_output/lang_server_records.json new file mode 100644 index 0000000..3985af5 --- /dev/null +++ b/scratches/pseco/synthetic_dataset/avap_test/records_output/lang_server_records.json @@ -0,0 +1,428 @@ +[ + { + "passed": false, + "error": "Command not found: getQueryParamList", + "Local_Language_Server_Execution": "Execution Data:\n500: Internal Server Error" + }, + { + "passed": true, + "error": "", + "Local_Language_Server_Execution": { + "status": true, + "elapsed": 0.6782073974609375, + "result": { + "greeting": "Hello, Alice!" + } + } + }, + { + "passed": false, + "error": "Command not found: encodeSHA256", + "Local_Language_Server_Execution": { + "status": true, + "elapsed": 0.6546368598937988, + "result": { + "hashed_password": "e410f9baf32634f4e0492acede51942c0b76bff30b859408acdcba3b94941f1e", + "secure_token": "MnGg2AHegPR5CMLq2W10d8PwSQEM6EYz" + } + } + }, + { + "passed": true, + "error": "", + "Local_Language_Server_Execution": { + "status": true, + "elapsed": 0.9698343276977539, + "result": { + "username": "alice" + } + } + }, + { + "passed": true, + "error": "", + "Local_Language_Server_Execution": { + "status": true, + "elapsed": 0.9964001178741455, + "result": { + "email": "user@example.com" + } + } + }, + { + "passed": false, + "error": "Command not found: encodeSHA256", + "Local_Language_Server_Execution": { + "status": true, + "elapsed": 0.6653525829315186, + "result": { + "hashed": "fcf730b6d95236ecd3c9fc2d92d7b6b2bb061514961aec041d6c7a7192f592e4" + } + } + }, + { + "passed": false, + "error": "Command not found: replace", + "Local_Language_Server_Execution": { + "status": true, + "elapsed": 0.6933853626251221, + "result": { + "result": "hello_world_foo" + } + } + }, + { + "passed": false, + "error": "Command not found: randomString", + "Local_Language_Server_Execution": { + "status": true, + "elapsed": 0.8636107444763184, + "result": { + "token": "RT1B5UdjhfPF0yrP72ENFdWsMOGF6Zel" + } + } + }, + { + "passed": true, + "error": "", + "Local_Language_Server_Execution": { + "status": true, + "elapsed": 0.7546753883361816, + "result": { + "result": "adulto" + } + } + }, + { + "passed": true, + "error": "", + "Local_Language_Server_Execution": { + "status": true, + "elapsed": 0.66571044921875, + "result": { + "result": "perfecto" + } + } + }, + { + "passed": false, + "error": "Command not found: variableToList", + "Local_Language_Server_Execution": { + "status": true, + "elapsed": 1.0307579040527344, + "result": { + "length": 1 + } + } + }, + { + "passed": false, + "error": "Command not found: getQueryParamList", + "Local_Language_Server_Execution": "Errors encountered:" + }, + { + "passed": false, + "error": "Command not found: variableFromJSON", + "Local_Language_Server_Execution": { + "status": true, + "elapsed": 0.6620609760284424, + "result": { + "name": "Carlos" + } + } + }, + { + "passed": false, + "error": "Command not found: AddVariableToJSON", + "Local_Language_Server_Execution": "Errors encountered:" + }, + { + "passed": false, + "error": "Command not found: encodeMD5", + "Local_Language_Server_Execution": { + "status": true, + "elapsed": 0.6491982936859131, + "result": { + "hashed": "5f4dcc3b5aa765d61d8327deb882cf99" + } + } + }, + { + "passed": false, + "error": "Command not found: getDateTime", + "Local_Language_Server_Execution": { + "status": true, + "elapsed": 0.6737937927246094, + "result": { + "today": "2026-03-30" + } + } + }, + { + "passed": false, + "error": "Command not found: stampToDatetime", + "Local_Language_Server_Execution": { + "status": false, + "elapsed": 0.7022957801818848, + "Errors:": [ + "Variable datestr not defined at line: 3" + ] + } + }, + { + "passed": false, + "error": "Command not found: getTimeStamp", + "Local_Language_Server_Execution": { + "status": true, + "elapsed": 0.927962064743042, + "result": { + "epoch": 1705276800 + } + } + }, + { + "passed": true, + "error": "", + "Local_Language_Server_Execution": { + "status": true, + "elapsed": 0.6997628211975098, + "result": { + "squared": 49 + } + } + }, + { + "passed": true, + "error": "", + "Local_Language_Server_Execution": { + "status": true, + "elapsed": 0.6906683444976807, + "result": { + "sum": "None" + } + } + }, + { + "passed": true, + "error": "", + "Local_Language_Server_Execution": "Execution Data:\n500: Internal Server Error" + }, + { + "passed": true, + "error": "", + "Local_Language_Server_Execution": "Errors encountered: \nVariable response not defined at line: 3" + }, + { + "passed": true, + "error": "", + "Local_Language_Server_Execution": "Execution encountered: \nVariable response not defined at line: 4" + }, + { + "passed": false, + "error": "Command not found: avapConnector", + "Local_Language_Server_Execution": { + "status": false, + "elapsed": 1.0673284530639648, + "Errors:": [ + "Variable status not defined at line: 3" + ] + } + }, + { + "passed": true, + "error": "", + "Local_Language_Server_Execution": { + "status": true, + "elapsed": 0.7820870876312256, + "result": { + "result": "fetched" + } + } + }, + { + "passed": false, + "error": "", + "Local_Language_Server_Execution": { + "status": true, + "elapsed": 0.8281633853912354, + "result": { + "accum": 15 + } + } + }, + { + "passed": false, + "error": "", + "Local_Language_Server_Execution": { + "status": true, + "elapsed": 0.7174324989318848, + "result": { + "result": "rango_valido" + } + } + }, + { + "passed": false, + "error": "Command not found: ormAccessSelect", + "Local_Language_Server_Execution": { + "status": false, + "elapsed": 0.6810524463653564, + "Errors:": [ + "'ProjectDatabase' object has no attribute 'conexion' at line: 1" + ] + } + }, + { + "passed": false, + "error": "Command not found: ormAccessInsert", + "Local_Language_Server_Execution": "Errors encountered: Variable insert_result not defined at line: 5" + }, + { + "passed": false, + "error": "Command not found: ormAccessUpdate", + "Local_Language_Server_Execution": { + "status": false, + "elapsed": 0.7697818279266357, + "Errors:": [ + "Variable update_result not defined at line: 6" + ] + } + }, + { + "passed": true, + "error": "", + "Local_Language_Server_Execution": "Errors encountered:" + }, + { + "passed": false, + "error": "Command not found: variableFromJSON", + "Local_Language_Server_Execution": { + "status": true, + "elapsed": 0.7087039947509766, + "result": { + "length": 3 + } + } + }, + { + "passed": false, + "error": "", + "Local_Language_Server_Execution": { + "status": true, + "elapsed": 0.7014470100402832, + "result": { + "result": "token_valido" + } + } + }, + { + "passed": false, + "error": "Command not found: getListLen", + "Local_Language_Server_Execution": { + "status": true, + "elapsed": 0.7706844806671143, + "result": { + "result": true + } + } + }, + { + "passed": false, + "error": "Command not found: replace", + "Local_Language_Server_Execution": { + "status": true, + "elapsed": 0.7992682456970215, + "result": { + "result": false + } + } + }, + { + "passed": false, + "error": "", + "Local_Language_Server_Execution": { + "status": true, + "elapsed": 0.6971292495727539, + "result": { + "result_str": "bcdf" + } + } + }, + { + "passed": false, + "error": "", + "Local_Language_Server_Execution": { + "status": true, + "elapsed": 0.6751101016998291, + "result": { + "digit_sum": 131 + } + } + }, + { + "passed": false, + "error": "Command not found: int", + "Local_Language_Server_Execution": { + "status": true, + "elapsed": 0.7301974296569824, + "result": { + "count": 0 + } + } + }, + { + "passed": false, + "error": "Command not found: replace", + "Local_Language_Server_Execution": { + "status": false, + "elapsed": 0.8365917205810547, + "Errors:": [ + "Variable words not defined at line: 8" + ] + } + }, + { + "passed": false, + "error": "Command not found: int", + "Local_Language_Server_Execution": { + "status": false, + "elapsed": 1.0710501670837402, + "Errors:": [ + "integer division or modulo by zero at line: 7 integer division or modulo by zero at line: 7" + ] + } + }, + { + "passed": false, + "error": "", + "Local_Language_Server_Execution": { + "status": false, + "elapsed": 0.6991498470306396, + "Errors:": [ + "unterminated string literal (detected at line 1) (, line 1) at line: 9" + ] + } + }, + { + "passed": false, + "error": "Command not found: sorted", + "Local_Language_Server_Execution": { + "status": true, + "elapsed": 0.7440598011016846, + "result": { + "sorted_nums": "None" + } + } + }, + { + "passed": false, + "error": "", + "Local_Language_Server_Execution": { + "status": true, + "elapsed": 0.7263014316558838, + "result": { + "decoded": "abcde" + } + } + } +] \ No newline at end of file diff --git a/scratches/pseco/synthetic_dataset/avap_test/records_output/parser_records.json b/scratches/pseco/synthetic_dataset/avap_test/records_output/parser_records.json new file mode 100644 index 0000000..7ef0e70 --- /dev/null +++ b/scratches/pseco/synthetic_dataset/avap_test/records_output/parser_records.json @@ -0,0 +1,863 @@ +[ + { + "execution_message": { + "success": false, + "error": "Command not found: getQueryParamList" + } + }, + { + "execution_message": { + "success": true, + "result": { + "greeting": "Hello, Alice!" + }, + "variables": { + "message": "Alice", + "greeting": "Hello, Alice!", + "_status": 200 + }, + "assertion_result": true, + "logs": [ + { + "command": "addParam", + "duration_ms": 0.212, + "success": true + }, + { + "command": "if", + "duration_ms": 0.28800000000000003, + "success": true + }, + { + "command": "addResult", + "duration_ms": 0.049, + "success": true + }, + { + "command": "assign", + "duration_ms": 0.024, + "success": true + } + ], + "http_status": 200 + } + }, + { + "execution_message": { + "success": false, + "error": "Command not found: encodeSHA256" + } + }, + { + "execution_message": { + "success": true, + "result": { + "username": "alice" + }, + "variables": { + "username": "alice" + }, + "assertion_result": true, + "logs": [ + { + "command": "addParam", + "duration_ms": 0.13999999999999999, + "success": true + }, + { + "command": "addResult", + "duration_ms": 0.034999999999999996, + "success": true + } + ], + "http_status": 200 + } + }, + { + "execution_message": { + "success": true, + "result": { + "email": "user@example.com" + }, + "variables": { + "email": "user@example.com", + "_status": 200 + }, + "assertion_result": true, + "logs": [ + { + "command": "addParam", + "duration_ms": 0.146, + "success": true + }, + { + "command": "addVar", + "duration_ms": 0.074, + "success": true + }, + { + "command": "addResult", + "duration_ms": 0.034, + "success": true + } + ], + "http_status": 200 + } + }, + { + "execution_message": { + "success": false, + "error": "Command not found: encodeSHA256" + } + }, + { + "execution_message": { + "success": false, + "error": "Command not found: replace" + } + }, + { + "execution_message": { + "success": false, + "error": "Command not found: randomString" + } + }, + { + "execution_message": { + "success": true, + "result": { + "result": "adulto" + }, + "variables": { + "age": "25", + "result": "adulto" + }, + "assertion_result": true, + "logs": [ + { + "command": "addParam", + "duration_ms": 0.175, + "success": true + }, + { + "command": "if", + "duration_ms": 0.219, + "success": true + }, + { + "command": "addResult", + "duration_ms": 0.048, + "success": true + } + ], + "http_status": 200 + } + }, + { + "execution_message": { + "success": true, + "result": { + "result": "perfecto" + }, + "variables": { + "score": "100", + "_status": 200, + "result": "perfecto" + }, + "assertion_result": true, + "logs": [ + { + "command": "addParam", + "duration_ms": 0.187, + "success": true + }, + { + "command": "if", + "duration_ms": 0.876, + "success": true + }, + { + "command": "addResult", + "duration_ms": 0.09000000000000001, + "success": true + } + ], + "http_status": 200 + } + }, + { + "execution_message": { + "success": false, + "error": "Command not found: variableToList" + } + }, + { + "execution_message": { + "success": false, + "error": "Command not found: getQueryParamList" + } + }, + { + "execution_message": { + "success": false, + "error": "Command not found: variableFromJSON" + } + }, + { + "execution_message": { + "success": false, + "error": "Command not found: AddVariableToJSON" + } + }, + { + "execution_message": { + "success": false, + "error": "Command not found: encodeMD5" + } + }, + { + "execution_message": { + "success": false, + "error": "Command not found: getDateTime" + } + }, + { + "execution_message": { + "success": false, + "error": "Command not found: stampToDatetime" + } + }, + { + "execution_message": { + "success": false, + "error": "Command not found: getTimeStamp" + } + }, + { + "execution_message": { + "success": true, + "result": { + "squared": 49 + }, + "variables": { + "n": "7", + "result": 49, + "squared": 49 + }, + "assertion_result": true, + "logs": [ + { + "command": "addParam", + "duration_ms": 0.177, + "success": true + }, + { + "command": "square", + "duration_ms": 0.094, + "success": true + }, + { + "command": "addResult", + "duration_ms": 0.038, + "success": true + } + ], + "http_status": 200 + } + }, + { + "execution_message": { + "success": true, + "result": { + "sum": 42 + }, + "variables": { + "a": "15", + "b": "27", + "result": 42, + "sum": 42 + }, + "assertion_result": true, + "logs": [ + { + "command": "addParam", + "duration_ms": 0.253, + "success": true + }, + { + "command": "addParam", + "duration_ms": 0.060000000000000005, + "success": true + }, + { + "command": "add", + "duration_ms": 0.154, + "success": true + }, + { + "command": "addResult", + "duration_ms": 0.054, + "success": true + } + ], + "http_status": 200 + } + }, + { + "execution_message": { + "success": true, + "result": { + "result": "error_division" + }, + "variables": { + "num": "10", + "result": "error_division", + "err": "No error detected" + }, + "assertion_result": true, + "logs": [ + { + "command": "addParam", + "duration_ms": 0.17, + "success": true + }, + { + "command": "try", + "duration_ms": 0.04, + "success": true + }, + { + "command": "assign", + "duration_ms": 0.064, + "success": true + }, + { + "command": "exception", + "duration_ms": 0.041, + "success": true + }, + { + "command": "assign", + "duration_ms": 0.024, + "success": true + }, + { + "command": "addResult", + "duration_ms": 0.033, + "success": true + } + ], + "http_status": 200 + } + }, + { + "execution_message": { + "success": true, + "result": { + "response": { + "args": {}, + "headers": { + "Accept": "*/*", + "Accept-Encoding": "gzip, deflate", + "Host": "httpbin.org", + "User-Agent": "python-requests/2.33.0", + "X-Amzn-Trace-Id": "Root=1-69ca35f3-7a7ea392014f0bf41a77473b" + }, + "origin": "207.246.65.119", + "url": "https://httpbin.org/get" + } + }, + "variables": { + "url": "https://httpbin.org/get", + "response": { + "args": {}, + "headers": { + "Accept": "*/*", + "Accept-Encoding": "gzip, deflate", + "Host": "httpbin.org", + "User-Agent": "python-requests/2.33.0", + "X-Amzn-Trace-Id": "Root=1-69ca35f3-7a7ea392014f0bf41a77473b" + }, + "origin": "207.246.65.119", + "url": "https://httpbin.org/get" + } + }, + "assertion_result": true, + "logs": [ + { + "command": "addParam", + "duration_ms": 0.185, + "success": true + }, + { + "command": "RequestGet", + "duration_ms": 202.913, + "success": true + }, + { + "command": "addResult", + "duration_ms": 0.11299999999999999, + "success": true + } + ], + "http_status": 200 + } + }, + { + "execution_message": { + "success": true, + "result": { + "response": { + "args": {}, + "data": "{\"key\": \"value\"}", + "files": {}, + "form": {}, + "headers": { + "Accept": "*/*", + "Accept-Encoding": "gzip, deflate", + "Content-Length": "16", + "Content-Type": "application/json", + "Host": "httpbin.org", + "User-Agent": "python-requests/2.33.0", + "X-Amzn-Trace-Id": "Root=1-69ca35f3-5a51fec722c2fa6d70f35792" + }, + "json": { + "key": "value" + }, + "origin": "207.246.65.119", + "url": "https://httpbin.org/post" + } + }, + "variables": { + "url": "https://httpbin.org/post", + "body": "{\"key\":\"value\"}", + "response": { + "args": {}, + "data": "{\"key\": \"value\"}", + "files": {}, + "form": {}, + "headers": { + "Accept": "*/*", + "Accept-Encoding": "gzip, deflate", + "Content-Length": "16", + "Content-Type": "application/json", + "Host": "httpbin.org", + "User-Agent": "python-requests/2.33.0", + "X-Amzn-Trace-Id": "Root=1-69ca35f3-5a51fec722c2fa6d70f35792" + }, + "json": { + "key": "value" + }, + "origin": "207.246.65.119", + "url": "https://httpbin.org/post" + } + }, + "assertion_result": true, + "logs": [ + { + "command": "addParam", + "duration_ms": 0.7879999999999999, + "success": true + }, + { + "command": "addParam", + "duration_ms": 0.062, + "success": true + }, + { + "command": "RequestPost", + "duration_ms": 125.87499999999999, + "success": true + }, + { + "command": "addResult", + "duration_ms": 0.135, + "success": true + } + ], + "http_status": 200 + } + }, + { + "execution_message": { + "success": false, + "error": "Command not found: avapConnector" + } + }, + { + "execution_message": { + "success": true, + "result": { + "result": "fetched" + }, + "variables": { + "handle": "7f1d86b7-f253-4b74-8f2c-34a65099713e", + "data": "fetched", + "result": "fetched" + }, + "assertion_result": true, + "logs": [ + { + "command": "go", + "duration_ms": 1.2489999999999999, + "success": true + }, + { + "command": "gather", + "duration_ms": 0.40900000000000003, + "success": true + }, + { + "command": "addResult", + "duration_ms": 0.11699999999999999, + "success": true + } + ], + "http_status": 200 + } + }, + { + "execution_message": { + "success": true, + "result": { + "accum": 15 + }, + "variables": { + "n": "5", + "accum": 15, + "i": 5 + }, + "assertion_result": false, + "logs": [ + { + "command": "addParam", + "duration_ms": 0.148, + "success": true + }, + { + "command": "assign", + "duration_ms": 0.047, + "success": true + }, + { + "command": "startLoop", + "duration_ms": 0.155, + "success": true + }, + { + "command": "addResult", + "duration_ms": 0.056, + "success": true + } + ], + "http_status": 200 + } + }, + { + "execution_message": { + "success": true, + "result": { + "result": "fuera_de_rango" + }, + "variables": { + "value": "50", + "result": "fuera_de_rango" + }, + "assertion_result": false, + "logs": [ + { + "command": "addParam", + "duration_ms": 0.202, + "success": true + }, + { + "command": "if", + "duration_ms": 0.781, + "success": true + }, + { + "command": "addResult", + "duration_ms": 0.092, + "success": true + } + ], + "http_status": 200 + } + }, + { + "execution_message": { + "success": false, + "error": "Command not found: ormAccessSelect" + } + }, + { + "execution_message": { + "success": false, + "error": "Command not found: ormAccessInsert" + } + }, + { + "execution_message": { + "success": false, + "error": "Command not found: ormAccessUpdate" + } + }, + { + "execution_message": { + "success": true, + "result": { + "result": 81 + }, + "variables": { + "result": 81 + }, + "assertion_result": true, + "logs": [ + { + "command": "calcSquare", + "duration_ms": 0.13699999999999998, + "success": true + }, + { + "command": "addResult", + "duration_ms": 0.146, + "success": true + } + ], + "http_status": 200 + } + }, + { + "execution_message": { + "success": false, + "error": "Command not found: variableFromJSON" + } + }, + { + "execution_message": { + "success": true, + "result": { + "result": "token_invalido" + }, + "variables": { + "token": "abcdefghijklmnopqrstuvwxyz123456", + "result": "token_invalido", + "_status": 401 + }, + "assertion_result": false, + "logs": [ + { + "command": "addParam", + "duration_ms": 0.203, + "success": true + }, + { + "command": "if", + "duration_ms": 1.175, + "success": true + }, + { + "command": "addResult", + "duration_ms": 0.32, + "success": true + } + ], + "http_status": 401 + } + }, + { + "execution_message": { + "success": false, + "error": "Command not found: getListLen" + } + }, + { + "execution_message": { + "success": false, + "error": "Command not found: replace" + } + }, + { + "execution_message": { + "success": true, + "result": { + "result_str": null + }, + "variables": { + "text": "abcdef", + "result": [ + "b", + "c", + "d", + "f" + ], + "result_str": null, + "_status": 200 + }, + "assertion_result": false, + "logs": [ + { + "command": "addParam", + "duration_ms": 0.18100000000000002, + "success": true + }, + { + "command": "assign", + "duration_ms": 0.13799999999999998, + "success": true + }, + { + "command": "connector_call", + "duration_ms": 0.003, + "success": true + }, + { + "command": "addResult", + "duration_ms": 0.046, + "success": true + }, + { + "command": "assign", + "duration_ms": 0.032, + "success": true + } + ], + "http_status": 200 + } + }, + { + "execution_message": { + "success": true, + "result": { + "digit_sum": null + }, + "variables": { + "s": "abAB", + "digit_sum": null, + "_status": 200 + }, + "assertion_result": false, + "logs": [ + { + "command": "addParam", + "duration_ms": 0.16, + "success": true + }, + { + "command": "if", + "duration_ms": 0.19699999999999998, + "success": true + }, + { + "command": "addResult", + "duration_ms": 0.037, + "success": true + }, + { + "command": "assign", + "duration_ms": 0.044, + "success": true + } + ], + "http_status": 200 + } + }, + { + "execution_message": { + "success": false, + "error": "Command not found: int" + } + }, + { + "execution_message": { + "success": false, + "error": "Command not found: replace" + } + }, + { + "execution_message": { + "success": false, + "error": "Command not found: int" + } + }, + { + "execution_message": { + "success": true, + "result": { + "split_result": null + }, + "variables": { + "txt": "Hello world!", + "split_result": null, + "_status": 200 + }, + "assertion_result": false, + "logs": [ + { + "command": "addParam", + "duration_ms": 0.501, + "success": true + }, + { + "command": "if", + "duration_ms": 0.281, + "success": true + }, + { + "command": "addResult", + "duration_ms": 0.038, + "success": true + }, + { + "command": "assign", + "duration_ms": 0.047, + "success": true + } + ], + "http_status": 200 + } + }, + { + "execution_message": { + "success": false, + "error": "Command not found: sorted" + } + }, + { + "execution_message": { + "success": true, + "result": { + "decoded": null + }, + "variables": { + "s": "fghij", + "decoded": null, + "_status": 200 + }, + "assertion_result": false, + "logs": [ + { + "command": "addParam", + "duration_ms": 0.158, + "success": true + }, + { + "command": "connector_call", + "duration_ms": 0.003, + "success": true + }, + { + "command": "addResult", + "duration_ms": 0.034, + "success": true + }, + { + "command": "assign", + "duration_ms": 0.046, + "success": true + } + ], + "http_status": 200 + } + } +] \ No newline at end of file diff --git a/scratches/pseco/synthetic_dataset/avap_test/test.avap b/scratches/pseco/synthetic_dataset/avap_test/test.avap index 55b264b..1caf175 100644 --- a/scratches/pseco/synthetic_dataset/avap_test/test.avap +++ b/scratches/pseco/synthetic_dataset/avap_test/test.avap @@ -1 +1,4 @@ -variableToList(1, myList) +addParam("datos", lista_entrada) +getListLen(lista_entrada, longitud) +addVar(_status, 200) +addResult(longitud) \ No newline at end of file diff --git a/scratches/pseco/synthetic_dataset/avap_test/test.ipynb b/scratches/pseco/synthetic_dataset/avap_test/test.ipynb index 0d31a49..f2ada10 100644 --- a/scratches/pseco/synthetic_dataset/avap_test/test.ipynb +++ b/scratches/pseco/synthetic_dataset/avap_test/test.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "id": "c46228bd", "metadata": {}, "outputs": [], @@ -12,38 +12,636 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "id": "91c20032", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "variableToList(\"a\", myList)\n", - "AddVariableToJSON(\"1\", \"b\", myList)\n", - "AddVariableToJSON(\"2\", \"c\", myList)\n", - "getListLen(myList, total)\n", - "addResult(total)\n" - ] - } - ], + "outputs": [], "source": [ "print(code)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "64d5e9d4", "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== Task 1 | success: False ===\n", + "addParam('user_list', user_data)\n", + "getQueryParamList('emails', email_list)\n", + "addVar(valid_count, 0)\n", + "addVar(invalid_count, 0)\n", + "addVar(processed_emails, [])\n", + "try()\n", + " getListLen(email_list, total_emails)\n", + " if(total_emails, 0, \">\")\n", + " addVar(i, 0)\n", + " startLoop(counter, 0, total_emails)\n", + " itemFromList(email_list, i, current_email)\n", + " getRegex(current_email, \"^[\\\\w\\\\.-]+@[\\\\w\\\\.-]+\\\\.[a-zA-Z]{2,}$\", email_match)\n", + " if(None, None, `email_match != None`)\n", + " addVar(valid_count, valid_count + 1)\n", + " replace(current_email, \" \", \"\", clean_email)\n", + " variableToList(clean_email, temp_list)\n", + " AddVariableToJSON(\"email\", clean_email, email_obj)\n", + " AddVariableToJSON(\"status\", \"valid\", email_obj)\n", + " else()\n", + " addVar(invalid_count, invalid_count + 1)\n", + " AddVariableToJSON(\"email\", current_email, email_obj)\n", + " AddVariableToJSON(\"status\", \"invalid\", email_obj)\n", + " end()\n", + " addVar(i, i + 1)\n", + " endLoop()\n", + " AddVariableToJSON(\"total_processed\", total_emails, report)\n", + " AddVariableToJSON(\"valid_emails\", valid_count, report)\n", + " AddVariableToJSON(\"invalid_emails\", invalid_count, report)\n", + " if(valid_count, 0, \">\")\n", + " addVar(_status, 200)\n", + " else()\n", + " addVar(_status, 422)\n", + " end()\n", + " else()\n", + " AddVariableToJSON(\"error\", \"No emails provided\", report)\n", + " addVar(_status, 400)\n", + " end()\n", + "exception(error_var)\n", + " AddVariableToJSON(\"error\", \"Processing failed\", report)\n", + " addVar(_status, 500)\n", + "end()\n", + "addResult(report)\n", + "\n", + "=== Task 1 | success: True ===\n", + "addParam(\"message\", message)\n", + "if(message, None, \"=\")\n", + " greeting = \"Hello, World!\"\n", + "else()\n", + " greeting = \"Hello, \" + message + \"!\"\n", + "end()\n", + "addResult(greeting)\n", + "_status = 200\n", + "\n", + "=== Task 2 | success: False ===\n", + "addParam(\"password\", password)\n", + "encodeSHA256(password, hashed_password)\n", + "randomString(\"[a-zA-Z0-9]\", 32, secure_token)\n", + "addResult(hashed_password)\n", + "addResult(secure_token)\n", + "\n", + "=== Task 1 | success: True ===\n", + "addParam(\"username\", username)\n", + "addResult(username)\n", + "\n", + "=== Task 2 | success: True ===\n", + "addParam(\"email\", email)\n", + "addVar(_status, 200)\n", + "addResult(email)\n", + "\n", + "=== Task 3 | success: False ===\n", + "addParam(\"password\", password)\n", + "encodeSHA256(password, hashed)\n", + "addResult(hashed)\n", + "\n", + "=== Task 4 | success: False ===\n", + "addParam(\"text\", text)\n", + "replace(text, \" \", \"_\", result)\n", + "addResult(result)\n", + "\n", + "=== Task 5 | success: False ===\n", + "randomString(\"[a-zA-Z0-9]\", 32, token)\n", + "addResult(token)\n", + "\n", + "=== Task 6 | success: True ===\n", + "addParam(\"age\", age)\n", + "if(age, 18, \">\")\n", + "result = \"adulto\"\n", + "else()\n", + "result = \"menor\"\n", + "end()\n", + "addResult(result)\n", + "\n", + "=== Task 7 | success: True ===\n", + "addParam(\"score\", score)\n", + "if(score, 100, \"==\")\n", + "addVar(_status, 200)\n", + "result = \"perfecto\"\n", + "else()\n", + "addVar(_status, 400)\n", + "result = \"incompleto\"\n", + "end()\n", + "addResult(result)\n", + "\n", + "=== Task 8 | success: False ===\n", + "variableToList(\"item1\", myList)\n", + "getListLen(myList, length)\n", + "addResult(length)\n", + "\n", + "=== Task 9 | success: False ===\n", + "getQueryParamList(\"items\", items)\n", + "getListLen(items, length)\n", + "addResult(length)\n", + "\n", + "=== Task 10 | success: False ===\n", + "addParam(\"data\", data)\n", + "variableFromJSON(data, \"name\", name)\n", + "addResult(name)\n", + "\n", + "=== Task 11 | success: False ===\n", + "info = {}\n", + "AddVariableToJSON(\"status\", \"ok\", info)\n", + "addResult(info)\n", + "\n", + "=== Task 12 | success: False ===\n", + "addParam(\"password\", password)\n", + "encodeMD5(password, hashed)\n", + "addResult(hashed)\n", + "\n", + "=== Task 13 | success: False ===\n", + "getDateTime(\"%Y-%m-%d\", 0, \"UTC\", today)\n", + "addResult(today)\n", + "\n", + "=== Task 14 | success: False ===\n", + "addParam(\"epoch\", epoch)\n", + "stampToDatetime(epoch, \"%Y-%m-%d %H:%M:%S\", 0, datestr)\n", + "addResult(datestr)\n", + "\n", + "=== Task 15 | success: False ===\n", + "addParam(\"date_str\", date_str)\n", + "getTimeStamp(date_str, \"%Y-%m-%d\", 0, epoch)\n", + "addResult(epoch)\n", + "\n", + "=== Task 16 | success: True ===\n", + "function square(n) {\n", + "result = n * n\n", + "return(result)\n", + "}\n", + "addParam(\"n\", n)\n", + "squared = square(n)\n", + "addResult(squared)\n", + "\n", + "=== Task 17 | success: True ===\n", + "function add(a, b) {\n", + "result = a + b\n", + "return(result)\n", + "}\n", + "addParam(\"a\", a)\n", + "addParam(\"b\", b)\n", + "sum = add(a, b)\n", + "addResult(sum)\n", + "\n", + "=== Task 18 | success: True ===\n", + "addParam(\"num\", num)\n", + "try()\n", + "result = num / 0\n", + "exception(err)\n", + "result = \"error_division\"\n", + "end()\n", + "addResult(result)\n", + "\n", + "=== Task 19 | success: True ===\n", + "addParam(\"url\", url)\n", + "RequestGet(url, \"\", \"\", response, 5000)\n", + "addResult(response)\n", + "\n", + "=== Task 20 | success: True ===\n", + "addParam(\"url\", url)\n", + "addParam(\"body\", body)\n", + "RequestPost(url, \"\", \"\", body, response, 3000)\n", + "addResult(response)\n", + "\n", + "=== Task 21 | success: False ===\n", + "connector = avapConnector(\"20908e93260147acb2636967021fbf5d\")\n", + "status = connector.get_status()\n", + "addResult(status)\n", + "\n", + "=== Task 22 | success: True ===\n", + "function fetchData() {\n", + "data = \"fetched\"\n", + "return(data)\n", + "}\n", + "handle = go fetchData()\n", + "result = gather(handle, 2000)\n", + "addResult(result)\n", + "\n", + "=== Task 23 | success: True ===\n", + "addParam(\"n\", n)\n", + "accum = 0\n", + "startLoop(i, 0, n)\n", + "accum = accum + i\n", + "endLoop()\n", + "addResult(accum)\n", + "\n", + "=== Task 24 | success: True ===\n", + "addParam(\"value\", value)\n", + "if(None, None, `value > 0 and value < 100`)\n", + "result = \"rango_valido\"\n", + "else()\n", + "result = \"fuera_de_rango\"\n", + "end()\n", + "addResult(result)\n", + "\n", + "=== Task 25 | success: False ===\n", + "ormAccessSelect(\"*\", \"users\", \"\", records)\n", + "addResult(records)\n", + "\n", + "=== Task 26 | success: False ===\n", + "addParam(\"username\", username)\n", + "addParam(\"email\", email)\n", + "fields = {\"username\": username, \"email\": email}\n", + "ormAccessInsert(fields, \"users\", insert_result)\n", + "addResult(insert_result)\n", + "\n", + "=== Task 27 | success: False ===\n", + "addParam(\"user_id\", user_id)\n", + "fields = \"active\"\n", + "values = {\"active\": 1}\n", + "selector = \"id = \" + str(user_id)\n", + "ormAccessUpdate(fields, values, \"users\", selector, update_result)\n", + "addResult(update_result)\n", + "\n", + "=== Task 28 | success: True ===\n", + "import \n", + "function calcSquare(x) {\n", + "result = x * x\n", + "return(result)\n", + "}\n", + "result = calcSquare(9)\n", + "addResult(result)\n", + "\n", + "=== Task 29 | success: False ===\n", + "addParam(\"items_json\", items_json)\n", + "variableFromJSON(items_json, \"items\", items)\n", + "getListLen(items, length)\n", + "addResult(length)\n", + "\n", + "=== Task 30 | success: True ===\n", + "addParam(\"token\", token)\n", + "if(None, None, `len(token) == 32`)\n", + "result = \"token_valido\"\n", + "addVar(_status, 200)\n", + "else()\n", + "result = \"token_invalido\"\n", + "addVar(_status, 401)\n", + "end()\n", + "addResult(result)\n", + "\n", + "=== Task 52 | success: False ===\n", + "addParam(\"numbers\", numbers)\n", + "addParam(\"threshold\", threshold)\n", + "result = True\n", + "getListLen(numbers, list_len)\n", + "i = 0\n", + "startLoop(i, 0, list_len)\n", + " itemFromList(numbers, i, current_item)\n", + " current_val = int(current_item)\n", + " thresh_val = int(threshold)\n", + " if(None, None, `current_val >= thresh_val`)\n", + " result = False\n", + " end()\n", + "endLoop()\n", + "addResult(result)\n", + "_status = 200\n", + "\n", + "=== Task 134 | success: False ===\n", + "addParam(\"txt\", txt)\n", + "result = False\n", + "if(None, None, `txt == \"\" or txt == None`)\n", + " result = False\n", + "else()\n", + " replace(txt, \",\", \" \", txt_clean)\n", + " last_word = txt_clean.split()[-1] if txt_clean.split() else \"\"\n", + " getListLen(last_word, last_len)\n", + " if(None, None, `last_len == 1 and last_word.lower() >= \"a\" and last_word.lower() <= \"z\"`)\n", + " result = True\n", + " else()\n", + " result = False\n", + " end()\n", + "end()\n", + "addResult(result)\n", + "_status = 200\n", + "\n", + "=== Task 51 | success: True ===\n", + "addParam(\"text\", text)\n", + "result = [s for s in text if s.lower() not in [\"a\", \"e\", \"i\", \"o\", \"u\"]]\n", + "result_str = \"\".join(result)\n", + "addResult(result_str)\n", + "_status = 200\n", + "\n", + "=== Task 66 | success: True ===\n", + "addParam(\"s\", s)\n", + "if(None, None, `s == \"\" or s == None`)\n", + " digit_sum = 0\n", + "else()\n", + " digit_sum = sum(ord(char) if char.isupper() else 0 for char in s)\n", + "end()\n", + "addResult(digit_sum)\n", + "_status = 200\n", + "\n", + "=== Task 147 | success: False ===\n", + "addParam(\"n\", n)\n", + "n_val = int(n)\n", + "A = [i*i - i + 1 for i in range(1, n_val + 1)]\n", + "count = 0\n", + "getListLen(A, len_a)\n", + "i = 0\n", + "startLoop(i, 0, len_a)\n", + " j = i + 1\n", + " startLoop(j, i + 1, len_a)\n", + " k = j + 1\n", + " startLoop(k, j + 1, len_a)\n", + " itemFromList(A, i, ai)\n", + " itemFromList(A, j, aj)\n", + " itemFromList(A, k, ak)\n", + " triple_sum = int(ai) + int(aj) + int(ak)\n", + " if(None, None, `triple_sum % 3 == 0`)\n", + " count = count + 1\n", + " end()\n", + " endLoop()\n", + " endLoop()\n", + "endLoop()\n", + "addResult(count)\n", + "_status = 200\n", + "\n", + "=== Task 101 | success: False ===\n", + "addParam(\"s\", s)\n", + "if(None, None, `s == \"\" or s == None`)\n", + " words = []\n", + "else()\n", + " replace(s, \",\", \" \", s_clean)\n", + " words = s_clean.split()\n", + "end()\n", + "addResult(words)\n", + "_status = 200\n", + "\n", + "=== Task 24 | success: False ===\n", + "addParam(\"n\", n)\n", + "n_val = int(n)\n", + "largest_div = 1\n", + "i = n_val - 1\n", + "startLoop(i, 1, n_val)\n", + " candidate = n_val - i\n", + " if(None, None, `n_val % candidate == 0`)\n", + " largest_div = candidate\n", + " return(largest_div)\n", + " end()\n", + "endLoop()\n", + "addResult(largest_div)\n", + "_status = 200\n", + "\n", + "=== Task 125 | success: True ===\n", + "addParam(\"txt\", txt)\n", + "if(None, None, `\" \" in txt`)\n", + " split_result = txt.split()\n", + "else()\n", + " if(None, None, `\",\" in txt`)\n", + " replace(txt, \",\", \" \", txt_replaced)\n", + " split_result = txt_replaced.split()\n", + " else()\n", + " split_result = len([i for i in txt if i.islower() and ord(i) % 2 == 0])\n", + " end()\n", + "end()\n", + "addResult(split_result)\n", + "_status = 200\n", + "\n", + "=== Task 145 | success: False ===\n", + "addParam(\"nums\", nums)\n", + "function digits_sum(n) {\n", + " neg = 1\n", + " if(None, None, `n < 0`)\n", + " n = -1 * n\n", + " neg = -1\n", + " end()\n", + " digits = [int(d) for d in str(n)]\n", + " digits[0] = digits[0] * neg\n", + " return(sum(digits))\n", + "}\n", + "sorted_nums = sorted(nums, key=digits_sum)\n", + "addResult(sorted_nums)\n", + "_status = 200\n", + "\n", + "=== Task 50 | success: True ===\n", + "addParam(\"s\", s)\n", + "decoded = \"\".join([chr(((ord(ch) - 5 - ord(\"a\")) % 26) + ord(\"a\")) for ch in s])\n", + "addResult(decoded)\n", + "_status = 200\n", + "\n" + ] + } + ], + "source": [ + "import json\n", + "from pathlib import Path\n", + "\n", + "analysis_path = Path(\"../../../../output/parser_analysis.json\")\n", + "\n", + "with analysis_path.open(\"r\", encoding=\"utf-8\") as f:\n", + " records = json.load(f)\n", + "\n", + "for record in records:\n", + " task_id = record.get(\"task_id\")\n", + " code = record.get(\"code\", \"\")\n", + " exec_msg = record.get(\"execution_message\", {})\n", + " success = exec_msg.get(\"success\", False)\n", + "\n", + " print(f\"=== Task {task_id} | success: {success} ===\")\n", + " print(code)\n", + " print()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "a5946318", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'source_file': 'mbap_avap_A.json',\n", + " 'task_id': 1,\n", + " 'text': 'Crea una API de validación y transformación de datos de usuarios que procese una lista de emails desde parámetros de consulta, valide cada email con expresión regular, transforme nombres de usuarios eliminando espacios, y genere un reporte con estadísticas de emails válidos/inválidos. La API debe manejar errores y devolver código de estado HTTP apropiado.',\n", + " 'code': 'addParam(\\'user_list\\', user_data)\\ngetQueryParamList(\\'emails\\', email_list)\\naddVar(valid_count, 0)\\naddVar(invalid_count, 0)\\naddVar(processed_emails, [])\\ntry()\\n getListLen(email_list, total_emails)\\n if(total_emails, 0, \">\")\\n addVar(i, 0)\\n startLoop(counter, 0, total_emails)\\n itemFromList(email_list, i, current_email)\\n getRegex(current_email, \"^[\\\\\\\\w\\\\\\\\.-]+@[\\\\\\\\w\\\\\\\\.-]+\\\\\\\\.[a-zA-Z]{2,}$\", email_match)\\n if(None, None, `email_match != None`)\\n addVar(valid_count, valid_count + 1)\\n replace(current_email, \" \", \"\", clean_email)\\n variableToList(clean_email, temp_list)\\n AddVariableToJSON(\"email\", clean_email, email_obj)\\n AddVariableToJSON(\"status\", \"valid\", email_obj)\\n else()\\n addVar(invalid_count, invalid_count + 1)\\n AddVariableToJSON(\"email\", current_email, email_obj)\\n AddVariableToJSON(\"status\", \"invalid\", email_obj)\\n end()\\n addVar(i, i + 1)\\n endLoop()\\n AddVariableToJSON(\"total_processed\", total_emails, report)\\n AddVariableToJSON(\"valid_emails\", valid_count, report)\\n AddVariableToJSON(\"invalid_emails\", invalid_count, report)\\n if(valid_count, 0, \">\")\\n addVar(_status, 200)\\n else()\\n addVar(_status, 422)\\n end()\\n else()\\n AddVariableToJSON(\"error\", \"No emails provided\", report)\\n addVar(_status, 400)\\n end()\\nexception(error_var)\\n AddVariableToJSON(\"error\", \"Processing failed\", report)\\n addVar(_status, 500)\\nend()\\naddResult(report)',\n", + " 'test_inputs': {'emails': ['user1@domain.com',\n", + " 'invalid-email',\n", + " 'test@example.org',\n", + " 'bad@',\n", + " 'admin@site.co.uk']},\n", + " 'test_list': [\"re.match(r'\\\\d+', str(report.get('total_processed', '')))\",\n", + " \"re.match(r'[2-5]\\\\d\\\\d', str(_status))\",\n", + " \"re.match(r'(valid|invalid)', str(report.get('error', '') or 'valid'))\"],\n", + " 'execution_message': {'success': False,\n", + " 'error': 'Command not found: getQueryParamList'},\n", + " 'passed': False,\n", + " 'error': 'Command not found: getQueryParamList',\n", + " 'Local_Language_Server_Execution': 'Execution Data:\\n500: Internal Server Error'}" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "records[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "60e04025", + "metadata": {}, + "outputs": [], + "source": [ + "input_record_keys = [\"source_file\", \"task_id\", \"text\",\"code\", \"test_inputs\", \"test_list\"]\n", + "parser_record_keys = [\"execution_message\"]\n", + "lang_server_record_keys = [\"passed\", \"error\", \"Local_Language_Server_Execution\"]\n", + "\n", + "\n", + "input_records = [\n", + " {k: v for k, v in record.items() if k in input_record_keys} for record in records \n", + "]\n", + "parser_records = [\n", + " {k: v for k, v in record.items() if k in parser_record_keys} for record in records \n", + "]\n", + "\n", + "lang_server_records = [\n", + " {k: v for k, v in record.items() if k in lang_server_record_keys} for record in records \n", + "]" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "2dd0b3c7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'source_file': 'mbap_avap_A.json',\n", + " 'task_id': 1,\n", + " 'text': 'Crea una API de validación y transformación de datos de usuarios que procese una lista de emails desde parámetros de consulta, valide cada email con expresión regular, transforme nombres de usuarios eliminando espacios, y genere un reporte con estadísticas de emails válidos/inválidos. La API debe manejar errores y devolver código de estado HTTP apropiado.',\n", + " 'code': 'addParam(\\'user_list\\', user_data)\\ngetQueryParamList(\\'emails\\', email_list)\\naddVar(valid_count, 0)\\naddVar(invalid_count, 0)\\naddVar(processed_emails, [])\\ntry()\\n getListLen(email_list, total_emails)\\n if(total_emails, 0, \">\")\\n addVar(i, 0)\\n startLoop(counter, 0, total_emails)\\n itemFromList(email_list, i, current_email)\\n getRegex(current_email, \"^[\\\\\\\\w\\\\\\\\.-]+@[\\\\\\\\w\\\\\\\\.-]+\\\\\\\\.[a-zA-Z]{2,}$\", email_match)\\n if(None, None, `email_match != None`)\\n addVar(valid_count, valid_count + 1)\\n replace(current_email, \" \", \"\", clean_email)\\n variableToList(clean_email, temp_list)\\n AddVariableToJSON(\"email\", clean_email, email_obj)\\n AddVariableToJSON(\"status\", \"valid\", email_obj)\\n else()\\n addVar(invalid_count, invalid_count + 1)\\n AddVariableToJSON(\"email\", current_email, email_obj)\\n AddVariableToJSON(\"status\", \"invalid\", email_obj)\\n end()\\n addVar(i, i + 1)\\n endLoop()\\n AddVariableToJSON(\"total_processed\", total_emails, report)\\n AddVariableToJSON(\"valid_emails\", valid_count, report)\\n AddVariableToJSON(\"invalid_emails\", invalid_count, report)\\n if(valid_count, 0, \">\")\\n addVar(_status, 200)\\n else()\\n addVar(_status, 422)\\n end()\\n else()\\n AddVariableToJSON(\"error\", \"No emails provided\", report)\\n addVar(_status, 400)\\n end()\\nexception(error_var)\\n AddVariableToJSON(\"error\", \"Processing failed\", report)\\n addVar(_status, 500)\\nend()\\naddResult(report)',\n", + " 'test_inputs': {'emails': ['user1@domain.com',\n", + " 'invalid-email',\n", + " 'test@example.org',\n", + " 'bad@',\n", + " 'admin@site.co.uk']},\n", + " 'test_list': [\"re.match(r'\\\\d+', str(report.get('total_processed', '')))\",\n", + " \"re.match(r'[2-5]\\\\d\\\\d', str(_status))\",\n", + " \"re.match(r'(valid|invalid)', str(report.get('error', '') or 'valid'))\"]}" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "input_records[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "5df84ee5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'execution_message': {'success': False,\n", + " 'error': 'Command not found: getQueryParamList'}}" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "parser_records[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "3f6d761c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'passed': False,\n", + " 'error': 'Command not found: getQueryParamList',\n", + " 'Local_Language_Server_Execution': 'Execution Data:\\n500: Internal Server Error'}" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "lang_server_records[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "966792dd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Saved input records: 43 -> /home/pseco/VsCodeProjects/assistance-engine/scratches/pseco/synthetic_dataset/avap_test/records_output/input_records.json\n", + "Saved parser records: 43 -> /home/pseco/VsCodeProjects/assistance-engine/scratches/pseco/synthetic_dataset/avap_test/records_output/parser_records.json\n", + "Saved server records: 43 -> /home/pseco/VsCodeProjects/assistance-engine/scratches/pseco/synthetic_dataset/avap_test/records_output/lang_server_records.json\n" + ] + } + ], + "source": [ + "import json\n", + "from pathlib import Path\n", + "\n", + "output_dir = Path(\"./records_output\")\n", + "output_dir.mkdir(parents=True, exist_ok=True)\n", + "\n", + "input_path = output_dir / \"input_records.json\"\n", + "parser_path = output_dir / \"parser_records.json\"\n", + "server_path = output_dir / \"lang_server_records.json\"\n", + "\n", + "with input_path.open(\"w\", encoding=\"utf-8\") as f:\n", + " json.dump(input_records, f, ensure_ascii=False, indent=2)\n", + "\n", + "with parser_path.open(\"w\", encoding=\"utf-8\") as f:\n", + " json.dump(parser_records, f, ensure_ascii=False, indent=2)\n", + "\n", + "with server_path.open(\"w\", encoding=\"utf-8\") as f:\n", + " json.dump(lang_server_records, f, ensure_ascii=False, indent=2)\n", + "\n", + "print(f\"Saved input records: {len(input_records)} -> {input_path.resolve()}\")\n", + "print(f\"Saved parser records: {len(parser_records)} -> {parser_path.resolve()}\")\n", + "print(f\"Saved server records: {len(lang_server_records)} -> {server_path.resolve()}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "929bb59f", + "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { - "display_name": ".venv", + "display_name": "assistance-engine", "language": "python", "name": "python3" }, diff --git a/scratches/pseco/synthetic_dataset/generate_parser_analysis.py b/scratches/pseco/synthetic_dataset/generate_parser_analysis.py new file mode 100644 index 0000000..4d381b3 --- /dev/null +++ b/scratches/pseco/synthetic_dataset/generate_parser_analysis.py @@ -0,0 +1,238 @@ +import io +import json +from pathlib import Path + +import requests +import typer +from loguru import logger + +from src.config import settings + +app = typer.Typer() + +DEFAULT_DATASETS = [ + "output/candidate_A_reward_10_v3.json", +] + + +def load_tasks(dataset_path: Path) -> list[dict]: + """Load tasks from a synthetic dataset JSON file. + + Args: + dataset_path: Path to the JSON file containing tasks. + + Returns: + List of task dictionaries. + """ + with dataset_path.open("r", encoding="utf-8") as f: + tasks: list[dict] = json.load(f) + logger.info(f"Loaded {len(tasks)} tasks from {dataset_path.name}") + return tasks + + +def execute_task(task: dict, api_url: str, timeout: int) -> dict: + """Send a single task to the parser API and return the result. + + Args: + task: Task dictionary with code and test data. + api_url: URL of the parser/validation API endpoint. + timeout: Timeout in seconds for the request. + + Returns: + Parsed response dictionary from the API. + """ + payload = json.dumps([task]).encode("utf-8") + file_obj = io.BytesIO(payload) + response = requests.post( + api_url, + files={"file": ("task.json", file_obj, "application/json")}, + timeout=timeout, + ) + return _parse_response(response.text) + + +def _parse_response(raw: str) -> dict: + """Parse the raw API response into a structured dict. + + Args: + raw: Raw response text from the API. + + Returns: + Parsed result dictionary. + """ + raw = raw.strip() + if not raw: + return {"success": False, "error": "Empty response from API"} + + decoder = json.JSONDecoder() + objects: list[dict] = [] + idx = 0 + while idx < len(raw): + try: + obj, end_idx = decoder.raw_decode(raw, idx) + objects.append(obj) + idx = end_idx + except json.JSONDecodeError: + idx += 1 + while idx < len(raw) and raw[idx] in " \t\n\r": + idx += 1 + + if not objects: + return {"success": False, "error": f"Could not parse response: {raw[:200]}"} + + for obj in objects: + if not obj.get("success"): + return obj + if "result_sequence" in obj and obj["result_sequence"]: + return obj["result_sequence"][0] + + return objects[0] + + +def build_analysis_record( + source_file: str, + task: dict, + result: dict, +) -> dict: + """Build a consolidated analysis record for a single task. + + Args: + source_file: Name of the source JSON file. + task: Original task dictionary. + result: Parsed API response for the task. + + Returns: + Consolidated record with task data and execution results. + """ + passed = result.get("success", False) and result.get( + "assertion_result", True + ) + error = result.get("error", "") if not passed else "" + + return { + "source_file": source_file, + "task_id": task.get("task_id"), + "text": task.get("text", ""), + "code": task.get("code", ""), + "test_inputs": task.get("test_inputs", {}), + "test_list": task.get("test_list", []), + "execution_message": result, + "passed": passed, + "error": error, + "Local_Language_Server_Execution": "", + } + + +def analyze_datasets( + dataset_paths: list[Path], + api_url: str, + timeout: int, +) -> list[dict]: + """Run parser analysis on every task across multiple dataset files. + + Args: + dataset_paths: List of resolved paths to dataset JSON files. + api_url: URL of the parser/validation API endpoint. + timeout: Timeout in seconds per request. + + Returns: + Consolidated list of analysis records. + """ + records: list[dict] = [] + errors: list[str] = [] + + for dataset_path in dataset_paths: + source_file = dataset_path.name + tasks = load_tasks(dataset_path) + + for idx, task in enumerate(tasks): + task_id = task.get("task_id", idx) + try: + result = execute_task(task, api_url, timeout) + record = build_analysis_record(source_file, task, result) + records.append(record) + status = "PASSED" if record["passed"] else "FAILED" + logger.info(f"[{source_file}] Task {task_id}: {status}") + except requests.RequestException as exc: + error_result = {"success": False, "error": str(exc)} + record = build_analysis_record(source_file, task, error_result) + records.append(record) + msg = f"[{source_file}] Task {task_id}: Request failed — {exc}" + errors.append(msg) + logger.error(msg) + + passed_count = sum(1 for r in records if r["passed"]) + total = len(records) + logger.info(f"Analysis complete: {passed_count}/{total} tasks passed") + + if errors: + logger.error( + f"\n{'=' * 60}\n" + f"ERROR SUMMARY — {len(errors)} task(s) failed:\n" + + "\n".join(f" - {e}" for e in errors) + + f"\n{'=' * 60}" + ) + + return records + + +def save_analysis(records: list[dict], output_path: Path) -> None: + """Write the consolidated analysis to a JSON file. + + Args: + records: List of analysis record dicts. + output_path: Destination file path. + """ + output_path.parent.mkdir(parents=True, exist_ok=True) + with output_path.open("w", encoding="utf-8") as f: + json.dump(records, f, ensure_ascii=False, indent=2) + logger.info(f"Saved parser analysis to {output_path}") + + +@app.command() +def generate_parser_analysis( + dataset_paths: list[str] = typer.Argument( + None, + help="Paths to dataset JSON files (relative to project root). " + "Defaults to all files in synthetic_datasets/.", + ), + output_path: str = typer.Option( + "output/parser_analysis_candidate_A_v3.json", + help="Output path for the consolidated analysis JSON.", + ), + api_url: str = typer.Option( + settings.parser_url, + help="URL of the parser/validation API endpoint.", + ), + timeout: int = typer.Option( + 120, + help="Timeout in seconds for each API request.", + ), +) -> None: + """Run parser analysis on one or more synthetic dataset files. + + Sends each task to the parser API, collects execution results, + and writes a consolidated JSON report with per-task outcomes + and a blank Local_Language_Server_Execution field. + + Example usage: + python generate_parser_analysis.py \\ + synthetic_datasets/mbap_avap_A.json \\ + synthetic_datasets/mbpp_avap.json \\ + --output-path output/parser_analysis.json + """ + if not dataset_paths: + dataset_paths = DEFAULT_DATASETS + resolved_paths = [settings.proj_root / p for p in dataset_paths] + resolved_output = settings.proj_root / output_path + + records = analyze_datasets(resolved_paths, api_url, timeout) + save_analysis(records, resolved_output) + + +if __name__ == "__main__": + try: + app() + except Exception as exc: + logger.exception(exc) + raise diff --git a/scratches/pseco/synthetic_dataset/reward_algorithms/generate_mbap_v2.py b/scratches/pseco/synthetic_dataset/reward_algorithms/generate_mbap_v2.py new file mode 100644 index 0000000..dded7f3 --- /dev/null +++ b/scratches/pseco/synthetic_dataset/reward_algorithms/generate_mbap_v2.py @@ -0,0 +1,1420 @@ +#!/usr/bin/env python3 +""" +AVAP Dataset Generator v2 — MAP-Elites Quality-Diversity Pipeline +================================================================== + +View reference + +""" + +import argparse +import json +import math +import os +import io +import random +import sys +import time +from collections import defaultdict +from itertools import combinations +from pathlib import Path + +import anthropic +import requests +from scripts.pipelines.samples_generator.construct_prior import AVAP_NODE_NAMES, ConstructPrior + +from src.config import settings +from dotenv import load_dotenv +load_dotenv() + +AVAP_NODE_TYPES = { + "addParam": ["addParam("], + "addResult": ["addResult("], + "_status": ["_status"], + "addVar": ["addVar("], + "getListLen": ["getListLen("], + "getQueryParamList": ["getQueryParamList("], + "itemFromList": ["itemFromList("], + "replace": ["replace("], + "randomString": ["randomString("], + "if_mode1": ["if("], + "if_mode2": ["if(None, None,"], + "else": ["else()"], + "end": ["end()"], + "startLoop": ["startLoop("], + "endLoop": ["endLoop()"], + "try": ["try()"], + "exception": ["exception()"], + "return": ["return("], + "go": ["go("], + "gather": ["gather("], + "avapConnector": ["avapConnector("], + "ormCheckTable": ["ormCheckTable("], + "ormDirect": ["ormDirect("], + "ormAccessSelect": ["ormAccessSelect("], + "ormAccessInsert": ["ormAccessInsert("], + "ormAccessUpdate": ["ormAccessUpdate("], + "variableFromJSON": ["variableFromJSON("], + "AddVariableToJSON": ["AddVariableToJSON("], + "encodeSHA256": ["encodeSHA256("], + "encodeMD5": ["encodeMD5("], + "getTimeStamp": ["getTimeStamp("], + "getDateTime": ["getDateTime("], + "stampToDatetime": ["stampToDatetime("], + "RequestGet": ["RequestGet("], + "RequestPost": ["RequestPost("], + "function": ["function "], + "import": ["import "], + "include": ["include("], +} + +NODE_TYPE_NAMES = AVAP_NODE_NAMES +_PRIOR_EPSILON = 0.05 + + +class CellValidator: + def __init__(self, parser_url: str, parser_timeout: int = 5): + self.parser_url = parser_url.rstrip("/") + self.parser_timeout = parser_timeout + self._parser_available = True + + def parse(self, code: str) -> tuple[bool, dict, str]: + + if not self._parser_available: + return None, {}, "parser_unavailable" + try: + resp = requests.post( + f"{self.parser_url}/parse", + #f"{settings.parser_url}/api/v1/upload", + json={"code": code}, + #files={"file": ("task.json", io.BytesIO(json.dumps([code]).encode("utf-8")), "application/json")}, + timeout=self.parser_timeout, + ) + data = resp.json() + if data.get("valid", False): + return True, data.get("ast", {}), "" + return False, {}, data.get("error", "parse error") + except requests.exceptions.ConnectionError: + self._parser_available = False + return None, {}, "parser_unavailable" + except Exception as e: + return False, {}, str(e) + + def detect_constructs(self, code: str, ast: dict) -> set: + if ast: + return self._from_ast(ast) + return self._from_source(code) + + def _from_ast(self, ast: dict) -> set: + found = set() + if isinstance(ast, dict): + if "type" in ast: + found.add(ast["type"]) + for v in ast.values(): + found |= self._from_ast(v) + elif isinstance(ast, list): + for item in ast: + found |= self._from_ast(item) + return found + + def _from_source(self, code: str) -> set: + found = set() + if "if(None, None," in code: + found.add("if_mode2") + elif "if(" in code: + found.add("if_mode1") + for name, patterns in AVAP_NODE_TYPES.items(): + if name in ("if_mode1", "if_mode2"): + continue # already handled + for pat in patterns: + if pat in code: + found.add(name) + break + return found + + def cell_quality( + self, + code: str, + ast: dict, + test_list: list, + cell: frozenset, + alpha: float = 0.3, + beta: float = 0.2, + gamma: float = 0.1, + ) -> tuple[float, dict]: + + detected = self.detect_constructs(code, ast) + all_types = set(NODE_TYPE_NAMES) + + cell_constructs = set(cell) + present_required = cell_constructs & detected + fidelity = len(present_required) / max(len(cell_constructs), 1) + + extra = detected - cell_constructs + bonus_ratio = len(extra) / max(len(all_types) - len(cell_constructs), 1) + + tq = sum( + 1 + for t in test_list + if isinstance(t, str) and "re.match(" in t and len(t.strip()) > 10 + ) / max(len(test_list), 1) + + lines = [l.strip() for l in code.split("\n") if l.strip()] + richness = min(len(lines) / 30.0, 1.0) # cap at 30 lines = 1.0 + + quality = fidelity + alpha * bonus_ratio + beta * tq + gamma * richness + + return quality, { + "fidelity": round(fidelity, 3), + "bonus_ratio": round(bonus_ratio, 3), + "test_quality": round(tq, 3), + "richness": round(richness, 3), + "quality": round(quality, 3), + "detected": sorted(detected), + "cell": sorted(cell), + "extra": sorted(extra), + } + + +class CoverageMap: + def __init__(self, cell_size: int = 3): + + self.cell_size = cell_size + self._map: dict[frozenset, tuple[dict, float, dict]] = {} + self._attempts: dict[frozenset, int] = defaultdict(int) + self._all_cells = self._build_cells() + + def _build_cells(self) -> list[frozenset]: + cells = [] + for size in range(2, self.cell_size + 1): + for combo in combinations(NODE_TYPE_NAMES, size): + cells.append(frozenset(combo)) + return cells + + @property + def total_cells(self) -> int: + return len(self._all_cells) + + @property + def filled_cells(self) -> int: + return len(self._map) + + @property + def fill_rate(self) -> float: + return self.filled_cells / max(self.total_cells, 1) + + def update( + self, + cell: frozenset, + example: dict, + quality: float, + components: dict, + ) -> bool: + self._attempts[cell] += 1 + current = self._map.get(cell) + if current is None or quality > current[1]: + self._map[cell] = (example, quality, components) + return True + return False + + def get_empty_cells(self) -> list[frozenset]: + return [c for c in self._all_cells if c not in self._map] + + def get_low_quality_cells(self, threshold: float = 0.7) -> list[frozenset]: + return [c for c, (_, q, _) in self._map.items() if q < threshold] + + def get_example(self, cell: frozenset) -> dict | None: + entry = self._map.get(cell) + return entry[0] if entry else None + + def all_examples(self) -> list[dict]: + return [ex for ex, _, _ in self._map.values()] + + def node_type_frequency(self) -> dict[str, int]: + + freq = defaultdict(int) + for cell in self._map: + for nt in cell: + freq[nt] += 1 + return dict(freq) + + def distribution_entropy(self) -> float: + + freq = self.node_type_frequency() + total = sum(freq.values()) + if total == 0: + return 0.0 + entropy = 0.0 + for count in freq.values(): + p = count / total + if p > 0: + entropy -= p * math.log2(p) + return round(entropy, 3) + + def fill_summary(self) -> str: + empty = len(self.get_empty_cells()) + low = len(self.get_low_quality_cells()) + entropy = self.distribution_entropy() + return ( + f"Cells: {self.filled_cells}/{self.total_cells} filled " + f"({100 * self.fill_rate:.1f}%) | " + f"Low quality: {low} | " + f"Empty: {empty} | " + f"Entropy: {entropy:.2f} bits" + ) + + +class CellSelector: + def __init__( + self, + coverage_map: CoverageMap, + quality_threshold: float = 0.80, + ucb_c: float = 1.0, + ): + self.map = coverage_map + self.quality_threshold = quality_threshold + self.ucb_c = ucb_c + self._total_calls = 0 + import random + + self._rng = random.Random(42) + + def select(self) -> frozenset: + self._total_calls += 1 + empty = self.map.get_empty_cells() + if empty: + return self._rng.choice(empty) + + low = self.map.get_low_quality_cells(self.quality_threshold) + if low: + return self._rng.choice(low) + + return self._ucb_select() + + def _ucb_select(self) -> frozenset: + best_cell = None + best_score = -float("inf") + total = max(self._total_calls, 1) + + for cell in self.map._all_cells: + attempts = max(self.map._attempts.get(cell, 0), 1) + entry = self.map._map.get(cell) + quality = entry[1] if entry else 0.0 + score = quality + self.ucb_c * math.sqrt(math.log(total) / attempts) + if score > best_score: + best_score = score + best_cell = cell + + return best_cell + + +class CellSelectorPrior(CellSelector): + def __init__( + self, + coverage_map: CoverageMap, + prior: ConstructPrior, + quality_threshold: float = 0.80, + ucb_c: float = 1.0, + phase3_threshold: float = 0.70, + ): + super().__init__(coverage_map, quality_threshold, ucb_c) + self.prior = prior + self.phase3_threshold = phase3_threshold + self._tail_cells: set[frozenset] = set() + self._phase3_active = False + + def select(self) -> frozenset: + self._total_calls += 1 + empty = self.map.get_empty_cells() + + if empty: + high_prior_empty = [ + c for c in empty if self.prior.cell_weight(c) > self.prior.epsilon * 1.5 + ] + if high_prior_empty: + return self._weighted_sample(high_prior_empty) + return self._weighted_sample(empty) + + low = self.map.get_low_quality_cells(self.quality_threshold) + if low: + return self._ucb_prior_select(low) + + return self._ucb_prior_select(self.map._all_cells) + + def _weighted_sample(self, cells: list[frozenset]) -> frozenset: + weights = [self.prior.cell_weight(c) for c in cells] + total = sum(weights) + if total == 0: + return self._rng.choice(cells) + r = self._rng.random() * total + cumsum = 0.0 + for cell, w in zip(cells, weights): + cumsum += w + if r <= cumsum: + return cell + return cells[-1] + + def _ucb_prior_select(self, cells) -> frozenset: + + best_cell = None + best_score = -float("inf") + total = max(self._total_calls, 1) + + for cell in cells: + attempts = max(self.map._attempts.get(cell, 0), 1) + entry = self.map._map.get(cell) + quality = entry[1] if entry else 0.0 + prior_w = self.prior.cell_weight(cell) + ucb_term = self.ucb_c * math.sqrt(math.log(total) / attempts) + score = prior_w * (quality + ucb_term) + if score > best_score: + best_score = score + best_cell = cell + + return best_cell + + +class GoldPool: + """Top-K pool of high-reward examples for Candidate A (CW-Reward).""" + + def __init__(self, max_size: int = 50, seed: int = 42): + self._pool: list[tuple[dict, float]] = [] + self.max_size = max_size + self._rng = random.Random(seed) + + @property + def size(self) -> int: + return len(self._pool) + + def add(self, example: dict, reward: float) -> bool: + """Add example to pool. Returns True if it entered the pool.""" + if len(self._pool) < self.max_size: + self._pool.append((example, reward)) + self._pool.sort(key=lambda x: -x[1]) + return True + if reward > self._pool[-1][1]: + self._pool[-1] = (example, reward) + self._pool.sort(key=lambda x: -x[1]) + return True + return False + + def few_shot_examples(self, n: int = 3) -> list[dict]: + """Return n diverse examples from the pool for few-shot prompting.""" + if not self._pool: + return [] + if len(self._pool) <= n: + return [ex for ex, _ in self._pool] + top_half = self._pool[: max(len(self._pool) // 2, n)] + sampled = self._rng.sample(top_half, n) + return [ex for ex, _ in sampled] + + def construct_sets(self) -> list[set[str]]: + """Return the construct sets of all pool examples.""" + return [set(ex.get("_detected", [])) for ex, _ in self._pool] + + def pool_summary(self) -> str: + if not self._pool: + return "GoldPool: empty" + rewards = [r for _, r in self._pool] + return ( + f"GoldPool: {len(self._pool)}/{self.max_size} | " + f"reward: min={min(rewards):.3f} max={max(rewards):.3f} " + f"mean={sum(rewards) / len(rewards):.3f}" + ) + + +def compute_ecs(detected: set[str]) -> float: + """Execution Coverage Score — fraction of all AVAP node types covered.""" + return len(detected) / max(len(NODE_TYPE_NAMES), 1) + + +def jaccard_similarity(a: set, b: set) -> float: + """Jaccard similarity between two sets.""" + union = a | b + if not union: + return 1.0 + return len(a & b) / len(union) + + +def jaccard_novelty(detected: set[str], pool: GoldPool) -> float: + """Novelty = 1 - max Jaccard similarity with any pool example.""" + pool_sets = pool.construct_sets() + if not pool_sets: + return 1.0 + max_sim = max(jaccard_similarity(detected, ps) for ps in pool_sets) + return 1.0 - max_sim + + +def compute_reward( + detected: set[str], + test_list: list, + pool: GoldPool, + w_ecs: float, + w_novelty: float, + w_tests: float, +) -> tuple[float, dict]: + """ + Candidate A composite reward: + reward(e) = w_ecs * ECS(e) + w_novelty * Jaccard_novelty(e, Pool) + w_tests * test_quality(e) + """ + ecs = compute_ecs(detected) + novelty = jaccard_novelty(detected, pool) + tq = sum( + 1 + for t in test_list + if isinstance(t, str) and "re.match(" in t and len(t.strip()) > 10 + ) / max(len(test_list), 1) + reward = w_ecs * ecs + w_novelty * novelty + w_tests * tq + return reward, { + "ecs": round(ecs, 3), + "novelty": round(novelty, 3), + "test_quality": round(tq, 3), + "reward": round(reward, 3), + "detected": sorted(detected), + } + + +SYSTEM_PROMPT = f"""Eres un experto en el lenguaje AVAP. +Se te proporciona el Language Reference Manual (LRM) completo de AVAP. +Tu tarea es generar UN problema de benchmark estilo MBPP para evaluar +modelos de lenguaje en su capacidad de generar código AVAP correcto. + +PRINCIPIO FUNDAMENTAL: genera código SIMPLE que FUNCIONE. +Es preferible un ejemplo corto y correcto que uno largo y roto. + +REGLAS ESTRICTAS para el código AVAP generado: +1. Una instrucción por línea. EOL es el terminador absoluto. +2. Sin indentación significativa (es solo decorativa). +3. Bloques: if()...else()...end(), startLoop()...endLoop(), try()...exception()...end() +4. Funciones: function name(args) {{{{ ... return(val) }}}} +5. if() Modo 1: if(var_o_literal, var_o_literal, "operador") +6. if() Modo 2: if(None, None, `expresion_completa_como_string`) +7. _status se asigna con: addVar(_status, 404) +8. ormAccessSelect firma: ormAccessSelect(campos, "tabla", selector, varTarget) +9. ormCheckTable firma: ormCheckTable(nombre_tabla, varTarget) +10. ormDirect firma: ormDirect("SELECT ... %s" % var, varTarget) +11. getQueryParamList firma: getQueryParamList(param_name, varTarget) +12. NUNCA uses registerEndpoint(), NUNCA uses mainHandler(). +13. El código se ejecuta DIRECTAMENTE, línea a línea. +14. Emplea UNICAMENTE las construcciones listadas en el inventario: {", ".join(AVAP_NODE_TYPES.keys())}, no inventes node types que no existan. +15. Evitar el uso de tablas no definidas previamente. +16. Evitar el uso de imports o includes. +17. Mantén el código entre 3 y 15 líneas. NO generes código largo ni sobrecomplicado. +18. Usa solo 1-2 constructs por ejemplo. No intentes combinar muchos a la vez. +19. Asegúrate de que cada instrucción usa EXACTAMENTE la firma documentada en el LRM. +20. No realizar ejemplos donde se hagan llamadas URLs esperando acceder a datos del servidor, inviable en este contexto. + +FORMATO DE SALIDA: responde ÚNICAMENTE con UN objeto JSON válido (no array). +Sin texto adicional, sin bloques de código markdown. +{{ + "task_id": 1, + "text": "", + "code": "", + "test_inputs": {{ "": }}, + "test_list": ["re.match(r'', )", ...] +}} + +test_list: USA ÚNICAMENTE re.match(). NUNCA comparaciones directas (==, !=). +test_list: Máximo 2 aserciones. Patrones regex simples. +""" + + +def build_cell_prompt( + lrm: str, + cell: frozenset, + existing_example: dict | None, + map_summary: str, +) -> str: + constructs_list = ", ".join(f"`{c}`" for c in sorted(cell)) + + improvement_note = "" + if existing_example: + improvement_note = f""" +El siguiente ejemplo YA existe para esta combinación con calidad mejorable. +Genera algo DISTINTO y MÁS COMPLEJO que lo supere: + +``` +{existing_example.get("code", "")} +``` +""" + + return f"""# LRM AVAP — Language Reference Manual + +{lrm} + +--- + +# ESTADO DEL MAPA DE COBERTURA + +{map_summary} + +--- + +# TAREA — ESPECIFICACIÓN OBLIGATORIA + +Genera UN ejemplo AVAP que use OBLIGATORIAMENTE TODOS estos constructs: + +**{constructs_list}** + +El ejemplo DEBE contener todos los constructs listados arriba. +Si tu código no los usa todos, la tarea fracasa. + +Adicionalmente: +- Combina los constructs requeridos en un escenario realista de microservicio HTTP +- Añade constructs adicionales donde sea natural (aumenta la puntuación) +- Código complejo y rico — no ejemplos triviales de 3 líneas +- Prioriza la funcionalidad del código frente incluir multitud de comprobaciones complejas. +- 2-3 aserciones re.match() en test_list +{improvement_note} +Responde ÚNICAMENTE con el objeto JSON. Sin texto antes ni después. +""" + + +def _reward_coverage_text(dataset: list) -> tuple[str, list[str]]: + """Build coverage summary and list of underrepresented constructs.""" + freq: dict[str, int] = defaultdict(int) + for ex in dataset: + for nt in ex.get("_detected", []): + freq[nt] += 1 + if not freq: + return ( + "No examples generated yet. Cover as many AVAP constructs as possible.", + list(NODE_TYPE_NAMES), + ) + covered = set(freq.keys()) + uncovered = sorted(set(NODE_TYPE_NAMES) - covered) + least_covered = sorted(freq, key=freq.get)[:10] + underrepresented = uncovered + least_covered + lines = [ + f"Total examples: {len(dataset)}", + f"Covered constructs: {len(covered)}/{len(NODE_TYPE_NAMES)}", + ] + if uncovered: + lines.append(f"UNCOVERED (prioritize): {', '.join(uncovered)}") + if least_covered: + lines.append(f"Least common: {', '.join(least_covered)}") + return "\n".join(lines), underrepresented + + +def build_reward_prompt( + lrm: str, + few_shots: list[dict], + coverage_text: str, + underrepresented: list[str], +) -> str: + """Build the user prompt for Candidate A reward mode.""" + few_shot_block = "" + if few_shots: + few_shot_block = "\n# EJEMPLOS DE ALTA CALIDAD (referencia)\n\n" + for i, ex in enumerate(few_shots, 1): + few_shot_block += f"## Ejemplo {i}\n" + few_shot_block += f"Enunciado: {ex.get('text', '')}\n" + few_shot_block += f"```\n{ex.get('code', '')}\n```\n\n" + steer_text = "" + if underrepresented: + constructs_str = ", ".join(f"`{c}`" for c in underrepresented[:8]) + steer_text = ( + f"\nPRIORIDAD: Constructs subrepresentados — intenta incluir " + f"algunos de ellos: {constructs_str}\n" + ) + return f"""# LRM AVAP — Language Reference Manual + +{lrm} + +--- + +# ESTADO DE COBERTURA DEL DATASET + +{coverage_text} +{few_shot_block} +--- + +# TAREA + +Genera UN ejemplo AVAP SIMPLE y CORRECTO como problema de benchmark. + +Requisitos: +- Código corto: entre 3 y 10 líneas de código AVAP +- Usa 1-2 constructs AVAP por ejemplo, no más +- El código DEBE ser ejecutable y correcto — verifica cada instrucción contra el LRM +- Escenario sencillo: recibir un parámetro, procesarlo, devolver un resultado +- El ejemplo debe ser DIFERENTE a los ejemplos de referencia mostrados arriba +- 1-2 aserciones re.match() simples en test_list +- NO combines muchos constructs — es mejor un ejemplo corto que funcione +{steer_text} +Responde ÚNICAMENTE con el objeto JSON. Sin texto antes ni después. +""" + + +def call_api( + client: anthropic.Anthropic, + lrm: str, + cell: frozenset, + task_id: int, + existing_example: dict | None, + map_summary: str, + retries: int = 3, +) -> dict | None: + + for attempt in range(1, retries + 1): + try: + message = client.messages.create( + model="claude-sonnet-4-20250514", + max_tokens=4000, + system=SYSTEM_PROMPT, + messages=[ + { + "role": "user", + "content": build_cell_prompt( + lrm, cell, existing_example, map_summary + ), + } + ], + ) + raw = message.content[0].text.strip() + + if raw.startswith("```"): + lines = raw.splitlines() + raw = "\n".join( + lines[1:-1] if lines[-1].strip() == "```" else lines[1:] + ) + + problem = json.loads(raw) + if not isinstance(problem, dict): + raise ValueError("Response is not a JSON object") + for field in ("text", "code", "test_list"): + if field not in problem: + raise ValueError(f"Missing field '{field}'") + if "test_inputs" not in problem: + problem["test_inputs"] = {} + problem["task_id"] = task_id + return problem + + except (json.JSONDecodeError, ValueError) as e: + print(f"\n Attempt {attempt}/{retries} — parse error: {e}") + if attempt < retries: + time.sleep(2**attempt) + except anthropic.RateLimitError: + wait = 30 * attempt + print(f"\n Rate limit — waiting {wait}s...") + time.sleep(wait) + except anthropic.APIError as e: + print(f"\n API error at attempt {attempt}: {e}") + if attempt < retries: + time.sleep(5) + + return None + + +def call_api_reward( + client: anthropic.Anthropic, + lrm: str, + few_shots: list[dict], + coverage_text: str, + underrepresented: list[str], + task_id: int, + retries: int = 3, +) -> dict | None: + """API call for Candidate A reward mode.""" + for attempt in range(1, retries + 1): + try: + message = client.messages.create( + model="claude-sonnet-4-20250514", + max_tokens=4000, + system=SYSTEM_PROMPT, + messages=[ + { + "role": "user", + "content": build_reward_prompt( + lrm, + few_shots, + coverage_text, + underrepresented, + ), + } + ], + ) + raw = message.content[0].text.strip() + if raw.startswith("```"): + lines = raw.splitlines() + raw = "\n".join( + lines[1:-1] if lines[-1].strip() == "```" else lines[1:] + ) + problem = json.loads(raw) + if not isinstance(problem, dict): + raise ValueError("Response is not a JSON object") + for field in ("text", "code", "test_list"): + if field not in problem: + raise ValueError(f"Missing field '{field}'") + if "test_inputs" not in problem: + problem["test_inputs"] = {} + problem["task_id"] = task_id + return problem + except (json.JSONDecodeError, ValueError) as e: + print(f"\n Attempt {attempt}/{retries} — parse error: {e}") + if attempt < retries: + time.sleep(2**attempt) + except anthropic.RateLimitError: + wait = 30 * attempt + print(f"\n Rate limit — waiting {wait}s...") + time.sleep(wait) + except anthropic.APIError as e: + print(f"\n API error at attempt {attempt}: {e}") + if attempt < retries: + time.sleep(5) + return None + + +def run_map_elites(args, client, lrm, output_path): + + validator = CellValidator(parser_url=args.parser) + cmap = CoverageMap(cell_size=args.cell_size) + selector = CellSelector(cmap, quality_threshold=args.quality_threshold) + dataset = [] + task_id = 1 + call_count = 0 + valid_count = 0 + cell_updates = 0 + + print( + f"\n MAP-Elites mode | cells: {cmap.total_cells} | target: {args.problems} examples" + ) + print( + f" Cell size: {args.cell_size} | Quality threshold: {args.quality_threshold}" + ) + print("─" * 65) + + max_calls = args.problems * 4 + + while len(dataset) < args.problems and call_count < max_calls: + cell = selector.select() + existing = cmap.get_example(cell) + call_count += 1 + + print( + f" [{call_count:04d}] Cell {sorted(cell)} " + f"| filled={cmap.filled_cells}/{cmap.total_cells} " + f"| dataset={len(dataset)} ... ", + end="", + flush=True, + ) + + problem = call_api( + client, + lrm, + cell, + task_id, + existing_example=existing, + map_summary=cmap.fill_summary(), + ) + + if problem is None: + print("SKIP (generation failed)") + continue + + code = problem["code"] + test_list = problem.get("test_list", []) + + is_valid, ast, error_msg = validator.parse(code) + + if is_valid is None: + is_valid, ast = True, {} + if call_count == 1: + print("\n Parser unavailable — using keyword fallback", flush=True) + + if is_valid is False: + print(f"INVALID ({error_msg[:40]})") + problem["_validation"] = {"valid": False, "error": error_msg} + continue + + valid_count += 1 + + # Compute cell quality + quality, components = validator.cell_quality( + code, + ast, + test_list, + cell, + alpha=args.alpha, + beta=args.beta, + gamma=args.gamma, + ) + problem["_cell"] = sorted(cell) + problem["_quality"] = components + + if components["fidelity"] < 1.0: + missing = set(cell) - set(components["detected"]) + print(f"MISSING constructs: {sorted(missing)}") + continue + + updated = cmap.update(cell, problem, quality, components) + if updated: + cell_updates += 1 + + dataset.append(problem) + task_id += 1 + + print( + f"OK quality={quality:.3f} " + f"fidelity={components['fidelity']:.2f} " + f"extra={len(components['extra'])}" + ) + + if len(dataset) % 50 == 0: + _save(dataset, output_path, cmap) + freq = cmap.node_type_frequency() + entropy = cmap.distribution_entropy() + print("\n ── Checkpoint ──────────────────────────────────") + print(f" Dataset: {len(dataset)} | Valid: {valid_count}/{call_count}") + print(f" {cmap.fill_summary()}") + print( + f" Top-5 most frequent: {sorted(freq, key=freq.get, reverse=True)[:5]}" + ) + print(f" Top-5 least frequent: {sorted(freq, key=freq.get)[:5]}") + print(" ────────────────────────────────────────────────\n") + + time.sleep(0.5) + + _save(dataset, output_path, cmap) + return dataset, cmap, valid_count, call_count + + +def run_map_elites_prior(args, client, lrm, output_path): + + print("\n Loading ConstructPrior...", flush=True) + prior_map = getattr(args, "prior_map", "construct_map.yaml") + epsilon = getattr(args, "prior_epsilon", _PRIOR_EPSILON) + yaml_path = Path(prior_map) + + if yaml_path.exists(): + prior = ConstructPrior.from_yaml(yaml_path, epsilon=epsilon) + else: + # Fallback: yaml not found — use static prior and warn + print(f" [WARN] construct_map.yaml not found at '{yaml_path}'.") + print(" [WARN] Using static fallback prior. Generate the real prior with:") + print( + " [WARN] python construct_prior.py --generate-map --github-token TOKEN" + ) + prior = ConstructPrior.from_static_fallback(epsilon=epsilon) + + print(f" {prior.coverage_summary()}") + + validator = CellValidator(parser_url=args.parser) + cmap = CoverageMap(cell_size=args.cell_size) + selector = CellSelectorPrior( + cmap, + prior, + quality_threshold=args.quality_threshold, + phase3_threshold=getattr(args, "prior_phase3_threshold", 0.70), + ) + dataset = [] + task_id = 1 + call_count = 0 + valid_count = 0 + cell_updates = 0 + + print( + f"\n MAP-Elites+Prior mode | cells: {cmap.total_cells} | target: {args.problems} examples" + ) + print( + f" Cell size: {args.cell_size} | Quality threshold: {args.quality_threshold}" + ) + print("─" * 65) + + max_calls = args.problems * 4 + + while len(dataset) < args.problems and call_count < max_calls: + cell = selector.select() + existing = cmap.get_example(cell) + prior_w = prior.cell_weight(cell) + call_count += 1 + + print( + f" [{call_count:04d}] Cell {sorted(cell)} " + f"| prior={prior_w:.3f} " + f"| filled={cmap.filled_cells}/{cmap.total_cells} " + f"| dataset={len(dataset)} ... ", + end="", + flush=True, + ) + + problem = call_api( + client, + lrm, + cell, + task_id, + existing_example=existing, + map_summary=cmap.fill_summary(), + ) + + if problem is None: + print("SKIP (generation failed)") + continue + + code = problem["code"] + test_list = problem.get("test_list", []) + + is_valid, ast, error_msg = validator.parse(code) + + if is_valid is None: + is_valid, ast = True, {} + if call_count == 1: + print("\n Parser unavailable — using keyword fallback", flush=True) + + if is_valid is False: + print(f"INVALID ({error_msg[:40]})") + problem["_validation"] = {"valid": False, "error": error_msg} + continue + + valid_count += 1 + + quality, components = validator.cell_quality( + code, + ast, + test_list, + cell, + alpha=args.alpha, + beta=args.beta, + gamma=args.gamma, + ) + problem["_cell"] = sorted(cell) + problem["_prior_weight"] = round(prior_w, 4) + problem["_quality"] = components + + if components["fidelity"] < 1.0: + missing = set(cell) - set(components["detected"]) + print(f"MISSING constructs: {sorted(missing)}") + continue + + updated = cmap.update(cell, problem, quality, components) + if updated: + cell_updates += 1 + + dataset.append(problem) + task_id += 1 + + print( + f"OK quality={quality:.3f} " + f"fidelity={components['fidelity']:.2f} " + f"prior={prior_w:.3f} " + f"extra={len(components['extra'])}" + ) + + if len(dataset) % 50 == 0: + _save(dataset, output_path, cmap, prior=prior) + freq = cmap.node_type_frequency() + entropy = cmap.distribution_entropy() + kl = prior.kl_divergence(freq) + print("\n ── Checkpoint ──────────────────────────────────") + print(f" Dataset: {len(dataset)} | Valid: {valid_count}/{call_count}") + print(f" {cmap.fill_summary()}") + print( + f" KL(dataset ‖ prior): {kl:.4f} (lower = closer to production patterns)" + ) + print( + f" Top-5 most frequent: {sorted(freq, key=freq.get, reverse=True)[:5]}" + ) + print(f" Top-5 least frequent: {sorted(freq, key=freq.get)[:5]}") + print(" ────────────────────────────────────────────────\n") + + time.sleep(0.5) + + _save(dataset, output_path, cmap, prior=prior) + return dataset, cmap, valid_count, call_count, prior + + +def _save(dataset: list, path: Path, cmap: CoverageMap, prior: ConstructPrior = None): + with open(path, "w", encoding="utf-8") as f: + json.dump(dataset, f, ensure_ascii=False, indent=2) + + # Save coverage map statistics alongside dataset + stats_path = path.with_name(path.stem + "_coverage_stats.json") + freq = cmap.node_type_frequency() + stats = { + "total_cells": cmap.total_cells, + "filled_cells": cmap.filled_cells, + "fill_rate": round(cmap.fill_rate, 4), + "distribution_entropy": cmap.distribution_entropy(), + "node_type_frequency": freq, + "low_quality_cells": len(cmap.get_low_quality_cells()), + "empty_cells": len(cmap.get_empty_cells()), + } + if prior is not None: + stats["kl_divergence_dataset_vs_prior"] = prior.kl_divergence(freq) + stats["prior_summary"] = prior.coverage_summary() + with open(stats_path, "w", encoding="utf-8") as f: + json.dump(stats, f, ensure_ascii=False, indent=2) + + +def run_reward(args, client, lrm, output_path): + """Candidate A — CW-Reward with GoldPool feedback loop.""" + validator = CellValidator(parser_url=args.parser) + pool = GoldPool(max_size=args.pool_size) + dataset = [] + task_id = 1 + call_count = 0 + valid_count = 0 + pool_entries = 0 + + w_ecs = args.w_ecs + w_novelty = args.w_novelty + w_tests = args.w_tests + + print(f"\n CW-Reward mode | target: {args.problems} examples") + print(f" Weights: ECS={w_ecs} Novelty={w_novelty} Tests={w_tests}") + print(f" Pool size: {args.pool_size}") + print("─" * 65) + + max_calls = args.problems * 4 + + while len(dataset) < args.problems and call_count < max_calls: + coverage_text, underrepresented = _reward_coverage_text(dataset) + few_shots = pool.few_shot_examples(n=3) + call_count += 1 + + print( + f" [{call_count:04d}] " + f"| {pool.pool_summary()} " + f"| dataset={len(dataset)} ... ", + end="", + flush=True, + ) + + problem = call_api_reward( + client, + lrm, + few_shots, + coverage_text, + underrepresented, + task_id, + ) + + if problem is None: + print("SKIP (generation failed)") + continue + + code = problem["code"] + test_list = problem.get("test_list", []) + + is_valid, ast, error_msg = validator.parse(code) + + if is_valid is None: + is_valid, ast = True, {} + if call_count == 1: + print( + "\n Parser unavailable — using keyword fallback", + flush=True, + ) + + if is_valid is False: + print(f"INVALID ({error_msg[:40]})") + continue + + valid_count += 1 + detected = validator.detect_constructs(code, ast) + + reward, components = compute_reward( + detected, + test_list, + pool, + w_ecs=w_ecs, + w_novelty=w_novelty, + w_tests=w_tests, + ) + + problem["_detected"] = sorted(detected) + problem["_reward"] = components + + entered = pool.add(problem, reward) + if entered: + pool_entries += 1 + + dataset.append(problem) + task_id += 1 + + print( + f"OK reward={reward:.3f} " + f"ecs={components['ecs']:.2f} " + f"novelty={components['novelty']:.2f} " + f"{'→ POOL' if entered else ''}" + ) + + if len(dataset) % 50 == 0: + _save_reward(dataset, output_path, pool, w_ecs, w_novelty, w_tests) + freq: dict[str, int] = defaultdict(int) + for ex in dataset: + for nt in ex.get("_detected", []): + freq[nt] += 1 + total_f = sum(freq.values()) + entropy = 0.0 + if total_f > 0: + for count in freq.values(): + p = count / total_f + if p > 0: + entropy -= p * math.log2(p) + print("\n ── Checkpoint ──────────────────────────────────") + print(f" Dataset: {len(dataset)} | Valid: {valid_count}/{call_count}") + print(f" {pool.pool_summary()}") + print( + f" Coverage: {len(freq)}/{len(NODE_TYPE_NAMES)} | Entropy: {entropy:.2f} bits" + ) + uncov = sorted(set(NODE_TYPE_NAMES) - set(freq.keys())) + print(f" Uncovered: {uncov[:10]}") + print(" ────────────────────────────────────────────────\n") + + time.sleep(0.5) + + _save_reward(dataset, output_path, pool, w_ecs, w_novelty, w_tests) + return dataset, pool, valid_count, call_count + + +def _save_reward( + dataset: list, + path: Path, + pool: GoldPool, + w_ecs: float, + w_novelty: float, + w_tests: float, +): + """Save dataset and stats for Candidate A reward mode.""" + with open(path, "w", encoding="utf-8") as f: + json.dump(dataset, f, ensure_ascii=False, indent=2) + + stats_path = path.with_name(path.stem + "_reward_stats.json") + freq: dict[str, int] = defaultdict(int) + for ex in dataset: + for nt in ex.get("_detected", []): + freq[nt] += 1 + total_f = sum(freq.values()) + entropy = 0.0 + if total_f > 0: + for count in freq.values(): + p = count / total_f + if p > 0: + entropy -= p * math.log2(p) + rewards = [ex.get("_reward", {}).get("reward", 0) for ex in dataset] + stats = { + "mode": "reward", + "weights": {"w_ecs": w_ecs, "w_novelty": w_novelty, "w_tests": w_tests}, + "dataset_size": len(dataset), + "pool_size": pool.size, + "pool_summary": pool.pool_summary(), + "distribution_entropy": round(entropy, 3), + "node_type_frequency": dict(freq), + "covered_constructs": len(freq), + "total_constructs": len(NODE_TYPE_NAMES), + "mean_reward": round(sum(rewards) / max(len(rewards), 1), 4), + } + with open(stats_path, "w", encoding="utf-8") as f: + json.dump(stats, f, ensure_ascii=False, indent=2) + + +def main(): + parser = argparse.ArgumentParser( + description="AVAP Dataset Generator v2 — MAP-Elites Quality-Diversity Pipeline" + ) + parser.add_argument("--lrm", default="avap.md") + parser.add_argument("--output", default="output/mbpp_avap_v2.json") + parser.add_argument("--problems", type=int, default=5000) + parser.add_argument( + "--parser", default="http://localhost:8080", help="AVAP parser URL" + ) + parser.add_argument( + "--cell-size", + type=int, + default=3, + help="Max constructs per cell: 2=pairs, 3=pairs+trios (default: 3)", + ) + parser.add_argument( + "--quality-threshold", + type=float, + default=0.80, + help="Min quality to consider a cell 'good' (default: 0.80)", + ) + parser.add_argument( + "--alpha", + type=float, + default=0.30, + help="Weight for bonus constructs in cell quality (default: 0.30)", + ) + parser.add_argument( + "--beta", + type=float, + default=0.20, + help="Weight for test quality in cell quality (default: 0.20)", + ) + parser.add_argument( + "--gamma", + type=float, + default=0.10, + help="Weight for code richness in cell quality (default: 0.10)", + ) + parser.add_argument( + "--mode", + choices=["map-elites-prior", "map-elites", "reward"], + default="map-elites-prior", + help=( + "map-elites-prior: Candidate F — MAP-Elites + ConstructPrior (default)\n" + "map-elites: Candidate E — MAP-Elites, uniform cell weighting\n" + "reward: Candidate A — CW-Reward pool (comparison baseline)" + ), + ) + parser.add_argument( + "--prior-map", + default="construct_map.yaml", + metavar="FILE", + help=( + "Path to construct_map.yaml generated by construct_prior.py.\n" + "Generate it first: python construct_prior.py --generate-map\n" + "Default: construct_map.yaml (in current directory)" + ), + ) + parser.add_argument( + "--prior-epsilon", + type=float, + default=_PRIOR_EPSILON, + help=f"Minimum prior weight for tail cells (default: {_PRIOR_EPSILON})", + ) + parser.add_argument( + "--prior-phase3-threshold", + type=float, + default=0.70, + help=( + "Quality threshold above which Phase 2 ends and tail (low-prior) " + "cells become the focus. Default: 0.70" + ), + ) + parser.add_argument( + "--w-ecs", + type=float, + default=0.50, + help="Candidate A: weight for ECS in reward formula (default: 0.50)", + ) + parser.add_argument( + "--w-novelty", + type=float, + default=0.35, + help="Candidate A: weight for Jaccard novelty in reward formula (default: 0.35)", + ) + parser.add_argument( + "--w-tests", + type=float, + default=0.15, + help="Candidate A: weight for test quality in reward formula (default: 0.15)", + ) + parser.add_argument( + "--pool-size", + type=int, + default=5, + help="Candidate A: max examples in GoldPool (default: 50)", + ) + parser.add_argument("--api-key", default=None) + args = parser.parse_args() + + api_key = args.api_key or os.environ.get("ANTHROPIC_API_KEY") + if not api_key: + sys.exit("ERROR: ANTHROPIC_API_KEY not set.") + + lrm_path = Path(args.lrm) + if not lrm_path.exists(): + sys.exit(f"ERROR: LRM '{lrm_path}' not found.") + lrm = lrm_path.read_text(encoding="utf-8") + + output_path = Path(args.output) + output_path.parent.mkdir(parents=True, exist_ok=True) + + client = anthropic.Anthropic(api_key=api_key) + + mode_label = { + "map-elites-prior": "Candidate F — MAP-Elites + ConstructPrior", + "map-elites": "Candidate E — MAP-Elites (uniform)", + "reward": "Candidate A — CW-Reward pool", + }[args.mode] + + print("=" * 65) + print(" AVAP Dataset Generator v2 — MAP-Elites Pipeline") + print("=" * 65) + print(f" Mode : {mode_label}") + print(f" LRM : {lrm_path}") + print(f" Output : {output_path}") + print(f" Target examples: {args.problems}") + print(f" Parser URL : {args.parser}") + print(f" Cell size : {args.cell_size}") + print(f" Quality thresh : {args.quality_threshold}") + if args.mode == "map-elites-prior": + yaml_exists = Path(args.prior_map).exists() + print( + f" Prior map : {args.prior_map} ({'✓ found' if yaml_exists else '✗ not found — will use static fallback'})" + ) + print(f" Prior epsilon : {args.prior_epsilon}") + elif args.mode == "reward": + print( + f" Reward weights : ECS={args.w_ecs} Novelty={args.w_novelty} Tests={args.w_tests}" + ) + print(f" Pool size : {args.pool_size}") + print("=" * 65) + + prior = None + pool = None + cmap = None + + if args.mode == "map-elites-prior": + result = run_map_elites_prior(args, client, lrm, output_path) + dataset, cmap, valid_count, call_count, prior = result + elif args.mode == "map-elites": + dataset, cmap, valid_count, call_count = run_map_elites( + args, client, lrm, output_path + ) + else: + dataset, pool, valid_count, call_count = run_reward( + args, client, lrm, output_path + ) + + # Final report + if cmap is not None: + freq = cmap.node_type_frequency() + entropy = cmap.distribution_entropy() + else: + freq = defaultdict(int) + for ex in dataset: + for nt in ex.get("_detected", []): + freq[nt] += 1 + freq = dict(freq) + total_f = sum(freq.values()) + entropy = 0.0 + if total_f > 0: + for count in freq.values(): + p = count / total_f + if p > 0: + entropy -= p * math.log2(p) + entropy = round(entropy, 3) + + print("\n" + "=" * 65) + print(" Pipeline complete") + print(f" Mode : {mode_label}") + print(f" Total API calls : {call_count}") + print( + f" Valid examples : {valid_count} ({100 * valid_count / max(call_count, 1):.1f}%)" + ) + print(f" Dataset size : {len(dataset)}") + if cmap is not None: + print(f" {cmap.fill_summary()}") + if pool is not None: + print(f" {pool.pool_summary()}") + print( + f" Distribution entropy : {entropy:.3f} bits (max={math.log2(len(NODE_TYPE_NAMES)):.2f})" + ) + if prior is not None: + kl = prior.kl_divergence(freq) + print( + f" KL(dataset ‖ prior) : {kl:.4f} (0 = perfect alignment with production code)" + ) + print(f" Most covered : {sorted(freq, key=freq.get, reverse=True)[:5]}") + print(f" Least covered : {sorted(freq, key=freq.get)[:5]}") + print(f" Output : {output_path}") + print("=" * 65) + + +if __name__ == "__main__": + main() + diff --git a/scripts/pipelines/flows/validate_synthetic_dataset.py b/scripts/pipelines/flows/validate_synthetic_dataset.py index 6903762..3b879eb 100644 --- a/scripts/pipelines/flows/validate_synthetic_dataset.py +++ b/scripts/pipelines/flows/validate_synthetic_dataset.py @@ -13,7 +13,7 @@ app = typer.Typer() @app.command() def validate_synthetic_dataset( - dataset_path: str = "output/mbpp_avap_v2_A.json", + dataset_path: str = "synthetic_datasets/synthetic_data_generated_bedrock.json", output_path: str = "synthetic_datasets/validated_synthetic_dataset.json", api_url: str = settings.parser_url, timeout: int = 120, diff --git a/synthetic_datasets/validated_mbap_avap_A.json b/synthetic_datasets/validated_mbap_avap_A.json deleted file mode 100644 index 0637a08..0000000 --- a/synthetic_datasets/validated_mbap_avap_A.json +++ /dev/null @@ -1 +0,0 @@ -[] \ No newline at end of file diff --git a/synthetic_datasets/validated_synthetic_dataset.json b/synthetic_datasets/validated_synthetic_dataset.json index b6a040d..6183af5 100644 --- a/synthetic_datasets/validated_synthetic_dataset.json +++ b/synthetic_datasets/validated_synthetic_dataset.json @@ -22,37 +22,6 @@ "re.match(r'^200$', str(_status))" ] }, - { - "task_id": 3, - "text": "Recibe el parámetro 'password', genera su hash SHA-256 y devuelve el hash como resultado.", - "code": "addParam(\"password\", password)\nencodeSHA256(password, hashed)\naddResult(hashed)", - "test_inputs": { - "password": "secret123" - }, - "test_list": [ - "re.match(r'^[a-f0-9]{64}$', str(hashed))" - ] - }, - { - "task_id": 4, - "text": "Recibe el parámetro 'text', reemplaza todos los espacios por guiones bajos y devuelve el resultado.", - "code": "addParam(\"text\", text)\nreplace(text, \" \", \"_\", result)\naddResult(result)", - "test_inputs": { - "text": "hello world foo" - }, - "test_list": [ - "re.match(r'^hello_world_foo$', str(result))" - ] - }, - { - "task_id": 5, - "text": "Genera un token aleatorio de 32 caracteres alfanuméricos y devuélvelo como resultado.", - "code": "randomString(\"[a-zA-Z0-9]\", 32, token)\naddResult(token)", - "test_inputs": {}, - "test_list": [ - "re.match(r'^[a-zA-Z0-9]{32}$', str(token))" - ] - }, { "task_id": 6, "text": "Recibe el parámetro 'age'. Si age es mayor que 18, devuelve 'adulto'; de lo contrario devuelve 'menor'.", @@ -76,48 +45,6 @@ "re.match(r'^200$', str(_status))" ] }, - { - "task_id": 8, - "text": "Crea una lista con el elemento 'item1', obtén su longitud y devuelve la longitud como resultado.", - "code": "variableToList(\"item1\", myList)\ngetListLen(myList, length)\naddResult(length)", - "test_inputs": {}, - "test_list": [ - "re.match(r'^1$', str(length))" - ] - }, - { - "task_id": 10, - "text": "Recibe el parámetro 'data' como JSON, extrae el campo 'name' y devuélvelo como resultado.", - "code": "addParam(\"data\", data)\nvariableFromJSON(data, \"name\", name)\naddResult(name)", - "test_inputs": { - "data": "{\"name\": \"Carlos\", \"age\": 30}" - }, - "test_list": [ - "re.match(r'^Carlos$', str(name))" - ] - }, - { - "task_id": 12, - "text": "Recibe el parámetro 'password', genera su hash MD5 y devuelve el hash como resultado.", - "code": "addParam(\"password\", password)\nencodeMD5(password, hashed)\naddResult(hashed)", - "test_inputs": { - "password": "mypassword" - }, - "test_list": [ - "re.match(r'^[a-f0-9]{32}$', str(hashed))" - ] - }, - { - "task_id": 14, - "text": "Recibe el parámetro 'epoch', conviértelo a string de fecha en formato 'YYYY-MM-DD HH:MM:SS' y devuelve el resultado.", - "code": "addParam(\"epoch\", epoch)\nstampToDatetime(epoch, \"%Y-%m-%d %H:%M:%S\", 0, datestr)\naddResult(datestr)", - "test_inputs": { - "epoch": 1700000000 - }, - "test_list": [ - "re.match(r'^\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}$', str(datestr))" - ] - }, { "task_id": 16, "text": "Define una función que recibe un número y devuelve su cuadrado. Llama a la función con el parámetro 'n' y devuelve el resultado.", @@ -175,6 +102,15 @@ "re.match(r'^.*$', str(response))" ] }, + { + "task_id": 22, + "text": "Lanza una función 'fetchData' de forma asíncrona con go, espera el resultado con gather (timeout 2000ms) y devuelve el resultado.", + "code": "function fetchData() {\ndata = \"fetched\"\nreturn(data)\n}\nhandle = go fetchData()\nresult = gather(handle, 2000)\naddResult(result)", + "test_inputs": {}, + "test_list": [ + "re.match(r'^fetched$', str(result))" + ] + }, { "task_id": 28, "text": "Importa la librería nativa 'math', calcula el cuadrado de 9 usando una función y devuelve el resultado.", @@ -183,16 +119,5 @@ "test_list": [ "re.match(r'^81$', str(result))" ] - }, - { - "task_id": 29, - "text": "Recibe el parámetro 'items_json' como JSON con una lista bajo la clave 'items'. Extrae la lista, obtén su longitud y devuelve la longitud.", - "code": "addParam(\"items_json\", items_json)\nvariableFromJSON(items_json, \"items\", items)\ngetListLen(items, length)\naddResult(length)", - "test_inputs": { - "items_json": "{\"items\": [\"x\", \"y\", \"z\"]}" - }, - "test_list": [ - "re.match(r'^3$', str(length))" - ] } ] \ No newline at end of file