Python get_logger示例

示例#1

文件： core.py 项目： Goblab/vot.ar

    def __init__(self, modo_local=False, hw_init=True):
        self.logger = get_logger(self.__class__.__name__)
        self.logger.debug("EHLO")

        self.config = Configuracion()
        if self.config.USAR_LOCK == 'true':
            self.lock = thread.allocate_lock()
        else:
            self.lock = None
        self.logger.debug("__init__: lock = " + str(self.lock))
        self.__set_estado_conexion(self.DESCONECTADO)
        self.__modulo_lector = ModuloLector(self._evento_tag, False)

        self._conexion = None
        self._timeout_id = None
        self._recuento_anterior = None

        self.inicializar_variables()

示例#2

    def __init__(self, modo_local=False, hw_init=True):
        self.logger = get_logger(self.__class__.__name__)
        self.logger.debug("EHLO")

        self.config = Configuracion()
        if self.config.USAR_LOCK == 'true':
            self.lock = thread.allocate_lock()
        else:
            self.lock = None
        self.logger.debug("__init__: lock = " + str(self.lock))
        self.__set_estado_conexion(self.DESCONECTADO)
        self.__modulo_lector = ModuloLector(self._evento_tag, False)

        self._conexion = None
        self._timeout_id = None
        self._recuento_anterior = None

        self.inicializar_variables()

示例#3

文件： multi_test.py 项目： Goblab/vot.ar

from msa.core import get_config
from msa.core.clases import Recuento
from msa.core.data import Ubicacion
from msa.core.data.candidaturas import Categoria
from msa.core.data.constants import NOMBRE_JSON_MESAS_DEFINITIVO
# no eliminar este import de ICODE2, el pickle lo necesita
from msa.desktop.transmision.transmision_web import TransmisionApp, Ventana
from msa.desktop.transmision.config import Configuracion
from msa.desktop.transmision.settings import (
    UBIC_MODULO, PATH_TEMPLATE_TRANSMISION)
from msa.settings import PATH_CERTS as GLOBAL_PATH_CERTS, PATH_CODIGO
from msa.tools.generadores.voto.genera_pickes_recuentos import generar
from msa.test import MSADBTest, get_test_connection


logger = get_logger("multi_test")


def esperar_evento():
    sleep(0.10)


class MockLector():
    def __init__(self, *args, **kwargs):
        pass

    def conectar(self, *args, **kwargs):
        return True

    def conectar_lector(self, *args, **kwargs):
        return True

示例#4

文件： print_controller.py 项目： Charlyzzz/vot.ar

# coding: utf-8
import dbus

from base64 import b64encode
from json import loads
from tempfile import NamedTemporaryFile

from msa import get_logger
from msa.core.settings import DBUS_BUSNAME_PRINTER, DBUS_IMPRESORA_PATH, \
        COMPRESION_IMPRESION, USA_ARMVE
from msa.core.imaging import get_dpi_boletas


logger = get_logger("dbus_client")


class DbusPrintController():
    def __init__(self):
        self.bus = dbus.SessionBus()
        self.printer = self._get_printer()
        self.tiene_papel = self._estado_inicial_tarjeta()
        self._callback_tarjeta = None
        self._signal_paper = self.registrar_estado_papel()
        self._signal_insertando = None
        self._signal_autofeed = None
        self._callback_expulsada = None

        self.printer.connect_to_signal("boleta_expulsada",
                                       self.boleta_expulsada)

    def _get_printer(self):

示例#5

文件： dbus_service.py 项目： Charlyzzz/vot.ar

# -*- coding: utf-8 -*-
import gobject

from dbus import service, SessionBus
from dbus.mainloop.glib import DBusGMainLoop

from msa import get_logger

logger = get_logger("core")


class MSADbusService(service.Object):
    """
        Clase Base para generar un servicio via DBUS.
    """

    def __init__(self, set_as_default=True):
        DBusGMainLoop(set_as_default=set_as_default)

        self.session_bus = SessionBus()
        # WARNING, NO BORRAR la asignación a la variable name aunque ésta no se
        # use, sino Dbus restartea el servicio N veces una por cada reintento
        # del cliente.
        name = service.BusName(self.bus_name, self.session_bus)
        self._real_init()
        service.Object.__init__(self, self.session_bus, self.object_path)

        self._loop = gobject.MainLoop()
        self._loop.run()
    
    def quit(self):

示例#6

文件： rfid_controller.py 项目： sunzu/vot.ar

import json
import time
import traceback

from base64 import b64decode, b64encode
from msa import get_logger

from msa.core.serial.rfid import get_lector, TAGError, SerialException
from msa.core.rfid.constants import CLASE_ICODE, CLASE_ICODE2, \
    TAGS_ADMIN, TAG_ADMIN, TAG_DATOS, TAG_VACIO, TAG_ERROR, CNX_ERROR, \
    TAG_COLISION, NO_TAG, TAG_INICIO, TAG_ADDENDUM, TAG_RECUENTO, \
    TAG_NO_ENTRA
from msa.core.serial.rfid.helpers import str2hexa2

logger = get_logger("core")


class RFIDController(object):
    """ Modulo que maneja el lector RFID.

        No esta hecho para ser usado directamente, sino para ser usado por los
        modulos que necesiten usar el lector rfid en modo automatico (ie. DBUS)
    """

    # Constantes usadas para consultar el tipo de tag detectado.

    NO_TAG = NO_TAG
    TAG_VACIO = TAG_VACIO
    TAG_DATOS = TAG_DATOS
    TAG_ERROR = TAG_ERROR

示例#7

文件： __init__.py 项目： Goblab/vot.ar

from PIL import Image

from msa import get_logger
from msa.constants import COD_LISTA_BLANCO, COD_TOTAL
from msa.core import get_config, get_tipo_elec
from msa.core.imaging.constants import RESOLUCION_BAJA, RESOLUCION_ALTA, \
    MEDIDAS_BOLETA
from msa.core.constants import DPI_VOTO_ALTA, DPI_VOTO_BAJA
from msa.core.data.candidaturas import Lista, Categoria
from msa.core.settings import IMPRESION_HD_BOLETAS
from msa.core.settings import USA_ARMVE, PATH_IMAGENES_CORE, USAR_QR, \
    PATH_TEMPLATES_BOLETAS
from msa.settings import MODO_DEMO


logger = get_logger("imaging")
env = Environment(loader=FileSystemLoader(PATH_TEMPLATES_BOLETAS))


def get_dpi_boletas():
    if IMPRESION_HD_BOLETAS:
        dpi = DPI_VOTO_ALTA
    else:
        dpi = DPI_VOTO_BAJA
    return dpi


def xml2pil(xml, width, height):
    """ Takes an SVG as input, renders via cairo and returns it as a PIL image
    """
    # http://stackoverflow.com/questions/6589358/convert-svg-to-png-in-python

示例#8

import shutil
import sys
from datetime import datetime
from random import choice, shuffle

import pyudev
import usb.core

from msa import get_logger
from msa.core.data.settings import PATH_DATOS_JSON
from msa.core.settings import (IMPRESION_USBLP, USB_PRINTER_PRODUCT_ID,
                               USB_PRINTER_VENDOR_ID)
from msa.settings import PATH_CODIGO, PATH_REPO_RECURSOS, PATH_TTS


logger = get_logger("helpers")


def touch(path):
    """
    Crea un archivo vacío
    """
    with open(path, 'a'):
        os.utime(path, None)


def crear_juego(nombre):
    """
    Crea un nuevo juego de datos
    """
    from msa.voto.settings import PATH_FOTOS_ORIGINALES

示例#9

文件： armve_controller.py 项目： Charlyzzz/vot.ar

from msa import get_logger
from msa.core.armve.constants import MSG_ERROR, AUTOFEED_SELECT
from msa.core.armve.settings import FALLBACK_2K
from msa.core.armve.helpers import array_to_string, array_to_printable_string
from msa.core.clases import Seleccion, Apertura, Autoridad, Recuento
from msa.core.imaging import ImagenPrueba
from msa.core.rfid.constants import NO_TAG, TAGS_ADMIN, TAG_ADMIN, TAG_DATOS, \
    TAG_COLISION, TAG_VACIO, CLASE_ICODE2, TIPOS_TAGS, TIPOS_TAGS_REV, \
    COD_TAG_DESCONOCIDO, TAG_VOTO, TAG_RECUENTO, COD_TAG_RECUENTO, \
    COD_TAG_INICIO, COD_TAG_ADDENDUM
from msa.core.settings import TOKEN, COMPROBAR_TOKEN
from msa.settings import QUEMA


logger = get_logger("armve_controller")


class ARMVEController(object):
    def __init__(self, parent):
        self.parent = parent
        self._getting_tag_data = False
        self._buffering = False
        self._print_on_finish = False

    def tag_leido(self, response):
        self.parent.encender_monitor()
        tipo, tag = self.get_tag(response)
        return tipo, dumps(tag)

    def _get_tag_response(self, response, index=0, multi=False):

示例#10

文件： print_service.py 项目： jadulled/vot.ar

import dbus
import gobject

from base64 import b64encode
from os import system

from msa import get_logger
from msa.core.ipc.server.dbus_service import MSADbusService
from msa.core.serial.printer import obtener_impresora
from msa.core.settings import DBUS_IMPRESORA_PATH, DBUS_BUSNAME_PRINTER, SCAN_DELAY, PATH_IPC_SERVER
from msa.helpers import levantar_locales


levantar_locales()
logger = get_logger("print_service")


class PrinterDBus(MSADbusService):
    def __init__(self):
        """Constructor"""
        self.object_path = DBUS_IMPRESORA_PATH
        self.bus_name = DBUS_BUSNAME_PRINTER
        self._conn = False
        MSADbusService.__init__(self, True)

    def _real_init(self):
        self.ultimo_estado_tarjeta = None
        self.printer = obtener_impresora()

        def _tarjeta_ingresada(callback):

示例#11

文件： __init__.py 项目： sunzu/vot.ar

import time
import os
import platform

from PIL import Image

from msa import get_logger
from msa.core.helpers import detect_printer_port
from msa.core.settings import COMPRESION_IMPRESION, USB_PRINTER_PRODUCT_ID, \
    USB_PRINTER_VENDOR_ID, USAR_CYTHON, IMPRESION_USBLP
from msa.core.imaging import get_dpi_boletas
from msa.core.constants import DPI_VOTO_BAJA, DPI_VOTO_ALTA, \
    DEBUG_IMPRESION_TEST_FILE

_usb_printer = False
logger = get_logger("impresion")

if IMPRESION_USBLP:
    try:
        import usb.core
        _usb_printer = IMPRESION_USBLP
    except ImportError:
        pass


def obtener_impresora():
    """Devuelve una clase que sabe manejar la impresora conectada."""
    if _usb_printer:
        try:
            impresora = CustomTPTUSB()
            logger.info('Usando Impresora Serial')

示例#12

from time import sleep

from msa import get_logger
from msa.core.armve.constants import MSG_ERROR, AUTOFEED_SELECT
from msa.core.armve.settings import FALLBACK_2K
from msa.core.armve.helpers import array_to_string, array_to_printable_string
from msa.core.clases import Seleccion, Apertura, Autoridad, Recuento
from msa.core.imaging import ImagenPrueba
from msa.core.rfid.constants import NO_TAG, TAGS_ADMIN, TAG_ADMIN, TAG_DATOS, \
    TAG_COLISION, TAG_VACIO, CLASE_ICODE2, TIPOS_TAGS, TIPOS_TAGS_REV, \
    COD_TAG_DESCONOCIDO, TAG_VOTO, TAG_RECUENTO, COD_TAG_RECUENTO, \
    COD_TAG_INICIO, COD_TAG_ADDENDUM
from msa.core.settings import TOKEN, COMPROBAR_TOKEN
from msa.settings import QUEMA

logger = get_logger("armve_controller")


class ARMVEController(object):
    def __init__(self, parent):
        self.parent = parent
        self._getting_tag_data = False
        self._buffering = False
        self._print_on_finish = False

    def tag_leido(self, response):
        self.parent.encender_monitor()
        tipo, tag = self.get_tag(response)
        return tipo, dumps(tag)

    def _get_tag_response(self, response, index=0, multi=False):

示例#13

文件： __init__.py 项目： jadulled/vot.ar

from PIL import Image

from msa import get_logger
from msa.core.helpers import detect_printer_port
from msa.core.settings import (
    COMPRESION_IMPRESION,
    USB_PRINTER_PRODUCT_ID,
    USB_PRINTER_VENDOR_ID,
    USAR_CYTHON,
    IMPRESION_USBLP,
)
from msa.core.imaging import get_dpi_boletas
from msa.core.constants import DPI_VOTO_BAJA, DPI_VOTO_ALTA, DEBUG_IMPRESION_TEST_FILE

_usb_printer = False
logger = get_logger("impresion")


if IMPRESION_USBLP:
    try:
        import usb.core

        _usb_printer = IMPRESION_USBLP
    except ImportError:
        pass


def obtener_impresora():
    """Devuelve una clase que sabe manejar la impresora conectada."""
    if _usb_printer:
        try:

示例#14

文件： modulos.py 项目： Goblab/vot.ar

# -*- coding:utf-8 -*-
""" Módulo que abstrae del manejo del lector de chips"""

from dbus.mainloop.glib import DBusGMainLoop
from json import loads
from base64 import b64decode

from msa import get_logger
from msa.core.ipc.client.rfid_controller import DbusLectorController

logger = get_logger("transmision-modulos")

# Constantes usadas para consultar el tipo de tag detectado.
NO_TAG = 'sin tag'
TAG_VACIO = 'tag vacio'
TAG_DATOS = 'tag con datos'
TAG_ERROR = 'error en tag'
TAG_COLISION = 'colision al leer tag'
TAG_ADMIN = 'tag admin'


class ModuloLector(object):
    """ Modulo con soporte para lector RFID.
        Lo único que pide su constructor es una función a ser llamada cuando
        se hace el polling (función callback).
        Para iniciar la consulta al lector, utilizar el método run(), para
        cerrarla, close().
    """

    def __init__(self, callback, comprobar_tag=True):
        """Constructor"""

示例#15

文件： transmision.py 项目： martjanz/vot.ar

)
from msa.desktop.transmision.helpers import (
    bloqueante,
    desbloqueante,
    mostrar_espera,
    get_desktop_path,
    actualizar_datos,
)
from msa.desktop.transmision.modulos import ModuloLector, NO_TAG, TAG_ERROR, TAG_VACIO, TAG_DATOS, TAG_ADMIN
from msa.desktop.transmision.settings import PING_EVERY, PATH_NETWORK_CONF_APP, PROTOCOLO, DEBUG
from msa.helpers import levantar_locales
from msa.core.settings import ACTA_DESGLOSADA


levantar_locales()
logger = get_logger(NOMBRE_APLICACION)
multi_test = False


class TransmisionApp(object):
    # Constantes de Estados
    DESCONECTADO = 0
    CONECTADO = 1
    AUTENTICADO = 2

    MARGEN_LECTURAS_CON_COLISION = 2
    MARGEN_LECTURAS_ERRONEAS = 2

    COLOR_OK = "#006600"
    COLOR_ERR = "#FF0000"
    COLOR_ALERTA = "#FF0000"

示例#16

from msa import get_logger
from msa.core.clases import Recuento
from msa.core.data import Ubicacion
from msa.core.data.candidaturas import Categoria
from msa.core.data.constants import NOMBRE_JSON_MESAS_DEFINITIVO
# no eliminar este import de ICODE2, el pickle lo necesita
from msa.desktop.transmision.core import TransmisionCore
from msa.desktop.transmision.config import Configuracion
from msa.desktop.transmision.settings import (UBIC_MODULO,
                                              PATH_TEMPLATE_TRANSMISION)
from msa.settings import PATH_CERTS as GLOBAL_PATH_CERTS, PATH_CODIGO
from msa.tools.generadores.voto.obtener_recuentos import obtener_tags
from msa.test import MSADBTest, get_test_connection

logger = get_logger("multi_test")

# Ajustes de timings. Esto varía depende la corrida, la conectividad, etc.
# Hay que ajustarlos de forma artesanal.
TIM_PRE_CONEXION = 1
TIM_POST_CONEXION = 5
TIM_POST_EV_TAG = 5
TIM_POST_CONFIRMACION = 4

PROCESOS = 10

# Modo solo carga
SOLO_CARGA = False


def esperar_evento():

示例#17

# -*- coding:utf-8 -*-
""" Módulo que abstrae del manejo del lector de chips"""

from dbus.mainloop.glib import DBusGMainLoop
from json import loads
from base64 import b64decode

from msa import get_logger
from msa.core.ipc.client.rfid_controller import DbusLectorController

logger = get_logger("transmision-modulos")

# Constantes usadas para consultar el tipo de tag detectado.
NO_TAG = 'sin tag'
TAG_VACIO = 'tag vacio'
TAG_DATOS = 'tag con datos'
TAG_ERROR = 'error en tag'
TAG_COLISION = 'colision al leer tag'
TAG_ADMIN = 'tag admin'


class ModuloLector(object):
    """ Modulo con soporte para lector RFID.
        Lo único que pide su constructor es una función a ser llamada cuando
        se hace el polling (función callback).
        Para iniciar la consulta al lector, utilizar el método run(), para
        cerrarla, close().
    """
    def __init__(self, callback, comprobar_tag=True):
        """Constructor"""
        self.callback = callback

示例#18

from os.path import join
from PIL import Image

from msa import get_logger
from msa.constants import COD_LISTA_BLANCO, COD_TOTAL
from msa.core import get_config, get_tipo_elec
from msa.core.imaging.constants import RESOLUCION_BAJA, RESOLUCION_ALTA, \
    MEDIDAS_BOLETA
from msa.core.constants import DPI_VOTO_ALTA, DPI_VOTO_BAJA
from msa.core.data.candidaturas import Lista, Categoria
from msa.core.settings import IMPRESION_HD_BOLETAS
from msa.core.settings import USA_ARMVE, PATH_IMAGENES_CORE, USAR_QR, \
    PATH_TEMPLATES_BOLETAS
from msa.settings import MODO_DEMO

logger = get_logger("imaging")
env = Environment(loader=FileSystemLoader(PATH_TEMPLATES_BOLETAS))


def get_dpi_boletas():
    if IMPRESION_HD_BOLETAS:
        dpi = DPI_VOTO_ALTA
    else:
        dpi = DPI_VOTO_BAJA
    return dpi


def xml2pil(xml, width, height):
    """ Takes an SVG as input, renders via cairo and returns it as a PIL image
    """
    # http://stackoverflow.com/questions/6589358/convert-svg-to-png-in-python

示例#19

#-*- coding:utf-8 -*-

from ConfigParser import SafeConfigParser

from msa import get_logger
from msa.desktop.transmision import settings


logger = get_logger("config-transmision")


class Configuracion(SafeConfigParser):

    DEFAULT_CONFIG = {'timeout': '60',
                      'host': 'transmision.comicio.com.ar',
                      'host_certs': 'operaciones.comicio.com.ar',
                      'debug': 'true',
                      'usar_lock': 'true',
                      'glade_file': 'TransmisionApp.glade',
                      'key_file': '.',
                      'cert_file': '.',
                      'ca_file': '.',
                      'validar_datos': 'false'}

    DEFAULT_SECTION = 'DEFAULT'

    def __init__(self, config_file=None):
        if config_file is None:
            config_file = settings.CONFIG_FILE
        logger.debug("levantando la config %s", config_file)

示例#20

文件： armve_service.py 项目： sunzu/vot.ar

from msa.core.armve.helpers import get_arm_port
from msa.core.armve.settings import SERIAL_TIMEOUT
from msa.core.constants import FAN_THRESHOLD_OFF
from msa.core.data import TemplateImpresion, TemplateMap, Ubicacion
from msa.core.data.candidaturas import Candidato, Categoria, Partido, Lista
from msa.core.ipc.server.armve_controller import ARMVEController
from msa.core.ipc.server.dbus_service import MSADbusService
from msa.core.temperature import get_fan_speed, get_temp
from msa.core.settings import DBUS_ARMVE_PATH, DBUS_BUSNAME_ARMVE, USAR_PIR, \
    ITERACIONES_APAGADO, DEFAULT_BRIGHTNESS, RFID_POWER, USAR_FAN
from msa.helpers import levantar_locales
from msa.settings import LOG_CAPTURE_STDOUT


levantar_locales()
logger = get_logger("armve_service")

if LOG_CAPTURE_STDOUT:
    sys.stdout = StreamToLogger(logger, INFO)
    sys.stderr = StreamToLogger(logger, ERROR)


class ARMVEDBus(MSADbusService):
    def __init__(self):
        """Constructor"""
        self.object_path = DBUS_ARMVE_PATH
        self.bus_name = DBUS_BUSNAME_ARMVE
        self._conn = False
        self.buffer = None
        self.printing = False
        self._fan_auto_mode = True

示例#21

文件： print_service.py 项目： sunzu/vot.ar

import dbus
import gobject

from base64 import b64encode
from os import system

from msa import get_logger
from msa.core.ipc.server.dbus_service import MSADbusService
from msa.core.serial.printer import obtener_impresora
from msa.core.settings import DBUS_IMPRESORA_PATH, DBUS_BUSNAME_PRINTER, \
    SCAN_DELAY, PATH_IPC_SERVER
from msa.helpers import levantar_locales


levantar_locales()
logger = get_logger("print_service")


class PrinterDBus(MSADbusService):

    def __init__(self):
        """Constructor"""
        self.object_path = DBUS_IMPRESORA_PATH
        self.bus_name = DBUS_BUSNAME_PRINTER
        self._conn = False
        MSADbusService.__init__(self, True)

    def _real_init(self):
        self.ultimo_estado_tarjeta = None
        self.printer = obtener_impresora()

示例#22

文件： helpers.py 项目： Charlyzzz/vot.ar

from msa import get_logger
from msa.settings import DEFAULT_LOCALE
try:
    from msa.voto.constants import NOMBRE_PO_VOTO
    from msa.voto.settings import PATH_LOCALE_VOTO
except ImportError:
    # En el caso de correr el armve_service.py para transmisión, en transmisión
    # no incluyo msa/voto y los import a msa.voto explotan.
    import os.path
    from msa.settings import PATH_RECURSOS
    NOMBRE_PO_VOTO = 'voto'
    PATH_LOCALE_VOTO = os.path.join(PATH_RECURSOS, 'voto', 'locale')


logger = get_logger("permisos")
_locale_actual = DEFAULT_LOCALE


def levantar_locales():
    reset_locales()


def reset_locales():
    cambiar_locale(DEFAULT_LOCALE)


def cambiar_locale(locale):
    global _locale_actual
    _locale_actual = locale
    language = translation(NOMBRE_PO_VOTO, PATH_LOCALE_VOTO, [locale])

示例#23

文件： conexion.py 项目： sunzu/vot.ar

import https_auth_handler
import time
import socket
import dns.rdataclass
import dns.resolver

from base64 import b64encode
from urllib2 import HTTPHandler, HTTPCookieProcessor, Request, HTTPError, \
    URLError, build_opener
from https_auth_handler import HTTPSClientAuthHandler
from ssl import SSLError

from msa import get_logger


logger = get_logger("trasmision-conexion")


class Respuesta(object):
    """ Esta clase es un wrapper para convertir la respuesta del servidor (un
        string) a un diccionario de claves y valores.
        Por ejemplo, si el server devuelve: 'OK',clave1=valor1&clave2=valor2,
        esta clase lo interpreta y brinda una funcion server_ok() y la
        respuesta en sí se la puede acceder usando una instancia de esta clase
        como diccionario (ej.: resp['mensaje'])
    """
    def __init__(self, respuesta_servidor):
        try:
            self._dict = json.loads(respuesta_servidor)
        except Exception as e:
            self.__codigo = 'ER'

示例#24

    MSG_ATENCION_NO_CONFIRMADAS, MSG_ERROR_LEER_CHIP, MSG_MESA_NO_HABILITADA,
    MSG_BIG_SI, MSG_BIG_NO, MSG_BIG_SPAN_COLOR, MSG_BIG_SPAN,
    MSG_BIG_SPAN_ALERT, MSG_GENERANDO_IMG, MSG_RESTO_ACTAS, ST_CONECTADO,
    ST_DESCONECTADO, ST_NO_LECTOR)
from msa.desktop.transmision.helpers import (bloqueante, desbloqueante,
                                             mostrar_espera, get_desktop_path,
                                             actualizar_datos)
from msa.desktop.transmision.modulos import ModuloLector, NO_TAG, TAG_ERROR, \
    TAG_VACIO, TAG_DATOS, TAG_ADMIN
from msa.desktop.transmision.settings import PING_EVERY, \
    PATH_NETWORK_CONF_APP, PROTOCOLO, DEBUG
from msa.helpers import levantar_locales
from msa.core.settings import ACTA_DESGLOSADA

levantar_locales()
logger = get_logger(NOMBRE_APLICACION)
multi_test = False


class TransmisionApp(object):
    # Constantes de Estados
    DESCONECTADO = 0
    CONECTADO = 1
    AUTENTICADO = 2

    MARGEN_LECTURAS_CON_COLISION = 2
    MARGEN_LECTURAS_ERRONEAS = 2

    COLOR_OK = '#006600'
    COLOR_ERR = '#FF0000'
    COLOR_ALERTA = '#FF0000'

示例#25

# coding: utf-8
import dbus
from json import loads
import gobject

from base64 import b64encode, b64decode

from msa import get_logger
from msa.core.settings import DBUS_BUSNAME_RFID, DBUS_LECTOR_PATH
from msa.core.rfid.constants import CLASE_ICODE, CLASE_ICODE2, CLASE_MIFARE


logger = get_logger("lector_client")


class DbusLectorController():
    def __init__(self, loop=None):
        self.bus = dbus.SessionBus(mainloop=loop)
        self._signal_tag = None

    def _get_lector(self, loop=None):
        try:
            lector = self.bus.get_object(DBUS_BUSNAME_RFID,
                                         DBUS_LECTOR_PATH)
        except dbus.exceptions.DBusException:
            lector = None
        return lector

    def enable_events(self):
        """ Habilita la notificación de eventos para uso automático,
            sólo funciona en ARMVE.

示例#26

文件： helpers.py 项目： sunzu/vot.ar

from gettext import translation

from msa import get_logger
from msa.settings import DEFAULT_LOCALE
try:
    from msa.voto.constants import NOMBRE_PO_VOTO
    from msa.voto.settings import PATH_LOCALE_VOTO
except ImportError:
    # En el caso de correr el armve_service.py para transmisión, en transmisión
    # no incluyo msa/voto y los import a msa.voto explotan.
    import os.path
    from msa.settings import PATH_RECURSOS
    NOMBRE_PO_VOTO = 'voto'
    PATH_LOCALE_VOTO = os.path.join(PATH_RECURSOS, 'voto', 'locale')

logger = get_logger("permisos")
_locale_actual = DEFAULT_LOCALE


def levantar_locales():
    reset_locales()


def reset_locales():
    cambiar_locale(DEFAULT_LOCALE)


def cambiar_locale(locale):
    global _locale_actual
    _locale_actual = locale
    language = translation(NOMBRE_PO_VOTO, PATH_LOCALE_VOTO, [locale])

示例#27

from base64 import b64decode
from json import loads
from PIL import Image

from msa import get_logger
from msa.core.clases import Seleccion, Apertura, Recuento, Autoridad
from msa.core.constants import DPI_VOTO_ALTA, DPI_VOTO_BAJA
from msa.core.imaging import get_dpi_boletas, ImagenPrueba
from msa.core.ipc.server.daemon import Daemon
from msa.core.serial.printer import obtener_impresora
from msa.core.settings import IMPRESION_HD_APERTURA, IMPRESION_HD_CIERRE
from msa.helpers import levantar_locales


logger = get_logger("print_or_cache")
levantar_locales()


def run(args):
    printer = obtener_impresora()
    if args.serialized is None or not args.serialized:
        logger.debug("Corriendo proceso de impresion o cache de impresion")
        logger.debug(args)
        image_file = open(args.filepath)
        data = image_file.read()
        size = [int(num) for num in args.size.split(",")]
        dpi = tuple([int(num) for num in args.dpi.split(",")])
        image = Image.fromstring(args.mode, size, data)
        printer.imprimir_image(image, dpi, args.transpose, args.compress,
                               args.only_buffer)