staplus-client 0.3.3__tar.gz

staplus_client-0.3.3/LICENSE

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

staplus_client-0.3.3/PKG-INFO

@@ -0,0 +1,470 @@
+Metadata-Version: 2.1
+Name: staplus-client
+Version: 0.3.3
+Summary: A client library to facilitate interaction with a STAplus Server
+Home-page: https://github.com/securedimensions/STAplus-Python-Client
+Author: Andreas Matheus
+Author-email: andreas.matheus@secure-dimensions.de
+License: LGPL3
+Keywords: ogc,staplus,sensorthingsapi,IoT
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: demjson3>=3.0.5
+Requires-Dist: furl>=2.1.3
+Requires-Dist: geojson>=2.5.0
+Requires-Dist: jsonpickle>=2.0.0
+Requires-Dist: requests>=2.26.0
+Requires-Dist: jsonpatch
+Requires-Dist: python-dateutil
+Requires-Dist: pillow
+Requires-Dist: sd-frost-sta-client
+
+# OGC STAplus (SensorThings) API Python Client
+
+This STAplus Python Client implements the [STAplus](https://docs.ogc.org/is/22-022r1/22-022r1.html) API. The aim is to simplify development of STAplus and SensorThings enabled client applications.
+
+**_NOTE:_** This implementation is an extension to the [FROST API Python Client](https://github.com/FraunhoferIOSB/FROST-Python-Client). To have better control over bug fixing and improvements, this implementation is actually based on a fork of the FROST API Python Client, hosted on a Secure Dimensions Github repository: [STA Python Client](https://github.com/securedimensions/STA-Python-Client).
+
+## Python Version
+This library requires Python 3.11 or better to support parsing ISO datetime values (`datetime.datetime.fromisoformat`). See [here](https://docs.python.org/3/library/datetime.html#datetime.datetime.fromisoformat) for more information.
+
+## Features
+* Support for all STAplus and SensorThings entity types
+* CRUD operations
+* Queries on entity lists
+* Query on single entity
+* MultiDatastreams
+* Cloning Entities
+* Fetching entities relative to an entity (using many-association)
+* Fetching one single entity relative to an entity (using one-association)
+
+## Installation via PyPi
+Installation via pip: `pip install staplus-client`
+
+## Limitations
+This implementation has the following limitations for the Entity `Location` and `FeatureOfInterest`:
+
+* `Location/location` must be a GeoJSON Geometry object (this is an Any in the SensorThings datamodel)
+* `FeatureOfInterest/feature` must be a GeoJSON Object (this is an Any in the SensorThings datamodel)
+
+For both entities, the `encodingType` attribute is not tested by the implementation. For interoperability with other applications, the value should be `application/geo+json`.
+
+## API
+
+The `STAplusService` class is central to the library. An instance of it represents a STAplus service and is identified by a URI.
+
+
+### Creating Entities via the STAplus Client
+The source code below demonstrates how to initialize the client for a STAplus endpoint on `url`. 
+
+```python
+import staplus_client as staplus
+
+url = "<your domain>/staplus/v1.1"
+service = staplus.STAplusService(url)
+```
+
+#### Configuring an Authentication Handler
+When interacting with a STAplus service that has enabled authentication, the use of an `AuthHandler` is required.
+
+```python
+import staplus_client as staplus
+
+url = "<your domain>/staplus/v1.1"
+auth_handler.AuthHandler(...)
+service = staPlus.STAplusService(url, auth_handler=auth)
+```
+
+#### Creating a Party Entity
+The `Party` entity represents a user or an institution. When interacting with a STAplus service that has enabled authentication, the `Party` entity represents the acting user and access control controls Create, Update and Delete.
+```python
+import staplus_client as staplus
+
+url = "<your domain>/staplus/v1.1"
+auth_handler.AuthHandler(...)
+service = staPlus.STAplusService(url, auth_handler=auth)
+ljs = staPlus.Party(description='I am Long John Silver the opportunistic pirate created by Robert Louis Stevenson',
+                    display_name='LJS',
+                    role='individual')
+service.create(ljs)
+```
+
+#### Creating a STAplus enriched Datastream
+The STAplus `Datastream` is capable to have a `Party` and a `License` associated. Also, the `Thing` is associated to a `Party` entity.
+```python
+import staplus_client as staplus
+
+url = "<your domain>/staplus/v1.1"
+auth_handler.AuthHandler(...)
+service = staplus.STAplusService(url, auth_handler=auth)
+ljs = staplus.Party(description='I am Long John Silver the opportunistic pirate created by Robert Louis Stevenson',
+                    display_name='LJS',
+                    role='individual')
+service.create(ljs)
+
+# find the CC-BY license
+cc_by = service.licenses().find('CC_BY')
+
+# Create a thing associated to LJS
+thing = staplus.Thing('Raspberry Pi', 'Raspberry Pi 4', )
+thing.party = ljs
+
+# Create a sensor
+sensor = staplus.Sensor('air temperature sensor', 'SmartCitizen air temperature sensor', 'test/html', None,
+                        'https://www.seeedstudio.com/Smart-Citizen-Starter-Kit-p-2865.html')
+
+# Create a datastream associated to LJS with CC-BY license
+datastream = staplus.Datastream('air temperature', 'air temperature measured with the SmartCitizen Kit',
+                                'http://www.opengis.net/def/observationType/OGC-OM/2.0/OM_Measurement', 
+                                staplus.UnitOfMeasurement('Celsius', 'C', 'https://qudt.org/vocab/unit/DEG_C'))
+datastream.observed_property = staplus.ObservedProperty('temperature', 'http://vocabs.lter-europe.net/EnvThes/22035',
+                                            'air temperature')
+datastream.party = ljs
+datastream.thing = thing
+datastream.sensor = sensor
+datastream.license = cc_by
+
+service.create(datastream)
+```
+
+#### Creating a few Observation entities
+```python
+import staplus_client as staplus
+
+url = "<your domain>/staplus/v1.1"
+auth_handler.AuthHandler(...)
+service = staplus.STAplusService(url, auth_handler=auth)
+ljs = staplus.Party(description='I am Long John Silver the opportunistic pirate created by Robert Louis Stevenson',
+                    display_name='LJS',
+                    role='individual')
+service.create(ljs)
+
+# The feature of interest
+marienplatz = {
+    "type": "Feature",
+    "geometry": {
+        "type": "Point",
+        "coordinates": [11.571831046,48.135666124]
+    }
+}
+foi = staplus.FeatureOfInterest('Marienplatz', 'famous place in Munich', 'application/vnd.geo+json', marienplatz)
+
+# The temperature
+observation = staplus.Observation("2023-07-02T15:34:00Z", 20, "2023-07-02T15:34:00Z")
+observation.feature_of_interest = foi
+observation.datastream = service.datastreams().find(<the datastream id created previously>)
+
+service.create(observation)
+
+observation = staplus.Observation("2023-07-02T15:34:10Z", 21, "2023-07-02T15:34:10Z")
+observation.feature_of_interest = foi
+observation.datastream = service.datastreams().find(<the datastream id created previously>)
+
+service.create(observation)
+```
+
+#### Creating an ObservationGroup Entity
+A `ObservationGroup` entity can be used as a container of observations that belong together.
+
+```python
+import staplus_client as staplus
+
+url = "<your domain>/staplus/v1.1"
+service = staPlus.STAplusService(url, auth_handler=auth)
+ljs = staPlus.Party(description='I am Long John Silver the opportunistic pirate created by Robert Louis Stevenson',
+                    display_name='LJS',
+                    role='individual')
+service.create(ljs)
+group = staPlus.ObservationGroup("Marienplatz", "observations on Marienplatz", "none", "")
+group.creation_time = parse_datetime("2023-07-02T15:35:00Z")
+# Add all the observations that are associated to the FoI named 'Marienplatz'
+group.observations = service.observations().query().filter("FeatureOfInterest/name eq 'Marienplatz'").list()
+group.license = service.licenses().find('CC_BY')
+group.party = ljs
+
+service.create(group)
+```
+
+#### Creating SensorThings Entities
+How to use this implementation on SensorThings Entity Types, please see the [FROST-Python-Client](https://github.com/securedimensions/STAplus-Python-Client) documentation.
+
+### Fetching Entities via the STAplus Client
+This implementation supports the fetching of `EntityList` and `Entity`.
+
+#### Fetching an EntityList
+An `EntityList` is the result from fetching entities that have a multiplicity `0..*` or `1..*`. To fetch the list of entities, you need to use the `.list()` function. The following example fetches all datastreams:
+
+```python
+import staplus_client as staplus
+
+url = "<your domain>/staplus/v1.1"
+service = staplus.STAplusService(url)
+datastreams = service.datastreams().query().list()
+```
+
+In order to get all entities of a given entity, you can use the function `get_<entity_plural>()`. For example, to fetch all datastreams of a given `Thing` please use the following code: 
+
+```python
+import staplus_client as staplus
+
+url = "<your domain>/staplus/v1.1"
+service = staplus.STAplusService(url)
+thing = service.things().find(1)
+thing_datastreams = thing.get_datastreams().query().list()
+```
+
+#### Fetching an Entity
+An `Entity` is the result from fetching an entity that has multiplicity `0..1` or `1`. To fetch one single entity you need to use the `.item()` function. The following example fetches the thing associated to a datastream:
+
+```python
+import staplus_client as staplus
+
+url = "<your domain>/staplus/v1.1"
+service = staplus.STAplusService(url)
+datastream = service.datastreams().find(1).item()
+datastream_thing = datastream.get_thing().query().item()
+```
+
+### Cloning an Entity
+When creating an Entity, mandatory entities can be provided either inline or by reference. To support the referencing of existing entities, the `clone()` function can be used. `clone()` returns a copy of the entity but only containing the `@iot.id`. This is important when preparing MQTT messages to publish observations.
+
+#### Example ObservationGroup with inline entities
+```JSON
+{
+  "Observations": [
+    {
+      "Datastream": {
+        "@iot.id": 1,
+        "description": "desc",
+        "name": "new name",
+        "observationType": "OM_Observation",
+        "observedArea": {
+          "coordinates": [11.509234, 48.110728],
+          "type": "Point"
+        },
+        "phenomenonTime": "2023-07-24T06:30:18+00:00/2023-09-14T05:40:25.292000+00:00",
+        "resultTime": "2023-07-24T06:30:18+00:00/2023-07-24T06:31:42+00:00",
+        "unitOfMeasurement": { "definition": "...", "name": "n", "symbol": "n" }
+      },
+      "FeatureOfInterest": {
+        "@iot.id": 77,
+        "description": "A rainy place",
+        "encodingType": "application/geo+json",
+        "feature": { "coordinates": [-6.22299, 53.306816], "type": "Point" },
+        "name": "Dublin",
+        "properties": {
+          "datastreams": [1, 2, 76, 2, 78, 77],
+          "multi_datastreams": [11]
+        }
+      },
+      "phenomenonTime": "2024-04-13T19:57:08+00:00",
+      "result": 19.111,
+      "resultTime": "2024-05-02T19:36:06+00:00"
+    },
+    {
+      "Datastream": {
+        "@iot.id": 2,
+        "description": "air relative humidity measured with the SmartCitizen Kit",
+        "name": "Relative Humidity",
+        "observationType": "http://www.opengis.net/def/observationType/OGC-OM/2.0/OM_Measurement",
+        "observedArea": {
+          "coordinates": [11.509234, 48.110728],
+          "type": "Point"
+        },
+        "phenomenonTime": "2023-07-24T06:30:18+00:00/2023-07-24T06:31:42+00:00",
+        "resultTime": "2023-07-24T06:30:18+00:00/2023-07-24T06:31:42+00:00",
+        "unitOfMeasurement": {
+          "definition": "https://qudt.org/vocab/unit/PERCENT",
+          "name": "Percentage",
+          "symbol": "%"
+        }
+      },
+      "FeatureOfInterest": {
+        "@iot.id": 77,
+        "description": "A rainy place",
+        "encodingType": "application/geo+json",
+        "feature": { "coordinates": [-6.22299, 53.306816], "type": "Point" },
+        "name": "Dublin",
+        "properties": {
+          "datastreams": [1, 2, 76, 2, 78, 77],
+          "multi_datastreams": [11]
+        }
+      },
+      "phenomenonTime": "2024-04-13T19:57:08+00:00",
+      "result": 43.0,
+      "resultTime": "2024-05-02T19:36:06+00:00"
+    },
+    {
+      "Datastream": {
+        "@iot.id": 76,
+        "description": "Precipitation measured with the FT-0310 Weather Station",
+        "name": "Rain",
+        "observationType": "http://www.opengis.net/def/observationType/OGC-OM/2.0/OM_Measurement",
+        "unitOfMeasurement": {
+          "definition": "https://qudt.org/vocab/unit/MilliM",
+          "name": "millimiter",
+          "symbol": "mm"
+        }
+      },
+      "FeatureOfInterest": {
+        "@iot.id": 77,
+        "description": "A rainy place",
+        "encodingType": "application/geo+json",
+        "feature": { "coordinates": [-6.22299, 53.306816], "type": "Point" },
+        "name": "Dublin",
+        "properties": {
+          "datastreams": [1, 2, 76, 2, 78, 77],
+          "multi_datastreams": [11]
+        }
+      },
+      "phenomenonTime": "2024-04-13T19:57:08+00:00",
+      "result": 87.0,
+      "resultTime": "2024-05-02T19:36:06+00:00"
+    },
+    {
+      "Datastream": {
+        "@iot.id": 77,
+        "description": "Wind direction measured with the FT-0310 Weather Station",
+        "name": "Wind direction",
+        "observationType": "http://www.opengis.net/def/observationType/OGC-OM/2.0/OM_Measurement",
+        "unitOfMeasurement": {
+          "definition": "https://qudt.org/vocab/unit/DEG",
+          "name": "degree",
+          "symbol": "deg"
+        }
+      },
+      "FeatureOfInterest": {
+        "@iot.id": 77,
+        "description": "A rainy place",
+        "encodingType": "application/geo+json",
+        "feature": { "coordinates": [-6.22299, 53.306816], "type": "Point" },
+        "name": "Dublin",
+        "properties": {
+          "datastreams": [1, 2, 76, 2, 78, 77],
+          "multi_datastreams": [11]
+        }
+      },
+      "phenomenonTime": "2024-04-13T19:57:08+00:00",
+      "result": 241.0,
+      "resultTime": "2024-05-02T19:36:06+00:00"
+    },
+    {
+      "FeatureOfInterest": {
+        "@iot.id": 77,
+        "description": "A rainy place",
+        "encodingType": "application/geo+json",
+        "feature": { "coordinates": [-6.22299, 53.306816], "type": "Point" },
+        "name": "Dublin",
+        "properties": {
+          "datastreams": [1, 2, 76, 2, 78, 77],
+          "multi_datastreams": [11]
+        }
+      },
+      "MultiDatastream": {
+        "@iot.id": 11,
+        "ObservedProperties": [
+          {
+            "@iot.id": 105,
+            "definition": "http://vocab.nerc.ac.uk/standard_name/wind_speed/",
+            "description": "Wind speed",
+            "name": "wspeed"
+          },
+          {
+            "@iot.id": 106,
+            "definition": "http://vocab.nerc.ac.uk/standard_name/wind_gust_from_direction/",
+            "description": "Wind gust",
+            "name": "wgust"
+          }
+        ],
+        "description": "Wind speed average and gust measured with the FT-0310 Weather Station",
+        "multiObservationDataTypes": [
+          "http://www.opengis.net/def/observationType/OGC-OM/2.0/OM_Measurement",
+          "http://www.opengis.net/def/observationType/OGC-OM/2.0/OM_Measurement"
+        ],
+        "name": "Wind speed avg and gust",
+        "observationType": "http://www.opengis.net/def/observationType/OGC-OM/2.0/OM_ComplexObservation",
+        "unitOfMeasurements": [
+          {
+            "definition": "https://qudt.org/vocab/unit/M-PER-SEC",
+            "name": "Meters per second",
+            "symbol": "m/s"
+          },
+          {
+            "definition": "https://qudt.org/vocab/unit/M-PER-SEC",
+            "name": "Meters per second",
+            "symbol": "m/s"
+          }
+        ]
+      },
+      "phenomenonTime": "2024-04-13T19:57:08+00:00",
+      "result": [0.0, 0.0],
+      "resultTime": "2024-05-02T19:36:06+00:00"
+    }
+  ],
+  "Party": {
+    "@iot.id": "36fd7ca4-08bb-11ef-b156-a337e8ef4d15",
+    "displayName": "LJS",
+    "role": "individual"
+  },
+  "creationTime": "2024-05-02T19:36:06+00:00",
+  "description": " ",
+  "endTime": "2024-05-02T19:36:06+00:00",
+  "name": "OG 2024-05-02T19:36:06+00:00"
+}
+```
+
+This example with inline `Datastream` and `FeatureOfInterest` entities has the size of 6245 Bytes.
+
+#### Example ObservationGroup with referencing entities
+```JSON
+{
+  "Observations": [
+    {
+      "Datastream": { "@iot.id": 1 },
+      "FeatureOfInterest": { "@iot.id": 77 },
+      "phenomenonTime": "2024-04-13T19:57:08+00:00",
+      "result": 19.111,
+      "resultTime": "2024-05-03T09:48:33+00:00"
+    },
+    {
+      "Datastream": { "@iot.id": 2 },
+      "FeatureOfInterest": { "@iot.id": 77 },
+      "phenomenonTime": "2024-04-13T19:57:08+00:00",
+      "result": 43.0,
+      "resultTime": "2024-05-03T09:48:33+00:00"
+    },
+    {
+      "Datastream": { "@iot.id": 76 },
+      "FeatureOfInterest": { "@iot.id": 77 },
+      "phenomenonTime": "2024-04-13T19:57:08+00:00",
+      "result": 87.0,
+      "resultTime": "2024-05-03T09:48:33+00:00"
+    },
+    {
+      "Datastream": { "@iot.id": 77 },
+      "FeatureOfInterest": { "@iot.id": 77 },
+      "phenomenonTime": "2024-04-13T19:57:08+00:00",
+      "result": 241.0,
+      "resultTime": "2024-05-03T09:48:33+00:00"
+    },
+    {
+      "FeatureOfInterest": { "@iot.id": 77 },
+      "MultiDatastream": { "@iot.id": 11 },
+      "phenomenonTime": "2024-04-13T19:57:08+00:00",
+      "result": [0.0, 0.0],
+      "resultTime": "2024-05-03T09:48:33+00:00"
+    }
+  ],
+  "Party": {
+    "@iot.id": "4cd42a10-0932-11ef-919f-57f24e9b90e3",
+    "displayName": "LJS",
+    "role": "individual"
+  },
+  "creationTime": "2024-05-03T09:48:33+00:00",
+  "description": " ",
+  "endTime": "2024-05-03T09:48:33+00:00",
+  "name": "OG 2024-05-03T09:48:33+00:00"
+}
+```
+
+This example with referenced `Datastream` and `FeatureOfInterest` entities has the size of 1420 Bytes.