Пример #1
0
def test_merge_io_formats_wps_complements_cwl():
    wps_fmt = [Format(CONTENT_TYPE_APP_JSON, encoding="utf-8")]
    cwl_fmt = [Format(CONTENT_TYPE_APP_JSON)]
    res_fmt = merge_io_formats(wps_fmt, cwl_fmt)
    assert isinstance(res_fmt, list)
    assert_formats_equal_any_order(
        res_fmt, [Format(CONTENT_TYPE_APP_JSON, encoding="utf-8")])
Пример #2
0
    def test_format_class(self):
        """Test pywps.formats.Format class
        """
        frmt = Format('mimetype', schema='halloworld', encoding='asdf',
                      validate=self.validate)

        self.assertEqual(frmt.mime_type, 'mimetype')
        self.assertEqual(frmt.schema, 'halloworld')
        self.assertEqual(frmt.encoding, 'asdf')
        self.assertTrue(frmt.validate('the input', 1))

        describeel = frmt.describe_xml()
        self.assertEqual('Format', describeel.tag)
        mimetype = xpath_ns(describeel, '/Format/MimeType')
        encoding = xpath_ns(describeel, '/Format/Encoding')
        schema = xpath_ns(describeel, '/Format/Schema')

        self.assertTrue(mimetype)
        self.assertTrue(encoding)
        self.assertTrue(schema)

        self.assertEqual(mimetype[0].text, 'mimetype')
        self.assertEqual(encoding[0].text, 'asdf')
        self.assertEqual(schema[0].text, 'halloworld')

        frmt2 = get_format('GML')

        self.assertFalse(frmt.same_as(frmt2))
Пример #3
0
    def test_format_class(self):
        """Test pywps.formats.Format class
        """
        frmt = Format('mimetype',
                      schema='halloworld',
                      encoding='asdf',
                      validate=self.validate)

        self.assertEqual(frmt.mime_type, 'mimetype')
        self.assertEqual(frmt.schema, 'halloworld')
        self.assertEqual(frmt.encoding, 'asdf')
        self.assertTrue(frmt.validate('the input', 1))

        describeel = frmt.describe_xml()
        self.assertEqual('Format', describeel.tag)
        mimetype = xpath_ns(describeel, '/Format/MimeType')
        encoding = xpath_ns(describeel, '/Format/Encoding')
        schema = xpath_ns(describeel, '/Format/Schema')

        self.assertTrue(mimetype)
        self.assertTrue(encoding)
        self.assertTrue(schema)

        self.assertEqual(mimetype[0].text, 'mimetype')
        self.assertEqual(encoding[0].text, 'asdf')
        self.assertEqual(schema[0].text, 'halloworld')

        frmt2 = get_format('GML')

        self.assertFalse(frmt.same_as(frmt2))
Пример #4
0
    def from_json(cls, json_input):
        instance = cls(
            identifier=json_input['identifier'],
            title=json_input.get('title'),
            abstract=json_input.get('abstract'),
            keywords=json_input.get('keywords', []),
            workdir=json_input.get('workdir'),
            metadata=[
                Metadata.from_json(data)
                for data in json_input.get('metadata', [])
            ],
            data_format=Format(
                schema=json_input['data_format'].get('schema'),
                extension=json_input['data_format'].get('extension'),
                mime_type=json_input['data_format']['mime_type'],
                encoding=json_input['data_format'].get('encoding')),
            supported_formats=[
                Format(schema=infrmt.get('schema'),
                       extension=infrmt.get('extension'),
                       mime_type=infrmt['mime_type'],
                       encoding=infrmt.get('encoding'))
                for infrmt in json_input['supported_formats']
            ],
            mode=json_input.get('mode', MODE.NONE))
        instance.as_reference = json_input.get('asreference', False)
        if json_input.get('file'):
            instance.file = json_input['file']
        elif json_input.get('href'):
            instance.url = json_input['href']
        elif json_input.get('data'):
            instance.data = json_input['data']

        return instance
Пример #5
0
def test_get_format():
    assert f.get_format(f.ContentType.APP_JSON) == Format(
        f.ContentType.APP_JSON)  # basic
    assert f.get_format(f.ContentType.APP_JSON + "; charset=UTF-8") == Format(
        f.ContentType.APP_JSON)
    assert f.get_format(f.ContentType.APP_GEOJSON) == Format(
        f.ContentType.APP_GEOJSON)  # pywps vendor MIME-type
    assert f.get_format(f.ContentType.APP_NETCDF
                        ).encoding == "base64"  # extra encoding data available
Пример #6
0
def test_merge_io_formats_both_wps_and_cwl():
    wps_fmt = [Format(CONTENT_TYPE_APP_NETCDF)]
    cwl_fmt = [Format(CONTENT_TYPE_APP_JSON)]
    res_fmt = merge_io_formats(wps_fmt, cwl_fmt)
    assert isinstance(res_fmt, list)
    assert_formats_equal_any_order(
        res_fmt,
        [Format(CONTENT_TYPE_APP_NETCDF),
         Format(CONTENT_TYPE_APP_JSON)])
Пример #7
0
def test_wps2json_io_default_format():
    # must create object with matching data/supported formats or error otherwise
    wps_io = ComplexInput("test", "", supported_formats=[DEFAULT_FORMAT], data_format=DEFAULT_FORMAT)
    # then simulate that a merging/resolution replaced the supported formats
    wps_io.supported_formats = []
    # conversion should employ the default format since none specified
    json_io = wps2json_io(wps_io)
    default = {
        "default": True,
        "mediaType": DEFAULT_FORMAT.mime_type,
        "extension": DEFAULT_FORMAT.extension,
        "encoding": DEFAULT_FORMAT.encoding,
        "schema": DEFAULT_FORMAT.schema,
    }
    assert json_io["formats"] == [default]

    # do the same thing again, but 'default' should be False because default plain/text
    # format is not defined as 'data_format' (used as default specifier)
    json_fmt = Format(ContentType.APP_JSON)
    wps_io = ComplexInput("test", "", supported_formats=[json_fmt], data_format=json_fmt)
    wps_io.supported_formats = []
    json_io = wps2json_io(wps_io)
    default = {
        "default": False,   # <-- this is what must be different
        "mediaType": DEFAULT_FORMAT.mime_type,
        "extension": DEFAULT_FORMAT.extension,
        "encoding": DEFAULT_FORMAT.encoding,
        "schema": DEFAULT_FORMAT.schema,
    }
    assert json_io["formats"] == [default]
Пример #8
0
    def test_json_in(self):
        """Test json import
        """

        injson = {}
        injson['schema'] = 'elcepelce'
        injson['extension'] = '.gml'
        injson['mime_type'] = 'application/gml+xml'
        injson['encoding'] = 'utf-8'

        frmt = Format(injson['mime_type'])
        frmt.json = injson

        self.assertEqual(injson['schema'], frmt.schema)
        self.assertEqual(injson['extension'], frmt.extension)
        self.assertEqual(injson['mime_type'], frmt.mime_type)
        self.assertEqual(injson['encoding'], frmt.encoding)
Пример #9
0
    def test_json_in(self):
        """Test json import
        """

        injson = {}
        injson['schema'] = 'elcepelce'
        injson['extension'] = '.gml'
        injson['mime_type'] = 'application/gml+xml'
        injson['encoding'] = 'utf-8'

        frmt = Format(injson['mime_type'])
        frmt.json = injson

        self.assertEqual(injson['schema'], frmt.schema)
        self.assertEqual(injson['extension'], frmt.extension)
        self.assertEqual(injson['mime_type'], frmt.mime_type)
        self.assertEqual(injson['encoding'], frmt.encoding)
Пример #10
0
def test_get_format_media_type_no_extension():
    for ctype in [
            f.ContentType.APP_OCTET_STREAM,
            f.ContentType.APP_FORM,
            f.ContentType.MULTI_PART_FORM,
    ]:
        fmt = f.get_format(ctype)
        assert fmt == Format(ctype, extension=None)
        assert fmt.extension == ""
Пример #11
0
def test_merge_io_formats_wps_overlaps_cwl():
    wps_fmt = [
        Format(ContentType.APP_JSON, encoding="utf-8"),    # complements CWL details
        Format(ContentType.APP_NETCDF),                    # duplicated in CWL (but different index)
        Format(ContentType.TEXT_PLAIN)                     # extra (but not default)
    ]
    cwl_fmt = [
        Format(ContentType.APP_JSON),      # overridden by WPS version
        Format(ContentType.APP_XML),       # extra preserved
        Format(ContentType.APP_NETCDF),    # duplicated with WPS, merged
    ]
    res_fmt = merge_io_formats(wps_fmt, cwl_fmt)
    assert isinstance(res_fmt, list)
    assert_formats_equal_any_order(res_fmt, [
        Format(ContentType.APP_JSON, encoding="utf-8"),
        Format(ContentType.APP_NETCDF),
        Format(ContentType.APP_XML),
        Format(ContentType.TEXT_PLAIN),
    ])
Пример #12
0
def test_get_format_default_no_extension():
    for val in ["", None]:
        for ctype in [
                f.ContentType.APP_OCTET_STREAM,
                f.ContentType.APP_FORM,
                f.ContentType.MULTI_PART_FORM,
        ]:
            fmt = f.get_format(val, default=ctype)
            assert fmt == Format(ctype, extension=None)
            assert fmt.extension == ""
Пример #13
0
    def test_format_class(self):
        """Test pywps.formats.Format class
        """
        frmt = Format('mimetype', schema='halloworld', encoding='asdf',
                      validate=self.validate)

        self.assertEqual(frmt.mime_type, 'mimetype')
        self.assertEqual(frmt.schema, 'halloworld')
        self.assertEqual(frmt.encoding, 'asdf')
        self.assertTrue(frmt.validate('the input', 1))

        describeel = frmt.json

        self.assertEqual(describeel["mime_type"], 'mimetype')
        self.assertEqual(describeel["encoding"], 'asdf')
        self.assertEqual(describeel["schema"], 'halloworld')

        frmt2 = get_format('GML')

        self.assertFalse(frmt.same_as(frmt2))
Пример #14
0
def get_format(mime_type, default=None):
    # type: (str, Optional[str]) -> Format
    """
    Obtains a :class:`Format` with predefined extension and encoding details from known MIME-types.
    """
    ctype = clean_mime_type_format(mime_type, strip_parameters=True)
    fmt = _CONTENT_TYPE_FORMAT_MAPPING.get(mime_type)
    if fmt is not None:
        return fmt
    if default is not None:
        ctype = default
    return Format(ctype, extension=get_extension(ctype))
Пример #15
0
    def test_format_class(self):
        """Test pywps.formats.Format class
        """
        frmt = Format('mimetype',
                      schema='halloworld',
                      encoding='asdf',
                      validate=self.validate)

        self.assertEqual(frmt.mime_type, 'mimetype')
        self.assertEqual(frmt.schema, 'halloworld')
        self.assertEqual(frmt.encoding, 'asdf')
        self.assertTrue(frmt.validate('the input', 1))

        describeel = frmt.json

        self.assertEqual(describeel["mime_type"], 'mimetype')
        self.assertEqual(describeel["encoding"], 'asdf')
        self.assertEqual(describeel["schema"], 'halloworld')

        frmt2 = get_format('GML')

        self.assertFalse(frmt.same_as(frmt2))
Пример #16
0
def test_any2cwl_io_from_wps():
    fmt = Format(ContentType.APP_NETCDF)
    wps_io = ComplexInput("test", "", supported_formats=[fmt], data_format=fmt)
    # use 'json' to obtain 'type' field, but otherwise fields are named the same as if using the object
    wps_as_json = wps_io.json
    cwl_io, cwl_ns = any2cwl_io(wps_as_json, "input")
    assert cwl_io == {
        "id": "test",
        "type": "File",
        "format": f"edam:{EDAM_MAPPING[ContentType.APP_NETCDF]}"
    }
    assert cwl_ns == EDAM_NAMESPACE_DEFINITION

    # retry by manually injecting the type to validate that
    # pre-resolved type can also be converted directly from object
    # since the object is used rather than its JSON representation,
    # potentially more field definitions are available to extract CWL equivalents
    setattr(wps_io, "type", "complex")
    cwl_io, cwl_ns = any2cwl_io(wps_io, "input")
    assert cwl_io == {
        "id": "test",
        "type": "File",
        "format": f"edam:{EDAM_MAPPING[ContentType.APP_NETCDF]}",
        "default": None,
    }
    assert cwl_ns == EDAM_NAMESPACE_DEFINITION

    wps_io.min_occurs = 10
    wps_io.max_occurs = 20
    # use 'json' to obtain 'type' field, but otherwise fields are named the same as if using the object
    cwl_io, cwl_ns = any2cwl_io(wps_io, "input")
    assert cwl_io == {
        "id": "test",
        "type": {"type": "array", "items": "File"},
        "format": f"edam:{EDAM_MAPPING[ContentType.APP_NETCDF]}",
        "default": None,
    }
    assert cwl_ns == EDAM_NAMESPACE_DEFINITION
Пример #17
0
def get_format(mime_type):
    # type: (str) -> Format
    """Obtains a :class:`Format` with predefined extension and encoding details from known MIME-types."""
    ctype = clean_mime_type_format(mime_type, strip_parameters=True)
    return _CONTENT_TYPE_FORMAT_MAPPING.get(
        mime_type, Format(ctype, extension=get_extension(ctype)))
Пример #18
0
    def json(self, value):
        """init this request from json back again

        :param value: the json (not string) representation
        """

        self.operation = value['operation']
        self.version = value['version']
        self.language = value['language']
        self.identifier = value['identifier']
        self.identifiers = value['identifiers']
        self.store_execute = value['store_execute']
        self.status = value['status']
        self.lineage = value['lineage']
        self.outputs = value['outputs']
        self.raw = value['raw']
        self.inputs = {}

        for identifier in value['inputs']:
            inpt = None
            inpt_defs = value['inputs'][identifier]

            for inpt_def in inpt_defs:

                if inpt_def['type'] == 'complex':
                    inpt = ComplexInput(
                        identifier=inpt_def['identifier'],
                        title=inpt_def.get('title'),
                        abstract=inpt_def.get('abstract'),
                        workdir=inpt_def.get('workdir'),
                        data_format=Format(
                            schema=inpt_def['data_format'].get('schema'),
                            extension=inpt_def['data_format'].get('extension'),
                            mime_type=inpt_def['data_format']['mime_type'],
                            encoding=inpt_def['data_format'].get('encoding')),
                        supported_formats=[
                            Format(schema=infrmt.get('schema'),
                                   extension=infrmt.get('extension'),
                                   mime_type=infrmt['mime_type'],
                                   encoding=infrmt.get('encoding'))
                            for infrmt in inpt_def['supported_formats']
                        ],
                        mode=MODE.NONE)
                    inpt.file = inpt_def['file']
                elif inpt_def['type'] == 'literal':

                    allowed_values = []
                    for allowed_value in inpt_def['allowed_values']:
                        if allowed_value['type'] == 'anyvalue':
                            allowed_values.append(AnyValue())
                        elif allowed_value['type'] == 'novalue':
                            allowed_values.append(NoValue())
                        elif allowed_value['type'] == 'valuesreference':
                            allowed_values.append(ValuesReference())
                        elif allowed_value['type'] == 'allowedvalue':
                            allowed_values.append(
                                AllowedValue(
                                    allowed_type=allowed_value['allowed_type'],
                                    value=allowed_value['value'],
                                    minval=allowed_value['minval'],
                                    maxval=allowed_value['maxval'],
                                    spacing=allowed_value['spacing'],
                                    range_closure=allowed_value[
                                        'range_closure']))

                    inpt = LiteralInput(identifier=inpt_def['identifier'],
                                        title=inpt_def.get('title'),
                                        abstract=inpt_def.get('abstract'),
                                        data_type=inpt_def.get('data_type'),
                                        workdir=inpt_def.get('workdir'),
                                        allowed_values=AnyValue,
                                        uoms=inpt_def.get('uoms'),
                                        mode=inpt_def.get('mode'))
                    inpt.uom = inpt_def.get('uom')
                    inpt.data = inpt_def.get('data')

                elif inpt_def['type'] == 'bbox':
                    inpt = BBoxInput(identifier=inpt_def['identifier'],
                                     title=inpt_def['title'],
                                     abstract=inpt_def['abstract'],
                                     crss=inpt_def['crs'],
                                     dimensions=inpt_def['dimensions'],
                                     workdir=inpt_def['workdir'],
                                     mode=inpt_def['mode'])
                    inpt.ll = inpt_def['bbox'][0]
                    inpt.ur = inpt_def['bbox'][1]

            if identifier in self.inputs:
                self.inputs[identifier].append(inpt)
            else:
                self.inputs[identifier] = [inpt]
Пример #19
0
def test_merge_io_formats_with_wps_and_default_cwl():
    wps_fmt = [Format(ContentType.APP_NETCDF)]
    cwl_fmt = [DEFAULT_FORMAT]
    res_fmt = merge_io_formats(wps_fmt, cwl_fmt)
    assert isinstance(res_fmt, list)
    assert_formats_equal_any_order(res_fmt, [Format(ContentType.APP_NETCDF)])