eoxserver.core.decoders package

Submodules

eoxserver.core.decoders.base module

This module provides base functionality for any other decoder class.

class eoxserver.core.decoders.base.BaseParameter(type=None, num=1, default=None)

Bases: property

Abstract base class for XML, KVP or any other kind of parameter.

fget(decoder)

Property getter function.

locator
select(decoder)

Interface method.

eoxserver.core.decoders.config module

This module contains facilities to help decoding configuration files. It relies on the ConfigParser module for actually reading the file.

class eoxserver.core.decoders.config.Option(key=None, type=None, separator=None, required=False, default=None, section=None, doc=None)

Bases: property

The Option is used as a property for Reader subclasses.

Parameters:
  • key – the lookup key; defaults to the property name of the Reader.
  • type – the type to parse the raw value; by default the raw string is returned
  • separator – the separator for list options; by default no list is assumed
  • required – if True raise an error if the option does not exist
  • default – the default value
  • section – override the section for this option
check(reader)
fget(reader)
class eoxserver.core.decoders.config.Reader(config)

Bases: object

Base class for config readers.

Parameters:config – an instance of ConfigParser.RawConfigParser

Readers should be used as such:

from ConfigParser import RawConfigParser
try:
    from cStringIO import StringIO
except ImportError:
    from io import StringIO
from textwrap import dedent
from eoxserver.core.decoders import config

class ExampleReader(config.Reader):
    section = "example_section"
    string_opt = config.Option()
    string_list_opt = config.Option(separator=",")
    integer_opt = config.Option(type=int)

    section = "other_section"
    mandatory_opt = config.Option(required=True)
    optional_opt = config.Option(default="some_default")

    special_section_opt = config.Option(section="special_section")

f = StringIO(dedent('''
    [example_section]
    string_opt = mystring
    string_list_opt = my,string,list
    integer_opt = 123456
    [other_section]
    mandatory_opt = mandatory_value
    # optional_opt = no value

    [special_section]
    special_section_opt = special_value
'''))

parser = RawConfigParser()
parser.readfp(f)
reader = ExampleReader(parser)

print reader.string_opt
print reader.string_list_opt
print reader.integer_opt
print reader.mandatory_opt
print reader.optional_opt
...
section = None
class eoxserver.core.decoders.config.ReaderMetaclass(name, bases, dct)

Bases: type

eoxserver.core.decoders.config.section(name)

Helper to set the section of a Reader.

eoxserver.core.decoders.kvp module

This module contains facilities to help decoding KVP strings.

class eoxserver.core.decoders.kvp.Decoder(params)

Bases: object

Base class for KVP decoders.

Parameters:params – an instance of either dict, django.http.QueryDict or basestring (which will be parsed using cgi.parse_qs())

Decoders should be used as such:

from eoxserver.core.decoders import kvp
from eoxserver.core.decoders import typelist

class ExampleDecoder(kvp.Decoder):
    mandatory_param = kvp.Parameter(num=1)
    list_param = kvp.Parameter(type=typelist(separator=","))
    multiple_param = kvp.Parameter("multi", num="+")
    optional_param = kvp.Parameter(num="?", default="default_value")

decoder = ExampleDecoder(
    "mandatory_param=value"
    "&list_param=a,b,c"
    "&multi=a&multi=b&multi=c"
)

print decoder.mandatory_param
print decoder.list_param
print decoder.multiple_param
print decoder.optional_param
class eoxserver.core.decoders.kvp.DecoderMetaclass(name, bases, dct)

Bases: type

Metaclass for KVP Decoders to allow easy parameter declaration.

class eoxserver.core.decoders.kvp.MultiParameter(selector, num=1, default=None, locator=None)

Bases: eoxserver.core.decoders.kvp.Parameter

Class for selecting different KVP parameters at once.

Parameters:
  • selector – a function to determine if a key is used for the multi parameter selection
  • num – defines how many times the key can be present; use any numeric value to set it to a fixed count, “*” for any number, “?” for zero or one time or “+” for one or more times
  • default – the default value
  • locator – override the locator in case of exceptions
select(decoder)

Interface method.

class eoxserver.core.decoders.kvp.Parameter(key=None, type=None, num=1, default=None, locator=None)

Bases: eoxserver.core.decoders.base.BaseParameter

Parameter for KVP values.

Parameters:
  • key – the lookup key; defaults to the property name of the Decoder
  • type – the type to parse the raw value; by default the raw string is returned
  • num – defines how many times the key can be present; use any numeric value to set it to a fixed count, “*” for any number, “?” for zero or one time or “+” for one or more times
  • default – the default value
  • locator – override the locator in case of exceptions
key = None
locator
select(decoder, decoder_class=None)

Interface method.

eoxserver.core.decoders.xml module

This module contains facilities to help decoding XML structures.

class eoxserver.core.decoders.xml.Decoder(tree)

Bases: object

Base class for XML Decoders.

param params:an instance of either lxml.etree.ElementTree, or basestring (which will be parsed using lxml.etree.fromstring())

Decoders should be used as such:

from eoxserver.core.decoders import xml
from eoxserver.core.decoders import typelist

class ExampleDecoder(xml.Decoder):
    namespaces = {"myns": "http://myns.org"}
    single = xml.Parameter("myns:single/text()", num=1)
    items = xml.Parameter("myns:collection/myns:item/text()", num="+")
    attr_a = xml.Parameter("myns:object/@attrA", num="?")
    attr_b = xml.Parameter("myns:object/@attrB", num="?", default="x")


decoder = ExampleDecoder('''
    <myns:root xmlns:myns="http://myns.org">
        <myns:single>value</myns:single>
        <myns:collection>
            <myns:item>a</myns:item>
            <myns:item>b</myns:item>
            <myns:item>c</myns:item>
        </myns:collection>
        <myns:object attrA="value"/>
    </myns:root>
''')

print decoder.single
print decoder.items
print decoder.attr_a
print decoder.attr_b
namespaces = {}
class eoxserver.core.decoders.xml.Parameter(selector, type=None, num=1, default=None, namespaces=None, locator=None)

Bases: eoxserver.core.decoders.base.BaseParameter

Parameter for XML values.

Parameters:
  • selector – the node selector; if a string is passed it is interpreted as an XPath expression, a callable will be called with the root of the element tree and shall yield any number of node
  • type – the type to parse the raw value; by default the raw string is returned
  • num – defines how many times the key can be present; use any numeric value to set it to a fixed count, “*” for any number, “?” for zero or one time or “+” for one or more times
  • default – the default value
  • namespaces – any namespace necessary for the XPath expression; defaults to the Decoder namespaces.
  • locator – override the locator in case of exceptions
locator
select(decoder)

Interface method.

Module contents

class eoxserver.core.decoders.Choice(*choices)

Bases: object

Tries all given choices until one does return something.

class eoxserver.core.decoders.Concatenate(*choices, **kwargs)

Bases: object

Helper to concatenate the results of all sub-parameters to one.

exception eoxserver.core.decoders.DecodingException(message, locator=None)

Bases: Exception

Base Exception class to be thrown whenever a decoding failed.

class eoxserver.core.decoders.Exclusive(*choices)

Bases: object

For mutual exclusive Parameters.

exception eoxserver.core.decoders.ExclusiveException(message, locator=None)

Bases: eoxserver.core.decoders.DecodingException

exception eoxserver.core.decoders.InvalidParameterException(message, locator=None)

Bases: eoxserver.core.decoders.DecodingException

code = 'InvalidParameterValue'
exception eoxserver.core.decoders.MissingParameterException(locator)

Bases: eoxserver.core.decoders.DecodingException

Exception to be thrown, when a decoder could not read one parameter, where exactly one was required.

code = 'MissingParameterValue'
exception eoxserver.core.decoders.MissingParameterMultipleException(locator)

Bases: eoxserver.core.decoders.DecodingException

Exception to be thrown, when a decoder could not read at least one parameter, where one ore more were required.

code = 'MissingParameterValue'
exception eoxserver.core.decoders.NoChoiceResultException(message, locator=None)

Bases: eoxserver.core.decoders.DecodingException

exception eoxserver.core.decoders.WrongMultiplicityException(locator, expected, result)

Bases: eoxserver.core.decoders.DecodingException

Decoding Exception to be thrown when the multiplicity of a parameter did not match the expected count.

code = 'InvalidParameterValue'
eoxserver.core.decoders.boolean(raw)

Functor to convert “true”/”false” to a boolean.

class eoxserver.core.decoders.enum(values, case_sensitive=True, error_class=<class 'ValueError'>)

Bases: object

Helper for parameters that are expected to be in a certain enumeration. A ValueError is raised if not.

class eoxserver.core.decoders.fixed(value, case_sensitive=True)

Bases: object

Helper for parameters that are expected to be have a fixed value and raises a ValueError if not.

eoxserver.core.decoders.lower(value)

Functor to return a lower-case string.

eoxserver.core.decoders.strip(value)

Functor to return a whitespace stripped string.

eoxserver.core.decoders.to_dict(decoder, dict_class=<class 'dict'>)

Utility function to get a dictionary representation of the given decoder. This function invokes all decoder parameters and sets the dictionary fields accordingly

class eoxserver.core.decoders.typelist(typ=None, separator=' ')

Bases: object

Helper for XMLDecoder schemas that expect a string that represents a list of a type separated by some separator.

eoxserver.core.decoders.upper(value)

Functor to return a upper-case string.

class eoxserver.core.decoders.value_range(min, max, type=<class 'float'>)

Bases: object

Helper to assert that a given parameter is within a specified range.