def list(self, ignore_patterns):
result = []
for prefix, path in logo_paths.items():
if not path:
continue
basedir, filename = os.path.split(path)
storage = FileSystemStorage(location=basedir)
storage.prefix = prefix
result.append((filename, storage))
if settings.FAVICON_PACKAGE and os.path.isdir(settings.FAVICON_PACKAGE):
storage = FileSystemStorage(location=settings.FAVICON_PACKAGE)
storage.prefix = 'favicon_package'
result += [(filename, storage) for filename in favicon_package_files]
return result
def list(self, ignore_patterns):
re_patterns = []
for pattern in ignore_patterns:
if pattern.startswith('*'):
re_pattern = re.compile(pattern[1:].replace('.', '\\.') + '$')
elif pattern.endswith('*'):
re_pattern = re.compile('^' + pattern[:-1].replace('.', '\\.'))
else:
re_pattern = re.compile(pattern)
if re_pattern is not None:
re_patterns.append(re_pattern)
for helio_static_dir in self.helio_static_dirs:
storage = FileSystemStorage(location=helio_static_dir)
for static_file in listdir(helio_static_dir):
yield (static_file, storage)
for component_base_dir in self.component_base_directories:
for (dir_root, dir_list, file_list) in walk_component_base_dir(component_base_dir):
for static_file in file_list:
if should_ignore_file(static_file, re_patterns):
continue
full_static_path = join(dir_root, static_file)
res = re.search(r'/(.*)/static', full_static_path)
if res is None:
continue
storage = FileSystemStorage(location=dir_root)
storage.prefix = res.group(1)
yield (static_file, storage)
def __init__(self, apps=None, *args, **kwargs):
from staticpreprocessor.conf import settings
# List of locations with static files
self.locations = []
# Maps dir paths to an appropriate storage instance
self.storages = SortedDict()
if not isinstance(settings.STATIC_PREPROCESSOR_DIRS, (list, tuple)):
raise ImproperlyConfigured(
'Your STATIC_PREPROCESSOR_DIRS setting is not a tuple or '
'list; perhaps you forgot a trailing comma?')
for root in settings.STATIC_PREPROCESSOR_DIRS:
if isinstance(root, (list, tuple)):
prefix, root = root
else:
prefix = ''
if os.path.abspath(settings.STATIC_PREPROCESSOR_ROOT) == \
os.path.abspath(root):
raise ImproperlyConfigured(
'The STATIC_PREPROCESSOR_DIRS setting should '
'not contain the STATIC_PREPROCESSOR_ROOT setting')
if (prefix, root) not in self.locations:
self.locations.append((prefix, root))
for prefix, root in self.locations:
filesystem_storage = FileSystemStorage(location=root)
filesystem_storage.prefix = prefix
self.storages[root] = filesystem_storage
def __init__(self, apps=None, *args, **kwargs):
self.locations = [("", self._get_bower_components_location())]
self.storages = collections.OrderedDict()
filesystem_storage = FileSystemStorage(location=self.locations[0][1])
filesystem_storage.prefix = self.locations[0][0]
self.storages[self.locations[0][1]] = filesystem_storage
def __init__(self, apps=None, *args, **kwargs):
# List of locations with static files
self.locations = []
# Maps dir paths to an appropriate storage instance
self.storages = SortedDict()
if not isinstance(settings.STATICFILES_DIRS, (list, tuple)):
raise ImproperlyConfigured(
"Your STATICFILES_DIRS setting is not a tuple or list; "
"perhaps you forgot a trailing comma?")
for root in settings.STATICFILES_DIRS:
if isinstance(root, (list, tuple)):
prefix, root = root
else:
prefix = ''
if settings.STATIC_ROOT and os.path.abspath(settings.STATIC_ROOT) == os.path.abspath(root):
raise ImproperlyConfigured(
"The STATICFILES_DIRS setting should "
"not contain the STATIC_ROOT setting")
if (prefix, root) not in self.locations:
self.locations.append((prefix, root))
for prefix, root in self.locations:
filesystem_storage = FileSystemStorage(location=root)
filesystem_storage.prefix = prefix
self.storages[root] = filesystem_storage
super(FileSystemFinder, self).__init__(*args, **kwargs)
def __init__(self, apps=None, *args, **kwargs):
self.locations = [
('', self._get_upload_media_location()),
]
self.storages = SortedDict()
filesystem_storage = FileSystemStorage(location=self.locations[0][1])
filesystem_storage.prefix = self.locations[0][0]
self.storages[self.locations[0][1]] = filesystem_storage
def __init__(self, apps=None, *args, **kwargs):
files = get_files(getattr(settings, "NPM_EXECUTABLE_PATH", None), getattr(settings, "NPM_PREFIX_PATH", None))
destination = getattr(settings, "NPM_DESTINATION_PREFIX", "")
self.locations = [(destination, files)]
self.storages = OrderedDict()
filesystem_storage = FileSystemStorage(location=self.locations[0][1])
filesystem_storage.prefix = self.locations[0][0]
self.storages[self.locations[0][1]] = filesystem_storage
def list(self, ignore_patterns):
storyfiles_dir = settings.HOMESTUCK_STORYFILES_DIR
dirs = glob(os.path.join(storyfiles_dir, "*", "img")) + \
glob(os.path.join(storyfiles_dir, "*", "*", "img"))
for directory in dirs:
storage = FileSystemStorage(location=directory)
storage.prefix = "storyfiles"
for path in utils.get_files(storage, ignore_patterns):
yield path, storage
def __init__(self, apps=None, *args, **kwargs):
self.themes = {}
for theme in get_available_themes():
prefix = "theme%s%s" % (os.sep, theme)
self.themes[theme] = []
theme_chain = get_theme_chain(theme)
for theme_module in theme_chain:
storage = FileSystemStorage(get_theme_dir(theme_module, "static"))
storage.prefix = prefix
self.themes[theme].append(storage)
def __init__(self, apps=None, *args, **kwargs):
location = getattr(settings, 'SASS_PROCESSOR_ROOT', settings.STATIC_ROOT)
if not os.path.isdir(location):
return
self.locations = [
('', location),
]
self.storages = OrderedDict()
filesystem_storage = FileSystemStorage(location=location)
filesystem_storage.prefix = self.locations[0][0]
self.storages[location] = filesystem_storage
def __init__(self, apps=None, *args, **kwargs):
self.locations = []
self.storages = OrderedDict()
root = self._get_bower_components_location()
if root is not None:
prefix = ''
self.locations.append((prefix, root))
filesystem_storage = FileSystemStorage(location=root)
filesystem_storage.prefix = prefix
self.storages[root] = filesystem_storage
def __init__(self, apps=None, *args, **kwargs):
nodebow_root = getattr(settings, 'NODEBOW_ROOT', settings.STATIC_ROOT)
bower_components = os.path.abspath(os.path.join(nodebow_root, 'bower_components'))
if not os.path.isdir(bower_components):
return
self.locations = [
('', bower_components),
]
self.storages = OrderedDict()
filesystem_storage = FileSystemStorage(location=bower_components)
filesystem_storage.prefix = self.locations[0][0]
self.storages[bower_components] = filesystem_storage
def __init__(self, apps=None, *args, **kwargs):
# List of locations with static files
self.locations = [('', settings.VERSIONED_STATIC_ROOT), ]
# Maps dir paths to an appropriate storage instance
self.storages = SortedDict()
for prefix, root in self.locations:
filesystem_storage = FileSystemStorage(location=root)
filesystem_storage.prefix = prefix
self.storages[root] = filesystem_storage
super(FileSystemFinder, self).__init__(*args, **kwargs)
def __init__(self, app_names=None, *args, **kwargs):
self.locations = []
self.storages = collections.OrderedDict()
for dependency in self.dependencies:
module = __import__(dependency)
path = '{0}/static'.format(os.path.dirname(module.__file__))
self.locations.append(('', path))
for prefix, root in self.locations:
filesystem_storage = FileSystemStorage(location=root)
filesystem_storage.prefix = prefix
self.storages[root] = filesystem_storage
super(FileSystemFinder, self).__init__(*args, **kwargs)
def __init__(self, apps=None, *args, **kwargs):
self.locations = [
('', self._get_bower_components_location()),
]
try:
self.storages = collections.OrderedDict()
except AttributeError:
from ordereddict import OrderedDict
self.storages = OrderedDict()
filesystem_storage = FileSystemStorage(location=self.locations[0][1])
filesystem_storage.prefix = self.locations[0][0]
self.storages[self.locations[0][1]] = filesystem_storage
def __init__(self, apps=None, *args, **kwargs):
self.npm_executable_path = getattr(settings, 'NPM_EXECUTABLE_PATH', 'npm')
self.npm_prefix_path = getattr(settings, 'NPM_PREFIX_PATH', '')
files = self.__get_files()
destination = getattr(settings, 'NPM_DESTINATION_PREFIX', '')
self.locations = [
(destination, files),
]
self.storages = OrderedDict()
filesystem_storage = FileSystemStorage(location=self.locations[0][1])
filesystem_storage.prefix = self.locations[0][0]
self.storages[self.locations[0][1]] = filesystem_storage
def __init__(self, apps=None, *args, **kwargs):
# List of locations with static files
self.locations = get_directories_in_tethys(('static', 'public'), with_app_name=True)
# Maps dir paths to an appropriate storage instance
self.storages = SortedDict()
for prefix, root in self.locations:
filesystem_storage = FileSystemStorage(location=root)
filesystem_storage.prefix = prefix
self.storages[root] = filesystem_storage
super().__init__(*args, **kwargs)
def __init__(self, apps=None, *args, **kwargs):
self.node_modules_path = get_yarn_root_path()
self.destination = getattr(settings, 'YARN_STATIC_FILES_PREFIX', '')
self.cache_enabled = getattr(settings, 'YARN_FINDER_USE_CACHE', True)
self.cached_list = None
self.match_patterns = flatten_patterns(getattr(settings, 'YARN_FILE_PATTERNS', None)) or ['*']
self.locations = [(self.destination, os.path.join(self.node_modules_path, 'node_modules'))]
self.storages = OrderedDict()
filesystem_storage = FileSystemStorage(location=self.locations[0][1])
filesystem_storage.prefix = self.locations[0][0]
self.storages[self.locations[0][1]] = filesystem_storage
def __init__(self, *args, **kwargs):
# The list of plugins that are handled
self.locations = []
# Mapping of plugin module paths to storage instances
self.storages = SortedDict()
plugins_dir = self.get_immediate_subdirs(settings.PLUGIN_DIR)
for root in plugins_dir:
if not os.path.exists(root) or not os.path.isdir(root):
continue
if ('', root) not in self.locations:
self.locations.append(('', root))
for _, root in self.locations:
filesystem_storage = FileSystemStorage(location=root)
filesystem_storage.prefix = ''
self.storages[root] = filesystem_storage
def __init__(self, apps=None, *args, **kwargs):
files_settings = {}
if hasattr(settings, 'NPM_EXECUTABLE_PATH'):
files_settings['npm_executable_path'] = settings.NPM_EXECUTABLE_PATH
if hasattr(settings, 'NPM_PREFIX_PATH'):
files_settings['npm_prefix_path'] = settings.NPM_PREFIX_PATH
files = get_node_modules_files(**files_settings)
destination = getattr(settings, 'NPM_DESTINATION_PREFIX', '')
self.locations = [
(destination, files),
]
self.storages = OrderedDict()
filesystem_storage = FileSystemStorage(location=self.locations[0][1])
filesystem_storage.prefix = self.locations[0][0]
self.storages[self.locations[0][1]] = filesystem_storage
def __init__(self, app_names=None, *args, **kwargs):
# List of locations with static files
self.locations = []
# Maps dir paths to an appropriate storage instance
self.storages = {}
for root in settings.STATICFILES_DIRS:
if isinstance(root, (list, tuple)):
prefix, root = root
else:
prefix = ""
if (prefix, root) not in self.locations:
self.locations.append((prefix, root))
for prefix, root in self.locations:
filesystem_storage = FileSystemStorage(location=root)
filesystem_storage.prefix = prefix
self.storages[root] = filesystem_storage
super().__init__(*args, **kwargs)
def __init__(self, app_names=None, *args, **kwargs):
# List of locations with static files
self.locations = []
# Maps dir paths to an appropriate storage instance
self.storages = OrderedDict()
for root in settings.STATICFILES_DIRS:
if isinstance(root, (list, tuple)):
prefix, root = root
else:
prefix = ''
if (prefix, root) not in self.locations:
self.locations.append((prefix, root))
for prefix, root in self.locations:
filesystem_storage = FileSystemStorage(location=root)
filesystem_storage.prefix = prefix
self.storages[root] = filesystem_storage
super().__init__(*args, **kwargs)
def get_locations(self):
#pylint:disable=too-many-locals
locations = []
storages = OrderedDict()
roots = []
site = get_current_site()
if site is not None:
# ``site`` could be ``None`` when this code is used through
# a manage.py command (ex: collectstatic).
#
# Here we are inserting the *theme* at a natural place,
# i.e. before the path postfix matching STATIC_URL.
url_parts = []
for part in django_settings.STATIC_URL.split('/'):
if part:
url_parts.append(part)
for static_dir in STATICFILES_DIRS:
drive, path = os.path.splitdrive(static_dir)
dir_parts = path.split(os.sep)
nb_dir_parts = len(dir_parts)
nb_url_parts = len(url_parts)
cut_point = nb_dir_parts - nb_url_parts
if cut_point > 0:
for dir_part, url_part in zip(dir_parts[cut_point:],
url_parts):
if dir_part != url_part:
cut_point = nb_dir_parts
break
else:
cut_point = nb_dir_parts
for theme in get_current_site().get_templates():
roots.append(
os.path.join(
drive, os.sep,
*(dir_parts[:cut_point] + [theme] +
dir_parts[cut_point:])))
for root in roots:
prefix = ''
if (prefix, root) not in locations:
locations.append((prefix, root))
filesystem_storage = FileSystemStorage(location=root)
filesystem_storage.prefix = prefix
storages[root] = filesystem_storage
locations = locations + self.locations
storages.update(self.storages)
return locations, storages
def __init__(self, apps=None, *args, **kwargs):
super(AppDirectoriesFinder, self).__init__(apps, *args, **kwargs)
# Extends apps, add to storages
layers = list(get_current_layer_stack(get_current_request()))
layers.reverse()
processed = []
for k, v in list(self.storages.items()):
for layer in layers:
pth = os.path.join(v.location, layer)
if os.path.exists(pth) and (pth not in processed):
processed.append(pth)
# We're not really adding an app, but the superclass
# attaches no app specific logic to it so it is safe.
self.apps.append(pth)
filesystem_storage = FileSystemStorage(location=pth)
filesystem_storage.prefix = ""
self.storages[pth] = filesystem_storage
def __init__(self, apps=None, *args, **kwargs):
# Maps dir paths to an appropriate storage instance
self.storages = SortedDict()
# Set of locations with static files
self.locations = set()
for root in settings.STATICFILES_DIRS:
if isinstance(root, (list, tuple)):
prefix, root = root
else:
prefix = ''
self.locations.add((prefix, root))
# Don't initialize multiple storages for the same location
for prefix, root in self.locations:
filesystem_storage = FileSystemStorage(location=root)
filesystem_storage.prefix = prefix
self.storages[root] = filesystem_storage
super(FileSystemFinder, self).__init__(*args, **kwargs)
def __init__(self, apps=None, *args, **kwargs):
super(AppDirectoriesFinder, self).__init__(apps, *args, **kwargs)
# Extends apps, add to storages
layers = list(get_current_layer_stack(get_current_request()))
layers.reverse()
processed = []
for k, v in self.storages.items():
for layer in layers:
pth = os.path.join(v.location, layer)
if os.path.exists(pth) and (pth not in processed):
processed.append(pth)
# We're not really adding an app, but the superclass
# attaches no app specific logic to it so it is safe.
self.apps.append(pth)
filesystem_storage = FileSystemStorage(location=pth)
filesystem_storage.prefix = ""
self.storages[pth] = filesystem_storage
def __init__(self, apps=None, *args, **kwargs):
# Maps dir paths to an appropriate storage instance
self.storages = SortedDict()
# Set of locations with static files
self.locations = set()
for root in settings.STATICFILES_DIRS:
if isinstance(root, (list, tuple)):
prefix, root = root
else:
prefix = ''
self.locations.add((prefix, root))
# Don't initialize multiple storages for the same location
for prefix, root in self.locations:
filesystem_storage = FileSystemStorage(location=root)
filesystem_storage.prefix = prefix
self.storages[root] = filesystem_storage
super(FileSystemFinder, self).__init__(*args, **kwargs)
def get_locations(self):
#pylint:disable=too-many-locals
locations = []
storages = OrderedDict()
roots = []
site = get_current_site()
if site is not None:
# ``site`` could be ``None`` when this code is used through
# a manage.py command (ex: collectstatic).
#
# Here we are inserting the *theme* at a natural place,
# i.e. before the path postfix matching STATIC_URL.
url_parts = []
for part in django_settings.STATIC_URL.split('/'):
if part:
url_parts.append(part)
for static_dir in STATICFILES_DIRS:
drive, path = os.path.splitdrive(static_dir)
dir_parts = path.split(os.sep)
nb_dir_parts = len(dir_parts)
nb_url_parts = len(url_parts)
cut_point = nb_dir_parts - nb_url_parts
if cut_point > 0:
for dir_part, url_part in zip(
dir_parts[cut_point:], url_parts):
if dir_part != url_part:
cut_point = nb_dir_parts
break
else:
cut_point = nb_dir_parts
for theme in get_current_site().get_templates():
roots.append(os.path.join(drive, os.sep,
*(dir_parts[:cut_point] + [theme]
+ dir_parts[cut_point:])))
for root in roots:
prefix = ''
if (prefix, root) not in locations:
locations.append((prefix, root))
filesystem_storage = FileSystemStorage(location=root)
filesystem_storage.prefix = prefix
storages[root] = filesystem_storage
locations = locations + self.locations
storages.update(self.storages)
return locations, storages
def __init__(self, apps=None, *args, **kwargs):
location = getattr(settings, 'SASS_PROCESSOR_ROOT',
settings.STATIC_ROOT)
if not location:
msg = "Neither 'SASS_PROCESSOR_ROOT' nor 'STATIC_ROOT' has been declared in project settings."
raise ImproperlyConfigured(msg)
if not os.path.isdir(location):
try:
location = getattr(settings, 'SASS_PROCESSOR_ROOT')
os.makedirs(location)
except (AttributeError, OSError):
return
self.locations = [
('', location),
]
self.storages = OrderedDict()
filesystem_storage = FileSystemStorage(location=location)
filesystem_storage.prefix = self.locations[0][0]
self.storages[location] = filesystem_storage
def __init__(self, apps=None, *args, **kwargs):
# List of locations with static files
self.locations = []
# Maps dir paths to an appropriate storage instance
self.storages = SortedDict()
for theme_name in os.listdir('{}/themes/'.format(settings.BOOKTYPE_ROOT)):
theme_dir = '{}/themes/{}'.format(settings.BOOKTYPE_ROOT, theme_name)
static_dir = '{}/static/'.format(theme_dir)
if os.path.isdir(static_dir):
theme_prefix = 'themes/{}'.format(theme_name)
self.locations.append((theme_prefix, static_dir))
filesystem_storage = FileSystemStorage(location=static_dir)
filesystem_storage.prefix = theme_prefix
self.storages[static_dir] = filesystem_storage
super(ThemeFinder, self).__init__(*args, **kwargs)
def __init__(self, app_names=None, *args, **kwargs):
# List of locations with static files
self.locations = []
# Maps dir paths to an appropriate storage instance
self.storages = OrderedDict()
if not isinstance(settings.STATICFILES, (list, tuple)):
raise ImproperlyConfigured("Your STATICFILES setting is not a tuple or list; ")
for root in settings.STATICFILES:
if isinstance(root, (list, tuple)):
prefix, root = root
else:
prefix = ''
if (prefix, root) not in self.locations:
self.locations.append((prefix, root))
for prefix, root in self.locations:
filesystem_storage = FileSystemStorage(location=os.path.dirname(root))
filesystem_storage.prefix = prefix
self.storages[root] = filesystem_storage
super(SpecificFileStaticFinder, self).__init__(*args, **kwargs)
def __init__(self, apps=None, *args, **kwargs):
# List of locations with static files
self.locations = []
paths = [
'%s/themes/%s/static' % (settings.BASE_PATH, get_active_theme()),
]
# Maps dir paths to an appropriate storage instance
self.storages = SortedDict()
for root in paths:
if isinstance(root, (list, tuple)):
prefix, root = root
else:
prefix = ''
if (prefix, root) not in self.locations:
self.locations.append((prefix, root))
for prefix, root in self.locations:
filesystem_storage = FileSystemStorage(location=root)
filesystem_storage.prefix = prefix
self.storages[root] = filesystem_storage
super(FileSystemFinder, self).__init__(*args, **kwargs)
def __init__(self, apps=None, *args, **kwargs):
self.locations = []
self.storages = SortedDict()
layers = list(settings.FOUNDRY['layers'])
processed = []
for app in settings.INSTALLED_APPS:
mod = import_module(app)
for layer in layers:
pth = os.path.join(os.path.dirname(mod.__file__), 'static', layer)
if os.path.exists(pth) and (pth not in processed):
processed.append(pth)
self.locations.append(('', pth))
for prefix, location in self.locations:
filesystem_storage = FileSystemStorage(location=location)
filesystem_storage.prefix = prefix
self.storages[location] = filesystem_storage
super(BaseFinder, self).__init__(*args, **kwargs)
def __init__(self, apps=None, *args, **kwargs):
super(FileSystemFinder, self).__init__(apps, *args, **kwargs)
# Extend locations
layers = list(get_current_layer_stack(get_current_request()))
layers.reverse()
processed = []
new_locations = []
for prefix, location in self.locations:
for layer in layers:
pth = os.path.join(location, layer)
if os.path.exists(pth) and (pth not in processed):
processed.append(pth)
new_locations.append(('', pth))
for location in reversed(new_locations):
self.locations.insert(0, location)
for prefix, location in new_locations:
filesystem_storage = FileSystemStorage(location=location)
filesystem_storage.prefix = prefix
self.storages[location] = filesystem_storage
def __init__(self, apps=None, *args, **kwargs):
super(FileSystemFinder, self).__init__(apps, *args, **kwargs)
# Extend locations
layers = list(get_current_layer_stack(get_current_request()))
layers.reverse()
processed = []
new_locations = []
for prefix, location in self.locations:
for layer in layers:
pth = os.path.join(location, layer)
if os.path.exists(pth) and (pth not in processed):
processed.append(pth)
new_locations.append(('', pth))
for location in reversed(new_locations):
self.locations.insert(0, location)
for prefix, location in new_locations:
filesystem_storage = FileSystemStorage(location=location)
filesystem_storage.prefix = prefix
self.storages[location] = filesystem_storage
def __init__(self, locations):
# List of locations with static files
self.locations = []
self.prefixes = set()
# Maps dir paths to an appropriate storage instance
self.storages = OrderedDict()
if not isinstance(locations, (list, tuple)):
raise TypeError("locations argument is not a tuple or list")
for root in locations:
prefix, root = root
if not prefix:
raise ValueError(
"Cannot use unprefixed locations for dynamic locations")
else:
prefix = prefix.rstrip("/")
if (prefix, root) not in self.locations:
self.locations.append((prefix, root))
self.prefixes.add(prefix)
for prefix, root in self.locations:
filesystem_storage = FileSystemStorage(location=root)
filesystem_storage.prefix = prefix
self.storages[root] = filesystem_storage
def __init__(self):
# get all registered apps
self.locations = []
self.storages = OrderedDict()
self.ignore_patterns = ["*.py", "*.pyc",]
for app_config in apps.get_app_configs():
path_directory = os.path.join(app_config.path, 'assets')
if os.path.isdir(path_directory):
storage = FileSystemStorage(location=path_directory)
storage.prefix = full_asset_path(app_config.name, "")
self.locations.append(app_config.name)
self.storages[app_config.name] = storage
super().__init__()
def __init__(self, apps=None, theme=None, *args, **kwargs):
# List of locations with static files
self.locations = []
# Maps dir paths to an appropriate storage instance
self.storages = SortedDict()
prefix = None
root = safe_join(
defaults.THEMES_PATH, theme or utils.get_siteskin_settings().theme,
'static')
if os.path.abspath(settings.STATIC_ROOT) == os.path.abspath(root):
raise ImproperlyConfigured(
"The STATICFILES_DIRS setting should not contain the "
"STATIC_ROOT setting")
if (prefix, root) not in self.locations:
self.locations.append((prefix, root))
for prefix, root in self.locations:
filesystem_storage = FileSystemStorage(location=root)
filesystem_storage.prefix = prefix
self.storages[root] = filesystem_storage
def __init__(self):
# Ensure urls are loaded
root_urls = settings.ROOT_URLCONF
importlib.import_module(root_urls)
# Get all registered django dash apps
self.apps = all_apps()
self.locations = []
self.storages = OrderedDict()
self.ignore_patterns = [
"*.py",
"*.pyc",
]
added_locations = {}
for app_slug, obj in self.apps.items():
caller_module = obj.caller_module
location = obj.caller_module_location
subdir = obj.assets_folder
path_directory = os.path.join(os.path.dirname(location), subdir)
if os.path.isdir(path_directory):
component_name = app_slug
storage = FileSystemStorage(location=path_directory)
path = full_asset_path(obj.caller_module.__name__, "")
storage.prefix = path
self.locations.append(component_name)
self.storages[component_name] = storage
super(DashAssetFinder, self).__init__()
def list(self, ignore_patterns):
"""
Given an optional list of paths to ignore, this should return
a two item iterable consisting of the relative path and storage
instance.
"""
for component in os.listdir(settings.THIRDPARTY_DIR):
# We are looking forward symlinks only
component_path = os.path.join(settings.THIRDPARTY_DIR, component)
if not os.path.islink(component_path) or not os.path.isdir(component_path):
continue
for (path, dirs, files) in os.walk(component_path):
for file in files:
name, extension = os.path.splitext(file)
for type, extensions in self.extensions.items():
if not extension in extensions:
continue
filesystem_storage = FileSystemStorage(location=path)
filesystem_storage.prefix = type
yield file, filesystem_storage
def list(self, ignore_patterns):
"""
Given an optional list of paths to ignore, this should return
a two item iterable consisting of the relative path and storage
instance.
"""
for component in os.listdir(settings.THIRDPARTY_DIR):
# We are looking forward symlinks only
component_path = os.path.join(settings.THIRDPARTY_DIR, component)
if not os.path.islink(component_path) or not os.path.isdir(
component_path):
continue
for (path, dirs, files) in os.walk(component_path):
for file in files:
name, extension = os.path.splitext(file)
for type, extensions in self.extensions.items():
if not extension in extensions:
continue
filesystem_storage = FileSystemStorage(location=path)
filesystem_storage.prefix = type
yield file, filesystem_storage
def __init__(self):
self.locations = []
self.storages = OrderedDict()
self.components = {}
self.ignore_patterns = [
"*.py",
"*.pyc",
]
try:
components = settings.PLOTLY_COMPONENTS
except:
components = []
for component_name in components:
module = importlib.import_module(component_name)
path_directory = os.path.dirname(module.__file__)
root = path_directory
storage = FileSystemStorage(location=root)
path = "dash/component/%s" % component_name
# Path_directory is where from
# path is desired url mount point of the content of path_directory
# component_name is the name of the component
storage.prefix = path
self.locations.append(component_name)
self.storages[component_name] = storage
self.components[path] = component_name
super(DashComponentFinder, self).__init__()
def __init__(self, app_names=None, *args, **kwargs):
self.locations = []
self.storages = OrderedDict()
TenantModel = get_tenant_model()
all_tenants = TenantModel.objects.values_list('schema_name', flat=True)
# print "=========== all_tenants ============"
# print all_tenants
try:
CURRENT_SCHEMA_TO_SERVER_STATICFILES = \
settings.CURRENT_SCHEMA_TO_SERVER_STATICFILES
except AttributeError:
raise ImproperlyConfigured(
'To use %s.%s you must '
'define the CURRENT_SCHEMA_TO_SERVER_STATICFILES '
'in your settings' %
(__name__, TenantFileSystemFinder.__name__))
if not CURRENT_SCHEMA_TO_SERVER_STATICFILES:
raise ImproperlyConfigured(
"Your CURRENT_SCHEMA_TO_SERVER_STATICFILES setting can't be empty; "
"it must have the value of the schema_name in which you are "
"currently working on")
else:
if CURRENT_SCHEMA_TO_SERVER_STATICFILES not in all_tenants:
raise ImproperlyConfigured(
"The value of CURRENT_SCHEMA_TO_SERVER_STATICFILES setting "
"doesnt correspond to a valid schema_name tentant")
schema_name = connection.schema_name if connection.schema_name != "public" \
else CURRENT_SCHEMA_TO_SERVER_STATICFILES
"""
if not hasattr(settings, "MULTITENANT_RELATIVE_STATIC_ROOT") or \
not settings.MULTITENANT_RELATIVE_STATIC_ROOT:
raise ImproperlyConfigured("You're using the TenantStaticFilesStorage "
"without having set the MULTITENANT_RELATIVE_STATIC_ROOT "
"setting to a filesystem path.")
"""
multitenant_relative_static_root = ""
if hasattr(settings, "MULTITENANT_RELATIVE_STATIC_ROOT"):
if '%s' in settings.MULTITENANT_RELATIVE_STATIC_ROOT:
multitenant_relative_static_root = \
settings.MULTITENANT_RELATIVE_STATIC_ROOT % \
schema_name
else:
multitenant_relative_static_root = \
os.path.join(settings.MULTITENANT_RELATIVE_STATIC_ROOT,
schema_name)
else:
multitenant_relative_static_root = schema_name
multitenant_static_root = os.path.join(
settings.STATIC_ROOT, multitenant_relative_static_root)
# print "multitenant_relative_static_root"
# print multitenant_relative_static_root
# print "multitenant_static_root"
# print multitenant_static_root
try:
multitenant_staticfiles_dirs = settings.MULTITENANT_STATICFILES_DIRS
except AttributeError:
raise ImproperlyConfigured(
'To use %s.%s you must '
'define the MULTITENANT_STATICFILES_DIRS '
'in your settings' %
(__name__, TenantFileSystemFinder.__name__))
if not isinstance(multitenant_staticfiles_dirs, (list, tuple)):
raise ImproperlyConfigured(
"Your MULTITENANT_STATICFILES_DIRS setting is not a tuple or list; "
"perhaps you forgot a trailing comma?")
tenant_paths = []
for template_dir in multitenant_staticfiles_dirs:
if '%s' in template_dir:
tenant_paths.append(template_dir % schema_name)
else:
tenant_paths.append(os.path.join(template_dir, schema_name))
dirs = tenant_paths
for root in dirs:
if isinstance(root, (list, tuple)):
prefix, root = root
else:
prefix = ''
# print "=========================================="
# print os.path.abspath(multitenant_static_root)
# print os.path.abspath(root)
if os.path.abspath(multitenant_static_root) == os.path.abspath(
root):
raise ImproperlyConfigured(
"The MULTITENANT_STATICFILES_DIRS setting should "
"not contain the (STATIC_ROOT + MULTITENANT_RELATIVE_STATIC_ROOT) path"
)
if (prefix, root) not in self.locations:
self.locations.append((prefix, root))
for prefix, root in self.locations:
filesystem_storage = FileSystemStorage(location=root)
filesystem_storage.prefix = prefix
self.storages[root] = filesystem_storage
def config_by_tenant_dir(self):
self.locations = []
self.storages = OrderedDict()
multitenant_relative_static_root = ""
if hasattr(settings, "MULTITENANT_RELATIVE_STATIC_ROOT"):
if '%s' in settings.MULTITENANT_RELATIVE_STATIC_ROOT:
multitenant_relative_static_root = \
settings.MULTITENANT_RELATIVE_STATIC_ROOT % \
self.current_tenant_dir_name
else:
multitenant_relative_static_root = \
os.path.join(settings.MULTITENANT_RELATIVE_STATIC_ROOT,
self.current_tenant_dir_name)
else:
multitenant_relative_static_root = self.current_tenant_dir_name
multitenant_static_root = os.path.join(settings.STATIC_ROOT,
multitenant_relative_static_root)
# print "multitenant_relative_static_root"
# print multitenant_relative_static_root
# print "multitenant_static_root"
# print multitenant_static_root
try:
multitenant_staticfiles_dirs = settings.MULTITENANT_STATICFILES_DIRS
except AttributeError:
raise ImproperlyConfigured('To use %s.%s you must '
'define the MULTITENANT_STATICFILES_DIRS '
'in your settings' %
(__name__, TenantFileSystemFinder.__name__))
if not isinstance(multitenant_staticfiles_dirs, (list, tuple)):
raise ImproperlyConfigured(
"Your MULTITENANT_STATICFILES_DIRS setting is not a tuple or list; "
"perhaps you forgot a trailing comma?")
tenant_paths = []
for staticfile_dir in multitenant_staticfiles_dirs:
if '%s' in staticfile_dir:
tenant_paths.append(staticfile_dir % self.current_tenant_dir_name)
else:
tenant_paths.append(os.path.join(staticfile_dir, self.current_tenant_dir_name))
dirs = tenant_paths
# print "----------- dirs -------------"
# print dirs
for root in dirs:
if isinstance(root, (list, tuple)):
prefix, root = root
else:
prefix = ''
# print "=========================================="
# print os.path.abspath(multitenant_static_root)
# print os.path.abspath(root)
if os.path.abspath(multitenant_static_root) == os.path.abspath(root):
raise ImproperlyConfigured(
"The MULTITENANT_STATICFILES_DIRS setting should "
"not contain the (STATIC_ROOT + MULTITENANT_RELATIVE_STATIC_ROOT) path")
if (prefix, root) not in self.locations:
self.locations.append((prefix, root))
for prefix, root in self.locations:
filesystem_storage = FileSystemStorage(location=root)
filesystem_storage.prefix = prefix
self.storages[root] = filesystem_storage
