frost-sta-client 1.1.48__py2.py3-none-any.whl → 1.1.50__py2.py3-none-any.whl

frost_sta_client/__version__.py

@@ -1,5 +1,5 @@
 __title__ = 'frost_sta_client'
-__version__ = '1.1.48'
+__version__ = '1.1.50'
 __license__ = 'LGPL3'
 __author__ = 'Fraunhofer IOSB'
 __copyright__ = 'Fraunhofer IOSB'

frost_sta_client/model/actuator.py

@@ -165,7 +165,7 @@ class Actuator(entity.Entity):
         if self.properties is not None and self.properties != {}:
             data['properties'] = self.properties
         if self.tasking_capabilities is not None and len(self.tasking_capabilities.entities) > 0:
-            data['taskingCapabilities'] = self.tasking_capabilities.__getstate__()
+            data['TaskingCapabilities'] = self.tasking_capabilities.__getstate__()
         return data
 
     def __setstate__(self, state):

frost_sta_client/model/datastream.py

@@ -1,338 +1,338 @@
-# Copyright (C) 2021 Fraunhofer Institut IOSB, Fraunhoferstr. 1, D 76131
-# Karlsruhe, Germany.
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Lesser General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-import inspect
-import json
-
-import frost_sta_client.model.ext.unitofmeasurement
-from frost_sta_client.dao.datastream import DatastreamDao
-
-from . import thing
-from . import sensor
-from . import observedproperty
-from . import observation
-from . import entity
-from .ext import unitofmeasurement
-from .ext import entity_list
-from .ext import entity_type
-
-from frost_sta_client import utils
-
-import geojson.geometry
-
-
-class Datastream(entity.Entity):
-
-    def __init__(self,
-                 name='',
-                 description='',
-                 observation_type='',
-                 unit_of_measurement=None,
-                 observed_area=None,
-                 properties=None,
-                 phenomenon_time=None,
-                 result_time=None,
-                 thing=None,
-                 sensor=None,
-                 observed_property=None,
-                 observations=None,
-                 **kwargs):
-        """
-        This class handles Datastreams assigned to a Thing. Before you create a Datastreams, you firstly have to
-        create a Thing, a Sensor and an observedProperty to which you have to refer by specifying its ids.
-
-        Parameters
-        ----------
-        name: str
-        description: str
-        observation_type: str
-        unit_of_measurement: dict
-            Should be a dict of keys 'name', 'symbol', 'definition' with values of str.
-
-        """
-        super().__init__(**kwargs)
-        if properties is None:
-            properties = {}
-        self.name = name
-        self.description = description
-        self.observation_type = observation_type
-        self.unit_of_measurement = unit_of_measurement
-        self.observed_area = observed_area
-        self.properties = properties
-        self.phenomenon_time = phenomenon_time
-        self.result_time = result_time
-        self.thing = thing
-        self.sensor = sensor
-        self.observations = observations
-        self.observed_property = observed_property
-
-
-    def __new__(cls, *args, **kwargs):
-        new_datastream = super().__new__(cls)
-        attributes = dict(_id=None, _name='', _description='', _properties={}, _observation_type='',
-                          _unit_of_measurement=None, _observed_area=None, _phenomenon_time=None, _result_time=None,
-                          _thing=None, _sensor=None, _observed_property=None, _observations=None, _self_link='',
-                          _service=None)
-        for key, value in attributes.items():
-            new_datastream.__dict__[key] = value
-        return new_datastream
-
-    @property
-    def name(self):
-        return self._name
-
-    @name.setter
-    def name(self, value):
-        if value is None:
-            self._name = None
-            return
-        if not isinstance(value, str):
-            raise ValueError('name should be of type str!')
-        self._name = value
-
-    @property
-    def description(self):
-        return self._description
-
-    @description.setter
-    def description(self, value):
-        if value is None:
-            self._description = None
-            return
-        if not isinstance(value, str):
-            raise ValueError('description should be of type str!')
-        self._description = value
-
-    @property
-    def observation_type(self):
-        return self._observation_type
-
-    @observation_type.setter
-    def observation_type(self, value):
-        if value is None:
-            self._observation_type = None
-            return
-        if not isinstance(value, str):
-            raise ValueError('observation_type should be of type str!')
-        self._observation_type = value
-
-    @property
-    def unit_of_measurement(self):
-        return self._unit_of_measurement
-
-    @unit_of_measurement.setter
-    def unit_of_measurement(self, value):
-        if value is None or isinstance(value, unitofmeasurement.UnitOfMeasurement):
-            self._unit_of_measurement = value
-            return
-        raise ValueError('unitOfMeasurement should be of type UnitOfMeasurement!')
-
-    @property
-    def observed_area(self):
-        return self._observed_area
-
-    @observed_area.setter
-    def observed_area(self, value):
-        if value is None:
-            self._location = None
-            return
-        geo_classes = [obj for _, obj in inspect.getmembers(geojson) if inspect.isclass(obj) and
-                       obj.__module__ == 'geojson.geometry']
-        if type(value) in geo_classes:
-            self._observed_area = value
-            return
-        else:
-            try:
-                json.dumps(value)
-            except TypeError:
-                raise ValueError('observedArea should be of json_serializable!')
-            self._observed_area = value
-
-    @property
-    def properties(self):
-        return self._properties
-
-    @properties.setter
-    def properties(self, value):
-        if value is None:
-            self._properties = None
-            return
-        if not isinstance(value, dict):
-            raise ValueError('properties should be of type dict')
-        self._properties = value
-
-    @property
-    def phenomenon_time(self):
-        return self._phenomenon_time
-
-    @phenomenon_time.setter
-    def phenomenon_time(self, value):
-        self._phenomenon_time = utils.check_datetime(value, 'phenomenon_time')
-
-    @property
-    def result_time(self):
-        return self._result_time
-
-    @result_time.setter
-    def result_time(self, value):
-        self._result_time = utils.check_datetime(value, 'result_time')
-
-    @property
-    def thing(self):
-        return self._thing
-
-    @thing.setter
-    def thing(self, value):
-        if value is None or isinstance(value, thing.Thing):
-            self._thing = value
-            return
-        raise ValueError('thing should be of type Thing!')
-
-    @property
-    def sensor(self):
-        return self._sensor
-
-    @sensor.setter
-    def sensor(self, value):
-        if value is None or isinstance(value, sensor.Sensor):
-            self._sensor = value
-            return
-        raise ValueError('sensor should be of type Sensor!')
-
-    @property
-    def observed_property(self):
-        return self._observed_property
-
-    @observed_property.setter
-    def observed_property(self, value):
-        if isinstance(value, observedproperty.ObservedProperty) or value is None:
-            self._observed_property = value
-            return
-        raise ValueError('observed property should by of type ObservedProperty!')
-
-    @property
-    def observations(self):
-        return self._observations
-
-    @observations.setter
-    def observations(self, values):
-        if values is None:
-            self._observations = None
-            return
-        if isinstance(values, list) and all(isinstance(ob, observation.Observation) for ob in values):
-            entity_class = entity_type.EntityTypes['Observation']['class']
-            self._observations = entity_list.EntityList(entity_class=entity_class, entities=values)
-            return
-        if isinstance(values, entity_list.EntityList) and \
-                all(isinstance(ob, observation.Observation) for ob in values.entities):
-            self._observations = values
-            return
-        raise ValueError('Observations should be a list of Observations')
-
-    def get_observations(self):
-        result = self.service.observations()
-        result.parent = self
-        return result
-
-    def ensure_service_on_children(self, service):
-        if self.thing is not None:
-            self.thing.set_service(service)
-        if self.sensor is not None:
-            self.sensor.set_service(service)
-        if self.observed_property is not None:
-            self.observed_property.set_service(service)
-        if self.observations is not None:
-            self.observations.set_service(service)
-
-    def __eq__(self, other):
-        if not super().__eq__(other):
-            return False
-        if self.name != other.name:
-            return False
-        if self.description != other.description:
-            return False
-        if self.observation_type != other.observation_type:
-            return False
-        if self.unit_of_measurement != other.unit_of_measurement:
-            return False
-        if self.properties != other.properties:
-            return False
-        if self.result_time != other.result_time:
-            return False
-        return True
-
-    def __ne__(self, other):
-        return not self == other
-
-    def __getstate__(self):
-        data = super().__getstate__()
-        if self.name is not None and self.name != '':
-            data['name'] = self.name
-        if self.description is not None and self.description != '':
-            data['description'] = self.description
-        if self.observation_type is not None and self.observation_type != '':
-            data['observationType'] = self.observation_type
-        if self.properties is not None and self.properties != {}:
-            data['properties'] = self.properties
-        if self.unit_of_measurement is not None:
-            data['unitOfMeasurement'] = self.unit_of_measurement
-        if self.observed_area is not None:
-            data['observedArea'] = self.observed_area
-        if self.phenomenon_time is not None:
-            data['phenomenonTime'] = utils.parse_datetime(self.phenomenon_time)
-        if self.result_time is not None:
-            data['resultTime'] = utils.parse_datetime(self.result_time)
-        if self.thing is not None:
-            data['Thing'] = self.thing
-        if self.sensor is not None:
-            data['Sensor'] = self.sensor
-        if self.observed_property is not None:
-            data['ObservedProperty'] = self.observed_property
-        if self.observations is not None and len(self.observations.entities) > 0:
-            data['Observations'] = self.observations.__getstate__()
-        return data
-
-    def __setstate__(self, state):
-        super().__setstate__(state)
-        self.name = state.get("name", None)
-        self.description = state.get("description", None)
-        self.observation_type = state.get("observationType", None)
-        self.properties = state.get("properties", {})
-        if state.get("unitOfMeasurement", None) is not None:
-            self.unit_of_measurement = frost_sta_client.model.ext.unitofmeasurement.UnitOfMeasurement()
-            self.unit_of_measurement.__setstate__(state["unitOfMeasurement"])
-        if state.get("observedArea", None) is not None:
-            self.observed_area = frost_sta_client.utils.process_area(state["observedArea"])
-        if state.get("phenomenonTime", None) is not None:
-            self.phenomenon_time = state["phenomenonTime"]
-        if state.get("resultTime", None) is not None:
-            self.result_time = state["resultTime"]
-        if state.get("Thing", None) is not None:
-            self.thing = frost_sta_client.model.thing.Thing()
-            self.thing.__setstate__(state["Thing"])
-        if state.get("ObservedProperty", None) is not None:
-            self.observed_property = frost_sta_client.model.observedproperty.ObservedProperty()
-            self.observed_property.__setstate__(state["ObservedProperty"])
-        if state.get("Sensor", None) is not None:
-            self.sensor = frost_sta_client.model.sensor.Sensor()
-            self.sensor.__setstate__(state["Sensor"])
-        if state.get("Observations", None) is not None and isinstance(state["Observations"], list):
-            entity_class = entity_type.EntityTypes['Observation']['class']
-            self.observations = utils.transform_json_to_entity_list(state['Observations'], entity_class)
-            self.observations.next_link = state.get("Observations@iot.nextLink", None)
-            self.observations.count = state.get("Observations@iot.count", None)
-
-    def get_dao(self, service):
-        return DatastreamDao(service)
+# Copyright (C) 2021 Fraunhofer Institut IOSB, Fraunhoferstr. 1, D 76131
+# Karlsruhe, Germany.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+import inspect
+import json
+
+import frost_sta_client.model.ext.unitofmeasurement
+from frost_sta_client.dao.datastream import DatastreamDao
+
+from . import thing
+from . import sensor
+from . import observedproperty
+from . import observation
+from . import entity
+from .ext import unitofmeasurement
+from .ext import entity_list
+from .ext import entity_type
+
+from frost_sta_client import utils
+
+import geojson.geometry
+
+
+class Datastream(entity.Entity):
+
+    def __init__(self,
+                 name='',
+                 description='',
+                 observation_type='',
+                 unit_of_measurement=None,
+                 observed_area=None,
+                 properties=None,
+                 phenomenon_time=None,
+                 result_time=None,
+                 thing=None,
+                 sensor=None,
+                 observed_property=None,
+                 observations=None,
+                 **kwargs):
+        """
+        This class handles Datastreams assigned to a Thing. Before you create a Datastreams, you firstly have to
+        create a Thing, a Sensor and an observedProperty to which you have to refer by specifying its ids.
+
+        Parameters
+        ----------
+        name: str
+        description: str
+        observation_type: str
+        unit_of_measurement: dict
+            Should be a dict of keys 'name', 'symbol', 'definition' with values of str.
+
+        """
+        super().__init__(**kwargs)
+        if properties is None:
+            properties = {}
+        self.name = name
+        self.description = description
+        self.observation_type = observation_type
+        self.unit_of_measurement = unit_of_measurement
+        self.observed_area = observed_area
+        self.properties = properties
+        self.phenomenon_time = phenomenon_time
+        self.result_time = result_time
+        self.thing = thing
+        self.sensor = sensor
+        self.observations = observations
+        self.observed_property = observed_property
+
+
+    def __new__(cls, *args, **kwargs):
+        new_datastream = super().__new__(cls)
+        attributes = dict(_id=None, _name='', _description='', _properties={}, _observation_type='',
+                          _unit_of_measurement=None, _observed_area=None, _phenomenon_time=None, _result_time=None,
+                          _thing=None, _sensor=None, _observed_property=None, _observations=None, _self_link='',
+                          _service=None)
+        for key, value in attributes.items():
+            new_datastream.__dict__[key] = value
+        return new_datastream
+
+    @property
+    def name(self):
+        return self._name
+
+    @name.setter
+    def name(self, value):
+        if value is None:
+            self._name = None
+            return
+        if not isinstance(value, str):
+            raise ValueError('name should be of type str!')
+        self._name = value
+
+    @property
+    def description(self):
+        return self._description
+
+    @description.setter
+    def description(self, value):
+        if value is None:
+            self._description = None
+            return
+        if not isinstance(value, str):
+            raise ValueError('description should be of type str!')
+        self._description = value
+
+    @property
+    def observation_type(self):
+        return self._observation_type
+
+    @observation_type.setter
+    def observation_type(self, value):
+        if value is None:
+            self._observation_type = None
+            return
+        if not isinstance(value, str):
+            raise ValueError('observation_type should be of type str!')
+        self._observation_type = value
+
+    @property
+    def unit_of_measurement(self):
+        return self._unit_of_measurement
+
+    @unit_of_measurement.setter
+    def unit_of_measurement(self, value):
+        if value is None or isinstance(value, unitofmeasurement.UnitOfMeasurement):
+            self._unit_of_measurement = value
+            return
+        raise ValueError('unitOfMeasurement should be of type UnitOfMeasurement!')
+
+    @property
+    def observed_area(self):
+        return self._observed_area
+
+    @observed_area.setter
+    def observed_area(self, value):
+        if value is None:
+            self._location = None
+            return
+        geo_classes = [obj for _, obj in inspect.getmembers(geojson) if inspect.isclass(obj) and
+                       obj.__module__ == 'geojson.geometry']
+        if type(value) in geo_classes:
+            self._observed_area = value
+            return
+        else:
+            try:
+                json.dumps(value)
+            except TypeError:
+                raise ValueError('observedArea should be of json_serializable!')
+            self._observed_area = value
+
+    @property
+    def properties(self):
+        return self._properties
+
+    @properties.setter
+    def properties(self, value):
+        if value is None:
+            self._properties = None
+            return
+        if not isinstance(value, dict):
+            raise ValueError('properties should be of type dict')
+        self._properties = value
+
+    @property
+    def phenomenon_time(self):
+        return self._phenomenon_time
+
+    @phenomenon_time.setter
+    def phenomenon_time(self, value):
+        self._phenomenon_time = utils.check_datetime(value, 'phenomenon_time')
+
+    @property
+    def result_time(self):
+        return self._result_time
+
+    @result_time.setter
+    def result_time(self, value):
+        self._result_time = utils.check_datetime(value, 'result_time')
+
+    @property
+    def thing(self):
+        return self._thing
+
+    @thing.setter
+    def thing(self, value):
+        if value is None or isinstance(value, thing.Thing):
+            self._thing = value
+            return
+        raise ValueError('thing should be of type Thing!')
+
+    @property
+    def sensor(self):
+        return self._sensor
+
+    @sensor.setter
+    def sensor(self, value):
+        if value is None or isinstance(value, sensor.Sensor):
+            self._sensor = value
+            return
+        raise ValueError('sensor should be of type Sensor!')
+
+    @property
+    def observed_property(self):
+        return self._observed_property
+
+    @observed_property.setter
+    def observed_property(self, value):
+        if isinstance(value, observedproperty.ObservedProperty) or value is None:
+            self._observed_property = value
+            return
+        raise ValueError('observed property should by of type ObservedProperty!')
+
+    @property
+    def observations(self):
+        return self._observations
+
+    @observations.setter
+    def observations(self, values):
+        if values is None:
+            self._observations = None
+            return
+        if isinstance(values, list) and all(isinstance(ob, observation.Observation) for ob in values):
+            entity_class = entity_type.EntityTypes['Observation']['class']
+            self._observations = entity_list.EntityList(entity_class=entity_class, entities=values)
+            return
+        if isinstance(values, entity_list.EntityList) and \
+                all(isinstance(ob, observation.Observation) for ob in values.entities):
+            self._observations = values
+            return
+        raise ValueError('Observations should be a list of Observations')
+
+    def get_observations(self):
+        result = self.service.observations()
+        result.parent = self
+        return result
+
+    def ensure_service_on_children(self, service):
+        if self.thing is not None:
+            self.thing.set_service(service)
+        if self.sensor is not None:
+            self.sensor.set_service(service)
+        if self.observed_property is not None:
+            self.observed_property.set_service(service)
+        if self.observations is not None:
+            self.observations.set_service(service)
+
+    def __eq__(self, other):
+        if not super().__eq__(other):
+            return False
+        if self.name != other.name:
+            return False
+        if self.description != other.description:
+            return False
+        if self.observation_type != other.observation_type:
+            return False
+        if self.unit_of_measurement != other.unit_of_measurement:
+            return False
+        if self.properties != other.properties:
+            return False
+        if self.result_time != other.result_time:
+            return False
+        return True
+
+    def __ne__(self, other):
+        return not self == other
+
+    def __getstate__(self):
+        data = super().__getstate__()
+        if self.name is not None and self.name != '':
+            data['name'] = self.name
+        if self.description is not None and self.description != '':
+            data['description'] = self.description
+        if self.observation_type is not None and self.observation_type != '':
+            data['observationType'] = self.observation_type
+        if self.properties is not None and self.properties != {}:
+            data['properties'] = self.properties
+        if self.unit_of_measurement is not None:
+            data['unitOfMeasurement'] = self.unit_of_measurement.__getstate__()
+        if self.observed_area is not None:
+            data['observedArea'] = self.observed_area
+        if self.phenomenon_time is not None:
+            data['phenomenonTime'] = utils.parse_datetime(self.phenomenon_time)
+        if self.result_time is not None:
+            data['resultTime'] = utils.parse_datetime(self.result_time)
+        if self.thing is not None:
+            data['Thing'] = self.thing.__getstate__()
+        if self.sensor is not None:
+            data['Sensor'] = self.sensor.__getstate__()
+        if self.observed_property is not None:
+            data['ObservedProperty'] = self.observed_property.__getstate__()
+        if self.observations is not None and len(self.observations.entities) > 0:
+            data['Observations'] = self.observations.__getstate__()
+        return data
+
+    def __setstate__(self, state):
+        super().__setstate__(state)
+        self.name = state.get("name", None)
+        self.description = state.get("description", None)
+        self.observation_type = state.get("observationType", None)
+        self.properties = state.get("properties", {})
+        if state.get("unitOfMeasurement", None) is not None:
+            self.unit_of_measurement = frost_sta_client.model.ext.unitofmeasurement.UnitOfMeasurement()
+            self.unit_of_measurement.__setstate__(state["unitOfMeasurement"])
+        if state.get("observedArea", None) is not None:
+            self.observed_area = frost_sta_client.utils.process_area(state["observedArea"])
+        if state.get("phenomenonTime", None) is not None:
+            self.phenomenon_time = state["phenomenonTime"]
+        if state.get("resultTime", None) is not None:
+            self.result_time = state["resultTime"]
+        if state.get("Thing", None) is not None:
+            self.thing = frost_sta_client.model.thing.Thing()
+            self.thing.__setstate__(state["Thing"])
+        if state.get("ObservedProperty", None) is not None:
+            self.observed_property = frost_sta_client.model.observedproperty.ObservedProperty()
+            self.observed_property.__setstate__(state["ObservedProperty"])
+        if state.get("Sensor", None) is not None:
+            self.sensor = frost_sta_client.model.sensor.Sensor()
+            self.sensor.__setstate__(state["Sensor"])
+        if state.get("Observations", None) is not None and isinstance(state["Observations"], list):
+            entity_class = entity_type.EntityTypes['Observation']['class']
+            self.observations = utils.transform_json_to_entity_list(state['Observations'], entity_class)
+            self.observations.next_link = state.get("Observations@iot.nextLink", None)
+            self.observations.count = state.get("Observations@iot.count", None)
+
+    def get_dao(self, service):
+        return DatastreamDao(service)

frost_sta_client/model/feature_of_interest.py

@@ -179,7 +179,7 @@ class FeatureOfInterest(entity.Entity):
         if self.feature is not None:
             data['feature'] = self.feature
         if self.observations is not None and len(self.observations.entities) > 0:
-            data['Observations'] = self.observations.__gestate__()
+            data['Observations'] = self.observations.__getstate__()
         return data
 
     def __setstate__(self, state):

frost_sta_client/model/historical_location.py

@@ -105,7 +105,7 @@ class HistoricalLocation(entity.Entity):
         if self.time is not None:
             data['time'] = utils.parse_datetime(self.time)
         if self.thing is not None:
-            data['Thing'] = self.thing
+            data['Thing'] = self.thing.__getstate__()
         if self.locations is not None and len(self.locations.entities) > 0:
             data['Locations'] = self.locations.__getstate__()
         return data

frost_sta_client/model/location.py

@@ -218,9 +218,9 @@ class Location(entity.Entity):
         if self.location is not None:
             data['location'] = self.location
         if self.things is not None:
-            data['Things'] = self.things
+            data['Things'] = self.things.__getstate__()
         if self.historical_locations is not None and len(self.historical_locations.entities) > 0:
-            data['HistoricalLocation'] = self.historical_locations.__getstate__()
+            data['HistoricalLocations'] = self.historical_locations.__getstate__()
         return data
 
     def __setstate__(self, state):

frost_sta_client/model/multi_datastream.py

@@ -290,13 +290,13 @@ class MultiDatastream(entity.Entity):
         if self.result_time is not None:
             data['resultTime'] = utils.parse_datetime(self.result_time)
         if self.thing is not None:
-            data['Thing'] = self.thing
+            data['Thing'] = self.thing.__getstate__()
         if self.sensor is not None:
-            data['Sensor'] = self.sensor
+            data['Sensor'] = self.sensor.__getstate__()
         if self.properties is not None and self.properties != {}:
             data['properties'] = self.properties
         if self.unit_of_measurements is not None and len(self.unit_of_measurements) > 0:
-            data['unitOfMeasurements'] = self.unit_of_measurements
+            data['unitOfMeasurements'] = self.unit_of_measurements.__getstate__()
         if self.multi_observation_data_types is not None and len(self.multi_observation_data_types) > 0:
             data['multiObservationDataTypes'] = self.multi_observation_data_types
         if self.observed_properties is not None and len(self.observed_properties.entities) > 0:

frost_sta_client/model/observedproperty.py

@@ -184,7 +184,7 @@ class ObservedProperty(entity.Entity):
         if self.properties is not None and self.properties != {}:
             data['properties'] = self.properties
         if self.datastreams is not None and len(self.datastreams.entities) > 0:
-            data['Datastream'] = self.datastreams.__getstate__()
+            data['Datastreams'] = self.datastreams.__getstate__()
         if self.multi_datastreams is not None and len(self.multi_datastreams.entities) > 0:
             data['MultiDatastreams'] = self.multi_datastreams.__getstate__()
         return data

frost_sta_client/model/task.py

@@ -98,16 +98,16 @@ class Task(entity.Entity):
         if self.creation_time is not None:
             data['creationTime'] = utils.parse_datetime(self.creation_time)
         if self.tasking_capability is not None:
-            data['TaskingCapability'] = self.tasking_capability
+            data['TaskingCapability'] = self.tasking_capability.__getstate__()
         return data
 
     def __setstate__(self, state):
         super().__setstate__(state)
         self.tasking_parameters = state.get('taskingParameters', {})
         self.creation_time = state.get('creationTime', None)
-        if state.get('taskingCapability', None) is not None:
+        if state.get('TaskingCapability', None) is not None:
             self.tasking_capability = frost_sta_client.model.tasking_capability.TaskingCapability()
-            self.tasking_capability.__setstate__(state['taskingCapability'])
+            self.tasking_capability.__setstate__(state['TaskingCapability'])
 
     def get_dao(self, service):
         return TaskDao(service)

frost_sta_client/model/tasking_capability.py

@@ -186,11 +186,11 @@ class TaskingCapability(entity.Entity):
         if self.properties is not None and self.properties != {}:
             data['properties'] = self.properties
         if self.thing is not None:
-            data['Thing'] = self.thing
+            data['Thing'] = self.thing.__getstate__()
         if self.tasks is not None and len(self.tasks.entities) > 0:
             data['Tasks'] = self.tasks.__getstate__()
         if self.actuator is not None:
-            data['Actuator'] = self.actuator
+            data['Actuator'] = self.actuator.__getstate__()
         return data
 
     def __setstate__(self, state):

frost_sta_client/utils.py

@@ -1,119 +1,122 @@
-# Copyright (C) 2021 Fraunhofer Institut IOSB, Fraunhoferstr. 1, D 76131
-# Karlsruhe, Germany.
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Lesser General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-import jsonpickle
-import datetime
-from dateutil.parser import isoparse
-import geojson
-import logging
-import sys
-import frost_sta_client.model.ext.entity_list
-
-
-def extract_value(location):
-    try:
-        value = int(location[location.find('(')+1: location.find(')')])
-    except ValueError:
-        value = str(location[location.find('(')+2: location.find(')')-1])
-    return value
-
-def transform_entity_to_json_dict(entity):
-    json_str = jsonpickle.encode(entity, unpicklable=False)
-    return jsonpickle.decode(json_str)
-
-def class_from_string(string):
-    module_name, class_name = string.rsplit(".", 1)
-    return getattr(sys.modules[module_name], class_name)
-
-def transform_json_to_entity(json_response, entity_class):
-    cl = class_from_string(entity_class)
-    obj = cl()
-    obj.__setstate__(json_response)
-    return obj
-
-def transform_json_to_entity_list(json_response, entity_class):
-    entity_list = frost_sta_client.model.ext.entity_list.EntityList(entity_class)
-    result_list = []
-    if isinstance(json_response, dict):
-        try:
-            response_list = json_response['value']
-            entity_list.next_link = json_response.get("@iot.nextLink", None)
-            entity_list.count = json_response.get("@iot.count", None)
-        except AttributeError as e:
-            raise e
-    elif isinstance(json_response, list):
-        response_list = json_response
-    else:
-        raise ValueError("expected json as a dict or list to transform into entity list")
-    entity_list.entities = [transform_json_to_entity(item, entity_list.entity_class) for item in response_list]
-    return entity_list
-
-
-def check_datetime(value, time_entity):
-    try:
-        parse_datetime(value)
-    except ValueError as e:
-        logging.error(f"error during {time_entity} check")
-        raise e
-    return value
-
-
-def parse_datetime(value) -> str:
-    if value is None:
-        return value
-    if isinstance(value, str):
-        if '/' in value:
-            try:
-                times = value.split('/')
-                if len(times) != 2:
-                    raise ValueError("If the time interval is provided as a string,"
-                                     " it should be in isoformat")
-                result = [isoparse(times[0]),
-                          isoparse(times[1])]
-            except ValueError:
-                raise ValueError("If the time entity interval is provided as a string,"
-                                 " it should be in isoformat")
-            result = result[0].isoformat() + '/' + result[1].isoformat()
-            return result
-        else:
-            try:
-                result = isoparse(value)
-            except ValueError:
-                raise ValueError("If the phenomenon time is provided as string, it should be in isoformat")
-            result = result.isoformat()
-            return result
-    if isinstance(value, datetime.datetime):
-        return value.isoformat()
-    if isinstance(value, list) and all(isinstance(v, datetime.datetime) for v in value):
-        return value[0].isoformat() + value[1].isoformat()
-    else:
-        raise ValueError('time entities should consist of one or two datetimes')
-
-
-def process_area(value):
-    if not isinstance(value, dict):
-        raise ValueError("geojsons can only be handled as dictionaries!")
-    if value.get("type", None) is None or value.get("coordinates", None) is None:
-        raise ValueError("Both type and coordinates need to be specified in the dictionary")
-    if value["type"] == "Point":
-        return geojson.geometry.Point(value["coordinates"])
-    if value["type"] == "Polygon":
-        return geojson.geometry.Polygon(value["coordinates"])
-    if value["type"] == "Geometry":
-        return geojson.geometry.Geometry(value["coordinates"])
-    if value["type"] == "LineString":
-        return geojson.geometry.LineString(value["coordinates"])
-    raise ValueError("can only handle geojson of type Point, Polygon, Geometry or LineString")
+# Copyright (C) 2021 Fraunhofer Institut IOSB, Fraunhoferstr. 1, D 76131
+# Karlsruhe, Germany.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import jsonpickle
+import datetime
+from dateutil.parser import isoparse
+import geojson
+import logging
+import sys
+import frost_sta_client.model.ext.entity_list
+
+
+def extract_value(location):
+    try:
+        value = int(location[location.find('(')+1: location.find(')')])
+    except ValueError:
+        value = str(location[location.find('(')+2: location.find(')')-1])
+    return value
+
+def transform_entity_to_json_dict(entity):
+    try:
+        data = entity.__getstate__()
+    except AttributeError:
+        data = entity.__dict__
+    return data
+
+def class_from_string(string):
+    module_name, class_name = string.rsplit(".", 1)
+    return getattr(sys.modules[module_name], class_name)
+
+def transform_json_to_entity(json_response, entity_class):
+    cl = class_from_string(entity_class)
+    obj = cl()
+    obj.__setstate__(json_response)
+    return obj
+
+def transform_json_to_entity_list(json_response, entity_class):
+    entity_list = frost_sta_client.model.ext.entity_list.EntityList(entity_class)
+    result_list = []
+    if isinstance(json_response, dict):
+        try:
+            response_list = json_response['value']
+            entity_list.next_link = json_response.get("@iot.nextLink", None)
+            entity_list.count = json_response.get("@iot.count", None)
+        except AttributeError as e:
+            raise e
+    elif isinstance(json_response, list):
+        response_list = json_response
+    else:
+        raise ValueError("expected json as a dict or list to transform into entity list")
+    entity_list.entities = [transform_json_to_entity(item, entity_list.entity_class) for item in response_list]
+    return entity_list
+
+
+def check_datetime(value, time_entity):
+    try:
+        parse_datetime(value)
+    except ValueError as e:
+        logging.error(f"error during {time_entity} check")
+        raise e
+    return value
+
+
+def parse_datetime(value) -> str:
+    if value is None:
+        return value
+    if isinstance(value, str):
+        if '/' in value:
+            try:
+                times = value.split('/')
+                if len(times) != 2:
+                    raise ValueError("If the time interval is provided as a string,"
+                                     " it should be in isoformat")
+                result = [isoparse(times[0]),
+                          isoparse(times[1])]
+            except ValueError:
+                raise ValueError("If the time entity interval is provided as a string,"
+                                 " it should be in isoformat")
+            result = result[0].isoformat() + '/' + result[1].isoformat()
+            return result
+        else:
+            try:
+                result = isoparse(value)
+            except ValueError:
+                raise ValueError("If the phenomenon time is provided as string, it should be in isoformat")
+            result = result.isoformat()
+            return result
+    if isinstance(value, datetime.datetime):
+        return value.isoformat()
+    if isinstance(value, list) and all(isinstance(v, datetime.datetime) for v in value):
+        return value[0].isoformat() + value[1].isoformat()
+    else:
+        raise ValueError('time entities should consist of one or two datetimes')
+
+
+def process_area(value):
+    if not isinstance(value, dict):
+        raise ValueError("geojsons can only be handled as dictionaries!")
+    if value.get("type", None) is None or value.get("coordinates", None) is None:
+        raise ValueError("Both type and coordinates need to be specified in the dictionary")
+    if value["type"] == "Point":
+        return geojson.geometry.Point(value["coordinates"])
+    if value["type"] == "Polygon":
+        return geojson.geometry.Polygon(value["coordinates"])
+    if value["type"] == "Geometry":
+        return geojson.geometry.Geometry(value["coordinates"])
+    if value["type"] == "LineString":
+        return geojson.geometry.LineString(value["coordinates"])
+    raise ValueError("can only handle geojson of type Point, Polygon, Geometry or LineString")

{frost_sta_client-1.1.48.dist-info → frost_sta_client-1.1.50.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: frost_sta_client
-Version: 1.1.48
+Version: 1.1.50
 Summary: a client library to facilitate interaction with a FROST SensorThingsAPI Server
 Home-page: https://github.com/FraunhoferIOSB/FROST-Python-Client
 Author: Fraunhofer IOSB

{frost_sta_client-1.1.48.dist-info → frost_sta_client-1.1.50.dist-info}/RECORD

@@ -1,6 +1,6 @@
 frost_sta_client/__init__.py,sha256=N0Rs6kwdPcpyz0p-Tfq2PYIAIIZsMmnSC0QXus_AmP0,1789
-frost_sta_client/__version__.py,sha256=5YVnrD-mRpv_hnD-BaKoRSM5HeJWnlcqol-5z0A_F68,355
-frost_sta_client/utils.py,sha256=hY9JO0F4jIXODXFu7xdFw2b6hGhYQky_UZI0UDRBPaI,4845
+frost_sta_client/__version__.py,sha256=YlJvHmENV_oKBVhv9GKooi1RsV_49ZSoiI5TUbXJCi8,355
+frost_sta_client/utils.py,sha256=YA8B3SkG0RFFumSPPH65rJ2BHrADzKtcCKXVKAUVG54,4747
 frost_sta_client/dao/__init__.py,sha256=RKxbQ3WLVygWyz_Kb-SzO7CfUdffq7LqtJHcHSOHmgo,221
 frost_sta_client/dao/actuator.py,sha256=WxRjeetR50Pb9AbhCdtc1VRSl09pgzfA2DsPBBZy-3E,1099
 frost_sta_client/dao/base.py,sha256=uAx1qSnXX2jwoZrjXjPW47bp-c-jMUyX8SpmY0eXM84,9209
@@ -16,18 +16,18 @@ frost_sta_client/dao/task.py,sha256=wRPoe8F3a8O8aAhgNtxvJm3LxD-oHUA6LilmXOZNJoM,
 frost_sta_client/dao/tasking_capability.py,sha256=cn5iG2aL2Zh74E8WRKpEfTRjupkY-4xK8xaIIIJ9waU,1138
 frost_sta_client/dao/thing.py,sha256=qPNrQjAmxrJ6dmJKVRr1eP6V9-zKVcIYr3t1DVNHtHo,1102
 frost_sta_client/model/__init__.py,sha256=LDj9AdnZ5Tjm0iZ2vTe_HyXxJ6x72GLsfKFNf5kww1U,627
-frost_sta_client/model/actuator.py,sha256=5foMfNehrDS0l5P_Gh6Ee5DlOS3mtRio0ULKRbZsJJw,7060
-frost_sta_client/model/datastream.py,sha256=FwscWHlpX5T_Zj_Prk1gxwZdMO-GLw9DivRnMluifkE,12903
+frost_sta_client/model/actuator.py,sha256=D6MWkoXDVOHd54DDggcpSki1s8aqdHZHOPnhu-rCnYg,7060
+frost_sta_client/model/datastream.py,sha256=tIp7egNtaLYzaNVeipVYbpA8KdULxY7704m_e-CDZto,12625
 frost_sta_client/model/entity.py,sha256=xf3EgxqUAg3Wk4nvZRNKkeFjYDMSS_47YPNVDVuFGO0,3671
-frost_sta_client/model/feature_of_interest.py,sha256=uMZN9o4udGoATmw6FTKKWZa5srfQFQpGvqNRjCul-uI,7186
-frost_sta_client/model/historical_location.py,sha256=UsPgUeYEa-ju_yyGSF0VrW0nVdTxMASsgfq7mB1iRZg,4615
-frost_sta_client/model/location.py,sha256=UoakCdiXRwuJ42RH4_pYrzKqAY4tnL0pPJ6CEKoNp04,9262
-frost_sta_client/model/multi_datastream.py,sha256=USZcs8dmDxI-D5RcX8ejbRavQQUhpBy1glWm7OP1PH8,14376
+frost_sta_client/model/feature_of_interest.py,sha256=NYFIUZA6tVs6hK2oy7fOM4KCjLccHllIscg0M7Ycr2E,7187
+frost_sta_client/model/historical_location.py,sha256=vZFv3NtKzTsFv1fMPwMSOeHc1QogiYcCu9lfNLvui68,4630
+frost_sta_client/model/location.py,sha256=DX27Za-4ookaQlaQ6tsyDPkRW6RkFc6-oD7zvatJgGk,9278
+frost_sta_client/model/multi_datastream.py,sha256=6rj_8NCSbxJ8afxg8O2eBzqDpe4xcNTKZaTb8AA3zY8,14421
 frost_sta_client/model/observation.py,sha256=YPNqH_CMfvaimkdAMtWW76-l5UIai32aej22pP3DnZ8,9221
-frost_sta_client/model/observedproperty.py,sha256=5ALOVMOSg4AB3CjX0vL_ddF0jKTJwBq89Nt9jE4eDcU,8346
+frost_sta_client/model/observedproperty.py,sha256=NeyVBDm7xyZf8nWQvAshoytaKqwNv1Jw20FOMCTyU-Q,8347
 frost_sta_client/model/sensor.py,sha256=ric_gEhn8oQWE7TR4Dwo1ASGysZpWJ6gsrQT4n_sgn4,8644
-frost_sta_client/model/task.py,sha256=-rM6mvlzjFkcIdW8HSeNZtfdA4ZqDqjzGTmGBxg423I,4351
-frost_sta_client/model/tasking_capability.py,sha256=iEabvKXcYo5nSTI-oWPYc2YXu3b-D-m6llXx80mwySc,7755
+frost_sta_client/model/task.py,sha256=xsNXokC2Z9GLdn9W_c9erC_yj3Duz_p5EY20HLhxX_o,4366
+frost_sta_client/model/tasking_capability.py,sha256=3aznDKyvzO4VMbuz4dLYY1oK9Ggk8fy18p9T13y05PU,7785
 frost_sta_client/model/thing.py,sha256=1F-mkQPML5mf6NkzXswuTJr8nGnDV1u8GYNj8YtNcl0,13257
 frost_sta_client/model/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 frost_sta_client/model/ext/data_array_document.py,sha256=Szvv4iHIHqQsost-ASInoTHYH7qc6qjMkgSYXJu-iYE,2201
@@ -40,8 +40,8 @@ frost_sta_client/query/query.py,sha256=hXd-ffYf2HDZ5aqVA5lW5XtoijIr4-4mTfevdRDz2
 frost_sta_client/service/__init__.py,sha256=au1GqHe1OB7Iq-i90plqmIrH-7wBE7ogDoQ2uX03Fj0,109
 frost_sta_client/service/auth_handler.py,sha256=qahYUK7Z0kGvbUcdtpodIA9sngYCfJz2jqKpLVGA8Z4,1117
 frost_sta_client/service/sensorthingsservice.py,sha256=H2wM4v5oPvJ6eBfvdkbYyLI4V1vaWpbAuq-Q_fGo3-A,4621
-frost_sta_client-1.1.48.dist-info/licenses/LICENSE,sha256=LPNKwDiu5awG-TPd0dqYJuC7k4PBPY4LCI_O0LSpW1s,7814
-frost_sta_client-1.1.48.dist-info/METADATA,sha256=2Hbvx_temj3FhEP5LUoU9StTu7ljdK81xXs-PdQia_M,5905
-frost_sta_client-1.1.48.dist-info/WHEEL,sha256=9bhjOwO--Rs91xaPcBdlYFUmIudhuXqFlPriQeYQITw,109
-frost_sta_client-1.1.48.dist-info/top_level.txt,sha256=c35-3D_K1E_y8fcadqI3j6kGQ7HBrkOqCNie5Rv64KI,17
-frost_sta_client-1.1.48.dist-info/RECORD,,
+frost_sta_client-1.1.50.dist-info/licenses/LICENSE,sha256=LPNKwDiu5awG-TPd0dqYJuC7k4PBPY4LCI_O0LSpW1s,7814
+frost_sta_client-1.1.50.dist-info/METADATA,sha256=_puhN-FXpb5axOVuwtPXbSTy2aprSKXWeOTdx_B3ONw,5905
+frost_sta_client-1.1.50.dist-info/WHEEL,sha256=JNWh1Fm1UdwIQV075glCn4MVuCRs0sotJIq-J6rbxCU,109
+frost_sta_client-1.1.50.dist-info/top_level.txt,sha256=c35-3D_K1E_y8fcadqI3j6kGQ7HBrkOqCNie5Rv64KI,17
+frost_sta_client-1.1.50.dist-info/RECORD,,

{frost_sta_client-1.1.48.dist-info → frost_sta_client-1.1.50.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (77.0.1)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py2-none-any
 Tag: py3-none-any