def insertIntoGallery( gallery_title, gallery_slug, screenshot, title, slug, gallery_description="", gallery_tags="", caption="", tags="", fab_dir='%s/.fabric-bolt' % (os.path.expanduser('~/')) ): # Add custom fabric-bolt settings directory sys.path.insert(0, fab_dir) # Utilize django within fabfile # Load custom fabric-bolt settings file django.settings_module('settings') # Loads the django Models get_wsgi_application() # Once loaded we can reference them from photologue.models import Photo from photologue.models import Gallery file = open(screenshot, 'rb') data = file.read() # First Generate or Retrieve the Photo Model and save or update it try: photo = Photo.objects.get(slug=slug) photo.date_added = datetime.now() photo.date_taken = datetime.now() print("~~~ FOUND existing Screenshot ~~~") except Photo.DoesNotExist: photo = Photo(title=title, slug=slug, caption=caption, is_public=True, tags=tags,) print("~~~ CREATED new Screenshot ~~~") try: photo.image.save(os.path.basename(screenshot), ContentFile(data)) except FieldError: # For some reason a field, 'photo,' is being passed to model as a field. pass print("~~~ SAVED Screenshot ~~~") # Now Create or Retrieve the named Gallery and add the photo to it. gallery = None try: gallery = Gallery.objects.get(title=gallery_title) print("~~~ FOUND existing Screenshot Gallery ~~~") except Gallery.DoesNotExist: gallery = Gallery(title=gallery_title, slug=gallery_slug, description=gallery_description, is_public=True, tags=gallery_tags,) gallery.save() print("~~~ CREATED new Screenshot Gallery ~~~") if gallery: gallery.photos.add(photo) print("~~~ Added Screenshot to Gallery ~~~") print("<a target=\"_parent\" href=\"/photologue/gallery/%s\">View Screenshot Gallery %s</a>") % (gallery_title, gallery_title) # Reset the syspath sys.path.remove(fab_dir)
def setup(app): ''' SETUP ''' from django.core.wsgi import get_wsgi_application get_wsgi_application() from app.sphinx import process_docstring # Register the docstring processor with sphinx app.connect('autodoc-process-docstring', process_docstring)
def runtests(): os.environ["DJANGO_SETTINGS_MODULE"] = "tests.settings" from django.core.wsgi import get_wsgi_application get_wsgi_application() from django.core.management import call_command result = call_command('test', 'userapp') sys.exit(result)
def application(environ, start_response): if 'DJANGO_SETTINGS_MODULE' in environ: os.environ['DJANGO_SETTINGS_MODULE'] = environ['DJANGO_SETTINGS_MODULE'] for var in env_variables_to_pass: os.environ[var] = environ.get(var, '') return get_wsgi_application()(environ, start_response)
def exec_list(args): """List the datasets and analyses.""" import os os.environ['DJANGO_SETTINGS_MODULE'] = 'topicalguide.settings' from django.core.wsgi import get_wsgi_application application = get_wsgi_application() from visualize.api import query_datasets options = { 'datasets': '*', 'dataset_attr': ['metadata'], 'analyses': '*', 'analysis_attr': ['metadata'], } datasets = query_datasets(options) if len(datasets) == 0: print('No datasets in database.') else: print('Format is as follows:') print("dataset-identifier (dataset's-readable-name)") print("\tanalysis-identifier (analysis'-readable-name)") print() print('Datasets:') for dataset, items in datasets.iteritems(): print(dataset+" ("+items['metadata']['readable_name']+")") analyses = items['analyses'] if len(analyses) == 0: print('\tNo analyses available.') else: for analysis, items2 in analyses.iteritems(): print('\t'+analysis+" ("+items2['metadata']['readable_name']+")")
def application(environ, start): # copy any vars into os.environ for key in environ: os.environ[key] = str(environ[key]) return get_wsgi_application()(environ, start)
def setUpClass(cls): # Keep a record of the original lazy storage instance so we can # restore it afterwards. We overwrite this in the setUp method so # that any new settings get picked up. if not hasattr(cls, '_originals'): cls._originals = {'staticfiles_storage': storage.staticfiles_storage} # Make a temporary directory and copy in test files cls.tmp = tempfile.mkdtemp() settings.STATICFILES_STORAGE = 'django.contrib.staticfiles.storage.CachedStaticFilesStorage' settings.STATICFILES_DIRS = [os.path.join(cls.tmp, 'static')] settings.STATIC_ROOT = os.path.join(cls.tmp, 'static_root') settings.WHITENOISE_ROOT = os.path.join(cls.tmp, 'root') for path, contents in TEST_FILES.items(): path = os.path.join(cls.tmp, path.lstrip('/')) try: os.makedirs(os.path.dirname(path)) except OSError as e: if e.errno != errno.EEXIST: raise with open(path, 'wb') as f: f.write(contents) # Collect static files into STATIC_ROOT call_command('collectstatic', verbosity=0, interactive=False) # Initialize test application django_app = get_wsgi_application() cls.application = DjangoWhiteNoise(django_app) cls.server = TestServer(cls.application) super(DjangoWhiteNoiseTest, cls).setUpClass()
def main(): os.environ['DJANGO_SETTINGS_MODULE'] = 'YoYoProject.settings' # path to your settings module #application = django.core.handlers.wsgi.WSGIHandler() wsgi_app = get_wsgi_application() container = tornado.wsgi.WSGIContainer(wsgi_app) settings = dict( #template_path=os.path.join(os.path.dirname(__file__), "templates"), static_path=os.path.join(os.path.dirname(__file__), "static"), debug=True, ) tornado_app = tornado.web.Application( [ (r'/hello-tornado', YYTornadoHandler), (r'/WebSocket/([a-zA-Z0-9]*)$', YYWebSocketHandler), ('.*', tornado.web.FallbackHandler, dict(fallback=container)), ], **settings) #container = tornado.wsgi.WSGIContainer(tornado_app) http_server = tornado.httpserver.HTTPServer(tornado_app) http_server.listen(options.port) print "start tornado with django at %d" %options.port tornado.ioloop.IOLoop.instance().start()
def get_django_wsgi(settings_module): os.environ.setdefault("DJANGO_SETTINGS_MODULE", settings_module) import django django.setup() return get_wsgi_application()
def setUpClass(cls): # Make a temporary directory and copy in test files cls.tmp = tempfile.mkdtemp() settings.STATICFILES_DIRS = [os.path.join(cls.tmp, 'static')] settings.WHITENOISE_USE_FINDERS = True settings.WHITENOISE_AUTOREFRESH = True for path, contents in TEST_FILES.items(): path = os.path.join(cls.tmp, path.lstrip('/')) try: os.makedirs(os.path.dirname(path)) except OSError as e: if e.errno != errno.EEXIST: raise with open(path, 'wb') as f: f.write(contents) # Clear cache to pick up new settings try: finders.get_finder.cache_clear() except AttributeError: finders._finders.clear() # Initialize test application django_app = get_wsgi_application() cls.application = DjangoWhiteNoise(django_app) cls.server = TestServer(cls.application) super(UseFindersTest, cls).setUpClass()
def test_get_wsgi_application(self): """ get_wsgi_application() returns a functioning WSGI callable. """ application = get_wsgi_application() environ = self.request_factory._base_environ( PATH_INFO="/", CONTENT_TYPE="text/html; charset=utf-8", REQUEST_METHOD="GET" ) response_data = {} def start_response(status, headers): response_data["status"] = status response_data["headers"] = headers response = application(environ, start_response) self.assertEqual(response_data["status"], "200 OK") self.assertEqual( set(response_data["headers"]), {('Content-Length', '12'), ('Content-Type', 'text/html; charset=utf-8')}) self.assertIn(bytes(response), [ b"Content-Length: 12\r\nContent-Type: text/html; charset=utf-8\r\n\r\nHello World!", b"Content-Type: text/html; charset=utf-8\r\nContent-Length: 12\r\n\r\nHello World!" ])
def import_crash_csv(dir,file): application = get_wsgi_application() from capstone.models import Crash file_name = os.path.join(dir, file) with open(file_name, "rU") as infile: reader = csv.reader(infile) next(reader, None) # skip the headers crash_list = [] for row in reader: if not row or len(row) < 20: continue crn, year, month, day, hour, intersect_type, collision_type, \ fatal_count, injury_count, sev_inj_count,maj_inj_count, \ mcycle_death_count, mcycle_sev_inj_count, \ bicycle_death_count, bicycle_sev_inj_count, ped_death_count, \ ignore, max_severity_level, lat, lng = row crash = Crash(crn=crn, year=year, month=month, day=day, hour=hour, intersect_type=intersect_type, collision_type=collision_type, fatal_count=fatal_count, injury_count=injury_count, sev_inj_count=sev_inj_count,maj_inj_count=maj_inj_count, mcycle_death_count=mcycle_death_count, mcycle_sev_inj_count=mcycle_sev_inj_count,bicycle_death_count=bicycle_death_count, bicycle_sev_inj_count=bicycle_sev_inj_count, ped_death_count=ped_death_count, max_severity_level=max_severity_level, lat=lat, lng=lng) crash_list.append(crash) print row Crash.objects.bulk_create(crash_list) print "Load data complete"
def main(): from django.core.wsgi import get_wsgi_application import tornado.wsgi wsgi_app = get_wsgi_application() container = tornado.wsgi.WSGIContainer(wsgi_app) setting = { 'cookie_secret': 'DFksdfsasdfkasdfFKwlwfsdfsa1204mx', 'template_path': os.path.join(os.path.dirname(__file__), 'templates'), 'static_path': os.path.join(os.path.dirname(__file__), 'static'), 'debug': False, } tornado_app = tornado.web.Application( [ (r'/ws/monitor', MonitorHandler), (r'/ws/terminal', WebTerminalHandler), (r'/ws/kill', WebTerminalKillHandler), (r'/ws/exec', ExecHandler), (r"/static/(.*)", tornado.web.StaticFileHandler, dict(path=os.path.join(os.path.dirname(__file__), "static"))), ('.*', tornado.web.FallbackHandler, dict(fallback=container)), ], **setting) server = tornado.httpserver.HTTPServer(tornado_app) server.listen(options.port, address=IP) tornado.ioloop.IOLoop.instance().start()
def main(): os.environ['DJANGO_SETTINGS_MODULE'] = 'haldir.settings' sys.path.append('./haldir') parse_command_line() wsgi_app = get_wsgi_application() container = tornado.wsgi.WSGIContainer(wsgi_app) settings = { 'debug': True, 'autoreload': True, # 'static_path': '/tmp/org.au9ustine.haldir/static' } tornado_app = tornado.web.Application( [ (r'/hello-tornado', HelloHandler), (r'/static/(.*)', tornado.web.StaticFileHandler, {'path': '/tmp/org.au9ustine.haldir/static'}), (r'.*', tornado.web.FallbackHandler, dict(fallback=container)), ], **settings) server = tornado.httpserver.HTTPServer(tornado_app) server.listen(options.port) tornado.ioloop.IOLoop.instance().start()
def application(environ, start_response): """ Grap Environement vars and return class Django WSGI application. """ if 'VIRTUALENV_PATH' in environ.keys(): os.environ['VIRTUALENV_PATH'] = environ['VIRTUALENV_PATH'] if 'DJANGO_SETTINGS_MODULE' in environ.keys(): os.environ['DJANGO_SETTINGS_MODULE'] = \ environ['DJANGO_SETTINGS_MODULE'] ROOT = os.path.dirname(__file__) VIRTUALENV_PATH = os.environ['VIRTUALENV_PATH'] version = 'python%s' % sys.version[0:3] site_packages = os.path.join( VIRTUALENV_PATH, 'lib', version, 'site-packages') site.addsitedir(site_packages) sys.path.append(ROOT) activate_this = os.path.join( VIRTUALENV_PATH, 'bin', 'activate_this.py') activate_env = os.path.expanduser(activate_this) execfile(activate_env, dict(__file__=activate_env)) from django.core.wsgi import get_wsgi_application _wsgi_application = get_wsgi_application() return _wsgi_application(environ, start_response)
def _import_django(self): from smarturls import surl self.surl = surl from django.http import HttpResponse, Http404, HttpResponseRedirect self.HttpResponse = HttpResponse self.Http404 = Http404 self.HttpResponseRedirect = HttpResponseRedirect from django.shortcuts import get_object_or_404, render_to_response self.get_object_or_404 = get_object_or_404 self.render_to_response = render_to_response from django.conf.urls.defaults import patterns, url self.patterns = patterns self.url = url from django.template import RequestContext self.RequestContext = RequestContext from django.core.wsgi import get_wsgi_application self.wsgi_application = get_wsgi_application() from django import forms self.forms = forms from fhurl import RequestForm, fhurl, JSONResponse self.fhurl = fhurl self.RequestForm = RequestForm self.JSONResponse = JSONResponse
def test_get_wsgi_application(self): """ Verify that ``get_wsgi_application`` returns a functioning WSGI callable. """ application = get_wsgi_application() environ = RequestFactory()._base_environ( PATH_INFO="/info", CONTENT_TYPE="text/html; charset=utf-8", REQUEST_METHOD="GET" ) response_data = {} def start_response(status, headers): response_data["status"] = status response_data["headers"] = headers response = application(environ, start_response) self.assertEqual(response_data["status"], "500 Internal Server Error") self.assertEqual( response_data["headers"], [('Content-Type', 'text/html; charset=utf-8')]) self.assertEqual( bytes(response), b'Content-Type: text/html; charset=utf-8\r\n\r\n{\n ' b' "badRequest": {\n ' b' "message": "Server Database does not contain information server", \n ' b' "code": 500\n }\n}')
def run_tornado(addr, port): # Don't try to read the command line args from openslides parse_command_line(args=[]) # Print listening address and port to command line if addr == '0.0.0.0': url_string = "the machine's local ip address" else: url_string = 'http://%s:%s' % (addr, port) # TODO: don't use print, use django logging print("Starting OpenSlides' tornado webserver listening to %(url_string)s" % {'url_string': url_string}) # Setup WSGIContainer app = WSGIContainer(get_wsgi_application()) # Collect urls projectpr_socket_js_router = SockJSRouter(ProjectorSocketHandler, '/projector/socket') from openslides.core.chatbox import ChatboxSocketHandler chatbox_socket_js_router = SockJSRouter(ChatboxSocketHandler, '/core/chatbox') other_urls = [ (r"%s(.*)" % settings.STATIC_URL, DjangoStaticFileHandler), (r'%s(.*)' % settings.MEDIA_URL, StaticFileHandler, {'path': settings.MEDIA_ROOT}), ('.*', FallbackHandler, dict(fallback=app))] # Start the application debug = settings.DEBUG tornado_app = Application(projectpr_socket_js_router.urls + chatbox_socket_js_router.urls + other_urls, debug=debug) server = HTTPServer(tornado_app) server.listen(port=port, address=addr) IOLoop.instance().start()
def test_get_wsgi_application(self): """ Verify that ``get_wsgi_application`` returns a functioning WSGI callable. """ application = get_wsgi_application() environ = RequestFactory()._base_environ( PATH_INFO="/", CONTENT_TYPE="text/html; charset=utf-8", REQUEST_METHOD="GET" ) response_data = {} def start_response(status, headers): response_data["status"] = status response_data["headers"] = headers response = application(environ, start_response) self.assertEqual(response_data["status"], "200 OK") self.assertEqual( response_data["headers"], [('Content-Type', 'text/html; charset=utf-8')]) self.assertEqual( unicode(response), u"Content-Type: text/html; charset=utf-8\n\nHello World!")
def main(): from django.core.wsgi import get_wsgi_application import tornado.wsgi wsgi_app = get_wsgi_application() container = tornado.wsgi.WSGIContainer(wsgi_app) setting = { "cookie_secret": "DFksdfsasdfkasdfFKwlwfsdfsa1204mx", "template_path": os.path.join(os.path.dirname(__file__), "templates"), "static_path": os.path.join(os.path.dirname(__file__), "static"), "debug": False, } tornado_app = tornado.web.Application( [ (r"/ws/monitor", MonitorHandler), (r"/ws/terminal", WebTerminalHandler), (r"/kill", WebTerminalKillHandler), (r"/ws/exec", ExecHandler), ( r"/static/(.*)", tornado.web.StaticFileHandler, dict(path=os.path.join(os.path.dirname(__file__), "static")), ), (".*", tornado.web.FallbackHandler, dict(fallback=container)), ], **setting ) server = tornado.httpserver.HTTPServer(tornado_app) server.listen(options.port) tornado.ioloop.IOLoop.instance().start()
def get_internal_wsgi_application(): """ Loads and returns the WSGI application as configured by the user in ``settings.WSGI_APPLICATION``. With the default ``startproject`` layout, this will be the ``application`` object in ``projectname/wsgi.py``. This function, and the ``WSGI_APPLICATION`` setting itself, are only useful for Django's internal servers (runserver, runfcgi); external WSGI servers should just be configured to point to the correct application object directly. If settings.WSGI_APPLICATION is not set (is ``None``), we just return whatever ``django.core.wsgi.get_wsgi_application`` returns. """ from django.conf import settings app_path = getattr(settings, 'WSGI_APPLICATION') if app_path is None: return get_wsgi_application() try: return import_string(app_path) except ImportError as e: msg = ( "WSGI application '%(app_path)s' could not be loaded; " "Error importing module: '%(exception)s'" % ({ 'app_path': app_path, 'exception': e, }) ) six.reraise(ImproperlyConfigured, ImproperlyConfigured(msg), sys.exc_info()[2])
def _setup_application(environ, start_response): """ Retrieve the relevant information from the WSGI environment and sets up the Django application. This function will (hopefully) be executed only once in the lifetime of the WSGI process, to initialize Django and reassign the 'application' variable. """ # Retrieve the Deploy environment from the WSGI environment deploy_env = environ.get('DJANGO_DEPLOY_ENV', 'dev') os.environ['DJANGO_DEPLOY_ENV'] = deploy_env # See if Django version is 1.4 or 1.3 import django if django.VERSION[1] == 4: # This is Django (probably) version 1.4 from django.core.wsgi import get_wsgi_application application = get_wsgi_application() elif django.VERSION[1] == 3: import django.core.handlers.wsgi application = django.core.handlers.wsgi.WSGIHandler() else: start_response('200 OK', [('Content-Type', 'text/plain')]) return ['Cannot determine the correct Django version\n'] # Pass the present request to the just initialized application. return application(environ, start_response)
def wsgi(settings_file, logfile=None): os.environ.setdefault('DJANGO_SETTINGS_MODULE', settings_file) if logfile: import datetime class logger(object): def __init__(self, logfile): self.logfile = logfile def write(self, data): self.log(data) def writeline(self, data): self.log(data) def log(self, msg): line = '%s - %s\n' % ( datetime.datetime.now().strftime('%Y%m%d %H:%M:%S'), msg) fp = open(self.logfile, 'a') try: fp.write(line) finally: fp.close() sys.stdout = sys.stderr = logger(logfile) # Run WSGI handler for the application from django.core.wsgi import get_wsgi_application return get_wsgi_application()
def run_tornado(addr, port, *args, **kwargs): """ Starts the tornado webserver as wsgi server for OpenSlides. It runs in one thread. """ # Save the port and the addr in a global var global RUNNING_HOST, RUNNING_PORT RUNNING_HOST = addr RUNNING_PORT = port # Don't try to read the command line args from openslides parse_command_line(args=[]) # Setup WSGIContainer app = WSGIContainer(get_wsgi_application()) # Collect urls sock_js_router = SockJSRouter(OpenSlidesSockJSConnection, '/sockjs') other_urls = [ (r'%s(.*)' % settings.STATIC_URL, DjangoStaticFileHandler), (r'%s(.*)' % settings.MEDIA_URL, StaticFileHandler, {'path': settings.MEDIA_ROOT}), ('.*', FallbackHandler, dict(fallback=app))] # Start the application debug = settings.DEBUG tornado_app = Application(sock_js_router.urls + other_urls, autoreload=debug, debug=debug) server = HTTPServer(tornado_app) server.listen(port=port, address=addr) IOLoop.instance().start() # Reset the global vars RUNNING_HOST = None RUNNING_PORT = None
def get_internal_wsgi_application(): """ Load and return the WSGI application as configured by the user in ``settings.WSGI_APPLICATION``. With the default ``startproject`` layout, this will be the ``application`` object in ``projectname/wsgi.py``. This function, and the ``WSGI_APPLICATION`` setting itself, are only useful for Django's internal server (runserver); external WSGI servers should just be configured to point to the correct application object directly. If settings.WSGI_APPLICATION is not set (is ``None``), return whatever ``django.core.wsgi.get_wsgi_application`` returns. """ from django.conf import settings app_path = getattr(settings, 'WSGI_APPLICATION') if app_path is None: return get_wsgi_application() try: return import_string(app_path) except ImportError as err: raise ImproperlyConfigured( "WSGI application '%s' could not be loaded; " "Error importing module." % app_path ) from err
def runner(): try: os.environ['DJANGO_SETTINGS_MODULE'] = 'stack.restapi.settings' basehttp.run('127.0.0.1', 8000, get_wsgi_application()) except KeyboardInterrupt: # The signal to exit pass
def main(): os.environ['DJANGO_SETTINGS_MODULE'] = 'agilepoker.settings' # TODO: edit this sys.path.append('./agilepoker') # path to your project if needed wsgi_app = get_wsgi_application() container = tornado.wsgi.WSGIContainer(wsgi_app) settings = { "debug": True, "template_path": os.path.join(os.path.dirname(__file__), "web"), "static_path": os.path.join(os.path.dirname(__file__), "web"), } tornado_app = tornado.web.Application( [ ('/login', LoginHandler), (r"/", MainHandler), ('/save', SaveGameHandler), (r'/channel', WebSocketHandler), ('.*', tornado.web.FallbackHandler, dict(fallback=container)), ], **settings) signal.signal(signal.SIGINT, signal_handler) server = tornado.httpserver.HTTPServer(tornado_app) server.listen(options.port) tornado.ioloop.PeriodicCallback(try_exit, 100).start() logger.info('Startin Tornado') tornado.ioloop.IOLoop.instance().start() print 'Tornado flush'
def get_internal_wsgi_application(): """ Loads and returns the WSGI application as configured by the user in ``settings.WSGI_APPLICATION``. With the default ``startproject`` layout, this will be the ``application`` object in ``projectname/wsgi.py``. This function, and the ``WSGI_APPLICATION`` setting itself, are only useful for Django's internal servers (runserver, runfcgi); external WSGI servers should just be configured to point to the correct application object directly. If settings.WSGI_APPLICATION is not set (is ``None``), we just return whatever ``django.core.wsgi.get_wsgi_application`` returns. """ from django.conf import settings app_path = getattr(settings, 'WSGI_APPLICATION') if app_path is None: return get_wsgi_application() module_name, attr = app_path.rsplit('.', 1) try: mod = import_module(module_name) except ImportError as e: raise ImproperlyConfigured( "WSGI application '%s' could not be loaded; " "could not import module '%s': %s" % (app_path, module_name, e)) try: app = getattr(mod, attr) except AttributeError as e: raise ImproperlyConfigured( "WSGI application '%s' could not be loaded; " "can't find '%s' in module '%s': %s" % (app_path, attr, module_name, e)) return app
def run_server(instance_dir, address, port, access_log=False): # workaround on osx, disable kqueue if sys.platform == "darwin": os.environ['EVENT_NOKQUEUE'] = "1" sys.path.insert(0, instance_dir) os.environ['DJANGO_SETTINGS_MODULE'] = 'settings' # This application object is used by any WSGI server configured to use this # file. This includes Django's development server, if the WSGI_APPLICATION # setting points here. from django.core.wsgi import get_wsgi_application application = get_wsgi_application() from gevent import monkey monkey.patch_all(dns=False) from gevent.pywsgi import WSGIServer if access_log: logfile = 'default' else: logfile = file(os.devnull, 'a+') server = WSGIServer((address, port), application, log=logfile) try: server.serve_forever() except KeyboardInterrupt: server.stop()
def load_django_settings(): """ Loads Django settings for the current site and sets them so Django internals can be run. """ #TODO:remove this once bug in django-celery has been fixed os.environ['ALLOW_CELERY'] = '0' #os.environ.setdefault("DJANGO_SETTINGS_MODULE", "dryden_site.settings") # In Django >= 1.7, fixes the error AppRegistryNotReady: Apps aren't loaded yet try: from django.core.wsgi import get_wsgi_application application = get_wsgi_application() except ImportError: pass # Load Django settings. settings = get_settings() try: from django.contrib import staticfiles from django.conf import settings as _settings for k,v in settings.__dict__.iteritems(): setattr(_settings, k, v) except ImportError: pass return settings
""" WSGI config for moviea_django project. It exposes the WSGI callable as a module-level variable named ``application``. For more information on this file, see https://docs.djangoproject.com/en/1.7/howto/deployment/wsgi/ """ import os os.environ.setdefault("DJANGO_SETTINGS_MODULE", "moviea_django.settings") from django.core.wsgi import get_wsgi_application from dj_static import Cling application = Cling(get_wsgi_application())
def __init__(self): self.django_handler = get_wsgi_application() self.static_handler = static.Cling( os.path.dirname(os.path.dirname(__file__)))
""" WSGI config for crime project. It exposes the WSGI callable as a module-level variable named ``application``. For more information on this file, see https://docs.djangoproject.com/en/1.11/howto/deployment/wsgi/ """ import os from django.core.wsgi import get_wsgi_application from whitenoise.django import DjangoWhiteNoise os.environ.setdefault("DJANGO_SETTINGS_MODULE", "crime.settings") # pylint: disable=invalid-name application = DjangoWhiteNoise(get_wsgi_application())
""" WSGI config for ui app. It exposes the WSGI callable as a module-level variable named ``application``. For more information on this file, see https://docs.djangoproject.com/en/1.8/howto/deployment/wsgi/ """ import os from django.core.wsgi import get_wsgi_application from dj_static import Cling os.environ.setdefault("DJANGO_SETTINGS_MODULE", "micromasters.settings") application = Cling(get_wsgi_application()) # pylint: disable=invalid-name
def _setup_env(): sys.path.insert(0, LS_PATH) os.environ.setdefault("DJANGO_SETTINGS_MODULE", "label_studio.core.settings.label_studio") application = get_wsgi_application()
""" WSGI config for dept_mgment project. It exposes the WSGI callable as a module-level variable named ``application``. For more information on this file, see https://docs.djangoproject.com/en/1.9/howto/deployment/wsgi/ """ import os from django.core.wsgi import get_wsgi_application os.environ.setdefault("DJANGO_SETTINGS_MODULE", "dept_mgment.settings") application = get_wsgi_application()