telegen-iot 0.1.4.dev9__py3-none-any.whl

TeleGen/__init__.py

@@ -0,0 +1,9 @@
+# pylint: disable=C0103
+
+from TeleGen.sensors import *
+from TeleGen.serial_sensors import *
+from TeleGen.binary_sensors import *
+from TeleGen.i2c_sensors import *
+from TeleGen.actuators import *
+
+__version__ = "0.1.4.dev09"

TeleGen/actuators.py

@@ -0,0 +1,102 @@
+from abc import ABC, abstractmethod
+from enum import Enum
+
+
+class ActuatorType(Enum):
+    FLOAT = 1
+    BOOLEAN = 2
+
+
+class ActuatorBase(ABC):
+    def __init__(self, port: str):
+        self.__port = port
+
+    @staticmethod
+    @abstractmethod
+    def actuator_name() -> str:
+        pass
+
+    @staticmethod
+    @abstractmethod
+    def actuator_type() -> ActuatorType:
+        pass
+
+    @property
+    def port(self) -> str:
+        return self.__port
+
+    @property
+    # pylint: disable=invalid-name
+    def id(self) -> str:
+        return self.__port
+
+
+class FloatActuatorBase(ActuatorBase):
+    def __init__(self, port: str):
+        super().__init__(port)
+        self.__value = 0
+
+    @staticmethod
+    @abstractmethod
+    def actuator_name() -> str:
+        pass
+
+    @staticmethod
+    def actuator_type() -> ActuatorType:
+        return ActuatorType.FLOAT
+
+    @property
+    def value(self) -> float:
+        return self.__value
+
+    @value.setter
+    def value(self, val: float):
+        self.__value = val
+
+
+class BooleanActuatorBase(ActuatorBase):
+    def __init__(self, port: str):
+        super().__init__(port)
+
+        self.__value = False
+
+    @staticmethod
+    @abstractmethod
+    def actuator_name() -> str:
+        pass
+
+    @staticmethod
+    def actuator_type() -> ActuatorType:
+        return ActuatorType.BOOLEAN
+
+    @property
+    def value(self) -> bool:
+        return self.__value
+
+    @value.setter
+    def value(self, val: bool):
+        self.__value = val
+
+
+class RelayActuator(BooleanActuatorBase):
+    @staticmethod
+    def actuator_name() -> str:
+        return "Relay"
+
+
+class LedActuator(BooleanActuatorBase):
+    def __init__(self, port: str):
+        super().__init__(port)
+        self.__color = "#FF0000"
+
+    @staticmethod
+    def actuator_name() -> str:
+        return "LED"
+
+    @property
+    def color(self) -> str:
+        return self.__color
+
+    @color.setter
+    def color(self, val: str):
+        self.__color = val

TeleGen/binary_sensors.py

@@ -0,0 +1,75 @@
+from abc import abstractmethod
+from enum import Enum
+import io
+
+from TeleGen.sensors import SensorBase, SensorType
+
+
+class BinarySensorBase(SensorBase):
+    def __init__(self, name: str):
+        super().__init__(name)
+        self.__value = io.BytesIO()
+        self._next_repeat_time = None
+        self._value_position = 0
+
+    @staticmethod
+    def sensor_type() -> SensorType:
+        return SensorType.BINARY
+
+    @staticmethod
+    @abstractmethod
+    def sensor_name() -> str:
+        pass
+
+    @property
+    def id(self) -> str:
+        return self.port.replace("/", "").replace(" ", "")
+
+    @property
+    def value(self) -> io.BytesIO:
+        return self.__value
+
+    @value.setter
+    def value(self, val: io.BytesIO):
+        self.__value = val
+
+
+class CameraImageSource(Enum):
+    FILE = 1
+    WEBCAM = 2
+
+
+class CameraSensor(BinarySensorBase):
+    def __init__(self, name: str):
+        super().__init__(name)
+        self.__image_source = CameraImageSource.FILE
+        self.__image_file_name = ""
+        self.__web_cam_device_id = ""
+
+    @staticmethod
+    def sensor_name() -> str:
+        return "Camera"
+
+    @property
+    def image_source(self) -> CameraImageSource:
+        return self.__image_source
+
+    @image_source.setter
+    def image_source(self, val: CameraImageSource):
+        self.__image_source = val
+
+    @property
+    def image_file_name(self) -> str:
+        return self.__image_file_name
+
+    @image_file_name.setter
+    def image_file_name(self, val: str):
+        self.__image_file_name = val
+
+    @property
+    def web_cam_device_id(self) -> str:
+        return self.__web_cam_device_id
+
+    @web_cam_device_id.setter
+    def web_cam_device_id(self, val: str):
+        self.__web_cam_device_id = val

TeleGen/i2c_sensors.py

@@ -0,0 +1,199 @@
+from abc import abstractmethod
+from enum import Enum
+from typing import List
+import random
+
+from TeleGen.sensors import SensorBase, SensorType
+
+
+class I2CSensorBase(SensorBase):
+    @staticmethod
+    def sensor_type() -> SensorType:
+        return SensorType.I2C
+
+    @staticmethod
+    @abstractmethod
+    def sensor_unit_type() -> SensorType:
+        pass
+
+    @staticmethod
+    @abstractmethod
+    def sensor_name() -> str:
+        pass
+
+    @property
+    def id(self) -> str:
+        return self.port
+
+    @property
+    def address(self) -> str:
+        return f"0x{int(self.port):02x}"
+
+
+class FloatI2CSensorBase(I2CSensorBase):
+    def __init__(self, port: str, valid_min: float, valid_max: float):
+        super().__init__(port)
+
+        self.__valid_min = valid_min
+        self.__valid_max = valid_max
+        self.value = valid_min
+        self.random_min = float(valid_min)
+        self.random_max = float(valid_max)
+
+    @staticmethod
+    @abstractmethod
+    def sensor_name() -> str:
+        pass
+
+    @staticmethod
+    @abstractmethod
+    def sensor_units() -> List[str]:
+        pass
+
+    @staticmethod
+    def sensor_unit_type() -> SensorType:
+        return SensorType.FLOAT
+
+    @property
+    @abstractmethod
+    def unit(self) -> str:
+        pass
+
+    @property
+    def value(self) -> float:
+        if self._random:
+            return round(random.uniform(self.__random_min, self.__random_max), 2)
+
+        return self.__value
+
+    @value.setter
+    def value(self, val: float):
+        if val < self.__valid_min or val > self.__valid_max:
+            raise ValueError()
+        self.__value = val
+
+    @property
+    def random_min(self) -> float:
+        return self.__random_min
+
+    @random_min.setter
+    def random_min(self, val: float):
+        if val < self.__valid_min or val > self.__valid_max:
+            raise ValueError()
+        self.__random_min = val
+
+    @property
+    def random_max(self) -> float:
+        return self.__random_max
+
+    @random_max.setter
+    def random_max(self, val: float):
+        if val < self.__valid_min or val > self.__valid_max:
+            raise ValueError()
+        self.__random_max = val
+
+    @property
+    def valid_min(self) -> float:
+        return self.__valid_min
+
+    @property
+    def valid_max(self) -> float:
+        return self.__valid_max
+
+
+class IntegerI2CSensorBase(I2CSensorBase):
+    def __init__(self, port: str, valid_min: int, valid_max: int):
+        super().__init__(port)
+
+        self.__valid_min = valid_min
+        self.__valid_max = valid_max
+        self.value = valid_min
+        self.random_min = int(valid_min)
+        self.random_max = int(valid_max)
+
+    @staticmethod
+    @abstractmethod
+    def sensor_name() -> str:
+        pass
+
+    @staticmethod
+    @abstractmethod
+    def sensor_units() -> List[str]:
+        pass
+
+    @staticmethod
+    def sensor_unit_type() -> SensorType:
+        return SensorType.INTEGER
+
+    @property
+    @abstractmethod
+    def unit(self) -> str:
+        pass
+
+    @property
+    def value(self) -> int:
+        if self._random:
+            return random.randint(self.__random_min, self.__random_max)
+
+        return self.__value
+
+    @value.setter
+    def value(self, val: int):
+        if val < self.__valid_min or val > self.__valid_max:
+            raise ValueError()
+        self.__value = val
+
+    @property
+    def random_min(self) -> int:
+        return self.__random_min
+
+    @random_min.setter
+    def random_min(self, val: int):
+        if val < self.__valid_min or val > self.__valid_max:
+            raise ValueError()
+        self.__random_min = val
+
+    @property
+    def random_max(self) -> int:
+        return self.__random_max
+
+    @random_max.setter
+    def random_max(self, val: int):
+        if val < self.__valid_min or val > self.__valid_max:
+            raise ValueError()
+        self.__random_max = val
+
+    @property
+    def valid_min(self) -> int:
+        return self.__valid_min
+
+    @property
+    def valid_max(self) -> int:
+        return self.__valid_max
+
+
+# pylint: disable=C0103
+class DistanceUnit(Enum):
+    Millimeter = 1
+
+
+class DistanceSensor(IntegerI2CSensorBase):
+    def __init__(self, port: str, unit):
+        if isinstance(unit, str):
+            unit = DistanceUnit[unit]
+
+        self.__unit = unit
+
+        super().__init__(port, 0, 999999)
+
+    @staticmethod
+    def sensor_name() -> str:
+        return "Distance"
+
+    @property
+    def unit(self) -> str:
+        return self.__unit.name
+
+    @staticmethod
+    def sensor_units() -> List[str]:
+        return [DistanceUnit.Millimeter.name]