staplus-client 0.3.3__py3-none-any.whl

staplus_client/model/datastream.py

@@ -0,0 +1,166 @@
+# Copyright (C) 2023-2024 Secure Dimensions GmbH, Munich, 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/>.
+
+from frost_sta_client.model import datastream
+from staplus_client import utils
+from staplus_client.model.ext import entity_list, entity_type
+from staplus_client.dao.datastream import DatastreamDao
+from staplus_client.model import license, party, campaign
+
+
+class Datastream(datastream.Datastream):
+
+    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,
+                 campaigns=None,
+                 party=None,
+                 license=None,
+                 **kwargs):
+        super().__init__(name, description, observation_type, unit_of_measurement,
+                         observed_area, properties, phenomenon_time, result_time, thing,
+                         sensor, observations, observed_property, **kwargs)
+        self.campaigns = campaigns
+        self.party = party
+        self.license = license
+
+    def __new__(cls, *args, **kwargs):
+        new_datastream = super().__new__(cls, args, kwargs)
+        attributes = dict(_campaigns=None, _party=None, _license=None, _self_link='', _service=None)
+        for key, value in attributes.items():
+            new_datastream.__dict__[key] = value
+        return new_datastream
+
+    @property
+    def party(self):
+        return self._party
+
+    @party.setter
+    def party(self, value):
+        if value is None or isinstance(value, party.Party):
+            self._party = value
+            return
+        raise ValueError('party should be of type Party!')
+
+    def get_party(self):
+        result = self.service.party()
+        result.parent = self
+        return result
+
+    @property
+    def license(self):
+        return self._license
+
+    @license.setter
+    def license(self, value):
+        if value is None or isinstance(value, license.License):
+            self._license = value
+            return
+        raise ValueError('license should be of type License!')
+
+    def get_license(self):
+        result = self.service.license()
+        result.parent = self
+        return result
+
+    def get_thing(self):
+        result = self.service.thing()
+        result.parent = self
+        return result
+
+    def get_sensor(self):
+        result = self.service.sensor()
+        result.parent = self
+        return result
+
+    def get_observed_property(self):
+        result = self.service.observed_property()
+        result.parent = self
+        return result
+
+    @property
+    def campaigns(self):
+        return self._campaigns
+
+    @campaigns.setter
+    def campaigns(self, values):
+        if values is None:
+            self._campaigns = None
+            return
+        if isinstance(values, list) and all(isinstance(ps, campaign.Campaign) for ps in values):
+            entity_class = entity_type.EntityTypes['Campaign']['class']
+            self._campaigns = entity_list.EntityList(entity_class=entity_class, entities=values)
+            return
+        if not isinstance(values, entity_list.EntityList) or \
+                any((not isinstance(ps, campaign.Campaign)) for ps in values.entities):
+            raise ValueError('campaigns should be a list of Campaign')
+        self._campaigns = values
+
+    def get_campaigns(self):
+        result = self.service.campaigns()
+        result.parent = self
+        return result
+
+    def ensure_service_on_children(self, service):
+        super().ensure_service_on_children(service)
+        if self.party is not None:
+            self.party.set_service(service)
+        if self.license is not None:
+            self.license.set_service(service)
+        if self.campaigns is not None:
+            self.campaigns.set_service(service)
+
+    def __getstate__(self):
+        data = super().__getstate__()
+        if self.party is not None:
+            data['Party'] = self.party
+        if self.license is not None:
+            data['License'] = self.license
+        if self._campaigns is not None and len(self.campaigns.entities) > 0:
+            data['Campaigns'] = self.campaigns.__getstate__()
+
+        return data
+
+    def __setstate__(self, state):
+        super().__setstate__(state)
+        if state.get("Party", None) is not None:
+            self.party = party.Party()
+            self.party.__setstate__(state["Party"])
+        if state.get("License", None) is not None:
+            self.license = license.License()
+            self.license.__setstate__(state["License"])
+        if state.get("Campaigns", None) is not None and isinstance(state["Campaigns"], list):
+            entity_class = entity_type.EntityTypes['Campaign']['class']
+            self.campaigns = utils.transform_json_to_entity_list(state['Campaigns'], entity_class)
+            self.campaigns.next_link = state.get("Campaigns@iot.nextLink", None)
+            self.campaigns.count = state.get("Campaigns@iot.count", None)
+
+    def get_dao(self, service):
+        return DatastreamDao(service)
+
+    def clone(self):
+        entity = self.__class__()
+        entity.id = self.id
+        return entity

staplus_client/model/entity.py

@@ -0,0 +1,29 @@
+# Copyright (C) 2023-2024 Secure Dimensions GmbH, Munich, 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/>.
+
+from frost_sta_client.model import entity
+from staplus_client.service.staplusservice import STAplusService
+
+class Entity(entity.Entity):
+    def service(self, value):
+        if value is None or isinstance(value, STAplusService):
+            self._service = value
+            return
+        raise ValueError('service should be of type STAplusService')
+
+    def set_service(self, service):
+        if self.service != service:
+            self.service = service
+            self.ensure_service_on_children(service)

staplus_client/model/ext/entity_list.py

@@ -0,0 +1,75 @@
+# Copyright (C) 2023-2024 Secure Dimensions GmbH, Munich, 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 logging
+import requests
+
+from staplus_client.service.staplusservice import STAplusService
+from staplus_client.model.entity import Entity
+from frost_sta_client.model.ext import entity_list
+
+class EntityList(entity_list.EntityList):
+    def __init__(self, entity_class, entities=None):
+        super().__init__(entity_class, entities)
+
+    def __next__(self):
+        idx, next_entity = next(self.iterable_entities, (len(self.entities), None))
+        if self.step_size is not None and idx is not None and idx % self.step_size == 0:
+            self.callback(idx)
+        if next_entity is not None:
+            return next_entity
+        if self.next_link is not None:
+            try:
+                response = self.service.execute('get', self.next_link)
+            except requests.exceptions.HTTPError as e:
+                error_json = e.response.json()
+                error_message = error_json['message']
+                logging.error("Query failed with status-code {}, {}".format(e.response.status_code, error_message))
+                raise e
+            logging.debug('Received response: {} from {}'.format(response.status_code, self.next_link))
+            try:
+                json_response = response.json()
+            except ValueError:
+                raise ValueError('Cannot find json in http response')
+
+            result_list = staplus_client.utils.transform_json_to_entity_list(json_response, self.entity_class)
+            self.entities += result_list.entities
+            self.set_service(self.service)
+            self.next_link = json_response.get("@iot.nextLink", None)
+            self.iterable_entities = iter(enumerate(self.entities[-len(result_list.entities):], start=idx))
+            return next(self.iterable_entities)[1]
+        raise StopIteration
+
+    @property
+    def service(self):
+        return self._service
+
+    @service.setter
+    def service(self, value):
+        if value is None or isinstance(value, STAplusService):
+            self._service = value
+            return
+        raise ValueError('service should be of type STAplusService')
+
+    def set_service(self, service):
+        self.service = service
+        for entity in self.entities:
+            entity.set_service(service)
+
+    def entities(self, values):
+        if isinstance(values, list) and all(isinstance(v, Entity) for v in values):
+            self._entities = values
+            return
+        raise ValueError('entities should be a list of STAplus entities')

staplus_client/model/ext/entity_type.py

@@ -0,0 +1,142 @@
+# Copyright (C) 2023-2024 Secure Dimensions GmbH, Munich, 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/>.
+
+EntityTypes = {
+    'Datastream': {
+        'singular': 'Datastream',
+        'plural': 'Datastreams',
+        'class': 'staplus_client.model.datastream.Datastream',
+        'relations_list': ['Sensor', 'Thing', 'ObservedProperty', 'Observations', 'Party', 'License', 'Campaign']
+    },
+    'MultiDatastream': {
+        'singular': 'MultiDatastream',
+        'plural': 'MultiDatastreams',
+        'class': 'staplus_client.model.multi_datastream.MultiDatastream',
+        'relations_list': ['Sensor', 'Thing', 'ObservedProperties', 'Observations', 'Party', 'License', 'Campaign']
+    },
+    'FeatureOfInterest': {
+        'singular': 'FeatureOfInterest',
+        'plural': 'FeaturesOfInterest',
+        'class': 'staplus_client.model.feature_of_interest.FeatureOfInterest',
+        'relations_list': ['Observations']
+    },
+    'HistoricalLocation': {
+        'singular': 'HistoricalLocation',
+        'plural': 'HistoricalLocations',
+        'class': 'staplus_client.model.historical_location.HistoricalLocation',
+        'relations_list': ['Thing', 'Locations']
+    },
+    'Actuator': {
+        'singular': 'Actuator',
+        'plural': 'Actuators',
+        'class': 'frost_sta_client.model.actuator.Actuator',
+        'relations_list': ['TaskingCapabilities']
+    },
+    'Location': {
+        'singular': 'Location',
+        'plural': 'Locations',
+        'class': 'staplus_client.model.location.Location',
+        'relations_list': ['Things', 'HistoricalLocations']
+    },
+    'Observation': {
+        'singular': 'Observation',
+        'plural': 'Observations',
+        'class': 'staplus_client.model.observation.Observation',
+        'relations_list': ['FeatureOfInterest', 'Datastream', 'MultiDatastream', 'Subjects', 'Objects']
+    },
+    'Thing': {
+        'singular': 'Thing',
+        'plural': 'Things',
+        'class': 'staplus_client.model.thing.Thing',
+        'relations_list': ['Datastreams', 'MultiDatastreams', 'Locations', 'HistoricalLocations', 'TaskingCapabilities',
+                           'Party']
+    },
+    'ObservedProperty': {
+        'singular': 'ObservedProperty',
+        'plural': 'ObservedProperties',
+        'class': 'staplus_client.model.observedproperty.ObservedProperty',
+        'relations_list': ['Datastreams', 'MultiDatastreams']
+    },
+    'Sensor': {
+        'singular': 'Sensor',
+        'plural': 'Sensors',
+        'class': 'staplus_client.model.sensor.Sensor',
+        'relations_list': ['Datastreams', 'MultiDatastreams']
+    },
+    'Task': {
+        'singular': 'Task',
+        'plural': 'Tasks',
+        'class': 'frost_sta_client.model.task.Task',
+        'relations_list': ['TaskingCapability']
+    },
+    'TaskingCapability': {
+        'singular': 'TaskingCapability',
+        'plural': 'TaskingCapabilities',
+        'class': 'frost_sta_client.model.tasking_capability.TaskingCapability',
+        'relations_list': ['Tasks', 'Actuator', 'Thing']
+    },
+    'UnitOfMeasurement': {
+        'singular': 'UnitOfMeasurement',
+        'plural': 'UnitOfMeasurements',
+        'class': 'frost_sta_client.model.ext.unitofmeasurement.UnitOfMeasurement'
+    },
+    'EntityList': {
+        'singular': 'EntityList',
+        'plural': 'EntityLists',
+        'class': 'staplus_client.model.ext.entity_list.EntityList'
+    },
+    #
+    # STAplus
+    #
+    'Party': {
+        'singular': 'Party',
+        'plural': 'Parties',
+        'class': 'staplus_client.model.party.Party',
+        'relations_list': ['Datastreams', 'MultiDatastreams', 'Things', 'Campaigns', 'ObservationGroups']
+    },
+    'License': {
+        'singular': 'License',
+        'plural': 'Licenses',
+        'class': 'staplus_client.model.license.License',
+        'relations_list': ['Datastreams', 'MultiDatastreams', 'ObservationGroups', 'Campaigns']
+    },
+    'Campaign': {
+        'singular': 'Campaign',
+        'plural': 'Campaigns',
+        'class': 'staplus_client.model.campaign.Campaign',
+        'relations_list': ['Party', 'License', 'Datastreams', 'MultiDatastreams', 'ObservationGroups']
+    },
+    'ObservationGroup': {
+        'singular': 'ObservationGroup',
+        'plural': 'ObservationGroups',
+        'class': 'staplus_client.model.observation_group.ObservationGroup',
+        'relations_list': ['Party', 'License', 'Observations', 'Relations', 'Campaigns']
+    },
+    'Relation': {
+        'singular': 'Relation',
+        'plural': 'Relations',
+        'class': 'staplus_client.model.relation.Relation',
+        'relations_list': ['Subject', 'Object', 'ObservationGroups']
+    }
+}
+
+list_for_class = {}
+for key, entity_type in EntityTypes.items():
+    list_for_class[entity_type["class"]] = entity_type["plural"]
+
+
+def get_list_for_class(clazz):
+    clazz_name = clazz.__module__ + "." + clazz.__name__
+    return list_for_class[clazz_name]

staplus_client/model/ext/unitofmeasurement.py

@@ -0,0 +1,5 @@
+from frost_sta_client.model.ext import unitofmeasurement
+
+class UnitOfMeasurement(unitofmeasurement.UnitOfMeasurement):
+    def __init__(self, name="", symbol="", definition=""):
+        super().__init__(name, symbol, definition)

staplus_client/model/feature_of_interest.py

@@ -0,0 +1,17 @@
+from frost_sta_client.model import feature_of_interest
+from staplus_client.dao.features_of_interest import FeaturesOfInterestDao
+
+class FeatureOfInterest(feature_of_interest.FeatureOfInterest):
+
+    def clone(self):
+        entity = self.__class__()
+        entity.id = self.id
+        return entity
+
+    def get_observations(self):
+        result = self.service.observations()
+        result.parent = self
+        return result
+
+    def get_dao(self, service):
+        return FeaturesOfInterestDao(service)

staplus_client/model/historical_location.py

@@ -0,0 +1,21 @@
+from frost_sta_client.model import historical_location
+from staplus_client.dao.historical_location import HistoricalLocationDao
+
+class HistoricalLocation(historical_location.HistoricalLocation):
+    def clone(self):
+        entity = self.__class__()
+        entity.id = self.id
+        return entity
+    
+    def get_thing(self):
+        result = self.service.thing()
+        result.parent = self
+        return result
+    
+    def get_locations(self):
+        result = self.service.locations()
+        result.parent = self
+        return result
+    
+    def get_dao(self, service):
+        return HistoricalLocationDao(service)