omero-marshal/omero_marshal/__init__.py at b8561a3b7a9202361a736d64cd01cf75a3d11714 · ome/omero-marshal · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
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
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# Copyright (c) 2015 Glencoe Software, Inc. All rights reserved.
#
# This software is distributed under the terms described by the LICENCE file
# you can find at the root of the distribution bundle.
# If the file is missing please request a copy by contacting
# jason@glencoesoftware.com.
#

import importlib
import pkgutil
import logging
import re
from .encode import encoders
from .decode import decoders
from packaging.version import Version
from omero_version import omero_version

logger = logging.getLogger('omero-marshal')


ENCODERS = dict()
DECODERS = dict()


def dumps(obj):
    pass


def get_encoder(t):
    try:
        return ENCODERS[t]
    except KeyError:
        logger.warn('Requested unknown encoder %s' % t, exc_info=True)
        return None


def get_decoder(t):
    t = get_full_type(t)
    try:
        return DECODERS[t]
    except KeyError:
        logger.warn('Requested unknown decoder %s' % t, exc_info=True)
        return None


VERSION_REGEXP = re.compile(r'^(\d+\.\d+)\.(a|b|dev|rc)?\d+')


def get_schema_version(version):
    m = VERSION_REGEXP.search(version)
    if m is None:
        raise Exception("Invalid OMERO version number: " + version)
    v = Version(m.group(1))
    if v >= Version('5.1.0') and v < Version('5.3.0'):
        return '2015-01'
    elif v >= Version('5.3.0') and v < Version('6.0.0'):
        return '2016-06'
    else:
        raise Exception("Unsupported OMERO version: " + version)


SCHEMA_VERSION = get_schema_version(omero_version)
BASE_URL = 'http://www.openmicroscopy.org/Schemas'
if SCHEMA_VERSION == "2015-01":
    ROI_NS = 'ROI'
    SA_NS = 'SA'
    SPW_NS = 'SPW'
else:
    ROI_NS = 'OME'
    SA_NS = 'OME'
    SPW_NS = 'OME'
OME_SCHEMA_URL = '%s/OME/%s' % (BASE_URL, SCHEMA_VERSION)
ROI_SCHEMA_URL = '%s/%s/%s' % (BASE_URL, ROI_NS, SCHEMA_VERSION)
SA_SCHEMA_URL = '%s/%s/%s' % (BASE_URL, SA_NS, SCHEMA_VERSION)
SPW_SCHEMA_URL = '%s/%s/%s' % (BASE_URL, SPW_NS, SCHEMA_VERSION)


def get_full_type(t):
    if t.startswith("http"):
        return t
    elif t.startswith("omero:"):
        return '%s/OMERO/%s#%s' % (BASE_URL, SCHEMA_VERSION, t[6:])
    else:
        return '%s/OME/%s#%s' % (BASE_URL, SCHEMA_VERSION, t)


class MarshallingCtx(object):

    def __init__(self, encoders, decoders):
        self.encoders = encoders
        self.decoders = decoders

    def get_encoder(self, t):
        try:
            return self.encoders[t]
        except KeyError:
            logger.warn('Requested unknown encoder %s' % t, exc_info=True)
            return None

    def get_decoder(self, t):
        t = get_full_type(t)
        try:
            return self.decoders[t]
        except KeyError:
            logger.warn('Requested unknown decoder %s' % t, exc_info=True)
            return None


_ctx = MarshallingCtx(ENCODERS, DECODERS)

packages = pkgutil.walk_packages(encoders.__path__, encoders.__name__ + '.')
for module_loader, name, ispkg in packages:
    m = importlib.import_module(name)
    try:
        t, encoder = m.encoder
        ENCODERS[t] = encoder(_ctx)
    except AttributeError:
        pass

packages = pkgutil.walk_packages(decoders.__path__, decoders.__name__ + '.')
for module_loader, name, ispkg in packages:
    m = importlib.import_module(name)
    try:
        t, decoder = m.decoder
        DECODERS[t] = decoder(_ctx)
    except AttributeError:
        pass