def whoami(request, format='json'):
if ServicesMetadata.objects.count() == 1:
services_metadata = ServicesMetadata.objects.all()[0]
_md = model_to_dict(services_metadata)
domain = Site.objects.all()[0].domain
_md['uri'] = 'http://%s' % domain
_md['sk_domain_name'] = domain
# TODO sistemare
_md['endpoint_SOS_url'] = settings.SITEURL + 'observations/sos'
else:
_md = {
'message': 'Missing metadata'
}
# software
_md['software'] = {
'ubuntu': get_ubuntu_release(),
'java': get_java_version(),
'tomcat': get_tomcat_version(),
'postgresql': get_postgres_version(),
'postgis': get_postgis_version(),
'python': sys.version,
'getit': geosk_version(),
'geonode': geonode_version(),
'pycsw': pycsw.__version__,
'django': django_version(),
'sos': get_sos_version()
}
return JsonResponse(_md)
class JobDataFuncTestFile(ACompatDataFile):
upload_to_data = job_data
job = models.ForeignKey(TestJobTwo, on_delete=models.CASCADE)
if StrictVersion('1.9.0') <= StrictVersion(
django_version()) < StrictVersion('1.10.0'):
data = models.FileField(upload_to=ADataFile.upload_to_data,
max_length=256)
def clean_content(self):
content = self.cleaned_data['content']
if not content and self.cleaned_data['is_custom']:
template_name = self.cleaned_data['template_name']
for template_loader in loader.template_source_loaders:
try:
content = template_loader.load_template_source(
template_name)[0]
break
except Exception:
continue
if django_version() >= '1.5':
from django.test.client import RequestFactory
request = RequestFactory().get('/')
else:
request = http.HttpRequest()
request.session = {}
context = template.RequestContext(
request,
{'page_slug': self.instance.title, 'page': self.instance})
if content:
try:
template.Template(content).render(context)
except Exception:
import traceback; traceback.print_exc()
raise forms.ValidationError(_("Template error detected"))
return content
def __init__(self):
self.methods = {
"PRIVMSG": self.msg,
"ACTION": self.me,
"NOTICE": self.notice,
"TOPIC": self.topic,
"RESET": self.reimport,
"MULTIPLE": self.multiple,
}
self.chanmodes = {}
self.whoreplies = {}
self.hostmask = "" # until we see ourselves speak, we do not know
self.servername = ""
self.lineRate = 1
self.versionName = "Yardbird"
self.versionNum = VERSION
udata = uname()
self.versionEnv = "Twisted %s and Django %s on %s-%s" % (
twisted_version.short(),
django_version(),
udata[0],
udata[4],
)
self.sourceURL = "http://zork.net/~nick/yardbird/ "
self.realname = "Charlie Parker Jr."
self.fingerReply = str(settings.INSTALLED_APPS)
self.l = task.LoopingCall(self.PING)
class ACompatDataFile(ADataFile):
class Meta:
abstract = True
if StrictVersion('1.10.0') <= StrictVersion(django_version()):
data = models.FileField(upload_to=ADataFile.upload_to_data,
max_length=256)
def __init__(self):
self.methods = {
'PRIVMSG': self.msg,
'ACTION': self.me,
'NOTICE': self.notice,
'TOPIC': self.topic,
'RESET': self.reimport,
'MULTIPLE': self.multiple,
}
self.chanmodes = {}
self.whoreplies = {}
self.hostmask = '' # until we see ourselves speak, we do not know
self.servername = ''
self.lineRate = 1
self.versionName = 'Yardbird'
self.versionNum = VERSION
udata = uname()
self.versionEnv = 'Twisted %s and Django %s on %s-%s' % \
(twisted_version.short(), django_version(), udata[0],
udata[4])
self.sourceURL = 'http://zork.net/~nick/yardbird/ '
self.realname = 'Charlie Parker Jr.'
self.fingerReply = str(settings.INSTALLED_APPS)
self.l = task.LoopingCall(self.PING)
def clean_content(self):
content = self.cleaned_data['content']
if not content and self.cleaned_data['is_custom']:
template_name = self.cleaned_data['template_name']
for template_loader in loader.template_source_loaders:
try:
content = template_loader.load_template_source(
template_name)[0]
break
except Exception:
continue
if django_version() >= '1.5':
from django.test.client import RequestFactory
request = RequestFactory().get('/')
else:
request = http.HttpRequest()
request.session = {}
context = template.RequestContext(request, {
'page_slug': self.instance.title,
'page': self.instance
})
if content:
try:
template.Template(content).render(context)
except Exception:
import traceback
traceback.print_exc()
raise forms.ValidationError(_("Template error detected"))
return content
def about(request):
LOGGER.debug('About page accessed', request)
server_version = connection.pg_version
env = (
{
'name': 'Python',
'version': python_version()
},
{
'name': 'Django',
'version': django_version()
},
{
'name':
'PostgreSQL',
'version':
'{:d}.{:d}.{:d}'.format(server_version // 10000,
(server_version // 100) % 100,
server_version % 100)
},
{
'name': 'Platforma',
'version': '{0}-{2}'.format(*uname())
},
)
return render(request, 'about.xhtml', {
'page_title': 'O aplikaci',
'apps': getappinfo(),
'env': env
})
def get_version():
from pootle import __version__
from translate import __version__ as tt_version
from django import get_version as django_version
return ("Pootle %s (Django %s, Translate Toolkit %s)" %
(__version__, django_version(), tt_version.sver))
def get_version():
from pootle import __version__
from translate import __version__ as tt_version
from django import get_version as django_version
return ("Pootle %s (Django %s, Translate Toolkit %s)" %
(__version__, django_version(), tt_version.sver))
def whoami(request, format='json'):
if ServicesMetadata.objects.count() == 1:
services_metadata = ServicesMetadata.objects.all()[0]
_md = model_to_dict(services_metadata)
domain = Site.objects.get_current().domain
_md['uri'] = 'http://%s' % domain
_md['sk_domain_name'] = domain
# TODO sistemare
_md['endpoint_SOS_url'] = settings.SITEURL + 'observations/sos'
else:
_md = {'message': 'Missing metadata'}
# software
_md['software'] = {
'ubuntu': get_ubuntu_release(),
'java': get_java_version(),
'tomcat': get_tomcat_version(),
'postgresql': get_postgres_version(),
'postgis': get_postgis_version(),
'python': sys.version,
'getit': geosk_version(),
'geonode': geonode_version(),
'pycsw': pycsw.__version__,
'django': django_version(),
'sos': get_sos_version()
}
return HttpResponse(json.dumps(_md, indent=2), mimetype="application/json")
def whoami(request, format='json'):
if ServicesMetadata.objects.count() == 1:
services_metadata = ServicesMetadata.objects.all()[0]
_md = model_to_dict(services_metadata)
domain = Site.objects.all()[0].domain
upurl = urlparse(os.environ['SITEURL'])
net_scheme = upurl.scheme
_md['uri'] = '%s://%s' % (net_scheme, domain)
_md['sk_domain_name'] = domain
# TODO sistemare
_md['endpoint_SOS_url'] = settings.SITEURL + 'observations/sos'
else:
_md = {'message': 'Missing metadata'}
# software
_md['software'] = {
'ubuntu': get_ubuntu_release(),
'java': get_java_version(),
'tomcat': get_tomcat_version(),
'postgresql': get_postgres_version(),
'postgis': get_postgis_version(),
'python': sys.version,
'getit': geosk_version(),
'geonode': geonode_version(),
'pycsw': pycsw.__version__,
'django': django_version(),
'sos': get_sos_version()
}
return JsonResponse(_md)
def is_django_15plus():
"""
allows us to apply functionality only in recent versions of Django.
.. testcase:: VersionsTestCase
"""
return LooseVersion(django_version()) >= LooseVersion('1.5')
def test_js_packages_with_pipeline_disabled(self):
"""Testing PipelineFormMedia.js_packages with PIPELINE_ENABLED=False"""
class MyMedia(PipelineFormMedia):
js_packages = ('scripts1', 'scripts2')
js = ('extra1.js', 'extra2.js')
media = Media(MyMedia)
script_tag = '<script type="text/javascript" src="%s"></script>' if django_version(
) < '3.1' else '<script src="%s"></script>'
self.assertEqual(MyMedia.js, [
'extra1.js',
'extra2.js',
'pipeline/js/first.js',
'pipeline/js/second.js',
'pipeline/js/application.js',
])
self.assertEqual(MyMedia.js, media._js)
self.assertEqual(media.render_js(), [
script_tag % path for path in (
'/static/extra1.js',
'/static/extra2.js',
'/static/pipeline/js/first.js',
'/static/pipeline/js/second.js',
'/static/pipeline/js/application.js',
)
])
def errapp(env, start_response):
from datetime import datetime
from django import get_version as django_version
global some_error
data = "<ul><li>{2}<li>Python: '{0}'<li>Django: '{3}'" \
"<li>some error happened: '{1}'</ul>"\
.format(sys.version, some_error, datetime.now(), django_version())
start_response("200 OK", [("Content-Type", "text/html")])
return [data]
def site(request):
"""
Adds site-related context variables to the context.
"""
return {
'DJANGO_VERSION': django_version(),
'DDTCMS_VERSION': '0.6',
'SITE_NAME': 'DDTCMS.com',
'DEBUG': settings.DEBUG,
'system_version': '0.1',
}
def get_version():
from xtle import __version__
from xtle.core.utils.version import get_git_hash
from translate import __version__ as tt_version
from django import get_version as django_version
githash = get_git_hash()
if githash:
githash = "[%s] " % githash
return ("Xtle %s %s(Django %s, Translate Toolkit %s)" %
(__version__, githash or '', django_version(), tt_version.sver))
def get_version():
from pootle import __version__
from pootle.core.utils.version import get_git_hash
from translate import __version__ as tt_version
from django import get_version as django_version
githash = get_git_hash()
if githash:
githash = "[%s] " % githash
return ("Pootle %s %s(Django %s, Translate Toolkit %s)" %
(__version__, githash or '', django_version(), tt_version.sver))
def format_error(error):
return u"Piston/%s (Django %s) crash report:\n\n%s" % \
(get_version(), django_version(), error)
json_response = dict({
"error": True,
"errorCode": 500,
"message": "Readability encountered a server error. We should have been made aware of this issue automatically. If this continues, please contact us at [email protected] and let us know under what conditions you're receiving this error."
})
if settings.DEBUG:
json_response['message'] += ' (%s)' % error
return json.dumps(json_response)
class ADataFile(models.Model):
class Meta:
abstract = True
upload_to_data = job_data
job = None # Just a placeholder for IDEs
data = None # Just a placeholder for IDEs
if StrictVersion(django_version()) < StrictVersion('1.10.0'):
# SEE: https://docs.djangoproject.com/en/1.10/topics/db/models/#field-name-hiding-is-not-permitted
job = None # Just a placeholder, Django < 1.10 does not support overriding Fields of abstract models
data = None # Just a placeholder, Django < 1.10 does not support overriding Fields of abstract models
else:
job = models.ForeignKey(
AJob, on_delete=models.CASCADE
) # placeholder, must be overridden by concrete class
data = models.FileField(upload_to=upload_to_data, max_length=256)
def site(request):
"""
Adds site-related context variables to the context.
"""
current_site = Site.objects.get_current()
current_theme = get_current_theme()
current_themename = "default"
if current_theme:
current_themename = current_theme.name
return {
'DJANGO_VERSION': django_version(),
'DDTCMS_VERSION': get_version(),
'SITE_NAME': current_site.name,
'SITE_DOMAIN': current_site.domain,
'SITE_URL': "http://www.%s" % (current_site.domain),
'SITE_TIME': datetime.datetime.now(),
'THEME_NAME': current_themename,
'DEBUG': settings.DEBUG,
}
def site(request):
"""
Adds site-related context variables to the context.
"""
current_site = Site.objects.get_current()
current_theme = get_current_theme()
current_themename = "default"
if current_theme:
current_themename= current_theme.name
return {
'DJANGO_VERSION': django_version(),
'DDTCMS_VERSION': get_version(),
'SITE_NAME': current_site.name,
'SITE_DOMAIN': current_site.domain,
'SITE_URL': "http://www.%s" % (current_site.domain),
'SITE_TIME': datetime.datetime.now(),
'THEME_NAME': current_themename,
'DEBUG': settings.DEBUG,
}
def __init__(self):
self.methods = {'PRIVMSG': self.msg,
'ACTION': self.me,
'NOTICE': self.notice,
'TOPIC': self.topic,
'RESET': self.reimport,
}
self.chanmodes = {}
self.whoreplies = {}
self.hostmask = '' # until we see ourselves speak, we do not know
self.servername = ''
self.lineRate = 1
self.versionName = 'Yardbird'
self.versionNum = VERSION
udata = uname()
self.versionEnv = 'Twisted %s and Django %s on %s-%s' % \
(twisted_version.short(), django_version(), udata[0],
udata[4])
self.sourceURL = 'http://zork.net/~nick/yardbird/ '
self.realname = 'Charlie Parker Jr.'
self.fingerReply = str(settings.INSTALLED_APPS)
def get_context_data(self, **kwargs):
"""Show system information"""
context = super().get_context_data(**kwargs)
request = self.request
info_data = {
_('Version'): {
_('Python Version'): sys.version_info.__repr__(),
_('Django Version'): django_version(),
_('Supervisr Commit'): django_settings.VERSION,
},
_('System'): {
_('uname'): platform.uname().__repr__(),
},
_('Request'): {
_('url_name'): (request.resolver_match.url_name
if request.resolver_match is not None else ''),
_('REMOTE_ADDR'):
request.META.get('REMOTE_ADDR'),
_('REMOTE_ADDR PTR'):
get_reverse_dns(request.META.get('REMOTE_ADDR')),
_('X-Forwarded-for'):
request.META.get('HTTP_X_FORWARDED_FOR'),
_('X-Forwarded-for PTR'):
get_reverse_dns(request.META.get('HTTP_X_FORWARDED_FOR')),
},
_('Settings'): {
_('Debug Enabled'):
django_settings.DEBUG,
_('Authentication Backends'):
django_settings.AUTHENTICATION_BACKENDS,
}
}
results = get_module_info.send(sender=None)
for handler, mod_info in results:
# Get the handler's root module
info_data[handler.__module__] = mod_info
context['info'] = info_data
return context
def handle_batched_events_request(request):
"""
Handles batched events POST requests.
Example batched events ::
{"email":"*****@*****.**","timestamp":1322000095,
"unique_arg":"my unique arg","event":"delivered"}
{"email":"*****@*****.**","timestamp":1322000096,
"unique_arg":"my unique arg","event":"open"}
"""
from distutils.version import LooseVersion as V
current_django_version = V(django_version())
if current_django_version >= V('1.4'):
events = json.loads(request.body.decode())
else:
events = json.loads(request.raw_post_data)
for event in events:
handle_single_event_request(event)
response = HttpResponse()
return response
def handle_batched_events_request(request):
"""
Handles batched events POST requests.
Example batched events ::
{"email":"*****@*****.**","timestamp":1322000095,
"unique_arg":"my unique arg","event":"delivered"}
{"email":"*****@*****.**","timestamp":1322000096,
"unique_arg":"my unique arg","event":"open"}
"""
from distutils.version import LooseVersion as V
current_django_version = V(django_version())
if current_django_version >= V('1.4'):
events = json.loads(request.body.decode())
else:
events = json.loads(request.raw_post_data)
for event in events:
handle_single_event_request(event)
response = HttpResponse()
return response
def home(request):
"""Top level url. Displays standard mds response containing following
information about the system :
Django version
Host OS
MDS version
Note: If Http "Accept" header is included and set to
"application/json", the returned message will be a standard MDS
response as follows:
{
'status':'SUCCESS',
'code':200,
'message': {
'django': django_version(),
'platform': u' '.join(platform.uname()[0:3]),
'version': version(),
}
}
"""
data = {
'status': 'SUCCESS',
'code': 200,
'message': {
'django': django_version(),
'platform': u' '.join(platform.uname()[0:4]),
'version': version(),
},
}
accept = request.META.get('HTTP_ACCEPT', None)
if 'application/json' in request.META.get('HTTP_ACCEPT'):
return HttpResponse(cjson.encode(data))
else:
return render_to_response('index.html', RequestContext(request, data))
def home(request):
"""Top level url. Displays standard mds response containing following
information about the system :
Django version
Host OS
MDS version
Note: If Http "Accept" header is included and set to
"application/json", the returned message will be a standard MDS
response as follows:
{
'status':'SUCCESS',
'code':200,
'message': {
'django': django_version(),
'platform': u' '.join(platform.uname()[0:3]),
'version': version(),
}
}
"""
data = {
'status':'SUCCESS',
'code':200,
'message': {
'django': django_version(),
'platform': u' '.join(platform.uname()[0:4]),
'version': version(),
},
}
accept = request.META.get('HTTP_ACCEPT',None)
if 'application/json' in request.META.get('HTTP_ACCEPT'):
return HttpResponse(cjson.encode(data))
else:
return render_to_response('index.html', RequestContext(request,data))
def format_error(error):
return u"Postal (Django %s) crash report:\n\n%s" % \
(django_version(), error)
def format_error(error):
return u"Piston/{0!s} (Django {1!s}) crash report:\n\n{2!s}".format(get_version(), django_version(), error)
def setUp(self):
if django_version() < '1.5':
self.skipTest('This test requires Django 1.5 or higher')
else:
super(CustomUserTestCase, self).setUp()
ApiKey.objects.all().delete()
def format_error(error):
return u"Piston/%s (Django %s) crash report:\n\n%s" % (get_version(), django_version(), error)
# from __future__ import unicode_literals, division from datetime import datetime from django import get_version as django_version from django.conf import settings from django.utils.timezone import get_default_timezone from quickapi import get_version as quickapi_version from reportapi import get_version as reportapi_version DEBUG = settings.DEBUG DJANGO_VERSION = django_version() REPORTAPI_VERSION = reportapi_version() QUICKAPI_VERSION = quickapi_version() PROJECT_NAME = getattr(settings, 'PROJECT_NAME', None) PROJECT_URL = getattr(settings, 'PROJECT_URL', None) REPORTAPI_DEBUG = getattr(settings, 'REPORTAPI_DEBUG', settings.DEBUG) REPORTAPI_LOGGING = getattr(settings, 'REPORTAPI_LOGGING', not settings.DEBUG) REPORTAPI_ROOT = getattr(settings, 'REPORTAPI_ROOT', '%sreports/' % settings.MEDIA_ROOT) REPORTAPI_URL = getattr(settings, 'REPORTAPI_URL', '%sreports/' % settings.MEDIA_URL) REPORTAPI_ENABLE_THREADS = getattr(settings, 'REPORTAPI_ENABLE_THREADS', False) REPORTAPI_FILES_UNIDECODE = getattr(settings, 'REPORTAPI_FILES_UNIDECODE', False) REPORTAPI_LANGUAGES = getattr(settings, 'REPORTAPI_LANGUAGES', ['en', 'ru']) REPORTAPI_UPLOADCODE_LENGTH = getattr(settings, 'REPORTAPI_UPLOADCODE_LENGTH', 12)
def powered_by_processor(request):
return {
"website_version_": website_version(),
"python_version_": python_version(),
"django_version_": django_version(),
}
def setUp(self):
if django_version() < "1.5":
self.skipTest("This test requires Django 1.5 or higher")
else:
super(CustomUserTestCase, self).setUp()
ApiKey.objects.all().delete()
def format_error(error):
return "Django Declarative APIs (Django %s) crash report:\n\n%s" % (
django_version(),
error,
)
def platform_version_info(request):
return {'version_springwhiz': SPRINGWHIZ_VERSION,
'version_python': python_version.split()[0],
'version_django': django_version()}
def __call__(self, request, *args, **kwargs):
"""
NB: Sends a `Vary` header so we don't cache requests
that are different (OAuth stuff in `Authorization` header.)
This function works as follows:
1 put post data in an easy to reach place
2 work out which view we want to call and call it
2a if there is an expected api usage exception, it handles catching it and retuning the appropriate details
2b if there is an unexpected failure in the view, it will catch that and log it
3 construct the response, using the appropriate amount of detail
4 render the response to json
"""
logging.info(" >>>> framework resource (enter)")
# try to keep as much in the try block as possible, as we want pretty error messages at the least
try:
# try to find the user_id
try:
request.user_id = self.auth(request)
except AttributeError:
pass
rm = request.method.upper()
handler = self.handler
handler.status = None # reset status
# Translate nested datastructs into `request.data` here.
if rm in ('POST', 'PUT'):
mimer = Mimer()
mimer.translate(request)
method_string = self.callmap.get(rm, None)
if method_string is None:
raise NotImplemented(rm)
meth = getattr(handler, method_string, False)
# tries to call the view
logging.info("%s: %s" % (handler.__class__.__name__, self.callmap.get(rm)))
result = meth(request, *args, **kwargs)
# construct the response using the appropriate detail then render to json
output_format = request.REQUEST.get('output','default')
try:
output_emitter = self.output[output_format]
except:
raise InvalidParameter("emission type", value=outputformat, fix="choose from [%s]" % "/".join(self.output.keys))
emitter = output_emitter(request=request)# give request so we can lazily load the user only if necessary
mimetype = emitter.mimetype
construct = emitter._construct(data=result)
stream = emitter.render({'data':construct})
if handler.status is None:
status = 200
else:
status = handler.status
except (APIException) as e:
stream = json.dumps(e.returnerror, indent=4)
status = e.status
mimetype = "application/json"
except Exception as e: #keep this stuff simple so we KNOW it works
logging.exception("Exception in API %s" % str(e))
status = 500
if settings.DEBUG:
stream = json.dumps({'error':{
'type':"APIError",
'message':("API (Django %s) crash report:\n\n%s" %
(django_version(), str(traceback.format_exc())))}}, indent=4)
mimetype = "application/json"
else:
stream = json.dumps({'error':{
'type':"APIError",
'message':"An API error has occured, please try again later."}}, indent=4)
mimetype = "application/json"
#logging.info(stream)
resp = HttpResponse(stream, mimetype=mimetype, status=status)
logging.info(" <<<< framework resource (exit)")
return resp
import platform
import os
import tarfile
from django.test import TestCase
from django.core.files import File
from django.http import HttpResponse
from django.test.client import RequestFactory
from django.core.files.base import ContentFile
from django import get_version as django_version
from tarview.views import BaseTarView
delete_zip = True # if you want to check them manually
name = "/tmp/test_py-%s_dj-%s.tar" % (platform.python_version(),
django_version())
class TarView(BaseTarView):
"""Test TarView basic implementation."""
_files = None
def get_files(self):
if self._files is None:
dirname = os.path.dirname(__file__)
self._files = [
File(open(os.path.join(dirname, 'test_file.txt')),
name="test_file.txt"),
File(open(os.path.join(dirname, 'test_file.odt')),
name="test_file.odt"),
ContentFile(b"Littlepip is best pony!",
import gzip
from io import BytesIO
from django import get_version as django_version
_CACHED_STATIC_FILES_STORAGE_AVAILABLE = django_version() < '3.1'
if _CACHED_STATIC_FILES_STORAGE_AVAILABLE:
from django.contrib.staticfiles.storage import CachedStaticFilesStorage
from django.contrib.staticfiles.storage import ManifestStaticFilesStorage, StaticFilesStorage
from django.contrib.staticfiles.utils import matches_patterns
from django.core.files.base import File
class PipelineMixin(object):
packing = True
def post_process(self, paths, dry_run=False, **options):
if dry_run:
return
from pipeline.packager import Packager
packager = Packager(storage=self)
for package_name in packager.packages['css']:
package = packager.package_for('css', package_name)
output_file = package.output_filename
if self.packing:
packager.pack_stylesheets(package)
paths[output_file] = (self, output_file)
from .. import conf
from .. import __version__ as library_version
if not hasattr(settings, 'UPLOADCARE'):
raise ImproperlyConfigured('UPLOADCARE setting must be set')
if 'pub_key' not in settings.UPLOADCARE:
raise ImproperlyConfigured('UPLOADCARE setting must have pub_key')
if 'secret' not in settings.UPLOADCARE:
raise ImproperlyConfigured('UPLOADCARE setting must have secret')
conf.pub_key = settings.UPLOADCARE['pub_key']
conf.secret = settings.UPLOADCARE['secret']
conf.user_agent_extension = 'Django/{0}; PyUploadcare-Django/{1}'.format(
django_version(), library_version)
if 'cdn_base' in settings.UPLOADCARE:
conf.cdn_base = settings.UPLOADCARE['cdn_base']
widget_version = settings.UPLOADCARE.get('widget_version', '3.x')
widget_build = settings.UPLOADCARE.get(
'widget_build', settings.UPLOADCARE.get('widget_variant', 'full.min'))
widget_filename = 'uploadcare.{0}.js'.format(widget_build).replace('..', '.')
hosted_url = ('https://ucarecdn.com/libs/widget/{version}/{filename}'.format(
version=widget_version, filename=widget_filename))
local_url = 'uploadcare/{filename}'.format(filename=widget_filename)
def is_pre_django2():
"""
Quick check if the used django version is pre 2.0
"""
return tuple(int(n) for n in django_version().split('.')) <= (2, 0, 0)
class BaseSettings():
PROJECT_VERSION = __version__
DJANGO_VERSION = django_version() # created at 3.1.3
PROJECT_NAME = 'qzandronum'
PROJECT_DIR = Path(__file__).resolve().parent
# Build paths inside the project like this: BASE_DIR / 'subdir'.
@property
def BASE_DIR(self):
return self.PROJECT_DIR.parent
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/3.1/howto/deployment/checklist/
# SECURITY WARNING: keep the secret key used in production secret!
@cbs.env
def SECRET_KEY(self):
'''Gets its value from os.environ['DJANGO_SECRET_KEY']'''
print('!!! ENV KEY failed, will use dummy')
return 'chzoay@llvwf-)u84#h5e(y7(=tr)oko9_+^-q8wch&02_$fw)'
# SECURITY WARNING: don't run with debug turned on in production!
@cbs.env(key='DEBUG')
def DEBUG(self):
return True
ALLOWED_HOSTS = ['*']
# Application definition
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
# 'django.contrib.sites', # needed for sitemap framework
'debug_toolbar',
'sniplates',
'celestia',
'core',
'builds',
'chunked_upload',
'django.contrib.staticfiles',
]
SITE_ID = 1 # needed for sites framework
MIDDLEWARE = [
'django.middleware.security.SecurityMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'debug_toolbar.middleware.DebugToolbarMiddleware',
'django.middleware.locale.LocaleMiddleware',
'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
]
ROOT_URLCONF = 'qzandronum.urls'
SETTING_CONTEXT_NAMES = (
'PROJECT_VERSION',
'DJANGO_VERSION',
# 'COMMON_SCRIPTS',
# 'COMMON_STYLES',
)
TEMPLATES = [
{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': [],
'APP_DIRS': True,
'OPTIONS': {
'context_processors': [
'django.template.context_processors.debug',
'django.template.context_processors.request',
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
'celestia.context_processors.setting',
],
},
},
]
WSGI_APPLICATION = 'qzandronum.wsgi.application'
STYLES_APP = 'core'
CELESTIA_STATIC_APPS = ('core', )
MAIN_STYLE_FILENAME = 'main'
CELESTIA_ALLOWED_NESTED_EXTS = ("tar", )
# Database
# https://docs.djangoproject.com/en/3.1/ref/settings/#databases
@property
def DATABASES(self):
return {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': self.BASE_DIR / 'qzandronum.sqlite3',
}
}
# Auth
AUTH_USER_MODEL = 'core.CoreUser'
LOGIN_URL = '/auth/login/'
LOGIN_REDIRECT_URL = '/'
# Password validation
# https://docs.djangoproject.com/en/3.1/ref/settings/#auth-password-validators
AUTH_PASSWORD_VALIDATORS = [
{
'NAME':
'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
},
{
'NAME':
'django.contrib.auth.password_validation.MinimumLengthValidator',
},
{
'NAME':
'django.contrib.auth.password_validation.CommonPasswordValidator',
},
{
'NAME':
'django.contrib.auth.password_validation.NumericPasswordValidator',
},
]
# Internationalization
# https://docs.djangoproject.com/en/3.1/topics/i18n/
LANGUAGE_CODE = 'en'
TIME_ZONE = 'Europe/Moscow' # 'UTC'
USE_I18N = True
USE_L10N = True
USE_TZ = True
LANGUAGES = [
('en', _('English')),
('ru', _('Russian')),
]
LOCALE_PATHS = [PROJECT_DIR / 'locale']
# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/3.1/howto/static-files/
# WARNING! Cast to Path!
@cbs.env(cast=Path)
def WEB_ROOT(self):
""" This is not standart setting, there are different approaches to put your
media and static files, some are confusing, I prefer to put it outside of
project dir, e.g. /srv/www/
"""
return self.BASE_DIR / 'webfiles'
@property
def STATIC_ROOT(self):
return self.WEB_ROOT / 'static'
@property
def MEDIA_ROOT(self):
return self.WEB_ROOT / 'media'
STATIC_URL = '/static/'
MEDIA_URL = '/files/'
CHUNKED_UPLOAD_PATH = 'builds_chunks/%Y-%m/'
CHUNKED_UPLOAD_MAX_BYTES = 2147483648 # 2GB
LOGGING = {
'version': 1,
'disable_existing_loggers': False,
'handlers': {
'console': {
'class': 'logging.StreamHandler',
},
},
'django': {
'handlers': ['console'],
'propagate': True,
'level': 'DEBUG',
},
}
def format_error(error):
return u"Piston/%s (Django %s) crash report:\n\n%s" % \
(get_version(), django_version(), error)
import platform
import os
import tarfile
from django.test import TestCase
from django.core.files import File
from django.http import HttpResponse
from django.test.client import RequestFactory
from django.core.files.base import ContentFile
from django import get_version as django_version
from tarview.views import BaseTarView
delete_zip = True # if you want to check them manually
name = "/tmp/test_py-%s_dj-%s.tar" % (platform.python_version(),django_version())
class TarView(BaseTarView):
"""Test TarView basic implementation."""
_files = None
def get_files(self):
if self._files is None:
dirname = os.path.dirname(__file__)
self._files = [
File(open(os.path.join(dirname, 'test_file.txt')), name="test_file.txt"),
File(open(os.path.join(dirname, 'test_file.odt')), name="test_file.odt"),
ContentFile(b"Littlepip is best pony!", name="test_file_manual.txt")
]
return self._files
from distutils.version import StrictVersion
from django import get_version as django_version
DEBUG = True
INSTALLED_APPS = (
# defaults from django 1.8
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
# end
'django-dia',
'test_project.anyapp',
)
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': 'testdb',
}
}
SECRET_KEY = 'mblqnc+y=9^c$44!!r9b!fw$a95@p_m31o7r3+9w4h&@tu)wps'
if StrictVersion(django_version()) < StrictVersion('1.9'):
MIDDLEWARE_CLASSES = ()
from .. import __version__ as library_version
if not hasattr(settings, 'UPLOADCARE'):
raise ImproperlyConfigured('UPLOADCARE setting must be set')
if 'pub_key' not in settings.UPLOADCARE:
raise ImproperlyConfigured('UPLOADCARE setting must have pub_key')
if 'secret' not in settings.UPLOADCARE:
raise ImproperlyConfigured('UPLOADCARE setting must have secret')
conf.pub_key = settings.UPLOADCARE['pub_key']
conf.secret = settings.UPLOADCARE['secret']
conf.user_agent_extension = 'Django/{0}; PyUploadcare-Django/{1}'.format(
django_version(), library_version)
if 'cdn_base' in settings.UPLOADCARE:
conf.cdn_base = settings.UPLOADCARE['cdn_base']
widget_version = settings.UPLOADCARE.get('widget_version', '3.x')
widget_build = settings.UPLOADCARE.get(
'widget_build',
settings.UPLOADCARE.get('widget_variant', 'full.min'))
widget_filename = 'uploadcare.{0}.js'.format(widget_build).replace('..', '.')
hosted_url = (
'https://ucarecdn.com/libs/widget/{version}/{filename}'
.format(version=widget_version, filename=widget_filename))
from django import get_version as django_version
DEBUG = True
INSTALLED_APPS = (
# defaults from django 1.8
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
# end
'django-dia',
'test_project.anyapp',
)
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': 'testdb',
}
}
SECRET_KEY = 'mblqnc+y=9^c$44!!r9b!fw$a95@p_m31o7r3+9w4h&@tu)wps'
if StrictVersion(django_version()) < StrictVersion('1.9'):
MIDDLEWARE_CLASSES = ()
def check_prerequisites():
print 'Checking prerequisites...'
print ' - Checking Python version (>= 2.3.0):',
print '%i.%i.%i' % sys.version_info[0:3],
if sys.version_info >= (2, 3, 0):
print '-> OK'
else:
print '-> FAILED'
return False
print ' - Checking Django version (>= 1.0.2):',
try:
from django import get_version as django_version
print django_version(),
if tuple(django_version().split('.')) >= (1, 0, 2):
print '-> OK'
else:
print '-> FAILED'
return False
except:
print 'Not installed'
print
print 'Go to http://www.djangoproject.com to download and install Django'
return False
print ' - Checking MySQLdb version (>= 1.2.2):',
try:
from MySQLdb import version_info as mysqldb_version
print '%i.%i.%i' % mysqldb_version[0:3],
if mysqldb_version >= (1, 2, 2):
print '-> OK'
else:
print '-> FAILED'
return False
except:
print 'Not installed'
print
print 'Go to http://sourceforge.net/projects/mysql-python to download and install MySQLdb'
return False
print ' - Checking git-python version (>= 0.1.6):',
try:
import git
print git.__version__,
if tuple(git.__version__.split('.')) >= ('0', '1', '6'):
print '-> OK'
else:
print '-> FAILED'
return False
except:
print 'Not installed'
print
print 'Go to http://gitorious.org/git-python to download and install git-python'
return False
print ' - Checking Pygments version (>= 1.1):',
try:
import pygments
print pygments.__version__,
if tuple(pygments.__version__.split('.')) >= ('1', '1'):
print '-> OK'
else:
print '-> FAILED'
print
print 'Go to http://pygments.org to download a newer Pygments version (you might need to download the development version using Mercurial)'
return False
except:
print 'Not installed'
print
print 'Go to http://pygments.org to download Pygments (you might need to download the development version using Mercurial)'
return False
print ' - Checking PHP version (>= 4.3.3):',
p = subprocess.Popen("php --version", shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
if p.wait() != 0:
print 'Not installed'
return False
m = re.search('^PHP (?P<version>\d\.\d\.\d) ?', p.stdout.readlines()[0])
print m.group('version'),
if tuple(m.group('version').split('.')) >= ('4', '3', '3'):
print '-> OK'
else:
print '-> FAILED'
return False
print ' - Checking MySQL version (>= 4.1):',
p = subprocess.Popen("mysql --version", shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
if p.wait() != 0:
print 'Not installed'
return False
m = re.search('Distrib (?P<version>\d\.\d\.\d) ?', p.stdout.readlines()[0])
print m.group('version'),
if tuple(m.group('version').split('.')) >= ('4', '1'):
print '-> OK'
else:
print '-> FAILED'
return False
print ' - Checking Git version (>= 1.5.0):',
p = subprocess.Popen("git --version", shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
if p.wait() != 0:
print 'Not installed'
return False
m = re.search('git version (?P<version>\d\.\d\.\d) ?', p.stdout.readlines()[0])
print m.group('version'),
if tuple(m.group('version').split('.')) >= ('1', '5', '0'):
print '-> OK'
else:
print '-> FAILED'
return False
print
print """Optional requirements:
If you want to enable the embedded math formulas on the wiki, the following
is needed (from the README):
OCaml 3.06 or later is required to compile texvc; this can be acquired from
http://caml.inria.fr/ if your system doesn't have it available.
The makefile requires GNU make.
Rasterization is done via LaTeX, dvipng. These need to be installed and in
the PATH: latex, dvipng
AMS* packages for LaTeX also need to be installed. Without AMS* some equations
will render correctly while others won't render. Most distributions of TeX
already contain AMS*. In Debian/Ubuntu you need to install tetex-extra.
To work properly with rendering non-ASCII Unicode characters, a supplemental TeX
package is needed (cjk-latex in Debian)
"""
return True
# Project project Django settings.
import os
import sys
import pandas
from django import get_version as django_version
from distutils.version import StrictVersion
DJANGO_19 = StrictVersion(django_version()) >= StrictVersion('1.9')
DJANGO_18 = not DJANGO_19
# CELERY SETUP
import djcelery
djcelery.setup_loader()
CELERY_RESULT_BACKEND='djcelery.backends.database:DatabaseBackend'
BROKER_URL = 'redis://localhost:6379'
#CELERY_RESULT_BACKEND = 'redis://localhost:6379'
CELERY_ACCEPT_CONTENT = ['json', 'pickle']
CELERY_TASK_SERIALIZER = 'pickle'
CELERY_RESULT_SERIALIZER = 'json'
# stop those annoying warnings
pandas.options.mode.chained_assignment = None
# PATH SETUP
PROJECT_NAME = 'savor'
PROJECT_DIR = os.path.realpath(os.path.dirname(__file__))
sys.path.append(PROJECT_DIR)
ENVIRON_DIR = os.path.realpath(os.path.join(PROJECT_DIR, '..'))
CLIENT_PROJECT = os.path.split(ENVIRON_DIR)[1]
def format_error(error):
return u"Postal (Django %s) crash report:\n\n%s" % \
(django_version(), error)
