def list(self, ignore_patterns):
print 'CALLING list with:', ignore_patterns
from django.conf import settings
urlconf = __import__(settings.ROOT_URLCONF, {}, {}, [''])
views = extract_views_from_urlpatterns(urlconf.urlpatterns)
views = [view for view in views if getattr(view[0], 'block', None)]
css = get_css_for_pages(views)
ensure_dir(settings.BEMPY_STATIC_DIR)
css_filename = os.path.join(settings.BEMPY_STATIC_DIR, 'bempy.css')
with open(css_filename, 'w') as f:
f.write(css.encode('utf-8'))
js = get_js_for_pages(views)
js_filename = os.path.join(settings.BEMPY_STATIC_DIR, 'bempy.js')
with open(js_filename, 'w') as f:
f.write(js.encode('utf-8'))
storage = StaticFilesStorage(settings.BEMPY_STATIC_DIR)
return [
('bempy.css', storage),
('bempy.js', storage),
# ('bempy/bempy.css', storage.path('bempy.css')),
# ('bempy/bempy.js', storage.path('bempy.js'))
]
def helppages_index(request):
s = StaticFilesStorage()
pages = list(get_files(s, location='helppages'))
slugs = [x[10:-5] for x in pages]
pks = [x[10:-1].split('_')[0] for x in pages]
return render(request, 'article_index.html', locals())
def test_get_file_hash(case):
# type: (TestCase) -> None
strategy = Strategy()
local_storage = StaticFilesStorage()
with tempfile.NamedTemporaryFile(dir=local_storage.base_location) as f:
f.write(b"spam")
hash_ = strategy.get_local_file_hash(f.name, local_storage)
case.assertTrue(re.fullmatch(r"^[A-z0-9]{32}$", hash_) is not None)
def collect_files(self):
"""Find and write static files. Along the way ignore the "compiled"
directory, if present"""
write_storage = StaticFilesStorage(self.BUILD_DIR + "/static/")
original_dirs = settings.STATICFILES_DIRS
settings.STATICFILES_DIRS = [s for s in original_dirs
if s != 'compiled']
for prefixed_path, source_file in self._input_files():
write_storage.save(prefixed_path, source_file)
settings.STATICFILES_DIRS = original_dirs
def inner(request,dir_):
static_file_storage = StaticFilesStorage()
files = list(static_file_storage.listdir(dir_))
for f in files:
if len(f) > 0:
out = f
files = f[0]
fullpath = os.path.join(dir_,files)
print(fullpath)
ctx = {'img':fullpath}
return render(request,'main/inner.html',ctx)
def test_get_file_hash(case):
# disable this test on appveyor until permissions issue is solved
if platform.system() == 'Windows':
return
storage = StaticFilesStorage()
with tempfile.NamedTemporaryFile(dir=storage.base_location) as f:
f.write(b'spam')
h = etag.get_file_hash(storage, f.name)
case.assertEqual(len(h), 34)
case.assertTrue(h.startswith('"'))
case.assertTrue(h.endswith('"'))
for c in h[1:-1]:
case.assertIn(c, hash_characters)
def test_templatetag(template_string, filename):
storage = StaticFilesStorage(location=settings.STATICFILES_TEST_DIR)
try:
storage.save(name=filename,
content=ContentFile("body { background: red; }"))
resp = T(template_string).render(CTX).strip().split("\n")
expected_output = '<link href="{}{}" rel="stylesheet" type="text/css" />'.format(
settings.STATIC_URL, filename)
assert expected_output in resp
assert "<!--" not in resp
assert "-->" not in resp
finally:
storage.delete(filename)
def handle(self, *args, **options):
local_storage = StaticFilesStorage()
base_path = local_storage.base_location
# Ignore files in our ignore patterns
ignore_patterns = getattr(settings, 'SYNCSTATIC_IGNORE_PATTERNS', None)
files = set(
utils.get_files(local_storage, ignore_patterns=ignore_patterns))
# Remove any files that went into compilation
files -= set(settings.PIPELINE_JS['main']['source_filenames'])
files -= set(settings.PIPELINE_CSS['main']['source_filenames'])
for file in files:
print('syncing to s3: %s' % file)
staticfiles_storage.save(file, local_storage.open(file, 'r'))
class CvTemplateForm(forms.Form):
s = StaticFilesStorage()
repertoire = []
repertoire_pas_propre = list(get_files(s, location='collab'))
for elt in repertoire_pas_propre:
if "assets" in elt:
pass
else:
nomDoc = elt.replace("collab\\", '')
if ".docx" in nomDoc:
valeur = (nomDoc, nomDoc)
repertoire.append(valeur)
else:
pass
template = forms.CharField(label='Quel template voulez-vous ?',
widget=forms.Select(choices=repertoire))
collabid = forms.CharField(widget=forms.HiddenInput(), required=True)
def main(request):
static_file_storage = StaticFilesStorage()
dirs = list(static_file_storage.listdir('.'))
for d in dirs:
if len(d) > 0:
out = d
dirs = out
#print(dirs)
#files = list(get_files(static_file_storage,location = 'assets'))
files = {'dirs':dirs}
try:
import os
#print(os.listdir('..'))
except:
pass
return render(request,'main/main.html',files)
def invoke_collect(self, layer, path):
""" Invoke collect, reset all instance storage first and initialize
a self.storage that's bound to the layers target STATIC_ROOT
"""
self.stdout.write("Collecting layer %s to path %s\n" % (layer, path))
self.storage = StaticFilesStorage(path)
try:
self.storage.path('')
except NotImplementedError:
self.local = False
else:
self.local = True
self.copied_files = []
self.symlinked_files = []
self.unmodified_files = []
self.post_processed_files = []
self.layer = layer
return self.collect()
def test_templatetag_multiple_parts_of_path():
filenames = ('css/level1.css', 'css/level1-level2.css',
'css/level1-level2-level3.css')
storage = StaticFilesStorage(location=settings.STATICFILES_TEST_DIR)
try:
for filename in filenames:
storage.save(name=filename,
content=ContentFile("body { background: red; }"))
resp = T('{% load path2css %}{% css4path "/level1/level2/level3/" %}'
).render(CTX).strip()
assert resp.split("\n") == [
'<link href="{}css/level1.css" rel="stylesheet" type="text/css" />'
.format(settings.STATIC_URL),
'<link href="{}css/level1-level2.css" rel="stylesheet" type="text/css" />'
.format(settings.STATIC_URL),
'<link href="{}css/level1-level2-level3.css" rel="stylesheet" type="text/css" />'
.format(settings.STATIC_URL)
]
finally:
for filename in filenames:
storage.delete(filename)
def test_should_copy_file(case):
# type: (TestCase) -> None
strategy = Strategy()
local_storage = StaticFilesStorage()
remote_hash = "foo"
mock_remote_hash = mock.patch.object(
strategy, "get_remote_file_hash", mock.MagicMock(return_value=remote_hash)
)
with mock_remote_hash:
with mock.patch.object(
strategy, "get_local_file_hash", mock.MagicMock(return_value=remote_hash)
):
case.assertFalse(
strategy.should_copy_file("path", "prefixed_path", local_storage)
)
with mock.patch.object(
strategy, "get_local_file_hash", mock.MagicMock(return_value="bar")
):
case.assertTrue(
strategy.should_copy_file("path", "prefixed_path", local_storage)
)
def test_templatetag_assignment(request_path, filenames):
storage = StaticFilesStorage(location=settings.STATICFILES_TEST_DIR)
try:
for filename in filenames:
storage.save(name=filename,
content=ContentFile("body { background: red; }"))
resp = T('''
{% load path2css %}
{% css4path path as GOOSE %}
{% for part, exists in GOOSE %}
{% if exists %}{{ part }}{% endif %}
{% endfor %}
''').render(Context({'path': request_path})).strip()
parts = [x.strip() for x in resp.split("\n") if x.strip()]
expected_output = [
"{}{}".format(settings.STATIC_URL, filename)
for filename in filenames
]
assert parts == expected_output
finally:
for filename in filenames:
storage.delete(filename)
from collectfast.strategies.base import HashStrategy
from collectfast.tests.utils import make_test
class Strategy(HashStrategy[FileSystemStorage]):
def __init__(self) -> None:
super().__init__(FileSystemStorage())
def get_remote_file_hash(self, prefixed_path: str) -> None:
pass
@make_test
def test_get_file_hash(case: TestCase) -> None:
strategy = Strategy()
local_storage = StaticFilesStorage()
with tempfile.NamedTemporaryFile(dir=local_storage.base_location) as f:
f.write(b"spam")
hash_ = strategy.get_local_file_hash(f.name, local_storage)
case.assertTrue(re.fullmatch(r"^[A-z0-9]{32}$", hash_) is not None)
@make_test
def test_should_copy_file(case: TestCase) -> None:
strategy = Strategy()
local_storage = StaticFilesStorage()
remote_hash = "foo"
mock_remote_hash = mock.patch.object(
strategy, "get_remote_file_hash",
mock.MagicMock(return_value=remote_hash))
def default_header():
path = 'defaults/header.jpg'
return ImageFile(open(StaticFilesStorage().path(path), 'rb'))
def xmlfiles(mylocation="xml"):
s = StaticFilesStorage()
xmls = list(get_files(s, location=mylocation))
xmlfiles = [(os.path.join(settings.STATIC_ROOT, filename))
for filename in xmls]
return xmlfiles
def get_file():
s = StaticFilesStorage()
return list(get_files(s, location='adj'))
def default_avatar(variation=0):
path = 'defaults/avatar_{0}.jpg'.format(variation % 10)
return ImageFile(open(StaticFilesStorage().path(path), 'rb'))
def find_static_files():
storage = StaticFilesStorage()
static_url = getattr(settings, 'STATIC_URL')
return ['{}{}'.format(static_url, file) for file in get_files(storage)]
def __init__(self, *args, **kwargs):
super(S3LocalCachedMixin, self).__init__(*args, **kwargs)
self._local = StaticFilesStorage(location=CONVOY_LOCAL_CACHE_ROOT)
