def create_user_package(self, name, metainfo, path=None):
"""
Create a new package in the user space and register it
Return the created package
:param path : the directory where to create the package
"""
if name in self.pkgs:
return self.pkgs[name]
# Create directory
if not path:
path = get_userpkg_dir()
path = os.path.join(path, name)
if not isdir(path):
os.mkdir(path)
if not os.path.exists(os.path.join(path, "__wralea__.py")):
# Create new Package and its wralea
p = UserPackage(name, metainfo, path)
p.write()
# Register package
self.load_directory(path)
self.write_config()
p = self.pkgs.get(name)
return p
def build_package(self):
from openalea.core.package import UserPackage
# Build MetaData
metainfo = dict(
version = '',
license = '',
authors = '',
institutes = '',
description = '',
url = '',
)
icons = self.dir.glob('icon.*')
if len(icons) > 0:
metainfo['icon'] = icons[0].basename()
name = self.pkgname()
self._package = UserPackage(name, metainfo, str(self.dir))
if not self.sgfactory:
self.read_specification()
# Add factorie of the dataflow
self._package.add_factory(self.sgfactory)
def build_package(self):
from openalea.core.package import UserPackage
# Build MetaData
metainfo = dict(
version = '',
license = '',
authors = '',
institutes = '',
description = '',
url = '',
)
icons = self.dir.glob('icon.*')
if len(icons) > 0:
metainfo['icon'] = icons[0].basename()
name = self.pkgname()
self._package = UserPackage(name, metainfo, str(self.dir))
if not self.sgfactory:
self.read_specification()
# Add factorie of the dataflow
self._package.add_factory(self.sgfactory)
class VlabObject(object):
"""
A vlab object is a directory containing a specification file,
and a set of data.
"""
text = ['TEXT', 'HINTS']
editors = ['MAP', 'loadmap', 'savemap', 'EDIT', 'SURFACE',
'bezieredit', 'PALETTE', 'palette', 'MEDIT', 'medit',
'GALLERY', 'gallery', 'EDIT', 'funcedit', 'panel', 'CHAR']#panel
programs = ['cpfg', 'lpfg']
ignore = [';', '#']
name2program = {'MAP': 'medit',
'SURFACE': 'bezieredit',
'PALETTE': 'palette',
'MEDIT': 'medit',
'GALLERY': 'gallery',
'EDIT': 'edit',
'CHAR': 'edit',
'loadmap': 'palette'}
def __init__(self, directory, pkgmanager):
self.dir = directory
print("Import into OpenAlea the %s directory"%self.dir.basename())
self._programs = []
self._files = {}
self._text = {}
self._editors = {}
self.pm = pkgmanager
self.sg = None
self.sgfactory = None
self.factories = []
self._package = None
def pkgname(self):
names = []
def search_name(d):
name= d.name
if name == 'ext':
search_name(d.dirname())
elif (d/'.id').isfile() or (d/'specifications').isfile():
names.insert(0, name)
search_name(d.dirname())
else:
return
d = self.dir
search_name(d)
_pkgname = 'vlab.'+'.'.join(names)
print(_pkgname)
return 'vlab.'+'.'.join(names)
def get_package(self):
if not self._package:
self.build_package()
self._package.write()
return self._package
def build_package(self):
from openalea.core.package import UserPackage
# Build MetaData
metainfo = dict(
version = '',
license = '',
authors = '',
institutes = '',
description = '',
url = '',
)
icons = self.dir.glob('icon.*')
if len(icons) > 0:
metainfo['icon'] = icons[0].basename()
name = self.pkgname()
self._package = UserPackage(name, metainfo, str(self.dir))
if not self.sgfactory:
self.read_specification()
# Add factorie of the dataflow
self._package.add_factory(self.sgfactory)
# Add data factories there
#for f in self.factories:
# self._package.add_factory(f)
def read_specification(self):
spec = self.dir / 'specifications'
from openalea.core.compositenode import CompositeNodeFactory
from openalea.core.compositenode import CompositeNode
f = spec.open()
self.sg = CompositeNode()
#name = self.dir.basename().split('-')[-1]
name = self.dir.basename()
self.sgfactory = CompositeNodeFactory(name)
self.read_files(f)
self.read_commands(f)
self.process_files()
self.build_graph()
f.close()
def read_files(self, f):
pattern ='\w+\.\w+'
for l in f:
if 'ignore:' in l or l is '*':
break
fn = l.strip()
if ':' not in fn and re.match(pattern, fn):
self._files[fn]=[]
def read_commands(self, f):
pattern = '\t*[a-zA-Z0-9_ \\-]+:\\s*$'
menus = []
for l in f:
if re.match(pattern, l):
level = l.rstrip().count('\t')
menu = l.strip()[:-1]
if len(menus) <= level:
menus.append(menu)
else:
menus[level] = menu
menus = menus[:level+1]
continue
# skip ignore files : logic no menus have been created.
if not menus:
continue
cmd = l.strip()
if cmd:
self.process_command('.'.join(menus), cmd)
def process_command(self, name, cmd):
command = cmd.split()
prog = command[0]
command[0] = self.name2program.get(prog, prog)
if prog in self.programs:
self.process_program(name, command)
elif prog in self.editors:
self.process_editor(name, command)
elif prog in self.text:
self.process_text(name, command)
else:
print('Do not know how to process this command: %s' % cmd)
def process_program(self, name, command):
""" Build a process node from the command.
"""
node = self.pm.get_node("vlab.bin", "process")
node.set_input(1, ' '.join(command))
prog_node = self.sg.add_node(node)
self._programs.append(prog_node)
def process_editor(self, name, command):
"""
Find the file on which the editor works on.
"""
cmd = ' '.join(command)
fn = ''
if len(command) > 1:
fn = command[-1]
if fn not in list(self._files.keys()):
print("WARNING: the file %s used by the editor %s in not in the specification file." %(fn, cmd))
return
#self._files[fn] = []
prog = command[0]
if prog != 'EDIT':
node = self.pm.get_node("vlab.bin", "editor")
node.set_input(1, cmd)
node.set_input(2, str(self.dir))
else:
node = self.pm.get_node("vlab.bin", "text editor")
filename = self.dir/fn
node.set_input(0, str(filename))
edit_node = self.sg.add_node(node)
self._editors.setdefault(fn, []).append(edit_node)
def process_text(self, name, command):
node = self.pm.get_node('catalog.file', 'viewfile')
text_node = self.sg.add_node(node)
filename = command[-1]
self._text.setdefault(filename, []).append(text_node)
def process_files(self):
from openalea.core.data import DataFactory
deps = self._files
files = list(deps.keys())
for f in files:
fn = self.dir/f
if fn.ext in ['.map', '.txt', '.s', '.e', '.rgb']:
continue #binary file or other
deps[f] = search(fn, files)
self._filenodes = {}
for f in files:
factory = DataFactory(f)
factory.package = self._package
self.factories.append(factory)
node = self.pm.get_node("vlab.bin", "vlab file stamp")
node.set_input(1, str(self.dir/f))
fnode = self.sg.add_node(node)
self._filenodes[f] = fnode
def build_graph(self):
"""
Specify connections between nodes.
"""
prog_deps = []
files = list(self._files.keys())
for p in self._programs:
cmd = self.sg.node(p).inputs[1].split()
fdeps = [f for f in files if f in cmd]
for f in fdeps:
fnode = self._filenodes[f]
self.sg.connect(fnode, 0, p, 0)
for f in files:
for fdep in self._files[f]:
depnode = self._filenodes[fdep]
node = self._filenodes[f]
self.sg.connect(depnode, 0, node, 0)
for f, nodes in self._editors.items():
if not f: # an editor can act withouot a file
continue
fnode = self._filenodes[f]
for node in nodes:
self.sg.connect(node, 0, fnode, 0)
for f, nodes in self._text.items():
fnode = self._filenodes[f]
for node in nodes:
self.sg.connect(fnode, 0, node, 0)
layout(self)
self.sg.to_factory(self.sgfactory)
class VlabObject(object):
"""
A vlab object is a directory containing a specification file,
and a set of data.
"""
text = ['TEXT', 'HINTS']
editors = ['MAP', 'loadmap', 'savemap', 'EDIT', 'SURFACE',
'bezieredit', 'PALETTE', 'palette', 'MEDIT', 'medit',
'GALLERY', 'gallery', 'EDIT', 'funcedit', 'panel', 'CHAR']#panel
programs = ['cpfg', 'lpfg']
ignore = [';', '#']
name2program = {'MAP': 'medit',
'SURFACE': 'bezieredit',
'PALETTE': 'palette',
'MEDIT': 'medit',
'GALLERY': 'gallery',
'EDIT': 'edit',
'CHAR': 'edit',
'loadmap': 'palette'}
def __init__(self, directory, pkgmanager):
self.dir = directory
print "Import into OpenAlea the %s directory"%self.dir.basename()
self._programs = []
self._files = {}
self._text = {}
self._editors = {}
self.pm = pkgmanager
self.sg = None
self.sgfactory = None
self.factories = []
self._package = None
def pkgname(self):
names = []
def search_name(d):
name= d.name
if name == 'ext':
search_name(d.dirname())
elif (d/'.id').isfile() or (d/'specifications').isfile():
names.insert(0, name)
search_name(d.dirname())
else:
return
d = self.dir
search_name(d)
_pkgname = 'vlab.'+'.'.join(names)
print _pkgname
return 'vlab.'+'.'.join(names)
def get_package(self):
if not self._package:
self.build_package()
self._package.write()
return self._package
def build_package(self):
from openalea.core.package import UserPackage
# Build MetaData
metainfo = dict(
version = '',
license = '',
authors = '',
institutes = '',
description = '',
url = '',
)
icons = self.dir.glob('icon.*')
if len(icons) > 0:
metainfo['icon'] = icons[0].basename()
name = self.pkgname()
self._package = UserPackage(name, metainfo, str(self.dir))
if not self.sgfactory:
self.read_specification()
# Add factorie of the dataflow
self._package.add_factory(self.sgfactory)
# Add data factories there
#for f in self.factories:
# self._package.add_factory(f)
def read_specification(self):
spec = self.dir / 'specifications'
from openalea.core.compositenode import CompositeNodeFactory
from openalea.core.compositenode import CompositeNode
f = spec.open()
self.sg = CompositeNode()
#name = self.dir.basename().split('-')[-1]
name = self.dir.basename()
self.sgfactory = CompositeNodeFactory(name)
self.read_files(f)
self.read_commands(f)
self.process_files()
self.build_graph()
f.close()
def read_files(self, f):
pattern ='\w+\.\w+'
for l in f:
if 'ignore:' in l or l is '*':
break
fn = l.strip()
if ':' not in fn and re.match(pattern, fn):
self._files[fn]=[]
def read_commands(self, f):
pattern = '\t*[a-zA-Z0-9_ \\-]+:\\s*$'
menus = []
for l in f:
if re.match(pattern, l):
level = l.rstrip().count('\t')
menu = l.strip()[:-1]
if len(menus) <= level:
menus.append(menu)
else:
menus[level] = menu
menus = menus[:level+1]
continue
# skip ignore files : logic no menus have been created.
if not menus:
continue
cmd = l.strip()
if cmd:
self.process_command('.'.join(menus), cmd)
def process_command(self, name, cmd):
command = cmd.split()
prog = command[0]
command[0] = self.name2program.get(prog, prog)
if prog in self.programs:
self.process_program(name, command)
elif prog in self.editors:
self.process_editor(name, command)
elif prog in self.text:
self.process_text(name, command)
else:
print 'Do not know how to process this command: %s' % cmd
def process_program(self, name, command):
""" Build a process node from the command.
"""
node = self.pm.get_node("vlab.bin", "process")
node.set_input(1, ' '.join(command))
prog_node = self.sg.add_node(node)
self._programs.append(prog_node)
def process_editor(self, name, command):
"""
Find the file on which the editor works on.
"""
cmd = ' '.join(command)
fn = ''
if len(command) > 1:
fn = command[-1]
if fn not in self._files.keys():
print "WARNING: the file %s used by the editor %s in not in the specification file." %(fn, cmd)
return
#self._files[fn] = []
prog = command[0]
if prog != 'EDIT':
node = self.pm.get_node("vlab.bin", "editor")
node.set_input(1, cmd)
node.set_input(2, str(self.dir))
else:
node = self.pm.get_node("vlab.bin", "text editor")
filename = self.dir/fn
node.set_input(0, str(filename))
edit_node = self.sg.add_node(node)
self._editors.setdefault(fn, []).append(edit_node)
def process_text(self, name, command):
node = self.pm.get_node('catalog.file', 'viewfile')
text_node = self.sg.add_node(node)
filename = command[-1]
self._text.setdefault(filename, []).append(text_node)
def process_files(self):
from openalea.core.data import DataFactory
deps = self._files
files = deps.keys()
for f in files:
fn = self.dir/f
if fn.ext in ['.map', '.txt', '.s', '.e', '.rgb']:
continue #binary file or other
deps[f] = search(fn, files)
self._filenodes = {}
for f in files:
factory = DataFactory(f)
factory.package = self._package
self.factories.append(factory)
node = self.pm.get_node("vlab.bin", "vlab file stamp")
node.set_input(1, str(self.dir/f))
fnode = self.sg.add_node(node)
self._filenodes[f] = fnode
def build_graph(self):
"""
Specify connections between nodes.
"""
prog_deps = []
files = self._files.keys()
for p in self._programs:
cmd = self.sg.node(p).inputs[1].split()
fdeps = [f for f in files if f in cmd]
for f in fdeps:
fnode = self._filenodes[f]
self.sg.connect(fnode, 0, p, 0)
for f in files:
for fdep in self._files[f]:
depnode = self._filenodes[fdep]
node = self._filenodes[f]
self.sg.connect(depnode, 0, node, 0)
for f, nodes in self._editors.iteritems():
if not f: # an editor can act withouot a file
continue
fnode = self._filenodes[f]
for node in nodes:
self.sg.connect(node, 0, fnode, 0)
for f, nodes in self._text.iteritems():
fnode = self._filenodes[f]
for node in nodes:
self.sg.connect(fnode, 0, node, 0)
layout(self)
self.sg.to_factory(self.sgfactory)
