def desde_tag(cls, tag, con_dnis=True):
        if con_dnis:
            struct = struct_recuento_dni
        else:
            struct = struct_recuento
        datos_tag = struct.parse(tag)
        por_categoria = int(datos_tag.por_categoria)
        cod_categoria = datos_tag.cod_categoria

        if SMART_PACKING:
            num_mesa, valores = unpack("".join(datos_tag.datos))
            mesa = Ubicacion.one(numero=str(num_mesa))
        else:
            tag = "".join(datos_tag.datos)
            len_cod_mesa = int(tag[:2])
            cod_mesa = tag[2:2 + len_cod_mesa]
            mesa = Ubicacion.one(cod_mesa)
            valores = unpack(tag[len_cod_mesa + 2:])

        if not mesa:
            raise MesaNoEncontrada()

        current_data_code(mesa.cod_datos)

        if por_categoria:
            categorias = Categoria.many(codigo=cod_categoria)
        else:
            categorias = Categoria.many(sorted='codigo')

        recuento = Recuento(mesa)
        principales = recuento._get_dict_candidatos()
        # leemos los valores y los seteamos en los resultados
        # vienen ordenados por cod_lista,cod_categoria
        for lista in Lista.many(sorted='codigo'):
            for categoria in categorias:
                candidato = Candidato.one(cod_categoria=categoria.codigo,
                                          cod_lista=lista.codigo, titular=True,
                                          numero_de_orden=1)
                if candidato is not None:
                    recuento._resultados[categoria.codigo,
                                         candidato.codigo] = valores.pop(0)

        ordered_keys = sorted(recuento.campos_extra.keys())
        for key in ordered_keys:
            recuento.campos_extra[key] = valores.pop(0)

        ordered_keys = sorted(recuento.listas_especiales.keys())
        for key in ordered_keys:
            recuento.listas_especiales[key] = valores.pop(0)

        if por_categoria:
            recuento.cod_categoria = cod_categoria

        if con_dnis:
            dnis = unpack_slow(datos_tag.documentos, 27)
            for dni in dnis:
                autoridad = Autoridad("", "", 0, dni)
                recuento.autoridades.append(autoridad)

        return recuento

 def _get_categorias(self):
     """Devuelve las categorias para esta mesa y para esta partido en caso
     de que sea ese tipo de eleccion."""
     if not get_tipo_elec("interna"):
         categorias = Categoria.many(sorted="posicion")
     else:
         cod_cats = set([candidato.categoria.codigo for candidato in
                         Candidato.many(cod_partido=self.partido.codigo)])
         categorias = Categoria.many(codigo__in=cod_cats, sorted="posicion")
     return categorias

    def completa(self, interna=None):
        """Determina si la seleccion es completa (candidatos en todas las
           categorias)."""
        if get_tipo_elec("interna") and interna is not None:
            categorias = Categoria.all()
            cat_usadas = []
            for categoria in categorias:
                has_cand = Candidato.one(cod_categoria=categoria.codigo,
                                         cod_interna=interna.codigo)
                if has_cand is not None:
                    cat_usadas.append(categoria)
            len_categoria = len(cat_usadas)

        else:
            len_categoria = len(Categoria.all())
        return len(self._candidatos) == len_categoria

 def _get_categorias(self, consulta_popular=False, todas=False):
     """Devuelve las categorias para esta mesa y para esta partido en caso
     de que sea una interna no PASO."""
     if not get_tipo_elec("interna"):
         filter = {"sorted": "posicion", "consulta_popular": consulta_popular}
         if not todas:
             filter["adhiere"] = None
         categorias = Categoria.many(**filter)
     else:
         candidatos = Candidato.many(cod_partido=self.agrupacion.codigo)
         cod_cats = set([candidato.categoria.codigo for candidato in candidatos])
         filter = {"sorted": "posicion", "consulta_popular": consulta_popular, "codigo__in": cod_cats}
         if not todas:
             filter["adhiere"] = None
         categorias = Categoria.all(**filter)
     return categorias

    def validar_seleccion(self, seleccion):
        """Valida que la seleccion tiene una cantidad permitida de votos por
        categoria.

        Argumentos:
            seleccion -- un objeto de tipo seleccion
        """
        # a menos que digamos otra cosa la seleccion es valida
        selecciones_validas = True
        len_selec = 0
        categorias = Categoria.all()
        # voy a recorrer las categorias fijandome que la cantidad de votos
        # almacenados en el objeto seleccion es valida para cada una de ellas
        candidatos = seleccion.candidatos_elegidos()
        for categoria in categorias:
            len_selecciones_categoria = 0
            # sumo a la cantidad maxima de selecciones
            len_selec += int(categoria.max_selecciones)
            for candidato in candidatos:
                # si el candidato pertenece a la categoría sumo un voto para el
                # total de votos de la misma
                if candidato.cod_categoria == categoria.codigo:
                    len_selecciones_categoria += 1
            # si hay mas votos que la cantidad de selecciones maximas
            # permitidas salimos
            if len_selecciones_categoria > int(categoria.max_selecciones):
                selecciones_validas = False
                break

        return selecciones_validas and len_selec == len(candidatos)

    def _get_datos_candidatos(self):
        templates = self.seleccion.mesa.templates_impresion(
            forzar_media=self.de_muestra)
        margen_izq = self.medidas_boleta['margen_izq']  # margen izquierdo
        original_dx = margen_izq
        idx_categorias = [categoria.codigo for categoria in
                          Categoria.many(sorted="posicion")]
        categorias_usadas = []
        lineas = []
        secciones = []

        # recorro las selecciones, dibujo el cargo elegido, lista, etc.
        for candidato in self.seleccion._candidatos:
            datos = self._get_datos_candidato(candidato, templates,
                idx_categorias, categorias_usadas, lineas)
            secciones.append(datos)

        for categoria in categorias_usadas:
            index = idx_categorias.index(categoria.codigo)
            template_impresion = templates[index]
            w = template_impresion['ancho']
            h = template_impresion['alto']
            if template_impresion.get('vr', True):
                dx = original_dx + template_impresion['posicion'][0]
                dy = self.medidas_boleta['padding_selecciones'] + \
                    template_impresion['posicion'][1]
                # sep vert (sin encabezado)
                puntos = (dx + w - 1, dy, dx + w - 1, dy + h)
                lineas.append(puntos)

        return lineas, secciones

    def _get_datos_candidatos(self):
        """Devuelve los datos de los candidatos de la seleccion."""
        filter = {"sorted": "posicion"}
        mostrar_adheridas = self.config("mostrar_adheridas", self.seleccion.mesa.cod_datos)
        if not mostrar_adheridas:
            filter["adhiere"] = None

        categorias = Categoria.many(**filter)
        template = self.seleccion.mesa.template_ubic()
        candidatos = self.seleccion.candidatos_elegidos()
        if template is not None:
            cand_bloques = len([cand for cand in candidatos if cand.categoria.adhiere is None or mostrar_adheridas])
            if cand_bloques > len(template.bloques):
                template = self.seleccion.mesa.fallback_template()

        secciones = []
        if template is not None:
            categorias_usadas = []
            idx_categorias = [categoria.codigo for categoria in categorias]

            # recorro las selecciones, traigo los daots del candidato.
            for candidato in candidatos:
                if candidato.categoria.adhiere is None or mostrar_adheridas:
                    datos = self._get_datos_candidato(candidato, template, idx_categorias, categorias_usadas)
                    secciones.append(datos)

        return secciones

    def a_human(self):
        texto = "%s - %s, %s, %s (%s)\n" % (self.mesa.descripcion,
                                            self.mesa.escuela,
                                            self.mesa.municipio,
                                            self.mesa.departamento,
                                            self.mesa.codigo)
        for categoria in Categoria.many(sorted="posicion"):
            texto += "%s\n" % categoria.nombre
            for lista in Lista.many(sorted='codigo'):
                candidato = Candidato.one(cod_categoria=categoria.codigo,
                                          cod_lista=lista.codigo,
                                          titular=True,
                                          numero_de_orden=1)
                if candidato is not None:
                    votos = self._resultados[categoria.codigo,
                                             candidato.codigo]
                    texto += "\t%s - %s Votos: %s\n" % (lista.nombre,
                                                        candidato.nombre,
                                                        votos)
            texto += "\n"

        texto += "\nCampos extra:\n"
        ordered_keys = sorted(self.campos_extra.keys())
        for key in ordered_keys:
            texto += "%s: %s\n" % (key, self.campos_extra[key])

        texto += "\nListas Especiales:\n"
        ordered_keys = sorted(self.listas_especiales.keys())
        for key in ordered_keys:
            texto += "%s: %s\n" % (_("titulo_votos_%s" % key),
                                   self.listas_especiales[key])

        return texto

 def get_preludio(self):
     """Devuelve el mensaje del preludio."""
     self.categoria = Categoria.one(self.data["cod_categoria"])
     mensaje = [self.categoria.texto_asistida_ingrese_nro,
                self._("confirmando_con_e_opcion"),
                self._("las_opciones_son")]
     return mensaje

 def rellenar_de_blanco(self):
     """Agrega voto en blanco a las categorias que no fueron votadas."""
     for categoria in Categoria.many():
         if self.candidato_categoria(categoria.codigo) is None:
             blanco = Candidatura.one(cod_categoria=categoria.codigo,
                                      clase="Blanco")
             if blanco is not None:
                 self.elegir_candidato(blanco)

 def _audio_opcion(self, opcion):
     num_opcion, datos = opcion
     mensaje = [
         self._('el_candidato'),
         datos['candidato']['texto_asistida'],
         self._('para'),
         Categoria.one(datos['categoria']['codigo']).texto_asistida]
     return mensaje

def get_categorias(cod_datos, desglosada):
    if desglosada:
        current_data_code(cod_datos)
        categorias = [(c.codigo, c.nombre, c.posicion) for c in
                      Categoria.many(sorted="posicion")]
    else:
        categorias = None

    return categorias

    def get_datos_seleccion(self, seleccion):
        """Devuelve los candidatos de Una seleccion ordenados por categoria."""
        cand_seleccion = []
        for categoria in Categoria.many(sorted="posicion"):
            candidatos = seleccion.candidato_categoria(categoria.codigo)
            for candidato in candidatos:
                cand_seleccion.append(candidato.id_umv)

        return cand_seleccion

 def _get_candidatos_categoria(self, cod_categoria, cod_partido):
     key = (cod_categoria, cod_partido)
     if key in self._cache_categorias:
         cand_list = self._cache_categorias[key]
     else:
         categoria = Categoria.one(cod_categoria)
         candidatos = categoria.candidatos(cod_partido, self.agrupador)
         cand_list = [candidato.full_dict(_image_name) for candidato in candidatos]
         self._cache_categorias[key] = cand_list
     return cand_list

 def audios_mostrar_confirmacion(self, data):
     """Carga los audios de la confirmacion."""
     paneles = []
     for datum in data:
         categoria = Categoria.one(datum[0]).to_dict()
         candidato = Candidatura.one(datum[1]).to_dict()
         dict_panel = {"categoria": categoria,
                       "candidato": candidato}
         paneles.append(dict_panel)
     self.audios("mostrar_confirmacion", paneles)

    def _crear_lista_actas(self):
        """Crea la lista de la secuencia de impresion de actas."""
        actas = []
        categorias = Categoria.many(sorted="posicion")
        grupos = sorted(list(set([cat.id_grupo for cat in categorias])))

        for tipo_acta in self.orden_actas:
            for grupo in grupos:
                datos_grupo = [tipo_acta, grupo]
                actas.append(datos_grupo)
        self.logger.info("Creanda lista de actas. %s actas a imprimir",
                         len(actas))
        return actas

    def get_imagen_acta(self, tipo=None):
        if tipo is None:
            if not ACTA_DESGLOSADA:
                tipo = (SECUENCIA_CERTIFICADOS[0], None)
            elif self.sesion.recuento.cod_categoria is not None:
                tipo = (SECUENCIA_CERTIFICADOS[0],
                        self.sesion.recuento.cod_categoria)
            else:
                primera_categoria = Categoria.one(sorted="posicion").codigo
                tipo = (SECUENCIA_CERTIFICADOS[0], primera_categoria)

        imagen = self.sesion.recuento.a_imagen(tipo, de_muestra=True, svg=True)
        image_data = quote(imagen.encode("utf-8"))
        return image_data

 def imagen_consulta(self):
     """Pisamos el metodo imagen_consulta para escucharlo en vez de verlo."""
     self.modulo.seleccion = self._datos_verificacion
     categorias = Categoria.many(sorted="posicion")
     cat_list = []
     for categoria in categorias:
         cat_dict = {}
         cat_dict['categoria'] = categoria.to_dict()
         cands = self.modulo.seleccion.candidato_categoria(categoria.codigo)
         cat_dict['candidato'] = cands[0].to_dict()
         cat_list.append(cat_dict)
     self.modulo.seleccion = None
     self.asistente = AsistenteVerificacion(self, cat_list, repetir=False)
     self._imagen_verificacion = None
     self._datos_verificacion = None

 def callback(self, opcion, numero):
     if self.confirmando is None:
         self.confirmando = [opcion, numero]
         categoria = Categoria.one(opcion['cod_categoria'])
         mensaje = [self._("ud_eligio"),
                    numero,
                    self._("para"),
                    categoria.texto_asistida,
                    opcion['texto_asistida'],
                    self._("acuerdo_cancelar")]
         self._decir(mensaje)
         self.controller.cambiar_monitor()
     else:
         self.controller.seleccionar_candidatos(
             [self.confirmando[0]['cod_categoria'],
              [self.confirmando[0]['codigo']]])

    def cargar_categorias(self, force=False, force_cat=None):
        """Envia el comando de cargar categorias o el comando de mostrar
        confirmacion dependiendo del contexto.
        En caso de que haya una categoria que no se voto o se este modificando
        una categoria envia el comando "cargar_categorias" en caso de que las
        categorias ya esten llenas envia el comando de mostrar confirmacion.
        """
        cat_list = self.get_data_categorias()
        next_cat = self.get_next_cat()

        run_command = True
        if next_cat is None:
            # este es el caso en que no tenemos ninguna categoria sin candidatos
            # seleccionados.
            if force:
                if force_cat is None:
                    # si ya esta todo lleno y no forzamos ninguna categoria
                    # vamos a la primera
                    next_cat = self._get_categorias()[0].codigo
                else:
                    # este es el caso en el que forzamos una categoria
                    categoria = Categoria.one(force_cat)
                    if not categoria.consulta_popular:
                        # tenemos que ver si la categoria que forzamos esta
                        # adherida a otra categoria y cambiar por la madre en
                        # caso de que sea asi.
                        madre = categoria.get_madre()
                        if madre is not None:
                            next_cat = madre.codigo
                        else:
                            next_cat = force_cat
                    else:
                        # si la categoria que forzamos es una consulta_popular
                        # vamos a levantara en modo consulta_popular
                        self.mostrar_consulta_popular(force_cat)
                        run_command = False
            else:
                # si no hay siguiente categoria quiere decir que tenemos que
                # llamar a la confirmacion
                self.mostrar_confirmacion()
                run_command = False

        if run_command:
            # solo va a entrar aca el caso de haber una proxima categoria que no
            # sea consulta popular
            self.send_command("cargar_categorias", [cat_list, next_cat])