def get_packages(self, pkg_name=None):
"""
Return all public packages.
"""
if pkg_name and is_protected(pkg_name):
pkg_name = None
if pkg_name and pkg_name in self:
pkgs = [pkg_name]
else:
pkgs = set(pk.name for pk in self.values() if not is_protected(pk.name))
return [self[p] for p in pkgs]
def update_category(self, package):
""" Update the category dictionary with package contents """
for nf in package.values():
# skip the deprecated name (starting with #)
if is_protected(nf.name):
continue
# empty category
if not nf.category:
nf.category = "Unclassified"
# parse the category
for c in nf.category.split(","):
# we work in lower case by convention
c = c.strip().lower()
# search for the sub category (split by .)
try:
c_root, c_others = c.split('.', 1)
except: # if there is no '.', c_others is empty
c_root = c
c_others = ''
if c_root in self.user_category.keywords:
# reconstruct the name of the category
c_temp = self.user_category.keywords[c_root] + '.' + c_others.title()
self.category.add_name(c_temp, nf)
else:
self.category.add_name(c.title(), nf)
def _dependencies(self, factory):
f = factory
if not f.is_composite_node():
return
for p, n in f.elt_factory.values():
if is_protected(p) or is_protected(n):
continue
try:
fact = self[p][n]
except:
# print p, n
continue
yield fact
for df in self._dependencies(fact):
yield df
def get_data(self, pattern='*.*', pkg_name=None, as_paths=False):
""" Return all data that match the pattern. """
pkgs = self.get_packages(pkg_name)
datafiles = [(pj(p.path, f.name) if as_paths else f) for p in pkgs
for f in p.values()
if (not is_protected(f.name) and f.is_data()
and fnmatch(f.name, pattern))]
return datafiles
def _missing_dependencies(self, factory, l=[]):
f = factory
if not f.is_composite_node():
return
for p, n in f.elt_factory.values():
if is_protected(p) or is_protected(n):
continue
try:
fact = self[p][n]
except:
l.append((p, n))
continue
yield fact
for df in self._missing_dependencies(fact, l):
yield df
def get_pseudo_pkg(self):
""" Return a pseudopackage structure """
pt = PseudoPackage('Root')
# Build the name tree (on uniq objects)
for k, v in self.pkgs.items():
if(not is_protected(k)):
pt.add_name(k, v)
return pt
def search_node(self, search_str, nb_inputs=-1, nb_outputs=-1):
"""
Return a list of Factory corresponding to search_str
If nb_inputs or nb_outputs is specified,
return only node with the same number of (in/out) ports
The results are sorted in the following way:
1 - Highest Priority : presence of search_str in factory name
and position in the name (closer to the
begining = higher score)
2 - Then : Number of occurences of search_str in the factory
description.
3 - Then : Number of occurences of search_str in the category name
4 - Finally : presence of search_str in package name and position
in the name (close to the begining = higher score)
"""
search_str = search_str.upper()
match = []
# Search for each package and for each factory
for name, pkg in self.items():
if is_protected(name):
continue # alias
for fname, factory in pkg.items():
if is_protected(fname):
continue # alias
# -- The scores for each string that is explored.
# They are long ints because we make a 96 bits bitshift
# to compute the final score --
facNameScore = 0
facDescScore = 0
facCateScore = 0
pkgNameScore = 0
fname = factory.name.upper()
if search_str in fname:
l = float(len(fname))
facNameScore = int(100 * (1 - fname.index(search_str) / l))
facDescScore = int(factory.description.upper().count(search_str))
facCateScore = int(factory.category.upper().count(search_str))
pname = pkg.name.upper()
if search_str in pname:
l = float(len(pname))
pkgNameScore = int(100 * (1 - pname.index(search_str) / l))
# A left shift by n bits is equivalent to multiplication by pow(2, n)
score = (int(facNameScore * pow(2, 32 * 3)) | int(facDescScore * pow(2, 32 * 2)) |
int(facCateScore * pow(2, 32 * 1)) | pkgNameScore)
if score > 0:
match.append((score, factory))
# Filter ports
if(nb_inputs >= 0):
match = [sc_x for sc_x in match if sc_x[1] and sc_x[1].inputs and len(sc_x[1].inputs) == nb_inputs]
if(nb_outputs >= 0):
match = [sc_x for sc_x in match if sc_x[1] and sc_x[1].outputs and len(sc_x[1].outputs) == nb_outputs]
if not len(match):
return match
match.sort(reverse=True)
match = list(zip(*match))[1]
return match