def setup_method(self, method):
     self.clis = []
     self.sess = self.create_client_session(self.user)
     self.name = UserAccount.uuid()
     ns = UserAccount.uuid()
     self.ft_space = ns + '/features'
     self.ann_space = ns + '/source'
class TableStoreTestHelper(object):

    def setup_class(self):
        self.ua = UserAccount()
        self.user = self.ua.new_user(perms='rwra--')

    def teardown_class(self):
        self.ua.close()

    def setup_method(self, method):
        self.clis = []
        self.sess = self.create_client_session(self.user)
        self.name = UserAccount.uuid()
        ns = UserAccount.uuid()
        self.ft_space = ns + '/features'
        self.ann_space = ns + '/source'

    def teardown_method(self, method):
        for cli in self.clis:
            cli.closeSession()

    def create_user_same_group(self):
        g = self.sess.getAdminService().getDefaultGroup(self.user.id.val)
        return self.ua.new_user(group=g)

    def create_client_session(self, user):
        cli = omero.client()
        self.clis.append(cli)
        un = unwrap(user.getOmeName())
        sess = cli.createSession(un, un)
        return sess
class TableStoreTestHelper(object):
    def setup_class(self):
        self.ua = UserAccount()
        self.user = self.ua.new_user(perms="rwra--")

    def teardown_class(self):
        self.ua.close()

    def setup_method(self, method):
        self.clis = []
        self.sess = self.create_client_session(self.user)
        self.name = UserAccount.uuid()
        ns = UserAccount.uuid()
        self.ft_space = ns + "/features"
        self.ann_space = ns + "/source"

    def teardown_method(self, method):
        for cli in self.clis:
            cli.closeSession()

    def create_user_same_group(self):
        g = self.sess.getAdminService().getDefaultGroup(self.user.id.val)
        return self.ua.new_user(group=g)

    def create_client_session(self, user):
        cli = omero.client()
        self.clis.append(cli)
        un = unwrap(user.getOmeName())
        sess = cli.createSession(un, un)
        return sess
 def setup_method(self, method):
     self.clis = []
     self.sess = self.create_client_session(self.user)
     self.name = UserAccount.uuid()
     ns = UserAccount.uuid()
     self.ft_space = ns + "/features"
     self.ann_space = ns + "/source"
 def setup_method(self, method):
     self.cli = omero.client()
     un = unwrap(self.user.getOmeName())
     self.sess = self.cli.createSession(un, un)
     self.fsmeta = {'fsname': 'a'}
     ns = UserAccount.uuid()
     self.nsc = ns + '/c'
     self.nsr = ns + '/r'
 def setup_method(self, method):
     self.cli = omero.client()
     un = unwrap(self.user.getOmeName())
     self.sess = self.cli.createSession(un, un)
     self.fsmeta = {'fsname': 'a', 'version': '1'}
     self.rowmetas = [{'id': '1'}, {'id': '2'}]
     self.valuess = [[1.0, 2.0], [-1.0, -2.0]]
     self.ns = UserAccount.uuid()
     self.nsc = self.ns + '/featureset'
     self.nsr = self.ns + '/sample'
    def test_create_map_ann(self):
        ns = UserAccount.uuid()
        ma = OmeroMetadata.MapAnnotations(self.sess, namespace=ns)
        d = {'a': '1', 'bb': 'cc'}
        aid = ma.create_map_ann({'a': '1', 'bb': 'cc'})

        params = omero.sys.ParametersI()
        params.addLong('id', aid)
        mr = self.sess.getQueryService().findByQuery(
            'from MapAnnotation ann join fetch ann.mapValue where id=:id',
            params)

        assert unwrap(mr.getNs()) == ns
        assert unwrap(mr.getMapValue()) == d
    def test_query_by_map_ann(self, projection):
        ns = UserAccount.uuid()
        ma = OmeroMetadata.MapAnnotations(self.sess, namespace=ns)

        d1 = {'a': '1', 'bb': 'cc'}
        d1f = {'bb': 'cc'}
        d2 = {'a': '1', 'bb': 'd'}
        d2f = {'bb': 'd'}

        m1 = omero.model.MapAnnotationI()
        m1.setNs(wrap(ns))
        m1.setMapValue(wrap(d1).val)
        m2 = omero.model.MapAnnotationI()
        m2.setNs(wrap(ns))
        m2.setMapValue(wrap(d2).val)

        m1 = self.sess.getUpdateService().saveAndReturnObject(m1)
        m2 = self.sess.getUpdateService().saveAndReturnObject(m2)

        rs = ma.query_by_map_ann(d1, projection)
        assert len(rs) == 1
        if projection:
            if projection is True:
                assert rs.values()[0] == d1
            else:
                assert rs.values()[0] == d1f
        else:
            assert unwrap(rs[0].getNs()) == ns
            assert unwrap(rs[0].getMapValue()) == d1

        rs = ma.query_by_map_ann({'a': '1'}, projection)
        assert len(rs) == 2
        if projection:
            rmv1, rmv2 = rs.values()
            if projection is True:
                self.assert_equal_any_order((rmv1, rmv2), (d1, d2))
            else:
                self.assert_equal_any_order((rmv1, rmv2), (d1f, d2f))
        else:
            assert unwrap(rs[0].getNs()) == ns
            assert unwrap(rs[1].getNs()) == ns
            rmv1 = unwrap(rs[0].getMapValue())
            rmv2 = unwrap(rs[1].getMapValue())
            self.assert_equal_any_order((rmv1, rmv2), (d1, d2))
 def setup_class(self):
     self.ua = UserAccount()
     self.user = self.ua.new_user()
class TestMapAnnotations(object):

    def setup_class(self):
        self.ua = UserAccount()
        self.user = self.ua.new_user()

    def teardown_class(self):
        self.ua.close()

    def setup_method(self, method):
        self.cli = omero.client()
        un = unwrap(self.user.getOmeName())
        self.sess = self.cli.createSession(un, un)

    def teardown_method(self, method):
        self.cli.closeSession()

    @staticmethod
    def assert_equal_any_order(a, b):
        assert ((a[0] == b[0] and a[1] == b[1]) or
                (a[0] == b[1] and a[1] == b[0]))

    def test_create_map_ann(self):
        ns = UserAccount.uuid()
        ma = OmeroMetadata.MapAnnotations(self.sess, namespace=ns)
        d = {'a': '1', 'bb': 'cc'}
        aid = ma.create_map_ann({'a': '1', 'bb': 'cc'})

        params = omero.sys.ParametersI()
        params.addLong('id', aid)
        mr = self.sess.getQueryService().findByQuery(
            'from MapAnnotation ann join fetch ann.mapValue where id=:id',
            params)

        assert unwrap(mr.getNs()) == ns
        assert unwrap(mr.getMapValue()) == d

    @pytest.mark.parametrize('projection', [True, False, ('bb',)])
    def test_query_by_map_ann(self, projection):
        ns = UserAccount.uuid()
        ma = OmeroMetadata.MapAnnotations(self.sess, namespace=ns)

        d1 = {'a': '1', 'bb': 'cc'}
        d1f = {'bb': 'cc'}
        d2 = {'a': '1', 'bb': 'd'}
        d2f = {'bb': 'd'}

        m1 = omero.model.MapAnnotationI()
        m1.setNs(wrap(ns))
        m1.setMapValue(wrap(d1).val)
        m2 = omero.model.MapAnnotationI()
        m2.setNs(wrap(ns))
        m2.setMapValue(wrap(d2).val)

        m1 = self.sess.getUpdateService().saveAndReturnObject(m1)
        m2 = self.sess.getUpdateService().saveAndReturnObject(m2)

        rs = ma.query_by_map_ann(d1, projection)
        assert len(rs) == 1
        if projection:
            if projection is True:
                assert rs.values()[0] == d1
            else:
                assert rs.values()[0] == d1f
        else:
            assert unwrap(rs[0].getNs()) == ns
            assert unwrap(rs[0].getMapValue()) == d1

        rs = ma.query_by_map_ann({'a': '1'}, projection)
        assert len(rs) == 2
        if projection:
            rmv1, rmv2 = rs.values()
            if projection is True:
                self.assert_equal_any_order((rmv1, rmv2), (d1, d2))
            else:
                self.assert_equal_any_order((rmv1, rmv2), (d1f, d2f))
        else:
            assert unwrap(rs[0].getNs()) == ns
            assert unwrap(rs[1].getNs()) == ns
            rmv1 = unwrap(rs[0].getMapValue())
            rmv2 = unwrap(rs[1].getMapValue())
            self.assert_equal_any_order((rmv1, rmv2), (d1, d2))
 def setup_class(self):
     self.ua = UserAccount()
     self.user = self.ua.new_user(perms='rwra--')
Example #12
0
 def setup_class(self):
     self.ua = UserAccount()
     self.user = self.ua.new_user()
Example #13
0
class TestUtils(object):

    def setup_class(self):
        self.ua = UserAccount()
        self.user = self.ua.new_user()

    def teardown_class(self):
        self.ua.close()

    def setup_method(self, method):
        self.cli = omero.client()
        un = unwrap(self.user.getOmeName())
        self.sess = self.cli.createSession(un, un)

    def teardown_method(self, method):
        self.cli.closeSession()

    def create_image(self):
        szx, szy, szz, szc, szt = 4, 5, 6, 7, 8

        def planegen():
            for count in xrange(szz * szc * szt):
                yield numpy.ones((szy, szx), numpy.uint16) * count

        conn = omero.gateway.BlitzGateway(client_obj=self.cli)
        im = conn.createImageFromNumpySeq(planegen(), __name__, szz, szc, szt)
        return im._obj

    @pytest.mark.parametrize('robject', [True, False])
    def test_create_roi_for_plane(self, robject):
        im = self.create_image()

        r = utils.create_roi_for_plane(
            self.sess, unwrap(im.getId()), 2, 4, 6, robject=robject)
        if not robject:
            p = omero.sys.ParametersI()
            p.addId(r)
            r = self.sess.getQueryService().findByQuery(
                'FROM Roi r JOIN FETCH r.shapes where r.id=:id', p)

        assert r.getImage().getId() == im.getId()
        assert r.sizeOfShapes() == 1

        s = r.getShape(0)
        assert unwrap(s.getX()) == 0
        assert unwrap(s.getY()) == 0
        assert unwrap(s.getWidth()) == 4
        assert unwrap(s.getHeight()) == 5
        assert unwrap(s.getTheZ()) == 2
        assert unwrap(s.getTheC()) == 4
        assert unwrap(s.getTheT()) == 6

    @pytest.mark.parametrize('projection', [True, False])
    def test_find_rois_for_plane(self, projection):
        def getIds(objs, robject=True):
            if robject:
                return sorted(unwrap(o.getId()) for o in objs)
            return sorted(objs)

        im = self.create_image()
        iid = unwrap(im.getId())

        r1 = utils.create_roi_for_plane(
            self.sess, unwrap(im.getId()), 2, 3, 4, robject=True)
        r2 = utils.create_roi_for_plane(
            self.sess, unwrap(im.getId()), 2, 4, 6, robject=True)

        r3 = utils.create_roi_for_plane(
            self.sess, unwrap(im.getId()), 2, 4, 8, robject=True)
        r3.getShape(0).setWidth(rdouble(1))
        r3 = self.sess.getUpdateService().saveAndReturnObject(r3)

        r4 = utils.create_roi_for_plane(
            self.sess, unwrap(im.getId()), 2, 4, 8, robject=True)
        r4.addShape(omero.model.RectI())
        r4 = self.sess.getUpdateService().saveAndReturnObject(r4)

        rs = utils.find_rois_for_plane(self.sess, iid=iid, z=1000)
        assert rs == []

        rs = utils.find_rois_for_plane(
            self.sess, iid=iid, fullplane=True, projection=projection)
        assert getIds(rs, not projection) == getIds([r1, r2])

        rs = utils.find_rois_for_plane(
            self.sess, iid=iid, singleshape=False, projection=projection)
        assert getIds(rs, not projection) == getIds([r1, r2, r4])

        rs = utils.find_rois_for_plane(
            self.sess, iid=iid, fullplane=False, projection=projection)
        assert getIds(rs, not projection) == getIds([r1, r2, r3])

        rs = utils.find_rois_for_plane(
            self.sess, iid=iid, c=4, fullplane=False, singleshape=False,
            projection=projection)
        assert getIds(rs, not projection) == getIds([r2, r3, r4])
 def setup_class(self):
     self.ua = UserAccount()
     self.user = self.ua.new_user(perms="rwra--")
class TestFeatureSetTableStore(object):

    def setup_class(self):
        self.ua = UserAccount()
        self.user = self.ua.new_user()

    def teardown_class(self):
        self.ua.close()

    def setup_method(self, method):
        self.cli = omero.client()
        un = unwrap(self.user.getOmeName())
        self.sess = self.cli.createSession(un, un)
        self.fsmeta = {'fsname': 'a'}
        ns = UserAccount.uuid()
        self.nsc = ns + '/c'
        self.nsr = ns + '/r'

    def teardown_method(self, method):
        self.cli.closeSession()

    @pytest.mark.parametrize('exists', [True, False])
    def test_get_table(self, exists):

        store = FeatureSetTableStoreProxy(
            self.sess, self.nsc, self.nsr, self.fsmeta)

        if exists:
            tid, tcols = TableStoreHelper.create_table(
                self.sess, self.nsc, self.fsmeta)
            table = store.get_table()

            assert table and table == store.table
            TableStoreHelper.assert_coltypes_equal(store.cols, tcols)
        else:
            with pytest.raises(OmeroTablesFeatureStore.NoTableMatchException):
                store.get_table()

    def test_new_table(self):

        tcols = [
            omero.grid.LongArrayColumn('Integers', '', 1),
            omero.grid.LongArrayColumn('Longs', '', 2),
            omero.grid.DoubleArrayColumn('Floats', '', 3),
            omero.grid.StringColumn('String', '', 4),
        ]

        desc = [
            (int, 'Integers', 1),
            (long, 'Longs', 2),
            (float, 'Floats', 3),
            (str, 'String', 4),
        ]

        store = FeatureSetTableStoreProxy(
            self.sess, self.nsc, self.nsr, self.fsmeta)
        store.new_table(desc)
        assert store.table
        TableStoreHelper.assert_coltypes_equal(store.cols, tcols)

        tid = unwrap(store.table.getOriginalFile().getId())

        params = omero.sys.ParametersI()
        params.addString('ns', self.nsc)
        ann = self.sess.getQueryService().findByQuery(
            'from MapAnnotation ann join fetch ann.mapValue where ann.ns=:ns',
            params)

        assert unwrap(ann.getNs()) == self.nsc
        m = unwrap(ann.getMapValue())
        assert len(m) == 2
        assert m['fsname'] == 'a'
        assert m['_tableid'] == str(tid)

        store.close()

    def test_open_table(self):
        tid, tcols = TableStoreHelper.create_table(
            self.sess, self.nsc, self.fsmeta)

        store = FeatureSetTableStoreProxy(
            self.sess, self.nsc, self.nsr, self.fsmeta)
        store.open_table(tid)
        assert store.table
        TableStoreHelper.assert_coltypes_equal(store.cols, tcols)

    def test_store1(self):
        tid, tcols = TableStoreHelper.create_table(
            self.sess, self.nsc, self.fsmeta)

        store = OmeroTablesFeatureStore.FeatureSetTableStore(
            self.sess, self.nsc, self.nsr, self.fsmeta)
        TableStoreHelper.assert_coltypes_equal(store.cols, tcols)
        assert store.table.getNumberOfRows() == 0

        rowmeta = {'objectid': 4}
        values = [[1, 2], [-1.0]]
        store.store1(rowmeta, values)

        assert store.table.getNumberOfRows() == 1
        data = store.table.readCoordinates([0])
        assert data.columns[0].values == [values[0]]
        assert data.columns[1].values == [values[1]]

        params = omero.sys.ParametersI()
        params.addString('ns', self.nsr)

        ann = self.sess.getQueryService().findAllByQuery(
            'from MapAnnotation ann join fetch ann.mapValue where ann.ns=:ns',
            params)
        assert len(ann) == 1
        ann = ann[0]

        assert unwrap(ann.getNs()) == self.nsr
        m = unwrap(ann.getMapValue())
        assert len(m) == 3
        assert m['objectid'] == '4'
        assert m['_tableid'] == str(tid)
        assert m['_offset'] == '0'

        store.close()

    def test_store(self):
        tid, tcols = TableStoreHelper.create_table(
            self.sess, self.nsc, self.fsmeta)

        store = OmeroTablesFeatureStore.FeatureSetTableStore(
            self.sess, self.nsc, self.nsr, self.fsmeta)
        TableStoreHelper.assert_coltypes_equal(store.cols, tcols)
        assert store.table.getNumberOfRows() == 0

        rowmetas = [{'objectid': 4}, {'objectid': 5}]
        valuess = [([1, 2], [-1.0]), ([3, 4], [-2.0])]
        store.store(rowmetas, valuess)

        assert store.table.getNumberOfRows() == 2
        data = store.table.readCoordinates([0, 1])
        assert data.columns[0].values == [valuess[0][0], valuess[1][0]]
        assert data.columns[1].values == [valuess[0][1], valuess[1][1]]

        params = omero.sys.ParametersI()
        params.addString('ns', self.nsr)

        ann = self.sess.getQueryService().findAllByQuery(
            'from MapAnnotation ann join fetch ann.mapValue where ann.ns=:ns',
            params)
        assert len(ann) == 2
        ann1 = ann[0]
        ann2 = ann[1]

        assert unwrap(ann1.getNs()) == self.nsr
        m1 = unwrap(ann1.getMapValue())
        assert len(m1) == 3
        assert m1['objectid'] == '4'
        assert m1['_tableid'] == str(tid)
        assert m1['_offset'] == '0'

        assert unwrap(ann2.getNs()) == self.nsr
        m2 = unwrap(ann2.getMapValue())
        assert len(m2) == 3
        assert m2['objectid'] == '5'
        assert m2['_tableid'] == str(tid)
        assert m2['_offset'] == '1'

        store.close()

    def test_fetch(self):
        tid, tcols = TableStoreHelper.create_table(
            self.sess, self.nsc, self.fsmeta)

        store = OmeroTablesFeatureStore.FeatureSetTableStore(
            self.sess, self.nsc, self.nsr, self.fsmeta)
        TableStoreHelper.assert_coltypes_equal(store.cols, tcols)
        assert store.table.getNumberOfRows() == 0

        rowmetas = [{'objectid': '4'}, {'objectid': '5'}]
        valuess = [([1, 2], [-1.0]), ([3, 4], [-2.0])]
        store.store(rowmetas, valuess)

        rowquery = {'objectid': '4'}
        ra, rv = store.fetch(rowquery)
        assert len(ra) == 1
        assert len(rv) == 1
        assert ra[0]['objectid'] == '4'
        assert rv[0] == valuess[0]

        rowquery = {'objectid': ['4', '5']}
        ra, rv = store.fetch(rowquery)
        # Could be either way round
        assert len(ra) == 2
        assert len(rv) == 2
        assert compare_2_2([ra[0]['objectid'], ra[1]['objectid']], ['4', '5'])
        assert compare_2_2(rv, valuess)

        store.close()
class TestFeatureTableStore(object):

    def setup_class(self):
        self.ua = UserAccount()
        self.user = self.ua.new_user()

    def teardown_class(self):
        self.ua.close()

    def setup_method(self, method):
        self.cli = omero.client()
        un = unwrap(self.user.getOmeName())
        self.sess = self.cli.createSession(un, un)
        self.fsmeta = {'fsname': 'a', 'version': '1'}
        self.rowmetas = [{'id': '1'}, {'id': '2'}]
        self.valuess = [[1.0, 2.0], [-1.0, -2.0]]
        self.ns = UserAccount.uuid()
        self.nsc = self.ns + '/featureset'
        self.nsr = self.ns + '/sample'

    def teardown_method(self, method):
        self.cli.closeSession()

    def test_create_feature_set(self):
        fts = OmeroTablesFeatureStore.FeatureTableStore(
            self.sess, namespace=self.ns, cachesize=1)

        with pytest.raises(OmeroTablesFeatureStore.NoTableMatchException):
            store = fts.get_feature_set(self.fsmeta)

        col_desc = [(int, 'x', 1)]
        fts.create_feature_set(self.fsmeta, col_desc)
        store = fts.get_feature_set(self.fsmeta)

        expected_cols = [omero.grid.LongArrayColumn('x', '', 1)]
        TableStoreHelper.assert_coltypes_equal(store.cols, expected_cols)

        with pytest.raises(OmeroTablesFeatureStore.TooManyTablesException):
            fts.create_feature_set(self.fsmeta, col_desc)

        fts.close()

    def test_get_feature_set(self):
        tid, tcols = TableStoreHelper.create_table(
            self.sess, self.nsc, self.fsmeta)
        fts = OmeroTablesFeatureStore.FeatureTableStore(
            self.sess, namespace=self.ns, cachesize=1)
        store = fts.get_feature_set(self.fsmeta)

        assert store.table
        TableStoreHelper.assert_coltypes_equal(store.cols, tcols)
        fts.close()

    def test_store_fetch(self):
        tid, tcols = TableStoreHelper.create_table(
            self.sess, self.nsc, self.fsmeta)
        fts = OmeroTablesFeatureStore.FeatureTableStore(
            self.sess, namespace=self.ns, cachesize=1)

        rowmetas = [{'objectid': 4}, {'objectid': 5}]
        valuess = [([1, 2], [-1.0]), ([3, 4], [-2.0])]
        fts.store(self.fsmeta, rowmetas, valuess)

        assert len(fts.fss) == 1

        store = fts.get_feature_set(self.fsmeta)
        assert store.table
        TableStoreHelper.assert_coltypes_equal(store.cols, tcols)

        rowquery = {'objectid': ['4', '5']}
        ra, rv = store.fetch(rowquery)
        # Could be either way round
        assert len(ra) == 2
        assert len(rv) == 2
        assert compare_2_2([ra[0]['objectid'], ra[1]['objectid']], ['4', '5'])
        assert compare_2_2(rv, valuess)

        fts.close()