def run(dest, meta):
source = os.path.split(meta)[1]
source_1024 = os.path.join(source, '1024')
source_h264 = os.path.join(source, 'h264')
photos = []
cur_dirpath = None
output = None
for dirpath, dirnames, filenames in os.walk(meta):
for filename in filenames:
if filename.startswith('.'):
log.debug('Ignoring hidden file %r', filename)
continue
if filename.split('.')[-1].lower() not in [
'cr2', 'png', 'jpg', 'jpeg', 'mpeg', 'wmv', '3gp', 'mov',
'mp4', 'mpg', 'avi'
]:
log.error('Unrecognised file type: %r', filename)
continue
if dirpath != cur_dirpath:
if output is not None:
write(output, sort(photos))
cur_dirpath = dirpath
output = os.path.join(
dest,
os.path.split(dirpath)[1].replace(' ', '_').lower())
photos = []
if filename.split('.')[-1].lower() in [
'cr2', 'png', 'jpg', 'jpeg'
]:
picpath = dirpath.replace(meta, source_1024)
if not os.path.isdir(os.path.join(dirpath, filename)):
path = relpath(os.path.join(picpath, filename),
source_1024)
photos.append(path)
else:
vidpath = dirpath.replace(meta, source_h264)
if not os.path.isdir(os.path.join(vidpath, filename)):
path = relpath(os.path.join(vidpath, filename),
source_h264)
photos.append(path)
# Last one
if photos:
write(output, sort(photos))
def destination(file):
rel_f = relpath(file, faust.xml_dir)
return os.path.join(faust.xml_dir, 'attic', rel_f)
def fix_relative(url):
if not url.startswith('/'):
return
return bn.relpath(url, current_path)
def mknode(path, url=''):
"""
What the recursive function does:
--------------------------------
Takes a path, generates the list. Only the directories are processed.
Each directory is then passed into the recursive function, where it
in turn generates a new list. When allowed to run without check, the
recursive function will generate the complete tree.
We need to stop the propagation of the recursion through all the
available nodes, based on certain conditions.
1) When the program starts, it should generate the first level of nodes.
This is actually quite easy, as we can control the node level by splitting
the path into a list (l). When the list enters its first level, the path (minus
the base path) should have exactly one node. So then, other paths consisting
of more than one node are not allowed to be generated, by stopping the propogation
of the recursion.
2) After that, the user should initiate the next action by choosing one
first-level node. A request is then made, consisting of a single node url.
This url should stop the propagation of the recursive function for all but the
requested child nodes of the parent url.
The notion of "parent" and "child" is key to solving the problem. Obviously, there
is no intrinsic awareness of a parent-child concept when generating the next level
of nodes from a previous one, other than the action of the user. The url is in
effect the "memory" for the generated next level of nodes.
The depth and the vector of the path matching the current url is taken into account.
Returns one node more than you asked for, and all others less than you asked for.
Let's say you have this tree:
a/b/c/
a/b/d/
a/b/e/
so if path_info = /a/b/
you'd want
a/
a/b/
a/b/c/
a/b/d/
a/b/e/
Caveat: The request for the parent does not return the true parent, only a match. As a
consequence, when a tree contains duplicate directory names within a single branch, the
strategy employed here will fail in some way.
It would be interesting to devise a way of obtaining the true parent, preferably short
of implementing something like mptt.
"""
p = path.replace(settings.APP_CONTENT_ROOT + '/', '')
if p:
link_text = path.split('/').pop()
if link_text.lower() in filter(lambda x: len(x) > 0, url.split('/')):
menu_class = 'active'
else:
menu_class = 'passive'
node = '<div class="menu-passive" id="%s" ><a class="%s" href="/folder/%s">%s</a>' % (p.replace('/', '_').lower(), menu_class, p.lower(), link_text)
else:
node = ''
# Initiate a dict d and get the relative path in respect to the
# full path path
d = {}
rel_path = relpath(path, settings.APP_CONTENT_ROOT).lower()
for f in os.listdir(path):
fullname = os.path.join(path, f)
if os.path.isdir(fullname):
# The path fullname will be used to generate the next listdir
# We need the relative path rel to check against the request
rel = relpath(fullname, settings.APP_CONTENT_ROOT).lower()
# The key rel is assigned a value relpath. All of the dirs in the current
# listdir will now be recognisable as having the same parent relpath.
d[rel] = rel_path
# The length of l is used for the first-level listdir
l = filter(lambda x: len(x) > 0, rel.split('/'))
# So now, if either the length l is 1 (first-level) or the
# relative path rel has a parent matching one of the nodes
# of the url, the path will be allowed to propagate.
if has_request_as_parent(d, rel, url) or len(l) == 1:
node += mknode(fullname, url)
if p:
node += '</div>'
else:
node += ''
return node
