mirror of
https://github.com/LCPQ/quantum_package
synced 2024-11-03 20:54:00 +01:00
310 lines
9.0 KiB
Python
Executable File
310 lines
9.0 KiB
Python
Executable File
#!/usr/bin/env python
|
|
# -*- coding: utf-8 -*-
|
|
"""
|
|
Module utilitary
|
|
|
|
Usage:
|
|
module_handler.py print_descendant [<module_name>...]
|
|
module_handler.py create_png [<module_name>...]
|
|
module_handler.py clean [ --all | <module_name>...]
|
|
module_handler.py create_git_ignore [<module_name>...]
|
|
|
|
Options:
|
|
print_descendant Print the genealogy of the NEEDED_CHILDREN_MODULES
|
|
aka (children, subchildren, etc)
|
|
create_png Create a png of the file
|
|
NEEDED_CHILDREN_MODULES The path of NEEDED_CHILDREN_MODULES
|
|
by default try to open the file in the current path
|
|
"""
|
|
import os
|
|
import sys
|
|
import os.path
|
|
import shutil
|
|
|
|
try:
|
|
from docopt import docopt
|
|
from qp_path import QP_SRC, QP_ROOT, QP_PLUGINS
|
|
except ImportError:
|
|
print "source .quantum_package.rc"
|
|
raise
|
|
|
|
|
|
def is_module(path_module_rel):
|
|
return os.path.isfile(os.path.join(QP_SRC, path_module_rel,
|
|
"NEEDED_CHILDREN_MODULES"))
|
|
|
|
|
|
def is_plugin(path_module_rel):
|
|
return os.path.isfile(os.path.join(QP_PLUGINS, path_module_rel,
|
|
"NEEDED_CHILDREN_MODULES"))
|
|
|
|
|
|
def is_exe(fpath):
|
|
return os.path.isfile(fpath) and os.access(fpath, os.X_OK) and not fpath.endswith(".py")
|
|
|
|
|
|
def get_dict_child(l_root_abs=None):
|
|
"""Loop over MODULE in QP_ROOT/src, open all the NEEDED_CHILDREN_MODULES
|
|
and create a dict[MODULE] = [sub module needed, ...]
|
|
"""
|
|
d_ref = dict()
|
|
|
|
if not l_root_abs:
|
|
l_root_abs = [QP_SRC]
|
|
|
|
for root_abs in l_root_abs:
|
|
for module_rel in os.listdir(root_abs):
|
|
|
|
module_abs = os.path.join(root_abs, module_rel)
|
|
try:
|
|
path_file = os.path.join(module_abs, "NEEDED_CHILDREN_MODULES")
|
|
|
|
with open(path_file, "r") as f:
|
|
l_children = f.read().split()
|
|
except IOError:
|
|
pass
|
|
else:
|
|
if module_rel not in d_ref:
|
|
d_ref[module_rel] = l_children
|
|
else:
|
|
print "Module {0} alredy defined"
|
|
print "Abort"
|
|
sys.exit(1)
|
|
|
|
return d_ref
|
|
|
|
|
|
def get_l_module_descendant(d_child, l_module):
|
|
"""
|
|
From a list of module return the module and descendant
|
|
"""
|
|
|
|
l = []
|
|
for module in l_module:
|
|
if module not in l:
|
|
l.append(module)
|
|
try:
|
|
l.extend(get_l_module_descendant(d_child, d_child[module]))
|
|
except KeyError:
|
|
print >> sys.stderr, "Error: "
|
|
print >> sys.stderr, "`{0}` is not a submodule".format(module)
|
|
print >> sys.stderr, "Check the typo (spelling, case, '/', etc.) "
|
|
sys.exit(1)
|
|
|
|
return list(set(l))
|
|
|
|
|
|
class ModuleHandler():
|
|
def __init__(self, l_root_abs=None):
|
|
self.dict_child = get_dict_child(l_root_abs)
|
|
|
|
@property
|
|
def l_module(self):
|
|
return self.dict_child.keys()
|
|
|
|
@property
|
|
def dict_parent(self):
|
|
"""
|
|
Get a dic of the first parent
|
|
"""
|
|
d_child = self.dict_child
|
|
|
|
d = {}
|
|
|
|
for module_name in d_child:
|
|
d[module_name] = [i for i in d_child.keys()
|
|
if module_name in d_child[i]]
|
|
|
|
return d
|
|
|
|
@property
|
|
def dict_descendant(self):
|
|
"""
|
|
Get a dic of all the genealogy desc (children and all_children)
|
|
"""
|
|
d = {}
|
|
|
|
d_child = self.dict_child
|
|
|
|
for module_name in d_child:
|
|
try:
|
|
d[module_name] = get_l_module_descendant(d_child,
|
|
d_child[module_name])
|
|
except KeyError:
|
|
print "Check NEEDED_CHILDREN_MODULES for {0}".format(
|
|
module_name)
|
|
sys.exit(1)
|
|
|
|
return d
|
|
|
|
@property
|
|
def dict_root(self):
|
|
"""
|
|
Return a dict(module_name) = module_boss
|
|
The top node in a tree.
|
|
"""
|
|
d_asc = self.dict_parent
|
|
d_desc = self.dict_descendant
|
|
|
|
l_all_module = self.l_module
|
|
|
|
dict_root = {}
|
|
|
|
for module in l_all_module:
|
|
dict_root[module] = [p for p in l_all_module
|
|
if module in [p] + d_desc[p] and not d_asc[p]
|
|
][0]
|
|
|
|
return dict_root
|
|
|
|
def l_descendant_unique(self, l_module):
|
|
d_desc = self.dict_descendant
|
|
|
|
d = {}
|
|
for module in l_module:
|
|
for e in d_desc[module]:
|
|
d[e] = 1
|
|
|
|
return d.keys()
|
|
|
|
def l_reduce_tree(self, l_module):
|
|
"""For a list of module in input return only the root"""
|
|
l_d_u = self.l_descendant_unique(l_module)
|
|
l_module_reduce = []
|
|
for module in l_module:
|
|
if module not in l_d_u:
|
|
l_module_reduce.append(module)
|
|
|
|
return l_module_reduce
|
|
|
|
def create_png(self, l_module):
|
|
"""Create the png of the dependency tree for a l_module"""
|
|
|
|
# Don't update if we are not in the main repository
|
|
from is_master_repository import is_master_repository
|
|
if not is_master_repository:
|
|
return
|
|
|
|
basename = "tree_dependency"
|
|
path = '{0}.png'.format(basename)
|
|
|
|
from graphviz import Digraph
|
|
|
|
all_ready_done = []
|
|
|
|
def draw_module_edge(module, l_children):
|
|
"Draw all the module recursifly"
|
|
|
|
if module not in all_ready_done:
|
|
for children in l_children:
|
|
# Add Edge
|
|
graph.edge(module, children)
|
|
# Recurs
|
|
draw_module_edge(children, d_ref[children])
|
|
all_ready_done.append(module)
|
|
|
|
graph = Digraph(comment=l_module, format="png", filename=basename)
|
|
d_ref = self.dict_child
|
|
|
|
# Create all the edge
|
|
for module in l_module:
|
|
graph.node(module, fontcolor="red")
|
|
draw_module_edge(module, d_ref[module])
|
|
|
|
# Try to render the png
|
|
# If not just touch it
|
|
try:
|
|
graph.render(cleanup=True)
|
|
except:
|
|
with open(path, 'a'):
|
|
os.utime(path, None)
|
|
return
|
|
|
|
|
|
if __name__ == '__main__':
|
|
|
|
arguments = docopt(__doc__)
|
|
|
|
if arguments['--all']:
|
|
l_module = [f for f in os.listdir(QP_SRC)
|
|
if os.path.isdir(os.path.join(QP_SRC, f))]
|
|
|
|
elif not arguments['<module_name>']:
|
|
dir_ = os.getcwd()
|
|
l_module = [os.path.basename(dir_)]
|
|
else:
|
|
l_module = arguments['<module_name>']
|
|
|
|
for module in l_module:
|
|
if not is_module(module):
|
|
print "{0} is not a valide module. Abort".format(module)
|
|
print "No NEEDED_CHILDREN_MODULES in it"
|
|
sys.exit(1)
|
|
|
|
m = ModuleHandler()
|
|
|
|
if arguments['print_descendant']:
|
|
|
|
for module in l_module:
|
|
print " ".join(sorted(m.l_descendant_unique([module])))
|
|
|
|
if arguments["create_png"]:
|
|
try:
|
|
m.create_png(l_module)
|
|
except RuntimeError:
|
|
pass
|
|
|
|
if arguments["clean"] or arguments["create_git_ignore"]:
|
|
|
|
l_dir = ['IRPF90_temp', 'IRPF90_man']
|
|
l_file = ["irpf90_entities", "tags", "irpf90.make", "Makefile",
|
|
"Makefile.depend", ".ninja_log", ".ninja_deps",
|
|
"ezfio_interface.irp.f"]
|
|
|
|
for module in l_module:
|
|
module_abs = os.path.realpath(os.path.join(QP_SRC, module))
|
|
l_symlink = m.l_descendant_unique([module])
|
|
l_exe = [f for f in os.listdir(module_abs)
|
|
if is_exe(os.path.join(module_abs, f))]
|
|
|
|
if arguments["clean"]:
|
|
for f in l_dir:
|
|
try:
|
|
shutil.rmtree(os.path.join(module_abs, f))
|
|
except:
|
|
pass
|
|
|
|
for symlink in l_symlink:
|
|
try:
|
|
os.unlink(os.path.join(module_abs, symlink))
|
|
except:
|
|
pass
|
|
|
|
for f in l_file:
|
|
try:
|
|
os.remove(os.path.join(module_abs, f))
|
|
except:
|
|
pass
|
|
|
|
for f in l_exe:
|
|
|
|
try:
|
|
os.remove(os.path.join(module_abs, f))
|
|
except:
|
|
pass
|
|
|
|
if arguments["create_git_ignore"]:
|
|
|
|
# Don't update if we are not in the main repository
|
|
from is_master_repository import is_master_repository
|
|
if not is_master_repository:
|
|
sys.exit()
|
|
|
|
path = os.path.join(module_abs, ".gitignore")
|
|
|
|
with open(path, "w+") as f:
|
|
f.write("# Automatically created by {0} \n".format(__file__).replace(QP_ROOT,"$QP_ROOT"))
|
|
l_text = l_dir + l_file + l_symlink + l_exe
|
|
l_text.sort()
|
|
f.write("\n".join(l_text))
|