added all server files

1 files changed, 198 insertions, 0 deletions

diff --git a/lib/python2.7/site-packages/django/conf/__init__.py b/lib/python2.7/site-packages/django/conf/__init__.py
new file mode 100644
index 0000000..6158439
--- /dev/null
+++ b/lib/python2.7/site-packages/django/conf/__init__.py
@@ -0,0 +1,198 @@
+"""
+Settings and configuration for Django.
+
+Values will be read from the module specified by the DJANGO_SETTINGS_MODULE environment
+variable, and then from django.conf.global_settings; see the global settings file for
+a list of all possible variables.
+"""
+
+import logging
+import os
+import sys
+import time     # Needed for Windows
+import warnings
+
+from django.conf import global_settings
+from django.core.exceptions import ImproperlyConfigured
+from django.utils.functional import LazyObject, empty
+from django.utils import importlib
+from django.utils.module_loading import import_by_path
+from django.utils import six
+
+ENVIRONMENT_VARIABLE = "DJANGO_SETTINGS_MODULE"
+
+
+class LazySettings(LazyObject):
+    """
+    A lazy proxy for either global Django settings or a custom settings object.
+    The user can manually configure settings prior to using them. Otherwise,
+    Django uses the settings module pointed to by DJANGO_SETTINGS_MODULE.
+    """
+    def _setup(self, name=None):
+        """
+        Load the settings module pointed to by the environment variable. This
+        is used the first time we need any settings at all, if the user has not
+        previously configured the settings manually.
+        """
+        try:
+            settings_module = os.environ[ENVIRONMENT_VARIABLE]
+            if not settings_module: # If it's set but is an empty string.
+                raise KeyError
+        except KeyError:
+            desc = ("setting %s" % name) if name else "settings"
+            raise ImproperlyConfigured(
+                "Requested %s, but settings are not configured. "
+                "You must either define the environment variable %s "
+                "or call settings.configure() before accessing settings."
+                % (desc, ENVIRONMENT_VARIABLE))
+
+        self._wrapped = Settings(settings_module)
+        self._configure_logging()
+
+    def __getattr__(self, name):
+        if self._wrapped is empty:
+            self._setup(name)
+        return getattr(self._wrapped, name)
+
+    def _configure_logging(self):
+        """
+        Setup logging from LOGGING_CONFIG and LOGGING settings.
+        """
+        if not sys.warnoptions:
+            try:
+                # Route warnings through python logging
+                logging.captureWarnings(True)
+                # Allow DeprecationWarnings through the warnings filters
+                warnings.simplefilter("default", DeprecationWarning)
+            except AttributeError:
+                # No captureWarnings on Python 2.6, DeprecationWarnings are on anyway
+                pass
+
+        if self.LOGGING_CONFIG:
+            from django.utils.log import DEFAULT_LOGGING
+            # First find the logging configuration function ...
+            logging_config_func = import_by_path(self.LOGGING_CONFIG)
+
+            logging_config_func(DEFAULT_LOGGING)
+
+            # ... then invoke it with the logging settings
+            if self.LOGGING:
+                logging_config_func(self.LOGGING)
+
+    def configure(self, default_settings=global_settings, **options):
+        """
+        Called to manually configure the settings. The 'default_settings'
+        parameter sets where to retrieve any unspecified values from (its
+        argument must support attribute access (__getattr__)).
+        """
+        if self._wrapped is not empty:
+            raise RuntimeError('Settings already configured.')
+        holder = UserSettingsHolder(default_settings)
+        for name, value in options.items():
+            setattr(holder, name, value)
+        self._wrapped = holder
+        self._configure_logging()
+
+    @property
+    def configured(self):
+        """
+        Returns True if the settings have already been configured.
+        """
+        return self._wrapped is not empty
+
+
+class BaseSettings(object):
+    """
+    Common logic for settings whether set by a module or by the user.
+    """
+    def __setattr__(self, name, value):
+        if name in ("MEDIA_URL", "STATIC_URL") and value and not value.endswith('/'):
+            raise ImproperlyConfigured("If set, %s must end with a slash" % name)
+        elif name == "ALLOWED_INCLUDE_ROOTS" and isinstance(value, six.string_types):
+            raise ValueError("The ALLOWED_INCLUDE_ROOTS setting must be set "
+                "to a tuple, not a string.")
+        object.__setattr__(self, name, value)
+
+
+class Settings(BaseSettings):
+    def __init__(self, settings_module):
+        # update this dict from global settings (but only for ALL_CAPS settings)
+        for setting in dir(global_settings):
+            if setting == setting.upper():
+                setattr(self, setting, getattr(global_settings, setting))
+
+        # store the settings module in case someone later cares
+        self.SETTINGS_MODULE = settings_module
+
+        try:
+            mod = importlib.import_module(self.SETTINGS_MODULE)
+        except ImportError as e:
+            raise ImportError(
+                "Could not import settings '%s' (Is it on sys.path? Is there an import error in the settings file?): %s"
+                % (self.SETTINGS_MODULE, e)
+            )
+
+        # Settings that should be converted into tuples if they're mistakenly entered
+        # as strings.
+        tuple_settings = ("INSTALLED_APPS", "TEMPLATE_DIRS")
+
+        for setting in dir(mod):
+            if setting == setting.upper():
+                setting_value = getattr(mod, setting)
+                if setting in tuple_settings and \
+                        isinstance(setting_value, six.string_types):
+                    warnings.warn("The %s setting must be a tuple. Please fix your "
+                                  "settings, as auto-correction is now deprecated." % setting,
+                                  DeprecationWarning, stacklevel=2)
+                    setting_value = (setting_value,) # In case the user forgot the comma.
+                setattr(self, setting, setting_value)
+
+        if not self.SECRET_KEY:
+            raise ImproperlyConfigured("The SECRET_KEY setting must not be empty.")
+
+        if hasattr(time, 'tzset') and self.TIME_ZONE:
+            # When we can, attempt to validate the timezone. If we can't find
+            # this file, no check happens and it's harmless.
+            zoneinfo_root = '/usr/share/zoneinfo'
+            if (os.path.exists(zoneinfo_root) and not
+                    os.path.exists(os.path.join(zoneinfo_root, *(self.TIME_ZONE.split('/'))))):
+                raise ValueError("Incorrect timezone setting: %s" % self.TIME_ZONE)
+            # Move the time zone info into os.environ. See ticket #2315 for why
+            # we don't do this unconditionally (breaks Windows).
+            os.environ['TZ'] = self.TIME_ZONE
+            time.tzset()
+
+
+class UserSettingsHolder(BaseSettings):
+    """
+    Holder for user configured settings.
+    """
+    # SETTINGS_MODULE doesn't make much sense in the manually configured
+    # (standalone) case.
+    SETTINGS_MODULE = None
+
+    def __init__(self, default_settings):
+        """
+        Requests for configuration variables not in this class are satisfied
+        from the module specified in default_settings (if possible).
+        """
+        self.__dict__['_deleted'] = set()
+        self.default_settings = default_settings
+
+    def __getattr__(self, name):
+        if name in self._deleted:
+            raise AttributeError
+        return getattr(self.default_settings, name)
+
+    def __setattr__(self, name, value):
+        self._deleted.discard(name)
+        return super(UserSettingsHolder, self).__setattr__(name, value)
+
+    def __delattr__(self, name):
+        self._deleted.add(name)
+        return super(UserSettingsHolder, self).__delattr__(name)
+
+    def __dir__(self):
+        return list(self.__dict__) + dir(self.default_settings)
+
+settings = LazySettings()