def call_api(self, input, value, endpoint, output):
     json_doc = self.api_call_constructor(input, value, endpoint).json()
     int2str(json_doc)
     if endpoint.startswith('http://myvariant.info/'):
         if "_id" in json_doc:
             json_doc["_id"] = json_doc["_id"].replace(':', '-')
         elif "hits" in json_doc:
             for _doc in json_doc["hits"]:
                 if "_id" in _doc:
                     _doc['_id'] = _doc['_id'].replace(":", "-")
     output_type = self.bioentity_info[output]['type']
     if output_type == 'Entity':
         jsonld_context = self.fetch_context(endpoint)
         json_doc.update(jsonld_context)
         # parse output nquads
         nquads = jsonld2nquads(json_doc)
         outputs = list(set(fetchvalue(nquads, output)))
         return (outputs,output_type)
     else:
         response = self.endpoint_info[endpoint]['get']['responses']['200']['x-responseValueType']
         for _response in response:
             if _response['valueType'] == output:
                 output_path = _response['path']
         outputs_command = 'json_doc'
         for _item in output_path.split('.'):
             outputs_command += ('["' + _item + '"]')
         outputs = eval(outputs_command)
         return (outputs, output_type)
Example #2
0
    def encode(self, license_text):
        """
        :type license_text: unicode
        :param license_text: an atlassian license in plain text
        :rtype: unicode
        """
        compressed_data = zlib.compress(license_text.encode('utf-8'),
                                        self.LICENSE_COMPRESS_LEVEL)
        license_prefix = ''.join(map(chr, self.LICENSE_PREFIX)).encode('utf-8')
        license_bytes = license_prefix + compressed_data

        license_digest = hashlib.sha1(license_bytes).digest()
        signature_bytes = self._dsa.sign_asn1(license_digest)

        license_length = len(license_bytes)
        length_bytes = struct.pack('>L', license_length)

        license_base64 = base64.b64encode(length_bytes + license_bytes +
                                          signature_bytes).decode('utf-8')
        encoded_length = utils.int2str(len(license_base64),
                                       self.ENCODED_LICENSE_LENGTH_BASE,
                                       self.ENCODED_LICENSE_LENGTH_ALPHABET)

        version_text = '{:0{}}'.format(self.VERSION_NUMBER,
                                       self.VERSION_LENGTH - 1)

        encoded_license = ''.join(
            [license_base64, self.SEPARATOR, version_text, encoded_length])
        wrapped_license = '\n'.join(
            textwrap.wrap(encoded_license,
                          self.ENCODED_LICENSE_LINE_LENGTH)) + '\n'

        return wrapped_license
Example #3
0
 def tostr(v):
     if isinstance(v, float):
         v = utils.float2str(v)
     elif isinstance(v, int):
         v = utils.int2str(v)
     elif isinstance(v, (list, tuple)):
         # Recursividad, divino tesoro...
         v = sanitize(v)
     return v
Example #4
0
def main():
    """
    Devuelve un diccionario con los listados de rollos 
    en existencias, fabricados y salidos en cada periodo.
    """
    ini_enero = mx.DateTime.DateTimeFrom(day = 1, month = 1, year = 2006)
    fin_enero = mx.DateTime.DateTimeFrom(day = -1, month = 1, year = 2006)
    ini_febrero = mx.DateTime.DateTimeFrom(day = 1, month = 2, year = 2006)
    fin_febrero = mx.DateTime.DateTimeFrom(day = -1, month = 2, year = 2006)
    rollos_existencias_enero = buscar_rollos_existencias(fin_enero)
    print "EXISTENCIAS AL 31 DE ENERO: %s" % (utils.int2str(len(rollos_existencias_enero)))
    rollos_fabricados_febrero = buscar_rollos_fabricados(ini_febrero, fin_febrero)
    print "FABRICADO EN FEBRERO: %s" % (utils.int2str(len(rollos_fabricados_febrero)))
    rollos_salidos_febrero = buscar_rollos_salidos(ini_febrero, fin_febrero)
    print "ROLLOS SALIDOS EN FEBRERO: %s" % (utils.int2str(len(rollos_salidos_febrero)))
    len_existencias_teoria_febrero = len(rollos_existencias_enero) + len(rollos_fabricados_febrero) - len(rollos_salidos_febrero)
    existencias_teoria_febrero = rollos_existencias_enero + rollos_fabricados_febrero
    for rollo in rollos_salidos_febrero:
        try:
            existencias_teoria_febrero.remove(rollo)
        except ValueError:
            print "Busted! El rollo ID %d salió en febrero pero no estaba en enero ni se fabricó en febrero." % (rollo.id)
        if rollo in existencias_teoria_febrero:
            print "Busted! El rollo ID %d sigue estando en las existencias de febrero." % (rollo.id)
    print "TOTAL TEÓRICO AL 28 DE FEBRERO: %s [%s]" % (utils.int2str(len_existencias_teoria_febrero), 
                                                       utils.int2str(len(existencias_teoria_febrero)))
    rollos_existencias_febrero = buscar_rollos_existencias(fin_febrero)
    print "TOTAL BD AL 28 DE FEBRERO: %s" % (utils.int2str(len(rollos_existencias_febrero)))
    return {'existencias enero': rollos_existencias_enero, 
            'fabricados febrero': rollos_fabricados_febrero, 
            'salidos febrero': rollos_salidos_febrero, 
            'existencias teoria febrero': existencias_teoria_febrero, 
            'existencias febrero': rollos_existencias_febrero}
 def buscar(self, boton):
     """
     Dadas fecha de inicio y de fin, lista todos los albaranes
     pendientes de facturar.
     """
     anno = utils.combo_get_value(self.wids['cbe_year'])
     resultado = []
     if anno == -1 or anno == None:
         # Intento leerlo del entry
         str_anno = self.wids['cbe_year'].child.get_text()
         try:
             anno = int(str_anno)
         except:
             pass
     if anno != -1 and anno != None:
         vpro = ventana_progreso.VentanaProgreso(padre = self.wids['ventana'])
         act = 0.0; tot = 8.0 * 12
         vpro.mostrar()
         total_produccion = {'rollos': 0, 'metros': 0, 'kilos': 0}
         total_existencias = {'rollos': 0, 'metros': 0, 'kilos': 0}
         total_composan_nacional = {'rollos': 0, 'metros': 0, 'kilos': 0}
         total_composan_internacional = {'rollos': 0, 'metros': 0, 'kilos': 0}
         total_gea21 = {'rollos': 0, 'metros': 0, 'kilos': 0}
         total_otros = {'rollos': 0, 'metros': 0, 'kilos': 0}
         total_salidas = {'rollos': 0, 'metros': 0, 'kilos': 0}
         total_pendiente = {'rollos': 0, 'metros': 0, 'kilos': 0}
         # DEBUG: for mes in xrange(1, 3):
         for mes in xrange(1, 13):
             fecha_ini = mx.DateTime.DateTimeFrom(day = 1, month = mes, year = anno)
             fecha_fin = mx.DateTime.DateTimeFrom(day = -1, month = mes, year = anno)    # Último día del mes
             mes_str = utils.corregir_nombres_fecha(mx.DateTime.Month[mes]).title()
             act = 1 + ((mes -1) * 8)
             vpro.set_valor(act/tot, "Calculando producción %s..." % (mes_str))
             produccion = get_produccion(fecha_ini, fecha_fin, incluir_sin_parte = True)
             act = 2 + ((mes -1) * 8)
             vpro.set_valor(act/tot, "Calculando existencias %s..." % (mes_str))
             existencias = get_existencias(fecha_fin)
             #act = 3 + ((mes -1) * 8)
             #vpro.set_valor(act/tot, "Calculando Composan nacional %s..." % (mes_str))
             #salidas_composan_nacional = get_salidas_composan_nacional(fecha_ini, fecha_fin)
             #act = 4 + ((mes -1) * 8)
             #vpro.set_valor(act/tot, "Calculando Composan internacional %s..." % (mes_str))
             #salidas_composan_internacional = get_salidas_composan_internacional(fecha_ini, fecha_fin)
             #act = 5 + ((mes -1) * 8)
             #vpro.set_valor(act/tot, "Calculando Gea 21 %s..." % (mes_str))
             #salidas_gea21 = get_salidas_gea21(fecha_ini, fecha_fin)
             #act = 6 + ((mes -1) * 8)
             #vpro.set_valor(act/tot, "Calculando Otros %s..." % (mes_str))
             #salidas_otros = get_salidas_otros(fecha_ini, fecha_fin)
             act = 5 + ((mes -1) * 8)
             vpro.set_valor(act/tot, "Calculando salidas por tarifa %s..." % (mes_str))
             salidas_composan_nacional, \
             salidas_composan_internacional, \
             salidas_gea21, \
             salidas_otros, \
             total_salidas_mes = get_salidas_compnac_compint_gea_otros(fecha_ini, fecha_fin)
             #act = 7 + ((mes -1) * 8)
             #vpro.set_valor(act/tot, "Calculando salidas totales %s..." % (mes_str))
             #total_salidas_mes = {}
             #for c in ('rollos', 'metros', 'kilos'): 
             #    total_salidas_mes[c] = salidas_composan_nacional[c] + salidas_composan_internacional[c] + salidas_gea21[c] + salidas_otros[c]
             act = 8 + ((mes -1) * 8)
             vpro.set_valor(act/tot, "Calculando pedidos pendientes %s..." % (mes_str))
             pedidos_pendientes = get_pedidos_pendientes(fecha_fin)
             resultado.append((mes_str, 
                               produccion['rollos'], 
                               utils.int2str(produccion['metros']), 
                               utils.float2str(produccion['kilos']), 
                               existencias['rollos'], 
                               utils.int2str(existencias['metros']), 
                               utils.float2str(existencias['kilos']), 
                               total_salidas_mes['rollos'], 
                               utils.int2str(total_salidas_mes['metros']), 
                               utils.float2str(total_salidas_mes['kilos']), 
                               salidas_composan_nacional['rollos'], 
                               utils.int2str(salidas_composan_nacional['metros']), 
                               utils.float2str(salidas_composan_nacional['kilos']),
                               salidas_composan_internacional['rollos'], 
                               utils.int2str(salidas_composan_internacional['metros']), 
                               utils.float2str(salidas_composan_internacional['kilos']), 
                               salidas_gea21['rollos'], 
                               utils.int2str(salidas_gea21['metros']), 
                               utils.float2str(salidas_gea21['kilos']), 
                               salidas_otros['rollos'], 
                               utils.int2str(salidas_otros['metros']), 
                               utils.float2str(salidas_otros['kilos']), 
                               pedidos_pendientes['rollos'], 
                               utils.int2str(pedidos_pendientes['metros']), 
                               utils.float2str(pedidos_pendientes['kilos']), 
                               mes))
             for campo in ('rollos', 'metros', 'kilos'):
                 for total, parcial in ((total_produccion, produccion), 
                                        (total_existencias, existencias), 
                                        (total_composan_nacional, salidas_composan_nacional), 
                                        (total_composan_internacional, salidas_composan_internacional), 
                                        (total_gea21, salidas_gea21), 
                                        (total_otros, salidas_otros), 
                                        (total_salidas, total_salidas_mes), 
                                        (total_pendiente, pedidos_pendientes)):
                     total[campo] += parcial[campo]
         resultado.append(("TOTAL", 
                           total_produccion['rollos'], 
                           utils.int2str(total_produccion['metros']),
                           utils.float2str(total_produccion['kilos']), 
                           total_existencias['rollos'],
                           utils.int2str(total_existencias['metros']),
                           utils.float2str(total_existencias['kilos']), 
                           total_salidas['rollos'],
                           utils.int2str(total_salidas['metros']),
                           utils.float2str(total_salidas['kilos']), 
                           total_composan_nacional['rollos'],
                           utils.int2str(total_composan_nacional['metros']),
                           utils.float2str(total_composan_nacional['kilos']),
                           total_composan_internacional['rollos'],
                           utils.int2str(total_composan_internacional['metros']),
                           utils.float2str(total_composan_internacional['kilos']), 
                           total_gea21['rollos'],
                           utils.int2str(total_gea21['metros']),
                           utils.float2str(total_gea21['kilos']), 
                           total_otros['rollos'],
                           utils.int2str(total_otros['metros']),
                           utils.float2str(total_otros['kilos']), 
                           total_pendiente['rollos'],
                           utils.int2str(total_pendiente['metros']),
                           utils.float2str(total_pendiente['kilos']), 
                           13))
         vpro.ocultar()
     self.rellenar_tabla(resultado)