def create_containers(self, project_name, dataset_name):
"""
Creates containers with names provided if they don't exist already.
Returns Project ID and Dataset ID.
"""
conn = BlitzGateway(self.USER,
self.PASSWORD,
host=self.HOST,
port=self.PORT)
connected = conn.connect()
if not connected:
sys.stderr.write("Server connection error")
sys.exit(1)
for g in conn.getGroupsMemberOf():
if g.getName() == self.GROUP:
break
conn.SERVICE_OPTS.setOmeroGroup(g.getId())
params = omero.sys.Parameters()
p = conn.getObject("Project",
attributes={'name': project_name},
params=params)
d = None
if p is None:
p = self.create_project(conn, project_name)
d = self.create_dataset(conn, dataset_name)
self.link_dataset(conn, p, d)
else:
print "Using existing Project", project_name
for c in p.listChildren():
if c.getName() == dataset_name:
d = c
break
if d is None:
d = self.create_dataset(conn, dataset_name)
self.link_dataset(conn, p, d)
else:
print "Using existing Dataset", dataset_name
conn.seppuku()
return p.getId(), d.getId()
def group_exists(self, user, group):
if not self.user_exists(user):
return False
else:
if group in self.known_users[user]:
print "in Group:", group
return True
try:
try:
conn = BlitzGateway(user, "ome", host='localhost')
conn.connect()
groups = conn.getGroupsMemberOf()
except:
return False
if group in [g.name for g in groups]:
print "in Group:", group
self.known_users[user].append(group)
return True
else:
print "is not in Group:", group, "- ignoring."
return False
finally:
conn.seppuku()
def user_exists(self, user):
if user in self.known_users.keys():
print "User:"******"root", "omero", host='localhost')
conn.connect()
params = omero.sys.Parameters()
params.theFilter = omero.sys.Filter()
u = conn.getObject("Experimenter", attributes={'omeName': user}, params=params)
except:
print "Error getting user - ignoring."
return False
if u is None:
print "User:"******"does not exist - ignoring."
return False
else:
print "User:", user,
self.known_users[user] = []
return True
finally:
conn.seppuku()
class OMEROConnectionManager:
''' Basic management of an OMERO Connection. Methods which make use of
a connection will attempt to connect if connect was not already
successfuly executed '''
def __init__(self, config_file=None):
# Set the connection as not established
self.conn = None
self.SUUID = None
self.HOST = None
self.PORT = None
self.USERNAME = None
self.PASSWORD = None
# If config_file not specified, first see if there's an active OMERO
# CLI session.
if config_file is None:
store = SessionsStore()
session_props = store.get_current()
self.HOST, self.USERNAME, self.SUUID, self.PORT = session_props
# config_file specified, or no active session. Continue with reading
# connection params from the config file.
if config_file is not None or self.SUUID is None:
# Normalize file path.
if config_file is None:
config_file = '~/.omero/config'
config_file = os.path.expanduser(config_file)
# Check config file exists.
if not (os.path.exists(config_file)
and os.path.isfile(config_file)):
sys.stderr.write('No active OMERO CLI session and '
'configuration file {} does not '
'exist\n'.format(config_file))
sys.exit(1)
# Check permisisons on config file.
if os.stat(config_file).st_mode & 0077:
sys.stderr.write('Configuration file contains private '
'credentials and must not be accessible by '
'other users. Please run:\n\n'
' chmod 600 {}\n\n'.format(config_file))
sys.exit(1)
# Read the credentials file.
config = ConfigParser.RawConfigParser()
config.read(config_file)
self.HOST = config.get('OMEROCredentials', 'host')
self.PORT = config.getint('OMEROCredentials', 'port')
self.USERNAME = config.get('OMEROCredentials', 'username')
self.PASSWORD = config.get('OMEROCredentials', 'password')
def connect(self):
''' Create an OMERO Connection '''
# If connection already established just return it
if self.conn is not None:
return self.conn
# Initialize the connection. At least HOST and PORT will be defined,
# but USERNAME and PASSWORD may be None if we are connecting to an
# existing session via its uuid.
self.conn = BlitzGateway(username=self.USERNAME,
passwd=self.PASSWORD,
host=self.HOST,
port=self.PORT)
# Connect. If USERNAME and PASSWORD are None then SUUID must be
# defined.
connected = self.conn.connect(sUuid=self.SUUID)
# Check that the connection was established
if not connected:
sys.stderr.write('Error: Connection not available, '
'please check your user name and password.\n')
sys.exit(1)
return self.conn
def disconnect(self):
''' Terminate the OMERO Connection '''
self.conn.seppuku(softclose=True)
self.conn = None
def hql_query(self, query, params=None):
''' Execute the given HQL query and return the results. Optionally
accepts a parameters object.
For conveniance, will unwrap the OMERO types '''
# Connect if not already connected
if self.conn is None:
self.connect()
if params is None:
params = ParametersI()
# Set OMERO Group to -1 to query across all available data
self.conn.SERVICE_OPTS.setOmeroGroup(-1)
# Get the Query Service
qs = self.conn.getQueryService()
# Execute the query
rows = qs.projection(query, params, self.conn.SERVICE_OPTS)
# Unwrap the query results
unwrapped_rows = []
for row in rows:
unwrapped_row=[]
for column in row:
if column is None:
unwrapped_row.append(None)
else:
unwrapped_row.append(column.val)
unwrapped_rows.append(unwrapped_row)
return unwrapped_rows
def __del__(self):
self.disconnect()
class OMEROConnectionManager(object):
''' Basic management of an OMERO Connection. Methods which make use of
a connection will attempt to connect if connection was not already
successfuly executed '''
def __init__(self, config_file=Path.home() / '.omero' / 'config'):
self.config_file = config_file
# Set the connection as not established
self.conn = None
def connect(self):
''' Create an OMERO Connection '''
# If connection already established just return it
if self.conn is not None:
return self.conn
params = get_params_from_session()
if params is None:
params = get_params_from_config_file(self.config_file)
# Initialize the connection. At least HOST and PORT will be defined,
# but USERNAME and PASSWORD may be None if we are connecting to an
# existing session via its uuid.
self.conn = BlitzGateway(username=params.get('username'),
passwd=params.get('password'),
host=params['host'],
port=params['port'])
# Connect. If USERNAME and PASSWORD are None then SUUID must be
# defined.
connected = self.conn.connect(sUuid=params.get('suuid'))
# Check that the connection was established
if not connected:
sys.stderr.write('Error: Connection not available, '
'please check your user name and password.\n')
sys.exit(1)
return self.conn
def disconnect(self):
''' Terminate the OMERO Connection '''
if self.conn:
self.conn.seppuku(softclose=True)
self.conn = None
def hql_query(self, query, params=None):
''' Execute the given HQL query and return the results. Optionally
accepts a parameters object.
For conveniance, will unwrap the OMERO types '''
# Connect if not already connected
if self.conn is None:
self.connect()
if params is None:
params = ParametersI()
# Set OMERO Group to -1 to query across all available data
self.conn.SERVICE_OPTS.setOmeroGroup(-1)
# Get the Query Service
qs = self.conn.getQueryService()
# Execute the query
rows = qs.projection(query, params, self.conn.SERVICE_OPTS)
# Unwrap the query results
unwrapped_rows = []
for row in rows:
unwrapped_row = []
for column in row:
if column is None:
unwrapped_row.append(None)
else:
unwrapped_row.append(column.val)
unwrapped_rows.append(unwrapped_row)
return unwrapped_rows
def __del__(self):
self.disconnect()
print "Add des (%s)" % (KEY)
obj.setDescription(omero.rtypes.rstring(KEY))
elif ANN == 'tag':
print "Add tag (%s)" % (KEY)
addTag(conn, obj, KEY)
elif ANN == 'map':
print "Add map-annotation (%s, %s)" % (KEY, VAL)
addMapAnnotation(conn, obj, "Metadata", [[KEY, VAL]])
else:
sys.stderr.write("Error: Command does not exist")
sys.exit(1)
if COM == 'del':
if ANN == 'des':
print "Del des"
obj.setDescription(omero.rtypes.rstring(""))
elif ANN == 'tag':
print "Del tag"
deleteAllTagAnnotation(conn, obj)
elif ANN == 'map':
print "Del map"
deleteAllMapAnnotation(conn, obj)
else:
sys.stderr.write("Error: Command does not exist")
sys.exit(1)
printAnnotation(conn, obj)
finally:
#conn._closeSession()
conn.seppuku()
class TestConfig(lib.ITest):
def setup_method(self, method):
# prepare session
self.r = RequestFactory().get('/rand')
middleware = SessionMiddleware()
middleware.process_request(self.r)
self.r.session.save()
self.rs = self.root.sf.getConfigService()
self.conn = BlitzGateway(client_obj=self.new_client())
def teardown_method(self, method):
self.conn.seppuku()
self.r.session.flush()
def testDefaultConfig(self):
""" Test loading default config """
deprecated = [
'omero.client.ui.menu.dropdown.everyone',
'omero.client.ui.menu.dropdown.leaders',
'omero.client.ui.menu.dropdown.colleagues'
]
default = self.rs.getClientConfigDefaults()
login_required(default_view).load_server_settings(self.conn, self.r)
s = {"omero": {"client": self.r.session.get('server_settings', {})}}
ss = self.r.session['server_settings']
# assert if alias gives the same value as deprecated
# rather then ${property}
for d in deprecated:
ds = d.split(".")
assert ss['ui']['menu']['dropdown'][ds[-1]]['label'] == default[d]
# workaround for alias as getClientConfigDefaults returns
# ${property} rather then value
assert ss['ui']['menu']['dropdown'][ds[-1]]['label'] == \
self.conn.getConfigService().getConfigValue(
default['%s.label' % d][2:-1])
# compare keys in default and config loaded by decorator
a = filter(lambda x: x not in (set(default.keys()) - set(deprecated)),
set(flattenProperties(s).keys()))
assert a == ['omero.client.email']
def testDefaultConfigConversion(self):
default = self.rs.getClientConfigDefaults()
# bool
key1 = 'omero.client.ui.tree.orphans.enabled'
self.rs.setConfigValue(key1, default[key1])
key11 = 'omero.client.ui.tree.orphans.name'
self.rs.setConfigValue(key11, default[key11])
# digit
key2 = 'omero.client.viewer.roi_limit'
self.rs.setConfigValue(key2, default[key2])
login_required(default_view).load_server_settings(self.conn, self.r)
ss = self.r.session['server_settings']
assert isinstance(ss['ui']['tree']['orphans']['enabled'], bool)
assert ss['ui']['tree']['orphans']['enabled'] == bool(default[key1])
assert isinstance(ss['ui']['tree']['orphans']['name'], str)
assert ss['ui']['tree']['orphans']['name'] == default[key11]
assert isinstance(ss['viewer']['roi_limit'], int)
assert ss['viewer']['roi_limit'] == json.loads(default[key2])
@pytest.mark.parametrize("prop", [
"colleagues", "leaders", "everyone", "colleagues.label",
"leaders.label", "everyone.label"
])
@pytest.mark.parametrize("label", ["foo"])
def testUpgradeDropdownMenuConfig(self, prop, label):
""" Test if alias loads deprecated property value """
d = self.rs.getClientConfigDefaults()
key = "omero.client.ui.menu.dropdown.%s" % prop
try:
self.rs.setConfigValue(key, label)
# test load_server_settings directly
login_required(default_view).load_server_settings(
self.conn, self.r)
s = self.r.session.get('server_settings', {})
prop = prop.replace(".label", "")
assert s['ui']['menu']['dropdown'][prop]['label'] == label
finally:
self.rs.setConfigValue(key, d[key])
def mock_getClientSettings(self, monkeypatch, default):
def get_clientSettings(*args, **kwargs):
not_exist = [
'omero.client.ui.menu.dropdown.everyone.label',
'omero.client.ui.menu.dropdown.leaders.label',
'omero.client.ui.menu.dropdown.colleagues.label',
'omero.client.ui.tree.orphans.enabled',
'omero.client.viewer.initial_zoom_level'
]
for n in not_exist:
if n in default:
del default[n]
return default
monkeypatch.setattr(omero.gateway.BlitzGateway, 'getClientSettings',
get_clientSettings)
@pytest.mark.parametrize("prop", ["colleagues", "leaders", "everyone"])
@pytest.mark.parametrize("label", ["foo"])
def testOldDropdownMenuConfig(self, monkeypatch, prop, label):
""" Test against older server with monkeypatch """
d = self.rs.getClientConfigDefaults()
key = "omero.client.ui.menu.dropdown.%s" % prop
try:
if label is not None:
self.rs.setConfigValue(key, label)
self.mock_getClientSettings(monkeypatch,
self.rs.getClientConfigValues())
# validate old config
ocs = self.conn.getClientSettings()
not_exist = [
'omero.client.ui.menu.dropdown.everyone.label',
'omero.client.ui.menu.dropdown.leaders.label',
'omero.client.ui.menu.dropdown.colleagues.label',
'omero.client.ui.tree.orphans.enabled',
'omero.client.viewer.initial_zoom_level'
]
for n in not_exist:
assert n not in ocs
# test load_server_settings directly
login_required(default_view).load_server_settings(
self.conn, self.r)
s = self.r.session.get('server_settings', {})
if label is not None:
assert s['ui']['menu']['dropdown'][prop]['label'] == label
else:
assert s['ui']['menu']['dropdown'][prop]['label'] == d[key]
finally:
self.rs.setConfigValue(key, d[key])
groupData = terms[pid]
groupName = groupData['name']
groupDesc = groupData['def']
tg = createTagGroup(groupName, groupDesc)
childNames = []
childDescs = []
for cid in groupData['children']:
cData = terms[cid]
childNames.append(cData['name'])
childDescs.append(cData['def'])
createAndSaveTags(childNames, childDescs, tg)
f.close()
conn.seppuku()
# -------- IF we just want to create Tags without Tag-Groups, we can do this... ---------
# names = []
# defs = []
# f = open("gene_ontology.1_2.obo.txt", "r")
# for l in f.readlines():
# if l.startswith("name:"):
# names.append(l.strip()[6:])
# elif l.startswith("def:"):
# defs.append(l.strip()[5:])
# f.close()
# # names = names[:20]
# # defs = defs[:20]
class TestConfig(lib.ITest):
def setup_method(self, method):
# prepare session
self.r = RequestFactory().get('/rand')
middleware = SessionMiddleware()
middleware.process_request(self.r)
self.r.session.save()
self.rs = self.root.sf.getConfigService()
self.conn = BlitzGateway(client_obj=self.new_client())
def teardown_method(self, method):
self.conn.seppuku()
self.r.session.flush()
def testDefaultConfig(self):
""" Test loading default config """
deprecated = [
'omero.client.ui.menu.dropdown.everyone',
'omero.client.ui.menu.dropdown.leaders',
'omero.client.ui.menu.dropdown.colleagues'
]
default = self.rs.getClientConfigDefaults()
login_required(default_view).load_server_settings(self.conn, self.r)
s = {"omero": {"client": self.r.session.get('server_settings', {})}}
ss = self.r.session['server_settings']
# assert if alias gives the same value as deprecated
# rather then ${property}
for d in deprecated:
ds = d.split(".")
assert ss['ui']['menu']['dropdown'][ds[-1]]['label'] == default[d]
# workaround for alias as getClientConfigDefaults returns
# ${property} rather then value
assert ss['ui']['menu']['dropdown'][ds[-1]]['label'] == \
self.conn.getConfigService().getConfigValue(
default['%s.label' % d][2:-1])
# compare keys in default and config loaded by decorator
a = filter(lambda x: x not in (
set(default.keys()) - set(deprecated)),
set(flattenProperties(s).keys()))
assert a == ['omero.client.email']
def testDefaultConfigConversion(self):
default = self.rs.getClientConfigDefaults()
# bool
key1 = 'omero.client.ui.tree.orphans.enabled'
self.rs.setConfigValue(key1, default[key1])
key11 = 'omero.client.ui.tree.orphans.name'
self.rs.setConfigValue(key11, default[key11])
# digit
key2 = 'omero.client.viewer.roi_limit'
self.rs.setConfigValue(key2, default[key2])
login_required(default_view).load_server_settings(self.conn, self.r)
ss = self.r.session['server_settings']
assert isinstance(ss['ui']['tree']['orphans']['enabled'], bool)
assert ss['ui']['tree']['orphans']['enabled'] == bool(default[key1])
assert isinstance(ss['ui']['tree']['orphans']['name'], str)
assert ss['ui']['tree']['orphans']['name'] == default[key11]
assert isinstance(ss['viewer']['roi_limit'], int)
assert ss['viewer']['roi_limit'] == json.loads(default[key2])
@pytest.mark.parametrize("prop", ["colleagues", "leaders", "everyone",
"colleagues.label", "leaders.label",
"everyone.label"])
@pytest.mark.parametrize("label", ["foo"])
def testUpgradeDropdownMenuConfig(self, prop, label):
""" Test if alias loads deprecated property value """
d = self.rs.getClientConfigDefaults()
key = "omero.client.ui.menu.dropdown.%s" % prop
try:
self.rs.setConfigValue(key, label)
# test load_server_settings directly
login_required(default_view).load_server_settings(
self.conn, self.r)
s = self.r.session.get('server_settings', {})
prop = prop.replace(".label", "")
assert s['ui']['menu']['dropdown'][prop]['label'] == label
finally:
self.rs.setConfigValue(key, d[key])
def mock_getClientSettings(self, monkeypatch, default):
def get_clientSettings(*args, **kwargs):
not_exist = [
'omero.client.ui.menu.dropdown.everyone.label',
'omero.client.ui.menu.dropdown.leaders.label',
'omero.client.ui.menu.dropdown.colleagues.label',
'omero.client.ui.tree.orphans.enabled',
'omero.client.viewer.initial_zoom_level'
]
for n in not_exist:
if n in default:
del default[n]
return default
monkeypatch.setattr(omero.gateway.BlitzGateway,
'getClientSettings',
get_clientSettings)
@pytest.mark.parametrize("prop", ["colleagues", "leaders", "everyone"])
@pytest.mark.parametrize("label", ["foo"])
def testOldDropdownMenuConfig(self, monkeypatch, prop, label):
""" Test against older server with monkeypatch """
d = self.rs.getClientConfigDefaults()
key = "omero.client.ui.menu.dropdown.%s" % prop
try:
if label is not None:
self.rs.setConfigValue(key, label)
self.mock_getClientSettings(monkeypatch,
self.rs.getClientConfigValues())
# validate old config
ocs = self.conn.getClientSettings()
not_exist = [
'omero.client.ui.menu.dropdown.everyone.label',
'omero.client.ui.menu.dropdown.leaders.label',
'omero.client.ui.menu.dropdown.colleagues.label',
'omero.client.ui.tree.orphans.enabled',
'omero.client.viewer.initial_zoom_level'
]
for n in not_exist:
assert n not in ocs
# test load_server_settings directly
login_required(default_view).load_server_settings(
self.conn, self.r)
s = self.r.session.get('server_settings', {})
if label is not None:
assert s['ui']['menu']['dropdown'][prop]['label'] == label
else:
assert s['ui']['menu']['dropdown'][prop]['label'] == d[key]
finally:
self.rs.setConfigValue(key, d[key])
