def crear_representante_secretaira(self):
self.find_element(
OrganismosJudicialesLocators.nuevo_repres_BTN).click()
self.find_element(
OrganismosJudicialesLocators.nombre_REP_INP).send_keys(
self.organismo_judicial['nombre_rep'])
self.find_element(
OrganismosJudicialesLocators.apellido_REP_INP).send_keys(
self.organismo_judicial['apellido_rep'])
self.driver.execute_script(
'$("#OrganismoJudicialType_secretarias_0_representantes_0_cuil").val("23-'
+ str(random.randint(11111111, 99999999)) + '-4")')
cuit_rep = "23-" + str(random.randint(11111111, 99999999)) + "-4"
self.driver.execute_script(
'$("#OrganismoJudicialType_secretarias_0_representantes_0_cuil").val("'
+ cuit_rep + '")')
self.find_element(OrganismosJudicialesLocators.cuit_SEC_INP).click()
Parameters.set_cuit_sec(cuit_rep.replace("-", ""))
self.find_element(OrganismosJudicialesLocators.cuil_REP_INP).click()
self.find_element(
OrganismosJudicialesLocators.telefono_REP_INP).send_keys(
self.organismo_judicial['telefono_rep'])
self.find_element(OrganismosJudicialesLocators.mail_REP_INP).send_keys(
self.organismo_judicial['mail_rep'])
self.find_element(
OrganismosJudicialesLocators.cargo_REP_INP).send_keys(
self.organismo_judicial['cargo_rep'])
self.find_element(
OrganismosJudicialesLocators.usuario_REP_INP).send_keys(
self.organismo_judicial['usuario_rep'])
self.find_element(OrganismosJudicialesLocators.activo_REP_CHK).click()
time.sleep(5)
def crear_orden(self):
self.find_element(
OA_Suplementos_locators.fecha_publicacion_INP).send_keys(
self.oa_sup["fecha"])
self.find_element(OA_Suplementos_locators.crear_oa_BTN).click()
# Guardo el nombre de la orden para luego poder buscarlo
titulo = self.find_element(OA_Suplementos_locators.titulo_LBL).text
regex = re.compile(r"Suplemento [0-9]")
match = regex.search(titulo)
print('match: ', match)
Parameters.set_nombre_oa_sup(match[0])
def publicador_subdependencia_uno_dependencia_uno(self):
self.find_element(OrganismoLocators.dep0_pub_nombre_INP).send_keys(self.__parametros["dep0_pub0_nombre"])
self.find_element(OrganismoLocators.dep0_pub_apellido_INP).send_keys(self.__parametros["dep0_pub0_apellido"])
self.driver.execute_script(
'$("#DependenciaOrganismoGDEType_publicadores_0_cuil").val("23-' + str(
random.randint(11111111, 99999999)) + '-4")')
self.find_element(OrganismoLocators.dep0_pub_cuil_INP).click()
self.find_element(OrganismoLocators.dep0_pub_tel_INP).send_keys(self.__parametros["dep0_pub0_tel"])
self.find_element(OrganismoLocators.dep0_pub_mail_INP).send_keys(self.__parametros["dep0_pub0_mail"])
usuario_gde = self.__parametros["dep0_pub0_usu_gde"] + str(random.randint(1, 6000))
Parameters.set_usu_pub(usuario_gde)
self.find_element(OrganismoLocators.dep0_pub_usuario_gde_INP).send_keys(usuario_gde)
self.find_element(OrganismoLocators.dep_pub_activo_CHK).click()
def __init__(self):
self.p = Parameters()
# load training set
self.train_data_five = []
self.train_data_four = []
self.train_data_three = []
self.train_data_two = []
with open("/mnt/hdd2/JINSU/PINet_new/TuSimple/dataset/five.json") as f:
while True:
line = f.readline()
if not line:
break
jsonString = json.loads(line)
self.train_data_five.append(jsonString)
with open("/mnt/hdd2/JINSU/PINet_new/TuSimple/dataset/four.json") as f:
while True:
line = f.readline()
if not line:
break
jsonString = json.loads(line)
self.train_data_four.append(jsonString)
with open(
"/mnt/hdd2/JINSU/PINet_new/TuSimple/dataset/three.json") as f:
while True:
line = f.readline()
if not line:
break
jsonString = json.loads(line)
self.train_data_three.append(jsonString)
with open("/mnt/hdd2/JINSU/PINet_new/TuSimple/dataset/two.json") as f:
while True:
line = f.readline()
if not line:
break
jsonString = json.loads(line)
self.train_data_two.append(jsonString)
self.size_train = len(self.train_data_two) + len(
self.train_data_three) + len(self.train_data_four) + len(
self.train_data_five)
print(self.size_train)
# load test set
self.test_data = []
with open(self.p.test_root_url + 'test_tasks_0627.json') as f:
#with open(self.p.test_root_url+'test_label.json') as f:
while True:
line = f.readline()
if not line:
break
jsonString = json.loads(line)
self.test_data.append(jsonString)
self.size_test = len(self.test_data)
def __init__(self):
print("Init()")
print(" Info()")
rospy.init_node('lane_detector_node', anonymous=True)
self.param = Parameters()
self.lane_agent = utils.agent.Agent()
self.lane_detector_init()
def __init__(self):
self.p = Parameters()
# load annotation data (training set)
self.train_data = []
self.test_data = []
with open(self.p.train_root_url + 'label_data_0313.json') as f:
while True:
line = f.readline()
if not line:
break
jsonString = json.loads(line)
self.train_data.append(jsonString)
random.shuffle(self.train_data)
with open(self.p.train_root_url + 'label_data_0531.json') as f:
while True:
line = f.readline()
if not line:
break
jsonString = json.loads(line)
self.train_data.append(jsonString)
random.shuffle(self.train_data)
with open(self.p.train_root_url + 'label_data_0601.json') as f:
while True:
line = f.readline()
if not line:
break
jsonString = json.loads(line)
self.train_data.append(jsonString)
random.shuffle(self.train_data)
self.size_train = len(self.train_data)
print(self.size_train)
# load annotation data (test set)
#with open(self.p.test_root_url+'test_tasks_0627.json') as f:
with open(self.p.test_root_url + 'test_label.json') as f:
while True:
line = f.readline()
if not line:
break
jsonString = json.loads(line)
self.test_data.append(jsonString)
#random.shuffle(self.test_data)
self.size_test = len(self.test_data)
print(self.size_test)
def before_all(context):
options = Options()
prefs = {"plugins.always_open_pdf_externally": True,
"download.prompt_for_download": False,
"download.default_directory": str(RUTA_ARCHIVO)}
options.add_experimental_option("prefs", prefs)
options.add_experimental_option("excludeSwitches", ["enable-automation"])
options.add_experimental_option('useAutomationExtension', False)
options.add_argument("--start-maximized")
context.driver = webdriver.Remote('http://localhost:8002/wd/hub', options=options)
context.driver.set_window_size(1366, 768)
# context.driver.execute_script("document.body.style.transform='scale(0.8)';")
# context.driver.maximize_window()
Parameters.execute_file("Datos")
context.page = Login(context.driver)
context.data = Parameters.get_data()
context.driver.get(context.data["ambiente"]["url"])
context.tipo = None
context.firmante = None
context.status = None
def __init__(self):
super(Agent, self).__init__()
self.p = Parameters()
self.lane_detection_network = lane_detection_network()
self.setup_optimizer()
self.current_epoch = 0
self.hard_sampling = hard_sampling.hard_sampling()
print(" Model parameters: {0:d}".format(
self.count_parameters(self.lane_detection_network)))
def creo_anexos(self):
aviso = Parameters.get_aviso_api(self.tipo)
api = Parameters.get_ambiente()["urlAPI"] + "/api/v1/aviso/crear_anexo"
path = str(Path(__file__).parents[2]) + '\\generated_data\\pdf.txt'
archivo = open(path, "r")
content = archivo.read()
archivo.close()
try:
if aviso["nombresAnexos"] is None:
print("No hay anexos")
else:
for x in aviso["nombresAnexos"].split(","):
r = requests.post(url=api,
data=json.dumps({
"id":
DataManager.get_id_aviso(),
"nombreAnexo":
x,
"anexo":
content
}))
print(r.json())
except KeyError:
print("No hay anexos")
def informo_publicacion(self):
api = Parameters.get_ambiente(
)["urlAPI"] + "/api/v1/aviso/informar_publicacion"
fecha_publicacion = self.aviso_erroneo["fechaPublicacion"].split("-")
utils = Utils(dia=fecha_publicacion[2],
mes=fecha_publicacion[1],
anio=fecha_publicacion[0])
r = requests.post(url=api,
data=json.dumps({
"id":
self.id_aviso,
"publicaciones_id":
"",
"fecha_publicacion":
utils.fecha_hoy_guion_invertida()
}))
print(r.json())
return r.json()["status"]
def verificar_orden_firmantes(self):
formatter = {'id_aviso': self.id_aviso}
locator = BandejaTramitesLocators.ESTADO_AVISO_TEMP.formatear_locator(
formatter)
self.find_element(locator).click()
# Conexiones de db no es muy recomendable abrirlas en los page objects
conexion = DBConnection("{MySQL ODBC 8.0 Unicode Driver}",
"10.2.1.112", "root", None, NOMBRE_BASE)
firmantes_aviso = self.aviso['firmantes']
lista_firmantes_ordenada = Parameters.get_ambiente()["ordenFirmante"]
try:
id_aviso = str(self.id_aviso)
resultado = conexion.execute_query_and_return_rows(
GET_FIRMANTES_AVISO, id_aviso)
print(resultado)
lista_firmantes_aviso = [
v for d in resultado for k, v in d.items()
]
if len(firmantes_aviso) == len(firmantes_aviso.split("-")):
return False
lista_intersectada_db = [
firmante for firmante in lista_firmantes_aviso
if firmante in lista_firmantes_ordenada
]
lista_intersectada_parametros = [
firmante for firmante in lista_firmantes_ordenada
if firmante in lista_intersectada_db
]
configurarcion_firmantes_aviso = [
firmante for firmante in lista_firmantes_ordenada
if firmante in lista_firmantes_aviso
]
if len(configurarcion_firmantes_aviso) != len(
lista_intersectada_db):
return False
return lista_intersectada_db == lista_intersectada_parametros
except QuerySinResultadosException as e:
print("Error en la query, no hubo resultados", e)
return False
import cv2
import json
import torch
import utils.agent as agent
import numpy as np
from copy import deepcopy
from utils.data_loader import Generator
import time
from config.parameters import Parameters
import utils.util as util
from tqdm import tqdm
import csaps
import argparse
import glob
import os
p = Parameters()
def parse_args():
parser = argparse.ArgumentParser()
parser.add_argument("--img_path",
'-i',
type=str,
default="demo/demo.jpg",
help="Path to demo img")
args = parser.parse_args()
return args
###############################################################
##
def agregar_aviso_oa_sup(self):
Parameters.set_aviso_oa_sup(
DataManager.get_id_aviso(),
self._NuevoAvisoAPI__parametros[0].get('textoAPublicar'))