def configure_logging(self, options): "Configure a standardized logging setup based on the verbosity option." self._verbosity = int(options['verbosity']) if not 0 <= self._verbosity <= 3: raise ValueError("Verbosity must be between 0 and 3") # Level 3 also sets the root logger to DEBUG. if self._verbosity == 3: getLogger().setLevel(logging.DEBUG)
def process_view(self, request, view_func, view_args, view_kwargs): """ Called for every view, and catches database connection issues to serve the proper maintenance page. """ try: return view_func(request, *view_args, **view_kwargs) except mongoengine.connection.ConnectionError as err: getLogger('app').error('Database access error: %s' % err) return response_service_unavailable()
def process_view(self, request, view_func, view_args, view_kwargs): """ Called for every view, and catches database connection issues to serve the proper maintenance page. """ try: return view_func(request, *view_args, **view_kwargs) except (mongoengine.connection.ConnectionError, DatabaseWriteDenied) as err: # TODO: Raise a DatabaseWriteDenied exception when trying to write to the database when in readonly mode. # Currently we rely on the developer checking settings.SITE_READ_ONLY in GET views. getLogger('app').error('Database access error: %s' % err) return response_service_unavailable()
def new(request): ''' Create a new short url based on the POST parameters ''' if 'login' in request.REQUEST and 'api_key' in request.REQUEST: login = request.REQUEST['login'] api_key = request.REQUEST['api_key'] user = User.objects(login=login, api_key=api_key).first() else: user = None if user is None: return response(status=HTTP_UNAUTHORIZED, message="Invalid credentials.") params = {} if 'long_url' in request.REQUEST: params['long_url'] = request.REQUEST['long_url'] (is_valid, error_message) = validate_url(params['long_url']) else: (is_valid, error_message) = (False, "Missing parameter: 'long_url'") if not is_valid: return response(status=HTTP_BAD_REQUEST, message=error_message) allow_slashes_in_prefix = 'allow_slashes_in_prefix' in request.REQUEST for key in ['short_path', 'prefix']: if key in request.REQUEST: params[key] = request.REQUEST[key] if '/' in params[key] and not (key == 'prefix' and allow_slashes_in_prefix): return response( status=HTTP_BAD_REQUEST, message="%s may not contain a '/' character." % key) try: link = Link.shorten(**params) getLogger('app').info('Successfully shortened %s into %s for user %s', link.long_url, link.hash, login) except ShortPathConflict, err: del params['short_path'], params['long_url'] if 'prefix' in params: del params['prefix'] params['hash'] = err.link.hash return response(status=HTTP_CONFLICT, message=str(err), **params)
def test_newsletter(request, newsletter_id): newsletter = get_object_or_404(Newsletter, id=newsletter_id) if not request.user.has_perm('can_edit_newsletter', newsletter): raise PermissionDenied dests = settings.COOP_CMS_TEST_EMAILS if request.method == "POST": try: nb_sent = send_newsletter(newsletter, dests) messages.success(request, _(u"The test email has been sent to {0} addresses: {1}").format(nb_sent, u', '.join(dests))) return HttpResponseRedirect(newsletter.get_edit_url()) except Exception, msg: messages.error(request, _(u"An error has occured.") + u'<br>' + unicode(msg)) logger = getLogger('django.request') logger.error('Internal Server Error: %s' % request.path, exc_info=sys.exc_info, extra={ 'status_code': 500, 'request': request } ) return HttpResponseRedirect(newsletter.get_edit_url())
def test_accepts_args(self): """ Ensure that user-supplied arguments and the EMAIL_SUBJECT_PREFIX setting are used to compose the email subject. Refs #16736. """ message = "Custom message that says '%s' and '%s'" token1 = 'ping' token2 = 'pong' logger = getLogger('django.request') # Inspired from regressiontests/views/views.py: send_log() # ensuring the AdminEmailHandler does not get filtered out # even with DEBUG=True. admin_email_handler = [ h for h in logger.handlers if h.__class__.__name__ == "AdminEmailHandler" ][0] # Backup then override original filters orig_filters = admin_email_handler.filters admin_email_handler.filters = [] logger.error(message, token1, token2) self.assertEqual(len(mail.outbox), 1) self.assertEqual(mail.outbox[0].to, ['*****@*****.**']) self.assertEqual(mail.outbox[0].subject, "-SuperAwesomeSubject-ERROR: Custom message that says 'ping' and 'pong'") # Restore original filters admin_email_handler.filters = orig_filters
def upload_import(request): logger = getLogger('app') if request.method == 'POST': # Provided numbers identify dives which should be imported numbers = request.POST.getlist('numbers') upload_id = request.POST.get('upload_id') upload = get_object_or_404(DiveUpload, pk=upload_id, user=request.user) try: logger.debug("Parsing dives from upload #%d" % int(upload_id)) # TODO: Parse only requested dives to improve performance dives = subsurface.parse_full(upload.data.path) logger.debug("Parsed %d dives" % len(dives)) # Save parsed dives count = 0 for dive, samples, events, sLocation in dives: if unicode(dive.number) in numbers: _save_dive(request.user, dive, samples, events, sLocation) count += 1 logger.info("Saved %d dives" % count) messages.success(request, "Successfully imported %d dives." % count) return redirect('divelog_dive_list') except ParseError as ex: logger.error(ex) messages.error(request, "Failed parsing XML file.<br />Underlying error: %s" % ex.message) return redirect('divelog_upload_view', upload_id = upload_id) raise Http404
def _save_dive(user, dive, samples, events, sLocation): logger = getLogger('app') logger.info("Saving dive %s" % dive.fingerprint) if sLocation: locations = Location.objects.filter(name=sLocation) if locations: location = locations[0] else: location = Location() location.name = sLocation location.user = user location.save() dive.location = location dive.user = user dive.size = len(samples) dive.save() for sample in samples: sample.dive = dive for event in events: event.dive = dive Sample.objects.bulk_create(samples) Event.objects.bulk_create(events)
def test_accepts_args(self): """ Ensure that user-supplied arguments and the EMAIL_SUBJECT_PREFIX setting are used to compose the email subject. Refs #16736. """ message = "Custom message that says '%s' and '%s'" token1 = 'ping' token2 = 'pong' logger = getLogger('django.request') admin_email_handler = self.get_admin_email_handler(logger) # Backup then override original filters orig_filters = admin_email_handler.filters try: admin_email_handler.filters = [] logger.error(message, token1, token2) self.assertEqual(len(mail.outbox), 1) self.assertEqual(mail.outbox[0].to, ['*****@*****.**']) self.assertEqual(mail.outbox[0].subject, "-SuperAwesomeSubject-ERROR: Custom message that says 'ping' and 'pong'") finally: # Restore original filters admin_email_handler.filters = orig_filters
def test_accepts_args_and_request(self): """ Ensure that the subject is also handled if being passed a request object. """ message = "Custom message that says '%s' and '%s'" token1 = 'ping' token2 = 'pong' logger = getLogger('django.request') admin_email_handler = self.get_admin_email_handler(logger) # Backup then override original filters orig_filters = admin_email_handler.filters try: admin_email_handler.filters = [] rf = RequestFactory() request = rf.get('/') logger.error(message, token1, token2, extra={ 'status_code': 403, 'request': request, } ) self.assertEqual(len(mail.outbox), 1) self.assertEqual(mail.outbox[0].to, ['*****@*****.**']) self.assertEqual(mail.outbox[0].subject, "-SuperAwesomeSubject-ERROR (internal IP): Custom message that says 'ping' and 'pong'") finally: # Restore original filters admin_email_handler.filters = orig_filters
def handle_exception(self, exc, request): from django.utils.log import getLogger from django.conf import settings logger = getLogger('django.request') exc_info = sys.exc_info() logger.error( 'Internal Server Error: %s', request.path, exc_info=exc_info, extra={ 'status_code': 500, 'request': request } ) resp = HttpResponse('', status=500, content_type='text/plain') resp.content = '' if hasattr(exc, 'resp_obj'): resp = exc.resp_obj resp.status_code = 500 resp.set_common_headers(request) else: resp = HttpResponse('', status=500, content_type='text/plain') resp.content = 'An error occured.' if settings.DEBUG: from django.views.debug import ExceptionReporter reporter = ExceptionReporter(request, *exc_info) resp.content = reporter.get_traceback_text() resp['Content-Type'] = 'text/plain' return resp
def _caller(*args, **kwargs): """Caller.""" logger = getLogger(**kwargs) ret_value = None # cache.add fails if if the key already exists # memcache delete is very slow, but we have to use it to take # advantage of using add() for atomic locking have_lock = lambda: str(cache.get(key)) == "true" task_lock = lambda: cache.add(key, "true", timeout) release_lock = lambda: cache.delete(key) if not have_lock(): try: task_lock() logger.debug("Lock aquired for task : %s(%s)" % (key, args)) ret_value = run_func(*args, **kwargs) except Exception as e: logger.error("The task failed to execute: %s (%s, %s)" % (e.message, type(e), e)) ret_value = e finally: if have_lock(): release_lock() logger.debug("Lock released for task: %s(%s)" % (key, args)) return ret_value else: logger.debug("The task is already locked: %s(%s)" % (key, args)) _caller = _dec
def set_logging(self, verbosity): """Set the log-level.""" log = getLogger('nsot_server') loglevel = self.get_loglevel(verbosity) log.setLevel(loglevel) self.log = log
def send_log(request, exc_info): logger = getLogger('django.request') logger.error('Internal Server Error: %s' % request.path, exc_info=exc_info, extra={ 'status_code': 500, 'request': request } )
def handle_label(self, label, **options): """ Prints count of of objects of each model for app == label """ module = __import__(label) module_models = models.get_models(getattr(module, 'models')) logger = getLogger('') for model in module_models: logger.info(u' '.join([unicode(model), unicode(model.objects.count())]))
def send_log(request, exc_info): logger = getLogger("django.request") # The default logging config has a logging filter to ensure admin emails are # only sent with DEBUG=False, but since someone might choose to remove that # filter, we still want to be able to test the behavior of error emails # with DEBUG=True. So we need to remove the filter temporarily. admin_email_handler = [h for h in logger.handlers if h.__class__.__name__ == "AdminEmailHandler"][0] orig_filters = admin_email_handler.filters admin_email_handler.filters = [] logger.error( "Internal Server Error: %s" % request.path, exc_info=exc_info, extra={"status_code": 500, "request": request} ) admin_email_handler.filters = orig_filters
def inner(*args, **kwargs): try: gen = func(*args, **kwargs) for v in gen: yield v except OperationalError as e: if getattr(settings, 'SPHINX_IMMORTAL', False): logger = getLogger("django.db.backends.sphinx") try: query = args[0].query except (IndexError, AttributeError): query = "unknown" logger.error(u"Sphinx search error at '{}'".format(query), exc_info=True) return raise
def test_truncate_subject(self): """ RFC 2822's hard limit is 998 characters per line. So, minus "Subject: ", the actual subject must be no longer than 989 characters. Refs #17281. """ message = 'a' * 1000 expected_subject = 'ERROR: aa' + 'a' * 980 self.assertEqual(len(mail.outbox), 0) logger = getLogger('django.request') logger.error(message) self.assertEqual(len(mail.outbox), 1) self.assertEqual(mail.outbox[0].subject, expected_subject)
def test_subject_accepts_newlines(self): """ Ensure that newlines in email reports' subjects are escaped to avoid AdminErrorHandler to fail. Refs #17281. """ message = u'Message \r\n with newlines' expected_subject = u'ERROR: Message \\r\\n with newlines' self.assertEqual(len(mail.outbox), 0) logger = getLogger('django.request') logger.error(message) self.assertEqual(len(mail.outbox), 1) self.assertFalse('\n' in mail.outbox[0].subject) self.assertFalse('\r' in mail.outbox[0].subject) self.assertEqual(mail.outbox[0].subject, expected_subject)
def recycle(): """ the purpose of this tasks is to recycle the data from the cache with version=2 in the main cache """ logger = getLogger('django_th.trigger_happy') all_packages = MyService.all_packages() for package in all_packages: cache = caches[package] # http://niwinz.github.io/django-redis/latest/#_scan_delete_keys_in_bulk for service in cache.iter_keys('th_*'): try: # get the value from the cache version=2 service_value = cache.get(service, version=2) # put it in the version=1 cache.set(service, service_value) # remote version=2 cache.delete_pattern(service, version=2) except ValueError: pass logger.info('recycle of cache done!')
def send_mail(accounts, subject, text_content, html_content): connection = mail.get_connection() connection.open() system_user = get_system_user() fails = 0 for account in accounts: if isinstance(account, (tuple, list)): account_email = account[1] account = account[0] else: account_email = account.email if not account_email: continue if account.id == system_user.id or account.is_bot: continue email = mail.EmailMultiAlternatives(subject, text_content, project_settings.EMAIL_NOREPLY, [account_email], connection=connection) email.attach_alternative(html_content, "text/html") try: email.send() except Exception: from django.utils.log import getLogger if not project_settings.TESTS_RUNNING: logger = getLogger('the-tale.workers.post_service_message_sender') logger.error('Exception while send email', exc_info=sys.exc_info(), extra={} ) fails += 1 connection.close() return fails == 0
def __init__(self): self._log = getLogger(__name__) if len(PanoptoMockData.app_resource_dirs) < 1: for app in settings.INSTALLED_APPS: try: mod = import_module(app) except ImportError, e: raise ImproperlyConfigured('ImportError %s: %s' % (app, e.args[0])) resource_dir = os.path.join(os.path.dirname(mod.__file__), 'resources/panopto/file') if os.path.isdir(resource_dir): # Cheating, to make sure our resources are overridable data = { 'path': resource_dir.decode(PanoptoMockData.fs_encoding), 'app': app, } if app == 'restclients': PanoptoMockData.app_resource_dirs.append(data) else: PanoptoMockData.app_resource_dirs.insert(0, data)
# GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with DjangoContribAderit. If not, see <http://www.gnu.org/licenses/>. ''' Extensions of qprocessors.py for adding new type of questions ''' __copyright__ = '''Copyright (C) 2012 Aderit srl''' from django.utils.log import getLogger from django.utils.simplejson import dumps from django.utils.translation import ugettext as _, ungettext from questionnaire import (question_proc, answer_proc, add_type, AnswerException) logger = getLogger('aderit.questionnaire_extensions.qprocessors') @question_proc('choice-select') def question_choice(request, question): choices = [] jstriggers = [] cd = question.getcheckdict() key = "question_%s" % question.number key2 = "question_%s_comment" % question.number val = None if key in request.POST: val = request.POST[key] else: if 'default' in cd: val = cd['default']
from django import forms from django.template import Context from django.template import RequestContext from django.template import loader from django.template import TemplateDoesNotExist from django.utils.html import escape from django.utils.html import conditional_escape from django.utils.log import getLogger from django.http import QueryDict from django.http import HttpResponse from django.http import HttpResponseRedirect logger = getLogger('debugging') simple_response = '''<html> <head><title>{response_string}</title></head> <body><h1>{response_string}</h1><p>{details}</p></body> </html>''' class BoolSelect(forms.Select): '''Fixed drop-down select for BOOLEAN_CHOICES''' def render_option(self, selected_choices, option_value, option_label): # Output is very much not expected. # Why in the world "selected_choices" # based on the *labels*? # logger.debug('What is selected: %s %s %s' % ( # repr(selected_choices), # repr(option_value), # repr(option_label))) option_value = option_value
# GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with DjangoContribAderit. If not, see <http://www.gnu.org/licenses/>. ''' Admin for Seantis Questionnaire extensions by Aderit. ''' __copyright__ = '''Copyright (C) 2012 Aderit srl''' from django.contrib import admin from django.forms import forms, models as forms_models from django.utils.log import getLogger from django.contrib.aderit.access_account import _get_model_from_auth_profile_module from django.contrib.aderit.questionnaire_extensions.models import Questionnaire, QuestionnaireMails logger = getLogger('aderit.questionnaire_extensions.admin') # class QuestionnaireAdmin(admin.ModelAdmin): # # fields = ('name', 'redirect_url', 'accounts') # # fields = ('name', 'redirect_url') # # filter_horizontal = ('accounts',) # def get_form(self, request, obj=None, **kwargs): # logger.debug("get_form: obj %s -- kw: %s -- self.fields: %s", # obj, kwargs, self.fields) # form_k = super(QuestionnaireAdmin, self).get_form(request, # obj=obj, # **kwargs) # acc_model = _get_model_from_auth_profile_module()
try: from threading import local except ImportError: from django.utils._threading_local import local from django.conf import settings from django.contrib.sites import models as sites_models from django.core.exceptions import MiddlewareNotUsed, ImproperlyConfigured from django.utils import log from django_tools.local_sync_cache.local_sync_cache import LocalSyncCache from django_tools.dynamic_site.models import SiteAlias USE_DYNAMIC_SITE_MIDDLEWARE = getattr(settings, "USE_DYNAMIC_SITE_MIDDLEWARE", False) logger = log.getLogger("django_tools.DynamicSite") #if "runserver" in sys.argv or "tests" in sys.argv: # log.logging.basicConfig(format='%(created)f pid:%(process)d %(message)s') # logger.setLevel(log.logging.DEBUG) # logger.addHandler(log.logging.StreamHandler()) # #if not logger.handlers: # # ensures we don't get any 'No handlers could be found...' messages # logger.addHandler(log.NullHandler()) Site = sites_models.Site # Shortcut class DynamicSiteId(object):
# Sort from biggest to lowest: AUTOUPDATECACHE_TIMES = list(AUTOUPDATECACHE_TIMES) AUTOUPDATECACHE_TIMES.sort(reverse=True) AUTOUPDATECACHE_TIMES = tuple(AUTOUPDATECACHE_TIMES) def get_max_age(load_average): """ return max age for the given load average. """ load_average += 0.1 for load, max_age in AUTOUPDATECACHE_TIMES: if load_average > load: break return max_age logger = log.getLogger("SmoothyFileBasedCache") #if "runserver" in sys.argv or "tests" in sys.argv: # log.logging.basicConfig(format='%(created)f pid:%(process)d %(message)s') # logger.setLevel(log.logging.DEBUG) # logger.addHandler(log.logging.StreamHandler()) # #if not logger.handlers: # # ensures we don't get any 'No handlers could be found...' messages # logger.addHandler(log.NullHandler()) class AutoUpdateFileBasedCache(FileBasedCache): CHANGE_TIME = None # Timestamp of the "last update" NEXT_SYNC = None # Point in the future to update the CHANGE_TIME
# You should have received a copy of the GNU General Public License # along with DjangoContribAderit. If not, see <http://www.gnu.org/licenses/>. '''Built-in, globally-available admin actions.''' from django.contrib import admin from django import template from django.contrib.admin import helpers from django.contrib.admin.util import model_ngettext from django.shortcuts import render_to_response from django.utils.encoding import force_unicode from django.utils.translation import ugettext_lazy as _ from django.utils.log import getLogger from django.http import HttpResponse import csv logger = getLogger('aderit.generic_utils.actions') def export_as_csv_action(modeladmin, request, queryset): """ Exports all selected objects from model """ opts = modeladmin.model._meta fields = [field.name for field in opts.fields] app_label = opts.app_label if request.POST.get('post'): fields_wanted = [] for i in request.POST.items(): if str(i[0]).startswith('field-'): fields_wanted.append(str(i[0])[6:]) response = HttpResponse(mimetype='text/csv')
def get_logger(): log.dictConfig(settings.LOGGING) return log.getLogger('custom')
import sys from django.conf import settings from django.contrib import messages from django.utils.safestring import mark_safe from django.utils.log import getLogger from django_tools.utils.messages import failsafe_message from pylucid_project.apps.pylucid.preference_forms import SystemPreferencesForm from pylucid_project.apps.pylucid.system import extrahead from pylucid_project.utils.escape import escape # see: http://www.pylucid.org/permalink/443/how-to-display-debug-information log = getLogger("pylucid-objects") # max value length in debug __setattr__ MAX_VALUE_LENGTH = 150 class PathInfo(object): def __init__(self, request): self.raw_path = request.path def set_url_lang_info(self, url_lang_code, url_slugs): """ set information fom the requested url. e.g.: /en/page/sub-page/ ->
''' Created on Jan 11, 2011 @author: akai ''' from django.contrib import admin import models from django.utils import log from django.conf import settings log.dictConfig(settings.LOGGING) logger = log.getLogger('custom') m = dir(models) for i in m: try: admin.site.register(getattr(models, i)) except Exception, e: pass #map(admin.site.register, map(__import__,dir(ideab.ideabuilder.models)))
from django.core.urlresolvers import reverse from django.db import models from django.db.models import Q from django.db.models.loading import get_model from django.utils.encoding import python_2_unicode_compatible from django.utils.functional import cached_property from django.utils.log import getLogger from ..files.utils import sign_s3_url from ..notifications.signals import notify from ..utils.decorators import autoconnect from ..utils.fields import ReservedKeywordsAutoSlugField from ..utils.models import BaseModel from .constants import BOARD_RESERVED_KEYWORDS logger = getLogger(__name__) @autoconnect @python_2_unicode_compatible class Board(BaseModel): name = models.CharField(max_length=255) slug = ReservedKeywordsAutoSlugField( populate_from='name', unique_with='account', editable=True, reserved_keywords=BOARD_RESERVED_KEYWORDS) account = models.ForeignKey('accounts.Account') created_by = models.ForeignKey('users.User') modified_by = models.ForeignKey('users.User',
import time if __name__ == "__main__": # For doctest only os.environ["DJANGO_SETTINGS_MODULE"] = "django.conf.global_settings" from django.conf import settings from django.core.cache.backends.db import DatabaseCache from django.core.cache.backends.filebased import FileBasedCache from django.core.cache.backends.locmem import LocMemCache from django.core.cache.backends.memcached import MemcachedCache, PyLibMCCache from django.utils import log logger = log.getLogger("django-tools.SmoothCache") if not logger.handlers: # ensures we don't get any 'No handlers could be found...' messages logger.addHandler(log.NullHandler()) #if "runserver" in sys.argv or "tests" in sys.argv: # log.logging.basicConfig(format='%(created)f pid:%(process)d %(message)s') # logger.setLevel(log.logging.DEBUG) # logger.addHandler(log.logging.StreamHandler()) SMOOTH_CACHE_CHANGE_TIME = getattr(settings, "SMOOTH_CACHE_CHANGE_TIME", "DJANGO_TOOLS_SMOOTH_CACHE_CHANGE_TIME") SMOOTH_CACHE_UPDATE_TIMESTAMP = getattr(settings, "SMOOTH_CACHE_UPDATE_TIMESTAMP", 10) SMOOTH_CACHE_TIMES = getattr(settings, "SMOOTH_CACHE_TIMES", ( # load value, max age in sec. (0, 5), # < 0.1 -> 5sec
:license: GNU GPL v3 or above, see LICENSE for more details. """ import sys import logging from django.conf import settings from django.contrib import messages from django.core.cache import cache from django.http import HttpResponse from django.utils.cache import get_max_age, patch_response_headers from django.utils.log import getLogger from django_tools.utils.importlib import get_attr_from_settings logger = getLogger("django-tools.CacheMiddleware") #logger.setLevel(logging.DEBUG) #logger.addHandler(logging.StreamHandler()) CACHE_MIDDLEWARE_ANONYMOUS_ONLY = getattr(settings, 'CACHE_MIDDLEWARE_ANONYMOUS_ONLY', False) RUN_WITH_DEV_SERVER = getattr(settings, "RUN_WITH_DEV_SERVER", "runserver" in sys.argv) EXTRA_DEBUG = getattr(settings, "CACHE_EXTRA_DEBUG", False) COUNT_FETCH_FROM_CACHE = getattr(settings, "COUNT_FETCH_FROM_CACHE", False) COUNT_UPDATE_CACHE = getattr(settings, "COUNT_UPDATE_CACHE", False) COUNT_IN_CACHE = getattr(settings, "COUNT_IN_CACHE", False) cache_callback = get_attr_from_settings("CACHE_CALLBACK",
from __future__ import unicode_literals from __future__ import absolute_import import datetime import time import arrow from celery import shared_task from django.conf import settings from django_th.services import default_provider from django_th.models import TriggerService from django.utils.log import getLogger # create logger logger = getLogger('django_th.trigger_happy') default_provider.load_services() def update_trigger(service): """ update the date when occurs the trigger """ now = arrow.utcnow().to(settings.TIME_ZONE).format('YYYY-MM-DD HH:mm:ss') TriggerService.objects.filter(id=service.id).update(date_triggered=now) def to_datetime(data): """ convert Datetime 9-tuple to the date and time format
# -*- coding: utf-8 -*- # vim: set fileencoding=utf-8 : from django.conf import settings from django.db.models import fields as models_fields from django.contrib.auth.models import User from django.core.validators import RegexValidator from django.utils.log import getLogger from django.utils.translation import ugettext_lazy as _ from django.contrib.aderit.access_account.models import AccessAccount from django.contrib.aderit.generic_utils.models.fields import \ GenericPhoneField as PhoneField logger = getLogger('account.models') ### User Profile Model class Account(AccessAccount): phone = PhoneField(_("Phone"), max_length=125, blank=True) # home phone mobile_phone = PhoneField(_("Mobile Phone"), max_length=125, blank=True) # mobile phone reported_by = models_fields.CharField(_("Reported By"), max_length=250, blank=True) # who spoke about class Meta: verbose_name = _('Account') verbose_name_plural = _('Accounts') ordering = ["user"] def __unicode__(self): return self.user.username
from django.utils.log import getLogger from django.views.generic import RedirectView # 2. 3rd parties from lxml import etree import magic # 3. system import sys, os, shutil, datetime, pprint, re, uuid import logging # 4. my import models, views # constants log = getLogger('app') mime = magic.open(magic.MIME_TYPE) mime.load() etree.register_namespace('D', 'DAV:') etree.register_namespace('M', 'urn:schemas-microsoft-com:') etree.register_namespace('A', 'http://apache.org/dav/props/') locks = dict() # id: (token:str, timeout:datetime) LOCK_MAX_TIMEOUT = 300 def __url2path(url): ''' ? Depth ? Converts requested URL into real path @return tuple - (ok, File() or None, filename:str or None)
# django_th classes from django_th.services.services import ServicesMgr from th_instapush.models import Instapush as InstapushModel """ handle process with instapush put the following in settings.py TH_SERVICES = ( ... 'th_instapush.my_instapush.ServiceInstapush', ... ) """ logger = getLogger("django_th.trigger_happy") class ServiceInstapush(ServicesMgr): """ Service Instapush """ def __init__(self, token=None, **kwargs): super(ServiceInstapush, self).__init__(token, **kwargs) self.token = token def read_data(self, **kwargs): """ get the data from the service as the pocket service does not have any date
:copyleft: 2011-2015 by the django-tools team, see AUTHORS for more details. :license: GNU GPL v3 or above, see LICENSE for more details. """ from __future__ import absolute_import, division, print_function import sys import time import datetime from django.conf import settings from django.core import cache from django.utils import log logger = log.getLogger("django_tools.local_sync_cache") #if "runserver" in sys.argv or "tests" in sys.argv: # log.logging.basicConfig(format='%(created)f pid:%(process)d %(message)s') # logger.setLevel(log.logging.DEBUG) # logger.addHandler(log.logging.StreamHandler()) #if not logger.handlers: # # ensures we don't get any 'No handlers could be found...' messages # logger.addHandler(log.NullHandler()) LOCAL_SYNC_CACHE_BACKEND = getattr(settings, "LOCAL_SYNC_CACHE_BACKEND", "local_sync_cache") def _get_cache():
import datetime import simplejson # Create your views here. from django.contrib.auth import authenticate, login from django.views.generic import View, ListView, DetailView from django.views.generic.base import TemplateView from django.core import serializers from django.http import HttpResponse from django.template import RequestContext from django.shortcuts import render_to_response from django.utils.log import getLogger from sensordata import models logger = getLogger("app") ######################################################################### # # Group of Home views # def ping(request): msg = "pong %s" % (datetime.datetime.now()) logger.info(msg) return HttpResponse(msg) class HomePageView(TemplateView): template_name = "home.html" def get_context_data(self, **kwargs):
from django.conf import settings from django.core import signals from django.core.cache import cache from django.template import RequestContext from django.template.loader import render_to_string from django.utils.http import urlquote from django.utils.log import getLogger from django.utils.translation import get_language, ugettext as _ from merengue.block.models import RegisteredBlock from merengue.registry import params from merengue.registry.items import RegistrableItem from merengue.registry.signals import item_registered logger = getLogger('merengue.block') # block information for debugging purposes block_debug_info = {} class BaseBlock(RegistrableItem): model = RegisteredBlock singleton = False is_addable = True cache_allowed = True default_caching_params = { 'enabled': False, 'only_anonymous': False, 'timeout': 0, 'vary_on_url': False,
import socket, sys, traceback, datetime, re import settings from django.core.mail import send_mail from django import http from django.shortcuts import Http404, render from django.utils.log import getLogger logger = getLogger('django.request') mailto_list = getattr(settings, 'ERROR_SNIPPET_EMAILS', []) from_addr = getattr(settings, 'DEFAULT_FROM_EMAIL', "admin@localhost") class error_ping(object): """ This is a middleware class that sends short email snippets per uncaught exception """ def process_exception(self, request, exception): if isinstance(exception, Http404): return None username = request.user.username if request.user.is_authenticated() else "Anonymous" datestring = datetime.datetime.isoformat(datetime.datetime.now()) user_agent = request.META.get('HTTP_USER_AGENT', 'NO USER AGENT FOUND') exc_info = sys.exc_info() (type, value, tb) = exc_info (path, lineno, exc, text) = traceback.extract_tb(tb)[-1] email_subj = "%s on %s" % (repr(exception), repr(socket.gethostname())) email_subj = re.sub(r'\n','',email_subj) email_msg = "User: %s\nTime: %s\nUser-agent: %s\nFile path %s:%d\nLine text: %s\n" % (username, datestring, user_agent, path, lineno, text) send_mail(email_subj, email_msg, from_addr, mailto_list) del tb
# -*- coding: utf-8 -*- from django.http import HttpResponseRedirect, HttpResponse, Http404 from django.utils.translation import ugettext as _ from django.utils.log import getLogger from django.contrib.auth.decorators import permission_required, login_required from django.shortcuts import get_object_or_404 from django.views.generic import ListView, DetailView from models import Product, ProductForm from TeaScrum.utils import render logger = getLogger('TeaScrum') @permission_required('product.add_product') def edit_product(request, pid=None): """ Show an edit form for a Product entity. """ if not pid: pid = request.REQUEST.get('pid', None) if pid: product = get_object_or_404(Product, pk=pid) if not product.owner_or_master(request.user): return render(request, 'error', {'err': _('Permission denied')}) else: product = None if request.method == 'POST': form = ProductForm(request.POST, instance=product) if form.is_valid():
import psycopg2 as Database import psycopg2.extensions except ImportError, e: from django.core.exceptions import ImproperlyConfigured raise ImproperlyConfigured("Error loading psycopg2 module: %s" % e) DatabaseError = Database.DatabaseError IntegrityError = Database.IntegrityError psycopg2.extensions.register_type(psycopg2.extensions.UNICODE) psycopg2.extensions.register_adapter(SafeString, psycopg2.extensions.QuotedString) psycopg2.extensions.register_adapter(SafeUnicode, psycopg2.extensions.QuotedString) logger = getLogger('django.db.backends') def utc_tzinfo_factory(offset): if offset != 0: raise AssertionError("database connection isn't set to UTC") return utc class CursorWrapper(object): """ A thin wrapper around psycopg2's normal cursor class so that we can catch particular exception instances and reraise them with the right types. """ def __init__(self, cursor): self.cursor = cursor
from django.contrib.auth import REDIRECT_FIELD_NAME from django.contrib.auth.decorators import (login_required, permission_required, user_passes_test) _DEFAULT_CACHE_TIMEOUT = getattr(settings, 'CACHE_MIDDLEWARE_SECONDS', 3600) _UNCLEANABLE_COOKIES = getattr(settings, 'UNCLEANABLE_COOKIES', ['__utmz', 'sessionid', 'csrftoken', '__utma']) class GenericUtilUseDecoratorError(Exception): """Illegal use of decorators in GenericUtilView""" pass logger = getLogger('aderit.generic_utils.views') def _setup_attrs(self, debug=False, **attrs): '''setattr @attrs on @self''' for k in attrs.keys(): if getattr(self, 'force_setup_attrs', False) or hasattr(self, k): setattr(self, k, attrs.get(k)) if debug is True: logger.debug("setattr done: %s ==> %s", k, attrs.get(k)) class GenericUtilView(View): '''Decoratable View''' debug_dispatch_method = False debug_dispatch_method_full = True
# GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with DjangoContribAderit. If not, see <http://www.gnu.org/licenses/>. '''Sending mails utility functions.''' __copyright__ = '''Copyright (C) 2012 Aderit srl''' from django.conf import settings from django.core.mail.backends.smtp import EmailBackend from django.core.mail.backends.base import BaseEmailBackend from django.utils.log import getLogger from django.contrib.aderit.send_mail.utils import send_email_msg from django.contrib.aderit.send_mail.models import SendMail logger = getLogger("aderit.send_mail") class SendTypeMailError(Exception): '''Error for SendTypeMail family functions''' def __repr__(self): return "Invalid parameters" def _SendTypeMail(kwargs, in_bulk=False): """ il dizionario kwargs prevede due khiavi obbligatorie: 'type' e 'mailto' 'type' : deve essere il valore di `type_mail' nel SendMail model 'mailto' : deve essere la LISTA dei destinatari Il dizionario @kwargs è del tipo:
""" Middleware for authentication. """ from django.contrib.auth import backends, middleware from django.conf import settings from django.core.exceptions import ValidationError from django.core.validators import EmailValidator from django.utils.log import getLogger from ..util import normalize_auth_header log = getLogger('nsot_server') class EmailHeaderMiddleware(middleware.RemoteUserMiddleware): header = normalize_auth_header(settings.USER_AUTH_HEADER) class EmailHeaderBackend(backends.RemoteUserBackend): """Custom backend that validates username is an email.""" def authenticate(self, remote_user): """Override default to return None if username is invalid.""" if not remote_user: return username = self.clean_username(remote_user) if not username: return return super(EmailHeaderBackend, self).authenticate(remote_user)
# -*- coding: utf-8 -*- from apps.core.models import Selection_Entity, Entity from apps.core.extend.paginator import ExtentPaginator from django.utils.log import getLogger from django.views.generic import ListView from datetime import datetime, timedelta from haystack.query import SearchQuerySet log = getLogger('django') TIME_FORMAT = '%Y-%m-%d 8:00:00' def get_time_range(): if datetime.now().hour > 8: today_start = datetime.now().strftime(TIME_FORMAT) today_end = (datetime.now() + timedelta(days=1)).strftime(TIME_FORMAT) else: today_start = (datetime.now() - timedelta(days=1)).strftime(TIME_FORMAT) today_end = datetime.now().strftime(TIME_FORMAT) return today_start, today_end def get_today_Secelction(): return Selection_Entity.objects.filter(pub_time__range=(get_time_range())) class SelectionReportListView(ListView): template_name = 'management/selection_report/list.html'
from django import template from django.template.defaultfilters import stringfilter from django.utils.safestring import mark_safe import re from django.utils.log import getLogger import json from django.utils.encoding import force_text from django.conf import settings from django.template.loader import render_to_string LOGGER = getLogger(__name__) register = template.Library() def obfuscate_string(value): ''' Simple string obfuscator Source: https://github.com/morninj/django-email-obfuscator ''' return ''.join(['&#{0:s};'.format(str(ord(char))) for char in value]) @register.filter def keyvalue(d, key): """ Forms expose fields like a dict, but they don't support get() or __contains__ so we need to just call and catch KeyError """ if not hasattr(d, '__getitem__'): return None try:
from the_tale.linguistics import prototypes from the_tale.linguistics.lexicon import keys from the_tale.linguistics.lexicon.relations import VARIABLE from the_tale.linguistics.lexicon.groups import relations as groups_relations from the_tale.linguistics.storage import game_dictionary from the_tale.linguistics.storage import game_lexicon from the_tale.linguistics.storage import restrictions_storage from . import exceptions from . import objects from . import models from .lexicon.keys import LEXICON_KEY logger = getLogger('the-tale.linguistics') def get_templates_count(): keys_count_data = prototypes.TemplatePrototype._db_filter( state=relations.TEMPLATE_STATE.IN_GAME).values('key').annotate( django_models.Count('key')) keys_count = {key: 0 for key in keys.LEXICON_KEY.records} keys_count.update({ keys.LEXICON_KEY(data['key']): data['key__count'] for data in keys_count_data }) groups_count = {
:copyleft: 2009-2011 by the PyLucid team, see AUTHORS for more details. :license: GNU GPL v3 or above, see LICENSE for more details. """ from django import http from django.contrib import messages from django.core.urlresolvers import reverse from django.shortcuts import render_to_response from django.utils.log import getLogger from django.views.decorators.csrf import csrf_exempt from pylucid_project.apps.pylucid.models import Language from pylucid_project.apps.pylucid.decorators import render_to logger = getLogger("pylucid.unittest_plugin") #_____________________________________________________________________________ # http_get_view() GET_KEY = "unittest_plugin" # plugin name ACTION_NONE_RESPONSE = "NoneResponse" ACTION_STRING_RESPONSE = "StringResponse" STRING_RESPONSE = "String response from http_get_view() unittest plugin." ACTION_HTTP_RESPONSE = "HttpResponse" HTTP_RESPONSE = "HttpResponse from unittest plugin." ACTION_REDIRECT = "RedirectResponse"
import hashlib import re from django.conf import settings from django import http from django.core.mail import mail_managers from django.utils.http import urlquote from django.core import urlresolvers from django.utils.log import getLogger logger = getLogger('django.request') class CommonMiddleware(object): """ "Common" middleware for taking care of some basic operations: - Forbids access to User-Agents in settings.DISALLOWED_USER_AGENTS - URL rewriting: Based on the APPEND_SLASH and PREPEND_WWW settings, this middleware appends missing slashes and/or prepends missing "www."s. - If APPEND_SLASH is set and the initial URL doesn't end with a slash, and it is not found in urlpatterns, a new URL is formed by appending a slash at the end. If this new URL is found in urlpatterns, then an HTTP-redirect is returned to this new URL; otherwise the initial URL is processed as usual. - ETags: If the USE_ETAGS setting is set, ETags will be calculated from the entire page content and Not Modified responses will be returned
from django import forms from django.http import Http404 from django.core.exceptions import ObjectDoesNotExist from django.core.paginator import EmptyPage from django.core.paginator import PageNotAnInteger from django.core.paginator import Paginator from django.utils.log import getLogger from main.utils import ActionView from main.utils import BoolSelect from main.models import MotionData from main.models import UserData logger = getLogger("debugging") # class MotionsView(ActionView): # def default(self): # self.data["myvar"] = "Hi there!" # return self.render_html("main/motion.html") logger = getLogger("debugging") class MotionForm(forms.ModelForm): class Meta: model = MotionData widgets = { "motion_motion_maint": BoolSelect(), "motion_run_reports": BoolSelect(), "motion_voter": BoolSelect(), "motion_admin": BoolSelect(), }
def __init__(self): self.logger = getLogger('nsot_server')
__version__ = VERSION from time import time import django from django.conf import settings if django.VERSION < (1, 7): from django.db.backends import util else: from django.db.backends import utils as util from django.utils.log import getLogger from readonly.exceptions import DatabaseWriteDenied logger = getLogger('django.db.backends') def _readonly(): return getattr(settings, 'SITE_READ_ONLY', False) def _get_readonly_dbs(): read_on_db_names = [] for db_key in getattr(settings, 'DB_READ_ONLY_DATABASES', tuple()): db = settings.DATABASES.get(db_key) if db: read_on_db_names.append(db['NAME']) return read_on_db_names
import sys from django.core.management.base import CommandError, NoArgsCommand from django.utils.log import getLogger from ...leads import sync_leads_from_profiles logger = getLogger('management_commands') class Command(NoArgsCommand): def handle_noargs(self, **options): try: sync_leads_from_profiles() except Exception as e: logger.error('sync_leads Error: ' + e.message, exc_info=sys.exc_info()) raise CommandError(e)
""" PyLucid signals ~~~~~~~~~~~~~~~ :copyleft: 2009-2013 by the PyLucid team, see AUTHORS for more details. :license: GNU GPL v3 or above, see LICENSE for more details. """ from django.utils.log import getLogger from django.dispatch.dispatcher import Signal # see: http://www.pylucid.org/permalink/443/how-to-display-debug-information log = getLogger("pylucid.signals") pre_render_global_template = Signal(providing_args=["request", "page_template"]) # post_render_global_template = django.dispatch.Signal(providing_args=["toppings", "size"]) def update_plugin_urls(sender, **kwargs): """ Would be connected in: * pylucid.models.pagetree * pylucid.models.pluginpage """ # import and connect signal here agains import loops from pylucid_project.system.pylucid_plugins import clear_plugin_url_caches
# coding: utf-8 from django.utils.log import getLogger from the_tale.game.heroes import messages logger = getLogger('the-tale.workers.game_logic') class Writer(object): __init__ = ('type', 'message', 'substitution', 'hero') def __init__(self, type, message, substitution, hero): self.type = type self.message = message self.substitution = substitution self.hero = hero def actor_id(self, actor): return 'quest_%s_actor_%s' % (self.type, actor) def name_id(self): return 'quest_%s_name' % (self.type, ) def action_id(self): return 'quest_%s_action_%s' % (self.type, self.message) def journal_id(self): return 'quest_%s_journal_%s' % (self.type, self.message)
import hashlib from django.db.backends.creation import BaseDatabaseCreation from django.db.backends.utils import truncate_name from django.db.models.fields.related import ManyToManyField from django.db.transaction import atomic from django.utils.encoding import force_bytes from django.utils.log import getLogger from django.utils import six logger = getLogger('django.db.backends.schema') class BaseDatabaseSchemaEditor(object): """ This class (and its subclasses) are responsible for emitting schema-changing statements to the databases - model creation/removal/alteration, field renaming, index fiddling, and so on. It is intended to eventually completely replace DatabaseCreation. This class should be used by creating an instance for each set of schema changes (e.g. a syncdb run, a migration file), and by first calling start(), then the relevant actions, and then commit(). This is necessary to allow things like circular foreign key references - FKs will only be created once commit() is called. """ # Overrideable SQL templates sql_create_table = "CREATE TABLE %(table)s (%(definition)s)" sql_create_table_unique = "UNIQUE (%(columns)s)"
import hashlib import operator from django.db.backends.creation import BaseDatabaseCreation from django.db.backends.utils import truncate_name from django.db.models.fields.related import ManyToManyField from django.db.transaction import atomic from django.utils.encoding import force_bytes from django.utils.log import getLogger from django.utils.six.moves import reduce from django.utils.six import callable logger = getLogger('django.db.backends.schema') class BaseDatabaseSchemaEditor(object): """ This class (and its subclasses) are responsible for emitting schema-changing statements to the databases - model creation/removal/alteration, field renaming, index fiddling, and so on. It is intended to eventually completely replace DatabaseCreation. This class should be used by creating an instance for each set of schema changes (e.g. a syncdb run, a migration file), and by first calling start(), then the relevant actions, and then commit(). This is necessary to allow things like circular foreign key references - FKs will only be created once commit() is called. """ # Overrideable SQL templates