Skip to content

lineage module

This is the lineage module.

This module contains geographic metadata structures derived from the ISO 19115-1:2014 and ISO 19115-2:2019 international standards regarding the lineage of the data, that is how the data has changed and the sources from which it is derived.

Algorithm

Bases: ABC

Details of the methodology by which geographic information was derived from the instrument readings.

Source code in opengis/metadata/lineage.py 
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
class Algorithm(ABC):
    """
    Details of the methodology by which geographic information was derived
    from the instrument readings.
    """

    @property
    @abstractmethod
    def citation(self) -> Citation:
        """Information identifying the algorithm and version or date."""

    @property
    @abstractmethod
    def description(self) -> str:
        """Information describing the algorithm used to generate the data."""

citation: Citation abstractmethod property

Information identifying the algorithm and version or date.

description: str abstractmethod property

Information describing the algorithm used to generate the data.

Lineage

Bases: ABC

Information about the events or source data used in constructing the data specified by the scope or lack of knowledge about lineage.

Source code in opengis/metadata/lineage.py 
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
class Lineage(ABC):
    """
    Information about the events or source data used in constructing the data
    specified by the scope or lack of knowledge about lineage.
    """

    @property
    @abstractmethod
    def statement(self) -> Optional[str]:
        """
        General explanation of the data producer's knowledge about the lineage
        of a resource.
        """

    @property
    @abstractmethod
    def scope(self) -> Optional[Scope]:
        """
        Type of resource and/or extent to which the lineage information
        applies.
        """

    @property
    @abstractmethod
    def additional_documentation(self) -> Optional[Sequence[Citation]]:
        """
        Resource. Example: A publication that describes the whole process to
        generate this resource, e.g., a dataset.
        """

    @property
    @abstractmethod
    def process_step(self) -> Optional[Sequence[ProcessStep]]:
        """
        Information about events in the life of a resource specified by the
        scope.

        MANDATORY: if `statement` and `source` are `None`.
        """

    @property
    @abstractmethod
    def source(self) -> Optional[Sequence[Source]]:
        """
        Information about the source data used in creating the data specified
        by the scope.

        MANDATORY: if `statement` and `process_step` are `None`.
        """

additional_documentation: Optional[Sequence[Citation]] abstractmethod property

Resource. Example: A publication that describes the whole process to generate this resource, e.g., a dataset.

process_step: Optional[Sequence[ProcessStep]] abstractmethod property

Information about events in the life of a resource specified by the scope.

MANDATORY: if statement and source are None.

scope: Optional[Scope] abstractmethod property

Type of resource and/or extent to which the lineage information applies.

source: Optional[Sequence[Source]] abstractmethod property

Information about the source data used in creating the data specified by the scope.

MANDATORY: if statement and process_step are None.

statement: Optional[str] abstractmethod property

General explanation of the data producer's knowledge about the lineage of a resource.

NominalResolution

Bases: ABC

Distance between consistent parts (centre, left side, right side) of adjacent pixels.

Source code in opengis/metadata/lineage.py 
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
class NominalResolution(ABC):
    """
    Distance between consistent parts (centre, left side, right side) of
    adjacent pixels.
    """

    @property
    @abstractmethod
    def scanning_resolution(self) -> Distance:
        """
        Distance between consistent parts (centre, left side, right side)
        of adjacent pixels in the scan plane.
        """

    @property
    @abstractmethod
    def ground_resolution(self) -> Distance:
        """
        Distance between consistent parts (centre, left side, right side)
        of adjacent pixels in the object space.
        """

ground_resolution: Distance abstractmethod property

Distance between consistent parts (centre, left side, right side) of adjacent pixels in the object space.

scanning_resolution: Distance abstractmethod property

Distance between consistent parts (centre, left side, right side) of adjacent pixels in the scan plane.

ProcessParameter

Bases: ABC

Parameter (value or resource) used in a process.

Source code in opengis/metadata/lineage.py 
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
class ProcessParameter(ABC):
    """Parameter (value or resource) used in a process."""

    @property
    @abstractmethod
    def name(self) -> MemberName:
        """Name/type of parameter."""

    @property
    @abstractmethod
    def direction(self) -> ParameterDirection:
        """
        Indication the parameter is an input to the process, an output,
        or both.
        """

    @property
    @abstractmethod
    def description(self) -> Optional[str]:
        """Narrative explaining the role of the parameter."""

    @property
    @abstractmethod
    def optionality(self) -> bool:
        """Indication the parameter is required."""

    @property
    @abstractmethod
    def repeatability(self) -> bool:
        """
        Indication if more than one value of the parameter may be provided.
        """

    @property
    @abstractmethod
    def value_type(self) -> Optional[RecordType]:
        """Data type of the value"""

    @property
    @abstractmethod
    def value(self) -> Optional[Record]:
        """Constant value."""

    @property
    @abstractmethod
    def resource(self) -> Optional[Source]:
        """Resource to be processed."""

description: Optional[str] abstractmethod property

Narrative explaining the role of the parameter.

direction: ParameterDirection abstractmethod property

Indication the parameter is an input to the process, an output, or both.

name: MemberName abstractmethod property

Name/type of parameter.

optionality: bool abstractmethod property

Indication the parameter is required.

repeatability: bool abstractmethod property

Indication if more than one value of the parameter may be provided.

resource: Optional[Source] abstractmethod property

Resource to be processed.

value: Optional[Record] abstractmethod property

Constant value.

value_type: Optional[RecordType] abstractmethod property

Data type of the value

ProcessStep

Bases: ABC

Information about an event or transformation in the life of the dataset including details of the algorithm and software used for processing.

Source code in opengis/metadata/lineage.py 
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
class ProcessStep(ABC):
    """
    Information about an event or transformation in the life of the dataset
    including details of the algorithm and software used for processing.
    """

    @property
    @abstractmethod
    def description(self) -> str:
        """
        Description of the event, including related parameters or tolerances.
        """

    @property
    @abstractmethod
    def rationale(self) -> Optional[str]:
        """Requirement or purpose for the process step."""

    @property
    @abstractmethod
    def step_date_time(self) -> Optional[datetime]:
        """Date, time, range or period of process step."""

    @property
    @abstractmethod
    def processor(self) -> Optional[Sequence[Responsibility]]:
        """
        Identification of, and means of communication with, person(s) and
        organisation(s) associated with the process step.
        """

    @property
    @abstractmethod
    def reference(self) -> Optional[Sequence[Citation]]:
        """Process step documentation."""

    @property
    @abstractmethod
    def scope(self) -> Optional[Scope]:
        """Type of resource and/or extent to which the process step applies."""

    @property
    @abstractmethod
    def source(self) -> Optional[Sequence[Source]]:
        """
        Type of the resource and/or extent to which the process step applies.
        """

    @property
    @abstractmethod
    def output(self) -> Optional[Sequence[Source]]:
        """
        Description of the product generated as a result of the process step.
        """

    @property
    @abstractmethod
    def processing_information(self) -> Optional[Processing]:
        """
        Comprehensive information about the procedure by which the algorithm
        was applied to derive geographic data from the raw instrument
        measurements, such as datasets, software used, and the processing
        environment.
        """

    @property
    @abstractmethod
    def report(self) -> Optional[Sequence[ProcessStepReport]]:
        """Report generated by the process step."""

description: str abstractmethod property

Description of the event, including related parameters or tolerances.

output: Optional[Sequence[Source]] abstractmethod property

Description of the product generated as a result of the process step.

processing_information: Optional[Processing] abstractmethod property

Comprehensive information about the procedure by which the algorithm was applied to derive geographic data from the raw instrument measurements, such as datasets, software used, and the processing environment.

processor: Optional[Sequence[Responsibility]] abstractmethod property

Identification of, and means of communication with, person(s) and organisation(s) associated with the process step.

rationale: Optional[str] abstractmethod property

Requirement or purpose for the process step.

reference: Optional[Sequence[Citation]] abstractmethod property

Process step documentation.

report: Optional[Sequence[ProcessStepReport]] abstractmethod property

Report generated by the process step.

scope: Optional[Scope] abstractmethod property

Type of resource and/or extent to which the process step applies.

source: Optional[Sequence[Source]] abstractmethod property

Type of the resource and/or extent to which the process step applies.

step_date_time: Optional[datetime] abstractmethod property

Date, time, range or period of process step.

ProcessStepReport

Bases: ABC

Report of what occurred during the process step.

Source code in opengis/metadata/lineage.py 
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
class ProcessStepReport(ABC):
    """Report of what occurred during the process step."""

    @property
    @abstractmethod
    def name(self) -> str:
        """Name of the processing report."""

    @property
    @abstractmethod
    def description(self) -> Optional[str]:
        """Textual description of what occurred during the process step."""

    @property
    @abstractmethod
    def file_type(self) -> Optional[str]:
        """Type of file that contains that processing report."""

description: Optional[str] abstractmethod property

Textual description of what occurred during the process step.

file_type: Optional[str] abstractmethod property

Type of file that contains that processing report.

name: str abstractmethod property

Name of the processing report.

Processing

Bases: ABC

Comprehensive information about the procedure(s), process(es) and algorithm(s) applied in the process step.

Source code in opengis/metadata/lineage.py 
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
class Processing(ABC):
    """
    Comprehensive information about the procedure(s), process(es) and
    algorithm(s) applied in the process step.
    """

    @property
    @abstractmethod
    def identifier(self) -> Identifier:
        """
        Information to identify the processing package that produced the data.
        """

    @property
    @abstractmethod
    def software_reference(self) -> Optional[Sequence[Citation]]:
        """Reference to document describing processing software."""

    @property
    @abstractmethod
    def procedure_description(self) -> Optional[str]:
        """Additional details about the processing procedures."""

    @property
    @abstractmethod
    def documentation(self) -> Optional[Sequence[Citation]]:
        """Reference to documentation describing the processing."""

    @property
    @abstractmethod
    def run_time_parameters(self) -> Optional[str]:
        """
        Parameters to control the processing operations, entered at run time.
        """

    @property
    @abstractmethod
    def other_property(self) -> Optional[Record]:
        """Instance of other property type not included in `Sensor`."""

    @property
    @abstractmethod
    def other_property_type(self) -> Optional[RecordType]:
        """Type of other property description."""

    @property
    @abstractmethod
    def algorithm(self) -> Optional[Sequence[Algorithm]]:
        """
        Details of the methodology by which geographic information was derived
        from the instrument readings.
        """

    @property
    @abstractmethod
    def parameter(self) -> Optional[ProcessParameter]:
        """Parameter(s) used in a process"""

algorithm: Optional[Sequence[Algorithm]] abstractmethod property

Details of the methodology by which geographic information was derived from the instrument readings.

documentation: Optional[Sequence[Citation]] abstractmethod property

Reference to documentation describing the processing.

identifier: Identifier abstractmethod property

Information to identify the processing package that produced the data.

other_property: Optional[Record] abstractmethod property

Instance of other property type not included in Sensor.

other_property_type: Optional[RecordType] abstractmethod property

Type of other property description.

parameter: Optional[ProcessParameter] abstractmethod property

Parameter(s) used in a process

procedure_description: Optional[str] abstractmethod property

Additional details about the processing procedures.

run_time_parameters: Optional[str] abstractmethod property

Parameters to control the processing operations, entered at run time.

software_reference: Optional[Sequence[Citation]] abstractmethod property

Reference to document describing processing software.

Source

Bases: ABC

Information about the source resource used in creating the data specified by the scope.

Source code in opengis/metadata/lineage.py 
 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
class Source(ABC):
    """
    Information about the source resource used in creating the data specified
    by the scope.
    """

    @property
    @abstractmethod
    def description(self) -> Optional[str]:
        """
        Detailed description of the level of the source resource.

        MANDATORY: if `scope` is `None`.
        """

    @property
    @abstractmethod
    def source_spatial_resolution(self) -> Optional[Resolution]:
        """
        Level of detail expressed as a scale factor, a distance or an angle.
        """

    @property
    @abstractmethod
    def source_reference_system(self) -> Optional[ReferenceSystem]:
        """Spatial reference system used by the source resource."""

    @property
    @abstractmethod
    def source_citation(self) -> Optional[Citation]:
        """Recommended reference to be used for the source resource."""

    @property
    @abstractmethod
    def source_metadata(self) -> Optional[Sequence[Citation]]:
        """Identifier and link to source metadata."""

    @property
    @abstractmethod
    def scope(self) -> Optional[Scope]:
        """
        Type of resource and/or extent of the source.

        MANDATORY: if `description` is `None`.
        """

    @property
    @abstractmethod
    def source_step(self) -> Optional[Sequence['ProcessStep']]:
        """Information about process steps in which this source was used."""

    @property
    @abstractmethod
    def processed_level(self) -> Optional[Identifier]:
        """Processing level of the source data."""

    @property
    @abstractmethod
    def resolution(self) -> Optional[NominalResolution]:
        """
        Distance between consistent parts (centre, left side, right side)
        of two adjacent pixels.
        """

description: Optional[str] abstractmethod property

Detailed description of the level of the source resource.

MANDATORY: if scope is None.

processed_level: Optional[Identifier] abstractmethod property

Processing level of the source data.

resolution: Optional[NominalResolution] abstractmethod property

Distance between consistent parts (centre, left side, right side) of two adjacent pixels.

scope: Optional[Scope] abstractmethod property

Type of resource and/or extent of the source.

MANDATORY: if description is None.

source_citation: Optional[Citation] abstractmethod property

Recommended reference to be used for the source resource.

source_metadata: Optional[Sequence[Citation]] abstractmethod property

Identifier and link to source metadata.

source_reference_system: Optional[ReferenceSystem] abstractmethod property

Spatial reference system used by the source resource.

source_spatial_resolution: Optional[Resolution] abstractmethod property

Level of detail expressed as a scale factor, a distance or an angle.

source_step: Optional[Sequence[ProcessStep]] abstractmethod property

Information about process steps in which this source was used.