本文整理匯總了Python中core.logger.Logger類的典型用法代碼示例。如果您正苦於以下問題：Python Logger類的具體用法？Python Logger怎麽用？Python Logger使用的例子？那麽, 這裏精選的類代碼示例或許可以為您提供幫助。
在下文中一共展示了Logger類的15個代碼示例，這些例子默認根據受歡迎程度排序。您可以為喜歡或者感覺有用的代碼點讚，您的評價將有助於係統推薦出更棒的Python代碼示例。
示例1: authorize
def authorize(self, email):
"""
Establece el buzón receptor dado como autorizado, crea las etiquetas DUPLICADO,
GESTIONADO, PDTE REINTENTAR y ERROR en el buzón dado.
:param email: Identificador del buzón.
:return: El buzón autorizado.
"""
from pending_authorization import PendingAuthorizationManager
from core.logger import Logger
try:
entity = self.get_by_email(email)
if entity is not None:
# Marcamos el buzón como autorizado.
entity.is_authorized = True
# Añadimos la información de tracking.
entity.updated_by = self._user
entity.put()
# Obtenemos el diccionario que representa el buzón actualizado.
entity = entity.to_dict()
# Eliminamos la autorización.
PendingAuthorizationManager.delete(entity["user_id"])
except Exception as e:
Logger.error(e)
raise e
return entity示例2: apply_rule
def apply_rule(self, rule, field, message_id, label_id, resource):
"""
Busca una regla a aplicar en el subject del mensaje.
:param rule: Regla a aplicar.
:param field: Campo a aplicar la regla.
:param message_id: Identificador del mensaje.
:param label_id: Identificador de la label.
:param resource: Recurso Gmail API.
"""
from re import MULTILINE, IGNORECASE, search
from core.logger import Logger
matches = search(rule, field, MULTILINE | IGNORECASE)
if matches:
Logger.info("Labeling message: {}".format(message_id))
# Modificamos el mensaje.
resource.modify(
id=message_id,
body={
"addLabelIds": [label_id], # Añadimos la etiqueta indicada.
"removeLabelIds": ["INBOX"] # Quitamos el mensaje del inbox.
}
)
return True
return False示例3: find_messages
def find_messages(cls, email):
"""
Obtiene la lista de mensajes recibidos en el buzón.
:param email: Buzón de correo.
:return: La lista de mensajes.
"""
from clients.gmail_api import GmailApiClient
from core.logger import Logger
try:
messages = []
resource = GmailApiClient(email).messages()
page_token = None
while True:
response = resource.list(
pageToken=page_token,
includeSpamTrash=False,
q="in:inbox is:unread"
)
if "messages" in response:
for message in response["messages"]:
if not any(x for x in messages if x["id"] == message["id"]):
messages.append(message)
if "nextPageToken" in response:
page_token = response["nextPageToken"]
else:
break
except Exception as e:
Logger.error(e)
raise e
return messages示例4: authorize
def authorize(self, email):
"""
Autoriza el buzón de correo indicado.
:param email: Identificador de buzón de correo.
:return: El buzón de correo autorizado.
"""
from managers.pending_authorization import PendingAuthorizationManager
from core.logger import Logger
try:
entity = self.get_by_email(email)
if entity is not None:
Logger.info("It's authorized: {}".format(entity.is_authorized))
# Marcamos el buzón como autorizado.
entity.is_authorized = True
entity.updated_by = self._user
entity.put()
# Obtenemos el diccionario que representa el buzón actualizado.
entity = entity.to_dict()
# Eliminamos la autorización.
PendingAuthorizationManager.delete(entity["user_id"])
except Exception as e:
Logger.error(e)
raise e
return entity示例5: create
def create(email, group_id, mailbox_id):
"""
Crea la autorización pendiente para el buzón dado.
:param email: Usuario del buzón.
:param group_id: Identificador del grupo.
:param mailbox_id: Identificador del buzón.
:return: La autorización creada.
"""
from core.logger import Logger
try:
# Creamos la entidad.
entity = PendingAuthorizationDao(
id=str(email),
group_id=int(group_id),
mailbox_id=int(mailbox_id)
)
entity.put()
# Obtenemos el diccionario que representa la autorización creada.
entity = entity.to_dict()
except Exception as e:
Logger.error(e)
raise e
return entity示例6: _post_message
def _post_message(self, message):
"""
Send the given message to the Facebook Messenger platform.
:param message: The message to post.
:return: The Facebook Messenger response.
"""
from core.logger import Logger
from google.appengine.api import urlfetch
from json import dumps
try:
# Post the message to the Facebook Messenger platform.
r = urlfetch.fetch(
url=self._fb_messenger_api_url,
method=urlfetch.POST,
headers={"Content-Type": "application/json"},
payload=dumps(message)
)
# Parse the response.
response = r.content if r.status_code == 200 else None
Logger.info("Facebook response:\n%s" % response)
# In case of error.
except BaseException as e:
Logger.error(e)
response = None
# Return the parsed response.
return response示例7: wrapper
def wrapper(request_handler, *args, **kwargs):
# Almacenamos la URL de origen.
self._origin = request_handler.request.path
# Obtenemos las credenciales del usuario en sesión a partir de su almacén.
storage = self.get_storage_for_user_in_request(request_handler)
credentials = storage.get()
Logger.info("Credentials...{}".format(credentials))
Logger.info("Origin......{}".format(self._origin))
# Si no existen credenciales de usuario almacenadas o bien están caducadas.
if credentials is None or credentials.access_token_expired:
# Creamos un flujo OAuth.
self.create_flow(request_handler)
# Obtenemos la URL de autorización.
authorize_url = self._flow.step1_get_authorize_url()
# Llevamos al usuario a la pantalla de autorización.
output = request_handler.redirect(authorize_url)
# En caso contrario, ejecutamos el método decorado.
else:
output = method(request_handler, *args, **kwargs)
return output示例8: authorize
def authorize(self, email):
"""
Establece el buzón receptor dado como autorizado.
:param email: Identificador del buzón.
:return: El buzón autorizado.
"""
from pending_authorization import PendingAuthorizationManager
from core.logger import Logger
try:
entity = self.get_by_email(email)
if entity is not None:
# Marcamos el buzón como autorizado.
entity.is_authorized = True
# Añadimos la información de tracking.
entity.updated_by = self._user
entity.put()
# Eliminamos la autorización.
PendingAuthorizationManager.delete(entity.email)
except Exception as e:
Logger.error(e)
raise e
return entity.to_dict()示例9: parse_criteria
def parse_criteria(cls, criteria):
result = ''
for key in criteria:
if type(criteria[key]) == dict:
if key.upper() == 'NOT':
result += ' NOT (%s) ' % cls.parse_criteria(criteria[key])
elif key.upper() in ['AND', 'OR']:
result += ' ('
#parse each value in criteria[key] and stick key in between them
innerResults = []
for innerKey in criteria[key]:
innerResults.append(cls.parse_criteria({innerKey: criteria[key][innerKey]}))
result += key.upper().join(innerResults)
result += ') '
else:
Logger.get_logger(__name__).warn('I\'m sorry, I don\'t speak idiot. Couldn\'t parse operator declaration: %s', key)
else:
if type(criteria[key]) == str:
result += ' %s = "%s" ' % (key, criteria[key])
else:
result += ' %s = %s ' % (key, criteria[key])
if result == '':
result = '1'
return result示例10: get
def get(self):
from core.logger import Logger
# Almacenamos las credenciales de usuario contenidas en la petición.
myself.store_credentials(self)
Logger.info("Origin...{}".format(myself.get_origin()))
# Navegamos a la URL de origen.
self.redirect("/" if myself is None or myself.get_origin() is None else myself.get_origin())示例11: activateLogDir
def activateLogDir(self):
""" create the log directory and create the versions.xml file
The log dir should be avtivate only if this object is tested as a valid toad subjects
See Valifation.isAToadSubject()
"""
if not os.path.exists(self.__logDir):
self.info("creating log dir {}".format(self.__logDir))
os.mkdir(self.__logDir)
Logger.__init__(self, self.__logDir)示例12: setup
def setup(self):
Logger.log_debug("Cockroach AI")
self.item.get_tank().subscribe(self.item.get_settings().getint('events', 'lights_on'), "light_detected", self)
self.item.get_tank().subscribe(self.item.get_settings().getint('events', 'lights_off'), "safe", self)
self.LIGHT_TOLERANCE = self.item.get_settings().getint('cockroach', 'light_tolerance')
self.LIGHT_COMMENTS = self.item.get_settings().get('cockroach', 'thoughts_light').split('||')
self.COLLISION_INERCE = self.item.get_settings().getint('cockroach', 'direction_lock_duration')
self.THOUGHTS_LIGHT = self.item.get_settings().get('cockroach', 'thoughts_light').split('||')
self.item.get_tank().subscribe(pygame.KEYDOWN, "key_down", self)
self.direction_lock = 0
random.seed()示例13: get_raw_message
def get_raw_message(self):
"""
Obtiene el bruto del mensaje correspondiente a los datos almacenados en la instancia actual.
:return: Una cadena de texto con el bruto del mensaje.
"""
try:
message = self.__create_message().as_string()
raw = base64.urlsafe_b64encode(message)
except Exception as e:
Logger.error(e)
raise e
return raw示例14: __init__
def __init__(self, message, originalException=None):
"""
A generic system exception
@type message: str
@param message: The exception message
@type originalException: Exception
@param originalException: The original exception raised
"""
logger = Logger(level=logging.ERROR)
if originalException is not None:
message += "\nOriginal exception:\n\t" + originalException.message
Exception.__init__(self, message)
logger.log(message)示例15: get
def get(self):
"""
Obtiene los mensajes del buzón correspondiente al día recién cerrado.
"""
from google.appengine.api import taskqueue
from managers.sender_account import SenderAccountManager
from managers.recipient_account import RecipientAccountManager
from managers.group import GroupManager
from core.logger import Logger
from json import dumps
# Obtenemos las cuentas emisoras activas y autorizadas.
senders = filter(lambda x: x["is_active"] and x["is_authorized"], SenderAccountManager.list())
# Obtenemos las cuentas receptoras activas y autorizadas.
recipients = filter(lambda x: x["is_active"] and x["is_authorized"], RecipientAccountManager.list())
# Obtenemos los grupos activos.
active_groups = filter(lambda x: x["is_active"], GroupManager.list())
# Por cada cuenta emisora en las cuentas emisoras activas y autorizadas.
for sender in senders:
Logger.info("Sender for...{}".format(sender))
groups = []
# Por cada grupo a los cuales pertenecen las cuenta emisora.
for group in sender["groups"]:
# Si encontramos algún grupo activo de los cuales pertenece la cuenta emisora, lo almacenamos.
if any([k for k in active_groups if k["id"] == group["id"]]):
groups.append(group)
# Si hemos encontrado algún grupo activo al cual pertenezca la cuenta emisora.
if groups:
sender_recipients = []
# Por cada cuenta receptora en las cuentas receptoras activas y autorizadas.
for recipient in recipients:
# Si encontramos algúna grupo entre los cuales pertenece la cuenta receptora, que esté activo
# y a la vez en la cuenta emisora, lo almacenamos.
if filter(lambda x: x in recipient["groups"], groups):
sender_recipients.append(recipient)
Logger.info("sender-recipient...{}".format(sender_recipients))
# Creamos la task.
taskqueue.add(
queue_name="message-management",
url="/tasks/message/management",
method="POST",
params={
"recipient_accounts": dumps(sender_recipients),
"sender_account": dumps(sender)
}
)