def conv_text(self, data):
o = self.connection
t = ""
for line in data:
res_srid = convert_srid(self.codi_r1, get_srid(o), [line["x"], line["y"]])
t += "{0};{1};{2}\n".format(format_f(res_srid[0], decimals=6), format_f(res_srid[1], decimals=6), 0)
return t[:-1]
def obtenir_camps_linia(self, installacio):
"""
Gets the data of the line where the cel·la is placed
:param installacio: Cel·la placement
:return: Municipi, provincia, tensio of the line
:rtype: dict
"""
o = self.connection
valor = installacio.split(',')
model = valor[0]
id_tram = int(valor[1])
if model == "giscedata.at.suport":
tram = o.GiscedataAtSuport.read(id_tram, ['linia'])
linia_id = tram['linia']
fields_to_read = [
'municipi', 'provincia', 'tensio'
]
linia = o.GiscedataAtLinia.read(int(linia_id[0]), fields_to_read)
municipi = ''
provincia = ''
id_municipi = linia['municipi'][0]
id_provincia = linia['provincia'][0]
tensio = format_f(float(linia['tensio']) / 1000.0, decimals=3)
if id_municipi and id_provincia:
provincia = o.ResCountryState.read(id_provincia, ['code'])['code']
municipi_dict = o.ResMunicipi.read(id_municipi, ['ine', 'dc'])
municipi = '{0}{1}'.format(municipi_dict['ine'][-3:],
municipi_dict['dc'])
res = {
'municipi': municipi,
'provincia': provincia,
'tensio': tensio
}
else:
ct_data = o.GiscedataCts.read(id_tram, ['id_municipi',
'tensio_p'])
municipi_id = ct_data['id_municipi'][0]
tensio = format_f(float(ct_data['tensio_p']) / 1000.0, decimals=3)
municipi_data = o.ResMunicipi.read(municipi_id, ['state',
'ine',
'dc'])
id_provincia = municipi_data['state'][0]
municipi = '{0}{1}'.format(municipi_data['ine'][-3:],
municipi_data['dc'])
provincia = o.ResCountryState.read(id_provincia, ['code'])['code']
res = {
'municipi': municipi,
'provincia': provincia,
'tensio': tensio
}
return res
def consumer(self):
o_codi_r1 = 'R1-%s' % self.codi_r1[-3:]
O = self.connection
fields_to_read = [
'name', 'cini', 'ct_id', 'tensio_id', 'potencia_instalada'
]
while True:
try:
item = self.input_q.get()
self.progress_q.put(item)
condensador = O.GiscedataCondensadors.read(item, fields_to_read)
o_cond = condensador['name']
o_cini = condensador.get('cini', '')
o_potencia = condensador['potencia_instalada']
o_node, posicion = self.get_node_vertex(condensador['name'])
o_node = o_node.replace('*', '')
ct = self.get_dades_ct(condensador['ct_id'][0])
o_propietari = int(ct['propietari'])
o_ine_muni, o_ine_prov = '', ''
if ct['id_municipi']:
o_ine_prov, o_ine_muni = self.get_ine(ct['id_municipi'][0])
o_tensio = format_f(
float(self.get_tensio(condensador['tensio_id'][0])) / 1000.0,
decimals=3
)
o_any = self.year
z = ''
res_srid = ['', '']
if posicion:
res_srid = convert_srid(
self.codi_r1, get_srid(O), posicion)
self.output_q.put([
o_node, # NUDO
o_cond, # CONDENSADOR
o_cini, # CINI
format_f(res_srid[0], decimals=3), # X
format_f(res_srid[1], decimals=3), # Y
z, # Z
o_ine_muni, # MUNICIPIO
o_ine_prov, # PROVINCIA
o_tensio, # NIVEL TENSION
format_f(o_potencia, decimals=3), # POTENCIA INSTALADA
o_codi_r1, # CODIGO DISTRIBUIDORA
o_propietari, # PROPIETARIO
o_any # AÑO INFORMACION
])
except Exception:
traceback.print_exc()
if self.raven:
self.raven.captureException()
finally:
self.input_q.task_done()
def consumer(self):
"""
Method that generates the csb file
:return: List of arrays
"""
O = self.connection
fields_to_read = [
'name', 'cini', 'denominacio', 'any_ps', 'vai', 'data_apm',
self.compare_field
]
while True:
try:
item = self.input_q.get()
self.progress_q.put(item)
despatx = O.GiscedataDespatx.read(
item, fields_to_read)
tmp_date = datetime.strptime(despatx['data_apm'], '%Y-%m-%d')
data_apm = tmp_date.strftime('%d/%m/%Y')
fecha_baja = ''
if despatx[self.compare_field]:
data_4131 = despatx[self.compare_field]
entregada = F6Res4131(**data_4131)
actual = F6Res4131(
despatx['name'],
despatx['cini'],
despatx['denominacio'],
data_apm,
fecha_baja,
format_f(despatx['vai']),
0
)
if actual == entregada:
estado = '0'
else:
estado = '1'
else:
estado = '2'
output = [
'{0}'.format(despatx['name']),
despatx['cini'] or '',
despatx['denominacio'] or '',
data_apm,
fecha_baja,
format_f(despatx['vai'], 3),
estado
]
self.output_q.put(output)
except Exception:
traceback.print_exc()
if self.raven:
self.raven.captureException()
finally:
self.input_q.task_done()
def consumer(self):
"""
Generates the line of the file
:return: Line
:rtype: str
"""
O = self.connection
fields_to_read = [
"codi", "finalitat", "id_instalacio", "codi_tipus_inst", "cini",
"ccaa", "ccaa_2", "any_apm", "capacidad_prv", "long_total",
"vol_total_inv", "ajudes", "inv_financiada", "vpi_retri", "estado"
]
while True:
try:
item = self.input_q.get()
self.progress_q.put(item)
linia = O.GiscedataCnmcLinies.read(item, fields_to_read)
if linia["ccaa"]:
ccaa = linia["ccaa"][0]
else:
ccaa = False
if linia["ccaa_2"]:
ccaa_2 = linia["ccaa_2"][0]
else:
ccaa_2 = False
output = [
linia["codi"][1],
linia["finalitat"],
linia["id_instalacio"],
linia["cini"],
get_name_ti(O, linia["codi_tipus_inst"][0]),
get_codigo_ccaa(O, ccaa),
get_codigo_ccaa(O, ccaa_2),
linia["any_apm"],
format_f(linia["long_total"], 3) or "0.00",
linia["capacidad_prv"],
format_f(linia["vol_total_inv"], 2) or "0.00",
format_f(linia["ajudes"], 2) or "0.00",
format_f(linia["inv_financiada"], 2) or "0.000",
format_f(linia["vpi_retri"], 2) or "0.00",
linia["estado"]
]
self.output_q.put(output)
except Exception:
traceback.print_exc()
if self.raven:
self.raven.captureException()
finally:
self.input_q.task_done()
def consumer(self):
"""
Consumer function that generates each line of the file
:return: None
"""
while True:
try:
item = self.input_q.get()
fields_read = [
"name", "tensio", "cini", "propietari", "x", "y",
"subestacio_id", "node_id"
]
fields_sub_read = [
"x", "y", "ct_id","id_municipi","id_provincia"
]
pos = self.connection.GiscedataCtsSubestacionsPosicio.read(
item, fields_read
)
sub = self.connection.GiscedataCtsSubestacions.read(
pos["subestacio_id"][0], fields_sub_read
)
point = [sub["x"], sub["y"]]
point_25830 = convert_srid(self.codi_r1, self.srid, point)
if "node_id" in sub:
nudo = sub["node_id"]
else:
nudo = self.cts_node[sub["ct_id"][0]]
self.output_q.put(
[
nudo, # Nudo
pos.get("name", ""), # Elemento de fiabilidad
"", # Tramo
pos.get("cini", ""), # CINI
format_f(point_25830[0], decimals=3),
format_f(point_25830[1], decimals=3),
0,
self.municipios[sub["id_municipi"][0]], # Codigo INE de municipio
self.provincias[sub["id_provincia"][0]], # Codigo de provincia INE
self.tensions.get(pos["tensio"][0], 0), # Nivel de tension
self.cod_dis, # Codigo de la compañia distribuidora
int(pos.get("propietari", 1)), # Propiedad
self.year # Año de inforacion
])
except Exception:
traceback.print_exc()
if self.raven:
self.raven.captureException()
finally:
self.input_q.task_done()
def consumer(self):
o = self.connection
fields_to_read = [
'ct', 'name', 'cini', 'potencia_nominal', 'propietari',
'perdues_buit', 'perdues_curtcircuit_nominal',
]
while True:
try:
# generar linies
item = self.input_q.get()
self.progress_q.put(item)
trafo = o.GiscedataTransformadorTrafo.read(
item, fields_to_read
)
o_ct = trafo['ct'] and trafo['ct'][1] or ''
o_node = self.get_node(item)
o_node = o_node.replace('*', '')
o_cini = trafo['cini'] or ''
o_maquina = trafo['name']
o_pot = format_f(
float(trafo['potencia_nominal']),
decimals=3
)
o_perdues_buit = format_f(
trafo['perdues_buit'] or 0.0,
decimals=3
)
o_perdues_nominal = format_f(
trafo['perdues_curtcircuit_nominal'] or 0.0,
decimals=3
)
o_propietari = int(trafo['propietari'])
o_any = self.year
self.output_q.put([
o_node, # NUDO
o_ct, # CT
o_cini, # CINI
o_maquina, # MAQUINA
o_pot, # POT MAQUINA
o_perdues_buit, # PERDIDAS VACIO
o_perdues_nominal, # PERDIDAS POT NOMINAL
o_propietari, # PROPIEDAD
o_any # AÑO INFORMACION
])
except Exception:
traceback.print_exc()
if self.raven:
self.raven.captureException()
finally:
self.input_q.task_done()
def consumer(self):
o_codi_r1 = "R1-%s" % self.codi_r1[-3:]
o = self.connection
fields_to_read = ["name", "cini", "propietari", "id_municipi", "id_provincia", "ct_id", "descripcio"]
while True:
try:
# generar linies
item = self.input_q.get()
self.progress_q.put(item)
sub = o.GiscedataCtsSubestacions.read(item, fields_to_read)
ids_sub = {"id_municipi": sub["id_municipi"], "id_provincia": sub["id_provincia"]}
vertex = self.get_vertex(sub["ct_id"][0])
ines = self.get_ines(ids_sub)
o_subestacio = sub["name"]
o_cini = sub["cini"]
o_denominacio = sub["descripcio"]
x = ""
y = ""
z = ""
if vertex[0]:
x = format_f(float(vertex[0]), decimals=3)
if vertex[1]:
y = format_f(float(vertex[1]), decimals=3)
o_municipi = ines["ine_municipi"]
o_provincia = ines["ine_provincia"]
o_prop = int(sub["propietari"])
o_any = self.year
res_srid = ["", ""]
if vertex:
res_srid = convert_srid(self.codi_r1, get_srid(o), vertex)
self.output_q.put(
[
o_subestacio,
o_cini,
o_denominacio,
format_f(res_srid[0], decimals=3),
format_f(res_srid[1], decimals=3),
z,
o_municipi,
o_provincia,
o_codi_r1,
o_prop,
o_any,
]
)
except:
traceback.print_exc()
if self.raven:
self.raven.captureException()
finally:
self.input_q.task_done()
def consumer(self):
o = self.connection
fields_to_read = [
'installacio', 'cini', 'propietari', 'name'
]
while True:
try:
# generar linies
item = self.input_q.get()
self.progress_q.put(item)
celles = o.GiscedataCellesCella.read(
item, fields_to_read
)
dict_linia = self.obtenir_camps_linia(celles['installacio'])
o_fiabilitat = celles['name']
o_node, vertex, o_tram = self.get_node_vertex_tram(o_fiabilitat)
o_cini = celles['cini']
z = ''
o_municipi = dict_linia.get('municipi')
o_provincia = dict_linia.get('provincia')
o_tensio = format_f(dict_linia.get('tensio'), decimals=3)
o_cod_dis = 'R1-%s' % self.codi_r1[-3:]
o_prop = int(celles['propietari'])
o_any = self.year
res_srid = ['', '']
if vertex:
res_srid = convert_srid(
self.codi_r1, get_srid(o), vertex)
self.output_q.put([
o_node,
o_fiabilitat,
o_tram,
o_cini,
format_f(res_srid[0], decimals=3),
format_f(res_srid[1], decimals=3),
z,
o_municipi,
o_provincia,
o_tensio,
o_cod_dis,
o_prop,
o_any
])
except:
traceback.print_exc()
if self.raven:
self.raven.captureException()
finally:
self.input_q.task_done()
def consumer(self):
"""
Generates the line of the file
:return: Line
:rtype: str
"""
O = self.connection
fields_to_read = [
"anyo", "limit_empresa", "demanda_empresa_p0", "inc_demanda",
"frri", "vpi_sup", "volum_total_inv", "ajudes_prev", "financiacio",
"vpi_retribuible_prv", "n_projectes", "voltotal_inv_bt_prv"
]
while True:
try:
item = self.input_q.get()
self.progress_q.put(item)
resumen = O.GiscedataCnmcResum_any.read(item, fields_to_read)
vpi_superado_prv = str(resumen["vpi_sup"]).upper()
demanda_empresa_p0 = format_f(resumen["demanda_empresa_p0"], 3)
if len(demanda_empresa_p0) > 8:
demanda_empresa_p0 = format_f(
resumen["demanda_empresa_p0"], 1
)
output = [
resumen["anyo"],
format_f(resumen["limit_empresa"], 2) or "0.00",
demanda_empresa_p0 or "0.00",
format_f(resumen["inc_demanda"], 3) or "0.00",
format_f(resumen["frri"], 3) or "0.00",
vpi_superado_prv,
format_f(resumen["volum_total_inv"], 2) or "0.00",
format_f(resumen["ajudes_prev"], 2) or "0.00",
format_f(resumen["financiacio"], 2) or "0.00",
format_f(resumen["vpi_retribuible_prv"], 2) or "0.00",
resumen["n_projectes"],
format_f(resumen["voltotal_inv_bt_prv"], 2) or "0.00"
]
self.output_q.put(output)
except Exception:
traceback.print_exc()
if self.raven:
self.raven.captureException()
finally:
self.input_q.task_done()
def consumer(self):
O = self.connection
fields_to_read = ['name', 'cini', 'denominacio', 'any_ps', 'vai']
while True:
try:
item = self.input_q.get()
self.progress_q.put(item)
despatx = O.GiscedataDespatx.read(
item, fields_to_read)
output = [
'{}'.format(despatx['name']),
despatx['cini'] or '',
despatx['denominacio'] or '',
despatx['any_ps'],
format_f(despatx['vai'])
]
self.output_q.put(output)
except Exception:
traceback.print_exc()
if self.raven:
self.raven.captureException()
finally:
self.input_q.task_done()
def obtenir_camps_linia(self, installacio):
o = self.connection
valor = installacio.split(',')
id_tram = int(valor[1])
tram = o.GiscedataAtSuport.read(id_tram, ['linia'])
linia_id = tram['linia']
fields_to_read = [
'municipi', 'provincia', 'tensio'
]
linia = o.GiscedataAtLinia.read(int(linia_id[0]), fields_to_read)
municipi = ''
provincia = ''
id_municipi = linia['municipi'][0]
id_provincia = linia['provincia'][0]
tensio = format_f(float(linia['tensio']) / 1000.0)
if id_municipi and id_provincia:
provincia = o.ResCountryState.read(id_provincia, ['code'])['code']
municipi_dict = o.ResMunicipi.read(id_municipi, ['ine', 'dc'])
municipi = '{0}{1}'.format(municipi_dict['ine'][-3:],
municipi_dict['dc'])
res = {
'municipi': municipi,
'provincia': provincia,
'tensio': tensio
}
return res
def consumer(self):
"""
Generates the line of the file
:return: Line
:rtype: str
"""
O = self.connection
fields_to_read = [
"cod_proyecto", "finalidad", "identificador_py", "cini_prv",
"cod_tipo_inst", "codigo_ccaa_1", "codigo_ccaa_2", "anio_prev_aps",
"longitud_prv", "capacidad_prv", "vol_inv_prev", "ayudas_prv",
"financiacion_prv", "vpi_retribuible_prv", "estado"
]
while True:
try:
item = self.input_q.get()
self.progress_q.put(item)
lbt = O.GiscedataCnmcLiniesbt.read(item, fields_to_read)
output = [
lbt["cod_proyecto"][1],
lbt["finalidad"],
lbt["identificador_py"],
lbt["cini_prv"],
get_name_ti(O, lbt["cod_tipo_inst"][0]),
get_codigo_ccaa(O, lbt["codigo_ccaa_1"][0]),
get_codigo_ccaa(O, lbt["codigo_ccaa_2"][0]),
lbt["anio_prev_aps"],
format_f(lbt["longitud_prv"], 3) or "0.00",
lbt["capacidad_prv"],
format_f(lbt["vol_inv_prev"], 2) or "0.00",
format_f(lbt["ayudas_prv"], 2) or "0.00",
format_f(lbt["financiacion_prv"], 2) or "0.00",
format_f(lbt["vpi_retribuible_prv"], 2) or "0.00",
lbt["estado"]
]
self.output_q.put(output)
except Exception:
traceback.print_exc()
if self.raven:
self.raven.captureException()
finally:
self.input_q.task_done()
def consumer(self):
"""
Generates the line of the file
:return: Line
:rtype: str
"""
O = self.connection
fields_to_read = []
while True:
try:
item = self.input_q.get()
self.progress_q.put(item)
pro = O.GiscedataCnmcProjectes.read(item, fields_to_read)
codigo = pro["codi"]
ccaa = 0
ccaa_2 = 0
if pro["ccaa"]:
ccaa = pro["ccaa"][0]
if pro["ccaa_2"]:
ccaa_2 = pro["ccaa_2"][0]
output = [
pro["codi"],
pro["name"],
get_codigo_ccaa(O, ccaa),
get_codigo_ccaa(O, ccaa_2),
pro["memoria"].replace("\n", " ")[:300] or "",
format_f(self.vol_total_inv_prev_proy[codigo], 2) or "0.00",
format_f(self.ayudas_prv_proy[codigo], 2) or "0.00",
format_f(self.financiacion_prv_proy[codigo], 2) or "0.00",
format_f(self.vpi_retribuible_prv_proy[codigo], 2) or "0.00",
pro["estado"]
]
self.output_q.put(output)
except Exception:
traceback.print_exc()
if self.raven:
self.raven.captureException()
finally:
self.input_q.task_done()
def consumer(self):
o = self.connection
fields_to_read = [
'ct', 'name', 'cini', 'potencia_nominal', 'propietari',
'perdues_buit', 'perdues_curtcircuit_nominal'
]
while True:
try:
# generar linies
item = self.input_q.get()
self.progress_q.put(item)
trafo = o.GiscedataTransformadorTrafo.read(
item, fields_to_read
)
o_ct = trafo['ct'] and trafo['ct'][1] or ''
o_node = self.get_node(item)
o_cini = trafo['cini'] or ''
o_maquina = trafo['name']
o_pot = format_f(
trafo['potencia_nominal'], decimals=3)
o_perdues_buit = format_f(
trafo['perdues_buit'] or 0, decimals=3)
o_perdues_nominal = format_f(
trafo['perdues_curtcircuit_nominal'] or 0, decimals=3)
o_propietari = int(trafo['propietari'])
o_any = self.year
self.output_q.put([
o_node,
o_ct,
o_cini,
o_maquina,
o_pot,
o_perdues_buit,
o_perdues_nominal,
o_propietari,
o_any
])
except:
traceback.print_exc()
if self.raven:
self.raven.captureException()
finally:
self.input_q.task_done()
def consumer(self):
"""
Generates the line of the file
:return: Line
:rtype: str
"""
O = self.connection
fields_to_read = [
"codi", "finalitat", "id_instalacio", "cini", "codi_tipus_inst",
"ccaa", "any_apm", "vol_total_inv", "ajudes", "inv_financiada",
"vpi_retri", "estado"
]
while True:
try:
item = self.input_q.get()
self.progress_q.put(item)
pos = O.GiscedataCnmcPosicions.read(item, fields_to_read)
output = [
pos["codi"][1],
pos["finalitat"],
pos["id_instalacio"],
pos["cini"],
get_name_ti(O, pos["codi_tipus_inst"][0]),
get_codigo_ccaa(O, pos["ccaa"][0]),
pos["any_apm"],
format_f(pos["vol_total_inv"], 2) or "0.00",
format_f(pos["ajudes"], 2) or "0.00",
format_f(pos["inv_financiada"], 2) or "0.00",
format_f(pos["vpi_retri"], 2) or "0.00",
pos["estado"]
]
self.output_q.put(output)
except Exception:
traceback.print_exc()
if self.raven:
self.raven.captureException()
finally:
self.input_q.task_done()
def conv_text(self, data):
"""
Converts the projection of a data
:param data: list of elemnets to convert
:return: Elements with the projection converted
"""
o = self.connection
t = ''
for line in data:
res_srid = convert_srid(
self.codi_r1,
get_srid(o),
[line['x'], line['y']]
)
t += '{0};{1};{2}\n'.format(
format_f(res_srid[0], decimals=6),
format_f(res_srid[1], decimals=6),
'')
return t[:-1]
def consumer(self):
"""
Generates the line of the file
:return: Line
:rtype: str
"""
self.input_q.get()
O = self.connection
try:
for year in self.years:
for ccaa in self.ccaas:
output = [
get_codigo_ccaa(O, ccaa),
year,
format_f(self.vol_inv[year][ccaa], 2) or "0.00",
format_f(self.ayudas[year][ccaa], 2) or "0.00",
format_f(self.financiacion[year][ccaa], 2) or "0.00",
format_f(self.vpi[year][ccaa], 2) or "0.00",
format_f(self.num_proy[year][ccaa], 0) or "0",
format_f(self.inv_bt[year][ccaa], 2) or "0.00",
]
self.output_q.put(output)
except Exception:
traceback.print_exc()
if self.raven:
self.raven.captureException()
finally:
self.input_q.task_done()
def consumer(self):
o = self.connection
fields_to_read = [
'ct', 'name', 'cini', 'potencia_nominal', 'propietari', 'id_estat',
'conexions', 'energia_anual', 'potencia_activa',
'potencia_reactiva', 'perdues_buit', 'perdues_curtcircuit_nominal'
]
while True:
try:
# generar linies
item = self.input_q.get()
self.progress_q.put(item)
trafo = o.GiscedataTransformadorTrafo.read(
item, fields_to_read
)
o_subestacio = trafo['ct'][1]
o_maquina = trafo['name']
o_cini = trafo['cini']
o_costat_alta = self.get_costat_alta(trafo)
o_costat_baixa = self.get_costat_baixa(trafo)
o_pot_maquina = format_f(
float(trafo['potencia_nominal']) / 1000.0, decimals=3)
o_pot_activa = format_f(
float(trafo['potencia_activa']), decimals=3)
o_pot_reactiva = format_f(
float(trafo['potencia_reactiva']), decimals=3)
o_energia_anual = format_f(
float(trafo['energia_anual']), decimals=3)
o_perdues = format_f(
float(trafo['perdues_buit']), decimals=3)
o_perdues_nominal = format_f(
float(
trafo['perdues_curtcircuit_nominal']
), decimals=3)
o_propietat = int(trafo['propietari'])
o_estat = self.get_estat(trafo['id_estat'][0])
o_any = self.year
self.output_q.put([
o_subestacio, # SUBESTACION
o_maquina, # MAQUINA
o_cini, # CINI
o_costat_alta, # PARQUE ALTA
o_costat_baixa, # PARQUE BAJA
o_pot_maquina, # POTENCIA MAQUINA
o_pot_activa, # POTENCIA ACTIVA
o_pot_reactiva, # POTENCIA REACTIVA
o_energia_anual, # ENERGIA ANUAL CIRCULADA
o_perdues, # PERDIDAS DE VACIO
o_perdues_nominal, # PERDIDAS POTENCIA NOMINAL
o_propietat, # PROPIEDAD
o_estat, # ESTADO
o_any # AÑO INFORMACION
])
except Exception:
traceback.print_exc()
if self.raven:
self.raven.captureException()
finally:
self.input_q.task_done()
def consumer(self):
o = self.connection
fields_to_read = [
'ct', 'name', 'cini', 'potencia_nominal', 'propietari', 'id_estat',
'conexions', 'energia_anual', 'potencia_activa',
'potencia_reactiva', 'perdues_buit', 'perdues_curtcircuit_nominal'
]
while True:
try:
# generar linies
item = self.input_q.get()
self.progress_q.put(item)
trafo = o.GiscedataTransformadorTrafo.read(
item, fields_to_read
)
o_subestacio = trafo['ct'][1]
o_maquina = trafo['name']
o_cini = trafo['cini']
o_costat_alta = self.get_costat_alta(trafo)
o_costat_baixa = self.get_costat_baixa(trafo)
o_pot_maquina = format_f(
float(trafo['potencia_nominal']) / 1000.0, decimals=3)
o_pot_activa = format_f(
float(trafo['potencia_activa']), decimals=3)
o_pot_reactiva = format_f(
float(trafo['potencia_reactiva']), decimals=3)
o_energia_anual = format_f(
float(trafo['energia_anual']), decimals=3)
o_perdues = format_f(
float(trafo['perdues_buit']), decimals=3)
o_perdues_nominal = format_f(
float(
trafo['perdues_curtcircuit_nominal']
), decimals=3)
o_propietat = int(trafo['propietari'])
o_estat = self.get_estat(trafo['id_estat'][0])
o_any = self.year
self.output_q.put([
o_subestacio,
o_maquina,
o_cini,
o_costat_alta,
o_costat_baixa,
o_pot_maquina,
o_pot_activa,
o_pot_reactiva,
o_energia_anual,
o_perdues,
o_perdues_nominal,
o_propietat,
o_estat,
o_any
])
except:
traceback.print_exc()
if self.raven:
self.raven.captureException()
finally:
self.input_q.task_done()
def consumer(self):
o = self.connection
fields_to_read = [
'propietari', 'subestacio_id', 'tensio'
]
dict_cts = {}
while True:
try:
# generar linies
item = self.input_q.get()
self.progress_q.put(item)
sub = o.GiscedataCtsSubestacionsPosicio.read(
item, fields_to_read
)
o_subestacio = sub['subestacio_id'][1]
o_parc = sub['subestacio_id'][1] + "-" + sub['tensio'][1]
subestacio = self.get_subestacio(sub['subestacio_id'][0])
o_node = subestacio['node']
o_cini = subestacio['cini']
o_tipus = self.get_tipus_parc(sub['subestacio_id'][0])
o_tensio = format_f(
float(sub['tensio'][1]) / 1000.0, decimals=3)
o_prop = int(sub['propietari'])
o_any = self.year
insert = True
if o_subestacio not in dict_cts.keys():
dict_cts[o_subestacio] = [o_tensio]
else:
llista_valors = dict_cts[o_subestacio]
for valor in llista_valors:
if valor == o_tensio:
insert = False
if insert:
dict_cts[o_subestacio].append(o_tensio)
if insert:
self.output_q.put([
o_subestacio,
o_parc,
o_node,
o_cini,
o_tipus,
o_tensio,
o_prop,
o_any
])
except:
traceback.print_exc()
if self.raven:
self.raven.captureException()
finally:
self.input_q.task_done()
def consumer(self):
"""
Consumer function that executes for each item of the return
of get_sequence
:return: None
"""
O = self.connection
while True:
try:
item = self.input_q.get()
self.progress_q.put(item)
fields_to_read = [
'name', 'polissa_polissa', 'cnmc_numero_lectures',
]
cups = O.GiscedataCupsPs.read(item, fields_to_read)
if self.reducir_cups:
o_cups = cups['name'][:20]
else:
o_cups = cups['name'][:22]
polissa_id = self.get_polissa(cups['id'])
polissa = O.GiscedataPolissa.read(polissa_id[0], ['tarifa'])
if 'RE' in polissa['tarifa'][1]:
continue
if polissa_id:
polissa_id = polissa_id[0]
o_comptador_cini = self.get_comptador_cini(polissa_id)
o_comptador_data = self.get_data_comptador(polissa_id)
else:
o_comptador_cini = ''
o_comptador_data = ''
o_num_lectures = format_f(
cups['cnmc_numero_lectures'], decimals=3) or '0'
o_titular = self.get_cambio_titularidad(cups['id'])
o_baixa = self.get_baixa_cups(cups['id'])
o_year = self.year
self.output_q.put([
o_cups, # CUPS
o_comptador_cini, # CINI
o_comptador_data, # INSTALACION
o_num_lectures, # NUMERO LECTURAS
o_titular, # CAMBIO TITULARIDAD
o_baixa, # BAJA SUMINISTRO
o_year # AÑO INFORMACION
])
except Exception:
traceback.print_exc()
if self.raven:
self.raven.captureException()
finally:
self.input_q.task_done()
def consumer(self):
O = self.connection
fields_to_read = ['name', 'cini', 'data_pm', 'cnmc_tipo_instalacion',
'id_municipi', 'perc_financament', 'descripcio']
while True:
try:
item = self.input_q.get()
self.progress_q.put(item)
ct = O.GiscedataCts.read(item, fields_to_read)
comunitat_codi = ''
data_pm = ''
if ct['data_pm']:
data_pm_ct = datetime.strptime(str(ct['data_pm']),
'%Y-%m-%d')
data_pm = data_pm_ct.strftime('%d/%m/%Y')
#funció per trobar la ccaa desde el municipi
fun_ccaa = O.ResComunitat_autonoma.get_ccaa_from_municipi
if ct['id_municipi']:
id_municipi = ct['id_municipi'][0]
else:
id_municipi = get_id_municipi_from_company(O)
if id_municipi:
id_comunitat = fun_ccaa(id_municipi)
comunitat_vals = O.ResComunitat_autonoma.read(
id_comunitat[0], ['codi'])
if comunitat_vals:
comunitat_codi = comunitat_vals['codi']
output = [
'{}'.format(ct['name']),
ct['cini'] or '',
ct['descripcio'] or '',
str(ct['cnmc_tipo_instalacion']) or '',
comunitat_codi or '',
format_f(round(100 - int(ct['perc_financament']))),
data_pm,
]
self.output_q.put(output)
except Exception:
traceback.print_exc()
if self.raven:
self.raven.captureException()
finally:
self.input_q.task_done()
def consumer(self):
o = self.connection
fields_to_read = [
'id', 'subestacio_id', 'name', 'tipus', 'propietari', 'cini'
]
while True:
try:
# generar linies
item = self.input_q.get()
self.progress_q.put(item)
parc = o.GiscedataParcs.read(
item, fields_to_read
)
subestacio = self.get_subestacio(parc['subestacio_id'][0])
o_subestacio = subestacio['name']
o_parc = parc['name']
o_node = subestacio['node']
o_node = o_node.replace('*', '')
o_cini = parc['cini']
o_tipus = parc['tipus'] - 1
tensio = self.get_tensio(parc['id'])
o_tensio = format_f(
float(tensio) / 1000.0, decimals=3)
o_prop = int(parc['propietari'])
o_any = self.year
insert = True
if insert:
self.output_q.put([
o_subestacio, # SUBESTACION
o_parc, # PARQUE
o_node, # NUDO
o_cini, # CINI
o_tipus, # TIPO PARQUE
o_tensio, # TENSION DEL PARQUE
o_prop, # PROPIEDAD
o_any # AÑO INFORMACION
])
except Exception as e:
traceback.print_exc()
if self.raven:
self.raven.captureException()
finally:
self.input_q.task_done()
def consumer(self):
O = self.connection
while True:
try:
item = self.input_q.get()
self.progress_q.put(item)
fields_to_read = [
'name', 'polissa_polissa', 'cnmc_numero_lectures'
]
cups = O.GiscedataCupsPs.read(item, fields_to_read)
o_cups = cups['name'][:22]
polissa_id = self.get_polissa(cups['id'])
if polissa_id:
polissa_id = polissa_id[0]
o_comptador_cini = self.get_comptador_cini(polissa_id)
o_comptador_data = self.get_data_comptador(polissa_id)
else:
o_comptador_cini = ''
o_comptador_data = ''
o_num_lectures = format_f(
cups['cnmc_numero_lectures'], decimals=3) or ''
o_titular = self.get_cambio_titularidad(cups['id'])
o_baixa = self.get_baixa_cups(cups['id'])
o_year = self.year
self.output_q.put([
o_cups,
o_comptador_cini,
o_comptador_data,
o_num_lectures,
o_titular,
o_baixa,
o_year
])
except:
traceback.print_exc()
if self.raven:
self.raven.captureException()
finally:
self.input_q.task_done()
def consumer(self):
"""
Method that generates the csb file
:return: List of arrays
"""
O = self.connection
fields_to_read = [
'name', 'data_industria', 'data_pm', 'id_municipi', 'cini',
'descripcio', 'perc_financament', 'data_baixa', 'posicions',
'cnmc_tipo_instalacion', self.compare_field
]
data_pm_limit = '{}-01-01'.format(self.year + 1)
data_baixa_limit = '{}-01-01'.format(self.year)
error_msg = "**** ERROR: El ct %s (id:%s) no està en giscedata_cts_subestacions.\n"
while True:
try:
item = self.input_q.get()
self.progress_q.put(item)
sub = O.GiscedataCtsSubestacions.read(item, fields_to_read)
if not sub:
txt = (error_msg.format((sub['name'], sub['id'])))
if not QUIET:
sys.stderr.write(txt)
sys.stderr.flush()
raise Exception(txt)
# Calculem any posada en marxa
data_pm = sub['data_pm']
if data_pm:
data_pm = datetime.strptime(str(data_pm), '%Y-%m-%d')
data_pm = data_pm.strftime('%d/%m/%Y')
comunitat = ''
if sub['id_municipi']:
id_municipi = sub['id_municipi'][0]
else:
id_municipi = get_id_municipi_from_company(O)
if id_municipi:
# funció per trobar la ccaa desde el municipi
fun_ccaa = O.ResComunitat_autonoma.get_ccaa_from_municipi
id_comunitat = fun_ccaa(id_municipi)
comunitat_vals = O.ResComunitat_autonoma.read(
id_comunitat[0], ['codi'])
if comunitat_vals:
comunitat = comunitat_vals['codi']
if sub['data_baixa']:
if sub['data_baixa'] < data_pm_limit:
fecha_baja = sub['data_baixa']
else:
fecha_baja = ''
else:
fecha_baja = ''
if 'posicions' in sub:
num_pos = 0
for pos in sub['posicions']:
pos_data = O.GiscedataCtsSubestacionsPosicio.read(
pos, ['interruptor', 'criteri_regulatori']
)
if pos_data['interruptor'] == '2' and \
pos_data['criteri_regulatori'] != "excloure":
num_pos += 1
else:
num_pos = 1
if sub[self.compare_field]:
last_data = sub[self.compare_field]
entregada = F3Res4666(**last_data)
actual = F3Res4666(
sub['name'],
sub['cini'],
sub['descripcio'],
comunitat,
format_f(
100.0 - sub.get('perc_financament', 0.0), 2
),
data_pm,
fecha_baja,
num_pos,
0
)
if entregada == actual:
estado = 0
else:
self.output_m.put("{} {}".format(sub["name"], adapt_diff(actual.diff(entregada))))
estado = 1
else:
if sub['data_pm']:
if sub['data_pm'][:4] != str(self.year):
self.output_m.put("Identificador:{} No estava en el fitxer carregat al any n-1 i la data de PM es diferent al any actual".format(sub["name"]))
estado = '1'
else:
estado = '2'
else:
self.output_m.put("Identificador:{} No estava en el fitxer carregat al any n-1".format(sub["name"]))
estado = '1'
output = [
'{0}'.format(sub['name']), # IDENTIFICADOR
sub['cini'] or '', # CINI
sub['descripcio'] or '', # DENOMINACION
comunitat, # CODIGO_CCAA
format_f(
100.0 - sub.get('perc_financament', 0.0), 2
), # FINANCIADO
data_pm, # FECHA_APS
fecha_baja, # FECHA_BAJA
num_pos, # POSICIONES
estado # ESTADO
]
self.output_q.put(output)
except Exception:
traceback.print_exc()
if self.raven:
self.raven.captureException()
finally:
self.input_q.task_done()
def consumer(self):
O = self.connection
count = 0
fields_to_read = ['name', 'municipi', 'data_pm', 'ct',
'coeficient', 'cini', 'perc_financament',
'longitud_cad', 'cable', 'voltatge', 'data_alta',
'propietari', 'cnmc_tipo_instalacion']
while True:
try:
count += 1
item = self.input_q.get()
self.progress_q.put(item)
linia = O.GiscedataBtElement.read(item, fields_to_read)
res = O.GiscegisEdge.search([('id_linktemplate', '=',
linia['name']),
('layer', 'ilike', '%BT%')])
if not res:
if not QUIET:
sys.stderr.write(
"**** ERROR: l'element %s (id:%s) no està en "
"giscegis_edges.\n" % (linia['name'], linia['id']))
sys.stderr.flush()
edge = {'start_node': (0, '%s_0' % linia['name']),
'end_node': (0, '%s_1' % linia['name'])}
elif len(res) > 1:
if not QUIET:
sys.stderr.write("**** ERROR: l'element %s (id:%s) "
"està més d'una vegada a "
"giscegis_edges. %s\n" %
(linia['name'], linia['id'], res))
sys.stderr.flush()
edge = {'start_node': (0, '%s_0' % linia['name']),
'end_node': (0, '%s_1' % linia['name'])}
else:
edge = O.GiscegisEdge.read(res[0], ['start_node',
'end_node'])
comunitat = ''
if linia['municipi']:
ccaa_obj = O.ResComunitat_autonoma
id_comunitat = ccaa_obj.get_ccaa_from_municipi(
linia['municipi'][0])
id_comunitat = id_comunitat[0]
comunidad = ccaa_obj.read(id_comunitat, ['codi'])
if comunidad:
comunitat = comunidad['codi']
data_pm = ''
if linia['data_pm']:
data_pm_linia = datetime.strptime(str(linia['data_pm']),
'%Y-%m-%d')
data_pm = data_pm_linia.strftime('%Y')
# Coeficient per ajustar longituds de trams
coeficient = linia['coeficient'] or 1.0
try:
tensio = (int(linia['voltatge']) / 1000.0)
except:
tensio = 0.0
propietari = linia['propietari'] and '1' or '0'
codi = linia['cnmc_tipo_instalacion']
# Agafem el cable de la linia
if linia['cable']:
cable = O.GiscedataBtCables.read(linia['cable'][0], [
'intensitat_admisible', 'seccio'])
else:
cable = {'seccio': 0, 'intensitat_admisible': 0}
intensitat = cable['intensitat_admisible']
#Capacitat
capacitat = round(
(cable['intensitat_admisible'] * int(linia['voltatge'])
* math.sqrt(3)) / 1000, 3)
if not capacitat:
capacitat = 1.0
#Descripció
origen = tallar_text(edge['start_node'][1], 50)
final = tallar_text(edge['end_node'][1], 50)
longitud = round(linia['longitud_cad'] * coeficient / 1000.0,
3) or 0.001
output = [
'B%s' % linia['name'],
linia['cini'] or '',
origen or '',
final or '',
codi or '',
comunitat,
comunitat,
format_f(round(100 - int(linia['perc_financament']))),
data_pm or '',
1,
1,
format_f(tensio),
format_f(longitud, 3),
format_f(intensitat),
format_f(cable['seccio']),
format_f(capacitat),
]
self.output_q.put(output)
except:
traceback.print_exc()
if self.raven:
self.raven.captureException()
finally:
self.input_q.task_done()
def consumer(self):
o_codi_r1 = 'R1-%s' % self.codi_r1[-3:]
O = self.connection
fields_to_read = [
'name', 'cini', 'id_municipi', 'tensio_p', 'id_subtipus',
'perc_financament', 'propietari', 'numero_maxim_maquines',
'potencia',"node_id"
]
while True:
try:
item = self.input_q.get()
self.progress_q.put(item)
ct = O.GiscedataCts.read(item, fields_to_read)
if ct.get("node_id"):
o_node = ct["node_id"][1]
node = O.GiscegisNodes.read(ct["node_id"][0],["geom"])
coords = wkt.loads(node["geom"]).coords[0]
vertex = [coords[0], coords[1]]
else:
o_node, vertex = self.get_node_vertex(item)
o_node = o_node.replace('*', '')
o_ct = ct['name']
o_cini = ct['cini'] or ''
if ct['id_municipi']:
o_ine_prov, o_ine_muni = self.get_ine(ct['id_municipi'][0])
else:
o_ine_muni, o_ine_prov = '', ''
try:
o_tensio_p = format_f(
float(ct['tensio_p']) / 1000.0, decimals=3) or ''
except:
o_tensio_p = ''
if ct['id_subtipus']:
o_tipo = self.get_tipus(ct['id_subtipus'][0])
else:
o_tipo = ''
o_potencia = float(self.get_potencia_trafos(item))
cups = O.GiscedataCupsPs.search([
('et', '=', ct['name']),
('polissa_polissa.tarifa.name', 'not in', ["RE", "RE12"])
])
o_energia = sum(
x['cne_anual_activa']
for x in O.GiscedataCupsPs.read(
cups, ['cne_anual_activa']
)
)
o_pic_activa = format_f(
self.get_saturacio(ct['id']), decimals=3)
o_pic_reactiva = ''
o_s_utilitades, o_s_disponibles = self.get_sortides_ct(
ct['name']
)
o_propietari = int(ct['propietari'])
o_num_max_maquines = ct['numero_maxim_maquines']
o_incorporacio = self.year
z = ''
res_srid = ['', '']
if vertex:
res_srid = convert_srid(
self.codi_r1, get_srid(O), vertex)
self.output_q.put([
o_node, # NUDO ALTA
o_ct, # CT
o_cini, # CINI
format_f(res_srid[0], decimals=3), # X
format_f(res_srid[1], decimals=3), # Y
z, # Z
o_ine_muni, # MUNICIPIO
o_ine_prov, # PROVINCIA
o_tensio_p, # NIVEL TENSION
o_tipo, # TIPO
format_f(o_potencia, decimals=3), # POTENCIA TOTAL INSTALADA
format_f(o_energia, decimals=3), # ENERGIA ANUAL CIRCULADA
o_pic_activa, # DEMANDA PICO ACTIVA
o_pic_reactiva, # DEMANDA PICO REACTIVA
o_s_utilitades, # NUMERO SALIDAS UTILIZADAS
o_s_disponibles, # MAXIMO SALIDAS UTILIZADAS
o_codi_r1, # CODIGO DISTRIBUIDORA
o_propietari, # PROPIEDAD
o_num_max_maquines, # NUM MAX MAQUINAS
o_incorporacio # AÑO INFORMACION
])
except Exception:
traceback.print_exc()
if self.raven:
self.raven.captureException()
finally:
self.input_q.task_done()
def consumer(self):
o = self.connection
fields_to_read = [
'name', 'cini', 'circuits', 'longitud_cad', 'linia', 'origen',
'final', 'coeficient', 'cable', 'tensio_max_disseny'
]
data_pm_limit = '%s-01-01' % (self.year + 1)
data_baixa = '%s-12-31' % self.year
static_search_params = [
('cini', '!=', '0000000'),
'|',
('data_pm', '=', False),
('data_pm', '<', data_pm_limit),
'|',
('data_baixa', '>', data_baixa),
('data_baixa', '=', False),
]
# Revisem que si està de baixa ha de tenir la data informada.
static_search_params += ['|',
'&', ('active', '=', False),
('data_baixa', '!=', False),
('active', '=', True)]
while True:
try:
# generar linies
item = self.input_q.get()
self.progress_q.put(item)
linia = o.GiscedataAtLinia.read(
item, ['trams', 'tensio', 'municipi', 'propietari',
'provincia']
)
o_prop = linia['propietari'] and '1' or '0'
search_params = [('id', 'in', linia['trams'])]
search_params += static_search_params
ids = o.GiscedataAtTram.search(
search_params, 0, 0, False, {'active_test': False})
for at in o.GiscedataAtTram.read(ids, fields_to_read):
# Coeficient per ajustar longituds de trams
coeficient = at['coeficient'] or 1.0
# Comprovar el tipus del cable
fields_to_read_cable = [
'tipus', 'resistencia', 'reactancia',
'intensitat_admisible'
]
cable = o.GiscedataAtCables.read(at['cable'][0],
fields_to_read_cable)
o_tipus = o.GiscedataAtTipuscable.read(cable['tipus'][0],
['codi'])['codi']
# Si el tram tram es embarrat amb una longitud > 100
# no l'afegim
if o_tipus == 'E' and at['longitud_cad'] > 100:
continue
if o_tipus == 'E':
o_tipus = 'S'
#Agafem la tensió
o_nivell_tensio = (
(at['tensio_max_disseny'] or linia['tensio']))
o_nivell_tensio = format_f(
float(o_nivell_tensio) / 1000.0, 3)
o_tram = 'A%s' % at['name']
res = o.GiscegisEdge.search(
[('id_linktemplate', '=', at['name']),
('layer', 'not ilike', self.layer),
('layer', 'not ilike', 'EMBARRA%BT%')
])
if not res or len(res) > 1:
edge = {'start_node': (0, '%s_0' % at['name']),
'end_node': (0, '%s_1' % at['name'])}
else:
edge = o.GiscegisEdge.read(res[0], ['start_node',
'end_node'])
o_node_inicial = tallar_text(edge['start_node'][1], 20)
o_node_final = tallar_text(edge['end_node'][1], 20)
o_cini = at['cini']
o_provincia = ''
if linia['provincia']:
o_provincia = self.get_provincia(linia['provincia'][0])
o_longitud = format_f(
float(at['longitud_cad']) * coeficient / 1000.0 or 0.001
, decimals=3)
o_num_circuits = at['circuits']
o_r = format_f(
cable['resistencia'] * (float(at['longitud_cad']) *
coeficient / 1000.0) or 0.0,
decimals=6)
o_x = format_f(
cable['reactancia'] * (float(at['longitud_cad']) *
coeficient / 1000.0) or 0.0,
decimals=6)
o_int_max = format_f(
cable['intensitat_admisible'] or 0.0, decimals=3)
o_op_habitual = 1 # Tots son actius
o_cod_dis = 'R1-%s' % self.codi_r1[-3:]
o_any = self.year
self.output_q.put([
o_tram,
o_node_inicial,
o_node_final,
o_cini,
o_provincia,
o_nivell_tensio,
o_longitud,
o_num_circuits,
o_tipus,
o_r,
o_x,
o_int_max,
o_op_habitual,
o_cod_dis,
o_prop,
o_any
])
except:
traceback.print_exc()
if self.raven:
self.raven.captureException()
finally:
self.input_q.task_done()
def consumer(self):
O = self.connection
fields_to_read = ['name', 'cini', 'data_pm', 'subestacio_id',
'cnmc_tipo_instalacion', 'perc_financament', 'tensio']
while True:
try:
item = self.input_q.get()
self.progress_q.put(item)
o_sub = ''
sub = O.GiscedataCtsSubestacionsPosicio.read(
item, fields_to_read)
if not sub:
txt = ('**** ERROR: El ct %s (id:%s) no està a '
'giscedata_cts_subestacions_posicio.\n' %
(sub['name'], sub['id']))
if not QUIET:
sys.stderr.write(txt)
sys.stderr.flush()
raise Exception(txt)
# Calculem any posada en marxa
data_pm = sub['data_pm']
if data_pm:
data_pm = datetime.strptime(str(data_pm), '%Y-%m-%d')
data_pm = data_pm.strftime('%Y')
#Codi tipus de instalació
codi = sub['cnmc_tipo_instalacion']
comunitat = ''
#tensio
ten = O.GiscedataTensionsTensio.read(sub['tensio'][0],
['tensio'])
tensio = (ten['tensio'] / 1000.0) or 0.0
cts = O.GiscedataCtsSubestacions.read(sub['subestacio_id'][0],
['id_municipi'])
denominacio = self.get_denom(sub['subestacio_id'][0])
if cts['id_municipi']:
id_municipi = cts['id_municipi'][0]
else:
id_municipi = get_id_municipi_from_company(O)
if id_municipi:
#funció per trobar la ccaa desde el municipi
fun_ccaa = O.ResComunitat_autonoma.get_ccaa_from_municipi
id_comunitat = fun_ccaa(id_municipi)
comunitat_vals = O.ResComunitat_autonoma.read(
id_comunitat[0], ['codi'])
if comunitat_vals:
comunitat = comunitat_vals['codi']
o_sub = self.get_description(sub['subestacio_id'][0])
output = [
o_sub,
sub['cini'] or '',
denominacio,
codi,
comunitat,
format_f(tensio),
format_f(round(100 - int(sub['perc_financament']))),
data_pm or '',
]
self.output_q.put(output)
except:
traceback.print_exc()
if self.raven:
self.raven.captureException()
finally:
self.input_q.task_done()
