1 import sys
2 sys.path.append('.')
3
4 import omero.gateway
5 import omero.model
6 import omero_version
7 from omero.rtypes import *
8 import os
9 import subprocess
10 import re
11 import time
12 import urllib2
13 from types import StringTypes
14
15 omero_version = omero_version.omero_version.split('-')[1].split('.')
16
17 BASEPATH = os.path.dirname(os.path.abspath(__file__))
18 TESTIMG_URL = 'http://users.openmicroscopy.org.uk/~cneves-x/'
21 from path import path
22 exe = path("omero")
23 p = path(".").abspath()
24 for x in range(10):
25 o = p / "dist" / "bin" / "omero"
26 l = p / "dist" / "lib" / "client"
27 if o.exists() and l.exists():
28 exe = o.abspath()
29 break
30 else:
31 p = (p / "..").abspath()
32 return exe.abspath()
33
38
39 -def login (alias, pw=None):
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77 -class UserEntry (object):
78 - def __init__ (self, name, passwd, firstname='', middlename='', lastname='', email='',
79 groupname=None, groupperms='rw----', admin=False):
80 self.name = name
81 self.passwd = passwd
82 self.firstname = firstname
83 self.middlename = middlename
84 self.lastname = lastname
85 self.email = email
86 self.admin = admin
87 self.groupname = groupname
88 self.groupperms = groupperms
89
90 - def fullname (self):
91 return '%s %s' % (self.firstname, self.lastname)
92
94 client = omero.gateway.BlitzGateway(self.name, self.passwd, group=self.groupname, try_super=self.admin)
95 if not client.connect():
96 print "Can not connect"
97 return None
98 if self.groupname is not None and client.getEventContext().groupName != self.groupname:
99 try:
100 a = client.getAdminService()
101 g = a.lookupGroup(self.groupname)
102 client.setGroupForSession(g.getId().val)
103 except:
104 pass
105 return client
106
107 @staticmethod
108 - def _getOrCreateGroup (client, groupname, groupperms='rw----'):
109 a = client.getAdminService()
110 try:
111 g = a.lookupGroup(groupname)
112 except:
113 g = omero.model.ExperimenterGroupI()
114 g.setName(omero.gateway.omero_type(groupname))
115 p = omero.model.PermissionsI()
116
117 for n, f in enumerate((p.setUserRead, p.setUserWrite,
118 p.setGroupRead, p.setGroupWrite,
119 p.setWorldRead, p.setWorldWrite)):
120 f(groupperms[n] != '-')
121 g.details.setPermissions(p)
122 a.createGroup(g)
123 g = a.lookupGroup(groupname)
124 return g
125
126 - def create (self, client):
127 a = client.getAdminService()
128 try:
129 a.lookupExperimenter(self.name)
130
131 return False
132 except:
133
134 pass
135 if self.groupname is None:
136 self.groupname = self.name + '_group'
137 g = UserEntry._getOrCreateGroup(client, self.groupname, self.groupperms)
138 u = omero.model.ExperimenterI()
139 u.setOmeName(omero.gateway.omero_type(self.name))
140 u.setFirstName(omero.gateway.omero_type(self.firstname))
141 u.setMiddleName(omero.gateway.omero_type(self.middlename))
142 u.setLastName(omero.gateway.omero_type(self.lastname))
143 u.setEmail(omero.gateway.omero_type(self.email))
144 a.createUser(u, g.getName().val)
145 if self.admin:
146 u =a.lookupExperimenter(self.name)
147 a.addGroups(u,(a.lookupGroup("system"),))
148 a.changeUserPassword(u.getOmeName().val, omero.gateway.omero_type(self.passwd))
149 return True
150
151 @staticmethod
152 - def addGroupToUser (client, groupname, groupperms='rw----'):
153 a = client.getAdminService()
154 if not 'system' in [x.name.val for x in a.containedGroups(client._userid)]:
155 admin = loginAsRoot()
156 a = admin.getAdminService()
157 else:
158 admin = client
159 g = UserEntry._getOrCreateGroup(client, groupname, groupperms)
160 a.addGroups(a.getExperimenter(client._userid), (g,))
161
162 @staticmethod
163 - def setGroupForSession (client, groupname):
164
165
166
167
168
169
170 a = client.getAdminService()
171 if not groupname in [x.name.val for x in a.containedGroups(client._userid)]:
172 UserEntry.addGroupToUser(client, groupname)
173 g = a.lookupGroup(groupname)
174 client.setGroupForSession(g.getId().val)
175
176
177
178
179 -class ObjectEntry (object):
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201 -class ProjectEntry (ObjectEntry):
202 - def __init__ (self, name, owner, create_group=False, group_perms=False):
203 self.name = name
204 self.owner = owner
205 self.create_group = create_group
206 self.group_perms = group_perms
207
208 - def get (self, client=None, fromCreate=False):
209 if client is None:
210 client = USERS[self.owner].login()
211 for p in client.listProjects():
212 if p.getName() == self.name:
213 p.__loadedHotSwap__()
214 return p
215 return None
216
217 - def create (self, client=None):
218 if client is None:
219 client = USERS[self.owner].login()
220 p = self.get(client)
221 if p is not None:
222
223 return p
224
225 p = omero.model.ProjectI(loaded=True)
226 p.setName(omero.gateway.omero_type(self.name))
227 p.setDescription(omero.gateway.omero_type(self.name))
228
229
230
231
232 if self.create_group:
233 if isinstance(self.create_group, StringTypes):
234 groupname = self.create_group
235 else:
236 raise ValueError('group must be string')
237
238 groupname = 'project_test'
239 s = loginAsRoot()
240 UserEntry.addGroupToUser (s, groupname)
241 UserEntry.setGroupForSession(client, groupname)
242 p = omero.gateway.ProjectWrapper(client, client.getUpdateService().saveAndReturnObject(p))
243 return self.get(client, True)
244
245 -class DatasetEntry (ObjectEntry):
246 - def __init__ (self, name, project, description=None, callback=None):
247 self.name = name
248 self.project = project
249 self.description = description
250 self.callback = callback
251
252 - def get (self, client, forceproj=None):
253 if forceproj is None:
254 if isinstance(self.project, StringTypes):
255 project = PROJECTS[self.project].get(client)
256 elif isinstance(self.project, ProjectEntry):
257 project = self.project.get(client)
258 else:
259 project = self.project
260 else:
261 project = forceproj
262 for d in project.listChildren():
263 if d.getName() == self.name and ((self.description is None and d.getDescription() == '') or (self.description is not None and omero.gateway.omero_type(d.getDescription()) == omero.gateway.omero_type(self.description))):
264 d.__loadedHotSwap__()
265 return d
266 return None
267
269 if isinstance(self.project, StringTypes):
270 project = PROJECTS[self.project]
271 user = USERS[project.owner]
272 client = user.login()
273 project = project.get(client)
274 else:
275 project = self.project
276 client = project._conn
277 d = self.get(client, project)
278 if d is not None and ((self.description is None and d.getDescription() == '') or (self.description is not None and omero.gateway.omero_type(d.getDescription()) == omero.gateway.omero_type(self.description))):
279
280 return d
281
282
283 d = omero.model.DatasetI(loaded=True)
284 d.setName(omero.gateway.omero_type(self.name))
285 if self.description is not None:
286 d.setDescription(omero.gateway.omero_type(self.description))
287
288
289
290 project.linkDataset(d)
291 project.save()
292 rv = self.get(client, project)
293 if self.callback:
294 self.callback(rv)
295 return rv
296
297 -class ImageEntry (ObjectEntry):
298 - def __init__ (self, name, filename, dataset, callback=None):
299 self.name = name
300 self.filename = filename
301 if self.name is None and filename:
302 self.name = os.path.basename(filename)
303 self.dataset = dataset
304 self.callback = callback
305
306 - def get (self, client, forceds=None):
307 if forceds is None:
308 dataset = DATASETS[self.dataset].get(client)
309 else:
310 dataset = forceds
311 for i in dataset.listChildren():
312 if i.getName() == self.name:
313 return i
314 return None
315
317 if isinstance(self.dataset, StringTypes):
318 dataset = DATASETS[self.dataset]
319 project = PROJECTS[dataset.project]
320 client = USERS[project.owner].login()
321 dataset = dataset.get(client)
322 else:
323 dataset = self.dataset
324 client = dataset._conn
325 i = self.get(client, dataset)
326 if i is not None:
327
328 return i
329
330 sys.stderr.write('I')
331 if self.filename is False:
332 UserEntry.setGroupForSession(client, dataset.getDetails().getGroup().getName())
333 self._createWithoutPixels(client, dataset)
334 return self.get(client, dataset)
335 fpath = os.path.join(BASEPATH, self.filename)
336 if not os.path.exists(fpath):
337 if not os.path.exists(os.path.dirname(fpath)):
338 os.makedirs(os.path.dirname(fpath))
339
340 try:
341
342 sys.stderr.write('<')
343 f = urllib2.urlopen(TESTIMG_URL + self.filename)
344 open(fpath, 'wb').write(f.read())
345 except urllib2.HTTPError:
346 raise IOError('No such file %s' % fpath)
347 host = dataset._conn.c.ic.getProperties().getProperty('omero.host') or 'localhost'
348 port = dataset._conn.c.ic.getProperties().getProperty('omero.port') or '4063'
349 if os.path.exists('../bin/omero'):
350 exe = '../bin/omero'
351 else:
352 exe = 'omero'
353 newconn = dataset._conn.clone()
354 newconn.connect()
355 UserEntry.setGroupForSession(newconn, dataset.getDetails().getGroup().getName())
356 session = newconn._sessionUuid
357
358 exe += ' import -s %s -k %s -d %i -p %s -n' % (host, session, dataset.getId(), port)
359 exe = exe.split() + [self.name, fpath]
360 try:
361 p = subprocess.Popen(exe, shell=False, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
362 except OSError:
363 print "!!Please make sure the 'omero' executable is in PATH"
364 return None
365
366 pid = p.communicate()
367
368 try:
369 img = omero.gateway.ImageWrapper(dataset._conn, dataset._conn.getQueryService().find('Pixels', long(pid[0].split('\n')[0].strip())).image)
370 except ValueError:
371 print pid
372 raise
373
374 img.setName(self.name)
375
376 img.save()
377 if self.callback:
378 self.callback(img)
379 return img
380
381 - def _createWithoutPixels (self, client, dataset):
382 img = omero.model.ImageI()
383 img.setName(omero.gateway.omero_type(self.name))
384 img.setAcquisitionDate(rtime(0))
385 if not dataset.imageLinksLoaded:
386 print ".!."
387 dataset._obj._imageLinksSeq = []
388 dataset._obj._imageLinksLoaded = True;
389 dataset.linkImage(img)
390 dataset.save()
391
394
403
406
407 -def getImage (client, alias, forceds=None):
409
422
423 NEWSTYLEPERMS = omero_version >= ['4','2','0']
445
446
447
448 ROOT=UserEntry('root','ome',admin=True)
449
450 USERS = {
451
452 }
453
454 PROJECTS = {
455
456 }
457
458 DATASETS = {
459
460 }
461
462 IMAGES = {
463
464 }
465