Skip to content

extension module

This is the extension module.

This module contains geographic metadata structures for metadata elements that are not contained in the ISO 19115-1:2014 international standard.

ApplicationSchemaInformation

Bases: ABC

Information about the application schema used to build the dataset.

Source code in opengis/metadata/extension.py 
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
class ApplicationSchemaInformation(ABC):
    """Information about the application schema used to build the dataset."""

    @property
    @abstractmethod
    def name(self) -> Citation:
        """Name of the application schema used."""

    @property
    @abstractmethod
    def schema_language(self) -> str:
        """Identification of the schema language used."""

    @property
    @abstractmethod
    def constraint_language(self) -> str:
        """Formal language used in Application Schema."""

    @property
    @abstractmethod
    def schema_ascii(self) -> Optional[str]:
        """Full application schema given as an ASCII file."""

    @property
    @abstractmethod
    def graphics_file(self) -> Optional[OnlineResource]:
        """Full application schema given as a graphics file."""

    @property
    @abstractmethod
    def software_development_file(self) -> Optional[OnlineResource]:
        """Full application schema given as a software development file."""

    @property
    @abstractmethod
    def software_development_file_format(self) -> Optional[str]:
        """
        Software dependent format used for the application schema software
        dependent file.
        """

constraint_language: str abstractmethod property

Formal language used in Application Schema.

graphics_file: Optional[OnlineResource] abstractmethod property

Full application schema given as a graphics file.

name: Citation abstractmethod property

Name of the application schema used.

schema_ascii: Optional[str] abstractmethod property

Full application schema given as an ASCII file.

schema_language: str abstractmethod property

Identification of the schema language used.

software_development_file: Optional[OnlineResource] abstractmethod property

Full application schema given as a software development file.

software_development_file_format: Optional[str] abstractmethod property

Software dependent format used for the application schema software dependent file.

DatatypeCode

Bases: Enum

Datatype of element or entity.

Source code in opengis/metadata/extension.py 
 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
class DatatypeCode(Enum):
    """Datatype of element or entity."""

    CLASS = "class"
    """
    Descriptor of a set of objects that share the same attributes, operations,
    methods, relationships, and behaviour.
    """

    CODE_LIST = "codelist"
    """
    Flexible enumeration useful for expressing a long list of values, can be
    extended.
    """

    ENUMERATION = "enumeration"
    """
    Data type whose instances form a list of named literal values, not
    extendable.
    """

    CODE_LIST_ELEMENT = "codelistElement"
    """Permissible value for a codelist or enumeration."""

    ABSTRACT_CLASS = "abstractClass"
    """Class that cannot be directly instantiated"""

    AGGREGATE_CLASS = "aggregateClass"
    """
    Class that is composed of classes it is connected to by an aggregate
    relationship.
    """

    SPECIFIED_CLASS = "specifiedClass"
    """Subclass that may be substituted for its superclass."""

    DATATYPE_CLASS = "datatypeClass"
    """
    Class  with few or no operations whose primary purpose is to hold the
    abstract state of another class for transmittal, storage, encoding, or
    persistent storage.
    """

    INTERFACE_CLASS = "interfaceClass"
    """
    Named set of operations that characterize the bahaviour of an element.
    """

    UNION_CLASS = "unionClass"
    """Class describing a selection of one of the specified types."""

    META_CLASS = "metaClass"
    """Class whose instances are classes."""

    TYPE_CLASS = "typeClass"
    """
    Class used for specification of a domain of instances (objects), together
    with the operations applicable to the objects. A type may have attributes
    and associations.
    """

    CHARACTER_STRING = "characterString"
    """Textual infromation."""

    INTEGER = "integer"
    """Numerical field."""

    ASSOCIATION = "association"
    """
    Semantic relationship between two classes that involves connections among
    their instances.
    """

ABSTRACT_CLASS = 'abstractClass' class-attribute instance-attribute

Class that cannot be directly instantiated

AGGREGATE_CLASS = 'aggregateClass' class-attribute instance-attribute

Class that is composed of classes it is connected to by an aggregate relationship.

ASSOCIATION = 'association' class-attribute instance-attribute

Semantic relationship between two classes that involves connections among their instances.

CHARACTER_STRING = 'characterString' class-attribute instance-attribute

Textual infromation.

CLASS = 'class' class-attribute instance-attribute

Descriptor of a set of objects that share the same attributes, operations, methods, relationships, and behaviour.

CODE_LIST = 'codelist' class-attribute instance-attribute

Flexible enumeration useful for expressing a long list of values, can be extended.

CODE_LIST_ELEMENT = 'codelistElement' class-attribute instance-attribute

Permissible value for a codelist or enumeration.

DATATYPE_CLASS = 'datatypeClass' class-attribute instance-attribute

Class with few or no operations whose primary purpose is to hold the abstract state of another class for transmittal, storage, encoding, or persistent storage.

ENUMERATION = 'enumeration' class-attribute instance-attribute

Data type whose instances form a list of named literal values, not extendable.

INTEGER = 'integer' class-attribute instance-attribute

Numerical field.

INTERFACE_CLASS = 'interfaceClass' class-attribute instance-attribute

Named set of operations that characterize the bahaviour of an element.

META_CLASS = 'metaClass' class-attribute instance-attribute

Class whose instances are classes.

SPECIFIED_CLASS = 'specifiedClass' class-attribute instance-attribute

Subclass that may be substituted for its superclass.

TYPE_CLASS = 'typeClass' class-attribute instance-attribute

Class used for specification of a domain of instances (objects), together with the operations applicable to the objects. A type may have attributes and associations.

UNION_CLASS = 'unionClass' class-attribute instance-attribute

Class describing a selection of one of the specified types.

ExtendedElementInformation

Bases: ABC

New metadata element, not found in ISO 19115, which is required to describe geographic data.

Source code in opengis/metadata/extension.py 
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
class ExtendedElementInformation(ABC):
    """
    New metadata element, not found in ISO 19115, which is required to
    describe geographic data.
    """

    @property
    @abstractmethod
    def name(self) -> Optional[str]:
        """
        Name of the extended metadata element.

        MANDATORY: if `data_type` != CODE_LIST and `datatype` != ENUMERATION
            and `data_type` != CODE_LIST_ELEMENT.
        """

    @property
    @abstractmethod
    def definition(self) -> str:
        """Definition of the extended element."""

    @property
    @abstractmethod
    def obligation(self) -> Optional[ObligationCode]:
        """
        Obligation of the extended element.

        MANDATORY: if `data_type` != CODE_LIST and `datatype` != ENUMERATION
            and `data_type` != CODE_LIST_ELEMENT.
        """

    @property
    @abstractmethod
    def condition(self) -> Optional[str]:
        """
        Condition under which the extended element is mandatory.

        MANDATORY: if `obligation` == .
        """

    @property
    @abstractmethod
    def data_type(self) -> DatatypeCode:
        """
        Code which identifies the kind of value provided in the extended
        element.
        """

    @property
    @abstractmethod
    def maximum_occurrence(self) -> Optional[int]:
        """
        Maximum occurrence of the extended element.

        MANDATORY: if `data_type` != CODE_LIST and `datatype` != ENUMERATION
            and `data_type` != CODE_LIST_ELEMENT.
        """

    @property
    @abstractmethod
    def domain_value(self) -> Optional[str]:
        """
        Valid values that can be assigned to the extended element.

        MANDATORY: if `data_type` != CODE_LIST and `datatype` != ENUMERATION
            and `data_type` != CODE_LIST_ELEMENT.
        """

    @property
    @abstractmethod
    def parent_entity(self) -> Sequence[str]:
        """
        Name of the metadata entity(s) under which this extended metadata
        element may appear. The name(s) may be standard metadata element(s) or
        other extended metadata element(s).
        """

    @property
    @abstractmethod
    def rule(self) -> str:
        """
        Specifies how the extended element relates to other existing elements
        and entities.
        """

    @property
    @abstractmethod
    def rationale(self) -> Optional[str]:
        """Reason for creating the extended element."""

    @property
    @abstractmethod
    def source(self) -> Sequence[Responsibility]:
        """Name of the person or organisation creating the extended element."""

    @property
    @abstractmethod
    def concept_name(self) -> Optional[str]:
        """
        The name of the item.

        MANDATORY: if `data_type` != CODE_LIST and `datatype` != ENUMERATION
            and `data_type` != CODE_LIST_ELEMENT.
        """

    @property
    @abstractmethod
    def code(self) -> Optional[str]:
        """Language neutral identifier.

        MANDATORY: if `data_type` != CODE_LIST and `datatype` != ENUMERATION
            and `data_type` != CODE_LIST_ELEMENT.
        """

code: Optional[str] abstractmethod property

Language neutral identifier.

if data_type != CODE_LIST and datatype != ENUMERATION

and data_type != CODE_LIST_ELEMENT.

concept_name: Optional[str] abstractmethod property

The name of the item.

if data_type != CODE_LIST and datatype != ENUMERATION

and data_type != CODE_LIST_ELEMENT.

condition: Optional[str] abstractmethod property

Condition under which the extended element is mandatory.

MANDATORY: if obligation == .

data_type: DatatypeCode abstractmethod property

Code which identifies the kind of value provided in the extended element.

definition: str abstractmethod property

Definition of the extended element.

domain_value: Optional[str] abstractmethod property

Valid values that can be assigned to the extended element.

if data_type != CODE_LIST and datatype != ENUMERATION

and data_type != CODE_LIST_ELEMENT.

maximum_occurrence: Optional[int] abstractmethod property

Maximum occurrence of the extended element.

if data_type != CODE_LIST and datatype != ENUMERATION

and data_type != CODE_LIST_ELEMENT.

name: Optional[str] abstractmethod property

Name of the extended metadata element.

if data_type != CODE_LIST and datatype != ENUMERATION

and data_type != CODE_LIST_ELEMENT.

obligation: Optional[ObligationCode] abstractmethod property

Obligation of the extended element.

if data_type != CODE_LIST and datatype != ENUMERATION

and data_type != CODE_LIST_ELEMENT.

parent_entity: Sequence[str] abstractmethod property

Name of the metadata entity(s) under which this extended metadata element may appear. The name(s) may be standard metadata element(s) or other extended metadata element(s).

rationale: Optional[str] abstractmethod property

Reason for creating the extended element.

rule: str abstractmethod property

Specifies how the extended element relates to other existing elements and entities.

source: Sequence[Responsibility] abstractmethod property

Name of the person or organisation creating the extended element.

MetadataExtensionInformation

Bases: ABC

Information describing metadata extensions.

Source code in opengis/metadata/extension.py 
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
class MetadataExtensionInformation(ABC):
    """Information describing metadata extensions."""

    @property
    @abstractmethod
    def extension_on_line_resource(self) -> Optional[OnlineResource]:
        """
        Information about on-line sources containing the community profile
        name and the extended metadata elements and information for all new
        metadata elements about on-line sources containing the community
        profile name, the extended metadata elements and information about all
        new metadata elements.
        """

    @property
    @abstractmethod
    def extended_element_information(self) -> Sequence[
        ExtendedElementInformation
    ]:
        """
        Provides information about a new metadata element, not found
        in ISO 19115, which is required to describe the resource.
        """

extended_element_information: Sequence[ExtendedElementInformation] abstractmethod property

Provides information about a new metadata element, not found in ISO 19115, which is required to describe the resource.

extension_on_line_resource: Optional[OnlineResource] abstractmethod property

Information about on-line sources containing the community profile name and the extended metadata elements and information for all new metadata elements about on-line sources containing the community profile name, the extended metadata elements and information about all new metadata elements.

ObligationCode

Bases: Enum

Obligation of the element or entity.

Source code in opengis/metadata/extension.py 
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
class ObligationCode(Enum):
    """Obligation of the element or entity."""

    MANDATORY = "mandatory"
    """Element is always required."""

    OPTIONAL = "optional"
    """Element is not required."""

    CONDITIONAL = "conditional"
    """element is required when a specific condition is met."""

    FORBIDDEN = None
    """
    The element should always be `None`. This obligation code is used only
    when a sub-class overrides an association and force it to a `None`
    value. An example is
    `opengis.referencing.datum.TemporalDatum.anchor_point`.
    """

CONDITIONAL = 'conditional' class-attribute instance-attribute

element is required when a specific condition is met.

FORBIDDEN = None class-attribute instance-attribute

The element should always be None. This obligation code is used only when a sub-class overrides an association and force it to a None value. An example is opengis.referencing.datum.TemporalDatum.anchor_point.

MANDATORY = 'mandatory' class-attribute instance-attribute

Element is always required.

OPTIONAL = 'optional' class-attribute instance-attribute

Element is not required.