layrz-sdk 3.0.13__py3-none-any.whl → 3.1.0__py3-none-any.whl

layrz_sdk/entities/charts/timeline.py

@@ -1,148 +0,0 @@
-"""Timeline chart entities"""
-
-from datetime import datetime
-from typing import Any, List
-
-from .alignment import ChartAlignment
-from .exceptions import ChartException
-
-
-class TimelineSerieItem:
-  """
-  Chart Data Serie Item for Timeline Charts
-  """
-
-  def __init__(self, name: str, start_at: datetime, end_at: datetime, color: str) -> None:
-    """
-    Constructor
-    ----
-    Arguments
-      - name : Name of the item.
-      - start_at : Start date of the item.
-      - end_at : End date of the item.
-      - color : Color of the item.
-    """
-    if not isinstance(name, str):
-      raise ChartException('name must be an instance of str')
-    self.name = name
-
-    if not isinstance(start_at, datetime):
-      raise ChartException('start_at must be an instance of datetime')
-    self.start_at = start_at
-
-    if not isinstance(end_at, datetime):
-      raise ChartException('end_at must be an instance of datetime')
-    self.end_at = end_at
-
-    if not isinstance(color, str):
-      raise ChartException('color must be an instance of str')
-    self.color = color
-
-
-class TimelineSerie:
-  """
-  Chart Data Serie for Timeline charts
-  """
-
-  def __init__(self, data: List[TimelineSerieItem], label: str) -> None:
-    """
-    Constructor
-    ----
-    Arguments
-      - data : List of data points.
-      - label : Label of the serie.
-    """
-    for i, datum in enumerate(data):
-      if not isinstance(datum, TimelineSerieItem):
-        raise ChartException(f'Y Axis serie {i} must be an instance of ChartDataSerie')
-    self.data = data
-
-    if not isinstance(label, str):
-      raise ChartException('label must be an instance of str')
-    self.label = label
-
-
-class TimelineChart:
-  """
-  Timeline chart configuration
-  """
-
-  def __init__(
-    self,
-    series: List[TimelineSerie],
-    title: str = 'Chart',
-    align: ChartAlignment = ChartAlignment.CENTER,
-  ) -> None:
-    """
-    Constructor
-    ----
-    Arguments
-      - series : Defines the series of the chart, uses the TimelineSerie class.
-                 Please read the documentation to more information.
-      - title : Title of the chart.
-      - align : Alignment of the chart.
-    """
-    for i, serie in enumerate(series):
-      if not isinstance(serie, TimelineSerie):
-        raise ChartException(f'Y Axis serie {i} must be an instance of TimelineSerie')
-    self.series = series
-
-    if not isinstance(title, str):
-      raise ChartException('title must be an instance of str')
-    self.title = title
-
-    if not isinstance(align, ChartAlignment):
-      raise ChartException('align must be an instance of ChartAlignment')
-    self.align = align
-
-  def render(self) -> Any:
-    """
-    Render chart to a Javascript Library.
-    Currently only available for ApexCharts.
-    """
-    return {'library': 'APEXCHARTS', 'configuration': self._render_apexcharts()}
-
-  def _render_apexcharts(self) -> Any:
-    """
-    Converts the configuration of the chart to Javascript library ApexCharts.
-    """
-
-    series = []
-
-    for serie in self.series:
-      data = []
-
-      for item in serie.data:
-        data.append(
-          {
-            'x': item.name,
-            'y': [item.start_at.timestamp() * 1000, item.end_at.timestamp() * 1000],
-            'fillColor': item.color,
-          }
-        )
-
-      series.append({'name': serie.label, 'data': data})
-
-    config = {
-      'series': series,
-      'title': {
-        'text': self.title,
-        'align': self.align.value,
-        'style': {'fontFamily': 'Fira Sans Condensed', 'fontSize': '20px', 'fontWeight': 'normal'},
-      },
-      'chart': {
-        'type': 'rangeBar',
-        'animations': {'enabled': False},
-        'toolbar': {'show': False},
-        'zoom': {'enabled': False},
-      },
-      'xaxis': {'type': 'datetime'},
-      'plotOptions': {
-        'bar': {
-          'horizontal': True,
-        }
-      },
-      'dataLabels': {'enabled': True},
-    }
-
-    return config

layrz_sdk/entities/checkpoints/__init__.py

@@ -1,4 +0,0 @@
-"""Checkpoints entities"""
-
-from .checkpoint import Checkpoint
-from .waypoint import Waypoint

layrz_sdk/entities/checkpoints/checkpoint.py

@@ -1,50 +0,0 @@
-"""Checkpoints entitites"""
-
-from datetime import datetime
-from typing import List
-
-from .waypoint import Waypoint
-
-
-class Checkpoint:
-  """
-  Checkpoint entity definition
-  ---
-  Attributes
-    - pk : Checkpoint activation ID
-    - asset_id : Asset ID
-    - waypoints : List of waypoints of the checkpoint
-    - start_at : Start date
-    - end_at : End date
-  """
-
-  def __init__(
-    self,
-    pk: int,
-    asset_id: int,
-    waypoints: List[Waypoint],
-    start_at: datetime,
-    end_at: datetime,
-  ) -> None:
-    """Constructor"""
-    self.pk = pk
-    self.asset_id = asset_id
-    self.waypoints = waypoints
-    self.start_at = start_at
-    self.end_at = end_at
-
-  @property
-  def _readable(self) -> str | None | bool:
-    """Readable"""
-    return (
-      f'Checkpoint(pk={self.pk}, asset_id={self.asset_id}, waypoints={self.waypoints}, '
-      + f'start_at={self.start_at}, end_at={self.end_at})'
-    )
-
-  def __str__(self) -> str | None | bool:
-    """Readable property"""
-    return self._readable
-
-  def __repr__(self) -> str | None | bool:
-    """Readable property"""
-    return self._readable

layrz_sdk/entities/checkpoints/waypoint.py

@@ -1,52 +0,0 @@
-"""Waypoint entity"""
-
-from datetime import datetime
-
-from layrz_sdk.entities.general.geofence import Geofence
-
-
-class Waypoint:
-  """
-  Checkpoint waypoint entity definition
-  ---
-  Attributes
-    - pk : Waypoint ID
-    - geofence : Related geofence
-    - start_at : Date of start this waypoint stage
-    - end_at : Date of end this waypoint stage
-    - sequence_real : Real sequence performed
-    - sequence_ideal : Ideal/defined sequence
-  """
-
-  def __init__(
-    self,
-    pk: int,
-    geofence: Geofence,
-    start_at: datetime,
-    end_at: datetime,
-    sequence_real: int,
-    sequence_ideal: int,
-  ) -> None:
-    """Constructor"""
-    self.pk = pk
-    self.geofence = geofence
-    self.start_at = start_at
-    self.end_at = end_at
-    self.sequence_real = sequence_real
-    self.sequence_ideal = sequence_ideal
-
-  @property
-  def _readable(self) -> str | None | bool:
-    """Readable"""
-    return (
-      f'Waypoint(pk={self.pk}, geofence={self.geofence}, start_at={self.start_at}, '
-      + f'end_at={self.end_at}, sequence_real={self.sequence_real}, sequence_ideal={self.sequence_ideal})'
-    )
-
-  def __str__(self) -> str | None | bool:
-    """Readable property"""
-    return self._readable
-
-  def __repr__(self) -> str | None | bool:
-    """Readable property"""
-    return self._readable

layrz_sdk/entities/events/__init__.py

@@ -1,2 +0,0 @@
-""" Events entities """
-from .event import Event

layrz_sdk/entities/events/event.py

@@ -1,58 +0,0 @@
-"""Event entity"""
-
-from datetime import datetime
-
-from layrz_sdk.entities.cases.trigger import Trigger
-from layrz_sdk.entities.general.geofence import Geofence, PresenceType
-from layrz_sdk.entities.telemetry.message import Message
-
-
-class Event:
-  """
-  Event entity definition
-
-  Available attributes
-  --------------------
-    pk : Event ID
-    trigger : Trigger object that triggered the event
-    asset_id : ID of the Asset owner of the event
-    message : Telemetry information of the event
-    activated_at : Reception/triggered at
-    geofence : Geofence where the event occurred
-    presence_type : Presence type of the event
-  """
-
-  def __init__(
-    self,
-    pk: int,
-    trigger: Trigger,
-    asset_id: int,
-    message: Message,
-    activated_at: datetime,
-    geofence: Geofence | None = None,
-    presence_type: PresenceType | None = None,
-  ) -> None:
-    """Constructor"""
-    self.pk = pk
-    self.trigger = trigger
-    self.asset_id = asset_id
-    self.message = message
-    self.activated_at = activated_at
-    self.geofence = geofence
-    self.presence_type = presence_type
-
-  @property
-  def _readable(self) -> str | None | bool:
-    """Readable"""
-    return (
-      f'Event(pk={self.pk}, trigger={self.trigger}, asset_id={self.asset_id}, '
-      + f'message={self.message}, activated_at={self.activated_at})'
-    )
-
-  def __str__(self) -> str | None | bool:
-    """Readable property"""
-    return self._readable
-
-  def __repr__(self) -> str | None | bool:
-    """Readable property"""
-    return self._readable

layrz_sdk/entities/formatting/__init__.py

@@ -1,2 +0,0 @@
-""" Formatting entities """
-from .text_align import TextAlignment

layrz_sdk/entities/general/__init__.py

@@ -1,9 +0,0 @@
-"""General entities"""
-
-from .asset import Asset
-from .asset_operation_mode import AssetOperationMode
-from .custom_field import CustomField
-from .device import Device
-from .geofence import Geofence, PresenceType
-from .sensor import Sensor
-from .user import User

layrz_sdk/entities/general/asset.py

@@ -1,72 +0,0 @@
-"""Asset Entity"""
-
-from typing import List
-
-from .asset_operation_mode import AssetOperationMode
-from .custom_field import CustomField
-from .device import Device
-from .sensor import Sensor
-
-
-class Asset:
-  """
-  Asset entity definition
-  ---
-  Attributes
-    - pk : Asset ID
-    - name : Name of the asset
-    - vin : Vehicle identification number
-    - plate : Vehicle plate number
-    - asset_type : Asset type ID
-    - devices : List of devices
-    - operation_mode : Operation mode of the asset
-    - custom_fields : List of custom fields
-    - children : List of children assets
-    - sensors : List of sensors
-  """
-
-  def __init__(
-    self,
-    pk: int,
-    name: str,
-    vin: str,
-    plate: str,
-    asset_type: int,
-    operation_mode: AssetOperationMode,
-    sensors: List[Sensor] = None,
-    custom_fields: List[CustomField] = None,
-    devices: List[Device] = None,
-    children: List = None,
-  ) -> None:
-    """Constructor"""
-    self.pk = pk
-    self.name = name
-    self.vin = vin
-    self.plate = plate
-    self.asset_type = asset_type
-    self.operation_mode = operation_mode
-    self.sensors = sensors if sensors else []
-    self.custom_fields = custom_fields if custom_fields else []
-    self.devices = devices if devices else []
-
-    if children and self.operation_mode == AssetOperationMode.ASSETMULTIPLE:
-      self.children = children
-    else:
-      self.children = []
-
-  @property
-  def _readable(self) -> str | None | bool:
-    """Readable"""
-    return (
-      f'Asset(pk={self.pk}, name={self.name}, vin={self.vin}, plate={self.plate}, '
-      + f'asset_type={self.asset_type}, operation_mode={self.operation_mode}, '
-      + f'custom_fields={self.custom_fields}, children={self.children}, sensors={self.sensors})'
-    )
-
-  def __str__(self) -> str | None | bool:
-    """Readable property"""
-    return self._readable
-
-  def __repr__(self) -> str | None | bool:
-    """Readable property"""
-    return self._readable

layrz_sdk/entities/general/custom_field.py

@@ -1,29 +0,0 @@
-"""Custom Field entitiy"""
-
-
-class CustomField:
-  """
-  Custom field definition
-  ---
-  Attributes
-    - name : Name of the custom field
-    - value : Value of the custom field
-  """
-
-  def __init__(self, name: str, value: str) -> None:
-    """Constructor"""
-    self.name = name
-    self.value = value
-
-  @property
-  def _readable(self) -> str | None | bool:
-    """Readable"""
-    return f'CustomField(name={self.name}, value={self.value})'
-
-  def __str__(self) -> str | None | bool:
-    """Readable property"""
-    return self._readable
-
-  def __repr__(self) -> str | None | bool:
-    """Readable property"""
-    return self._readable

layrz_sdk/entities/general/device.py

@@ -1,45 +0,0 @@
-"""Device entitiy"""
-
-
-class Device:
-  """
-  Device definition
-  ---
-  Attributes
-    - pk : Device ID
-    - name : Name of the device
-    - ident : Unique identifier of the device.
-    - protocol : Protocol slug of the device.
-    - is_primary : True if this device is the primary device of the asset.
-  """
-
-  def __init__(
-    self,
-    pk: int,
-    name: str,
-    ident: str,
-    protocol: str,
-    is_primary: bool = False,
-  ) -> None:
-    """Constructor"""
-    self.pk = pk
-    self.name = name
-    self.ident = ident
-    self.protocol = protocol
-    self.is_primary = is_primary
-
-  @property
-  def _readable(self) -> str | None | bool:
-    """Readable"""
-    return (
-      f'Device(pk={self.pk}, ident={self.ident}, name={self.name}, protocol={self.protocol}, '
-      + f'is_primary={self.is_primary})'
-    )
-
-  def __str__(self) -> str | None | bool:
-    """Readable property"""
-    return self._readable
-
-  def __repr__(self) -> str | None | bool:
-    """Readable property"""
-    return self._readable

layrz_sdk/entities/general/geofence.py

@@ -1,53 +0,0 @@
-"""Geofence entity"""
-
-from enum import Enum
-
-
-class Geofence:
-  """
-  Geofence entity definition
-  ---
-  Attributes
-    - pk : Geofence ID
-    - name : Geofence name
-    - color : Geofence color in Hex format
-  """
-
-  def __init__(self, pk: int, name: str, color: str) -> None:
-    """Constructor"""
-    self.pk = pk
-    self.name = name
-    self.color = color
-
-  @property
-  def _readable(self) -> str | None | bool:
-    """Readable"""
-    return f'Geofence(pk={self.pk}, name={self.name}, color={self.color})'
-
-  def __str__(self) -> str | None | bool:
-    """Readable property"""
-    return self._readable
-
-  def __repr__(self) -> str | None | bool:
-    """Readable property"""
-    return self._readable
-
-
-class PresenceType(Enum):
-  """Presence type enum"""
-
-  ENTRANCE = 'ENTRANCE'
-  EXIT = 'EXIT'
-
-  @property
-  def _readable(self) -> str | None | bool:
-    """Readable"""
-    return f'PresenceType.{self.value}'
-
-  def __str__(self) -> str | None | bool:
-    """Readable property"""
-    return self._readable
-
-  def __repr__(self) -> str | None | bool:
-    """Readable property"""
-    return self._readable

layrz_sdk/entities/general/sensor.py

@@ -1,31 +0,0 @@
-"""Sensor entity"""
-
-
-class Sensor:
-  """
-  Sensor entity
-  ---
-  Attributes
-    pk : Sensor ID
-    name : Name of the sensor
-    slug : Slug of the sensor
-  """
-
-  def __init__(self, pk: int, name: str, slug: str) -> None:
-    """Constructor"""
-    self.pk = pk
-    self.name = name
-    self.slug = slug
-
-  @property
-  def _readable(self) -> str | None | bool:
-    """Readable"""
-    return f'Sensor(pk={self.pk}, name={self.name}, slug={self.slug})'
-
-  def __str__(self) -> str | None | bool:
-    """Readable property"""
-    return self._readable
-
-  def __repr__(self) -> str | None | bool:
-    """Readable property"""
-    return self._readable

layrz_sdk/entities/general/user.py

@@ -1,29 +0,0 @@
-"""User entity"""
-
-
-class User:
-  """
-  User entity definition
-  ---
-  Attributes
-    pk : User ID
-    name : User name
-  """
-
-  def __init__(self, pk: int, name: str) -> None:
-    """Constructor"""
-    self.pk = pk
-    self.name = name
-
-  @property
-  def _readable(self) -> str | None | bool:
-    """Readable"""
-    return f'User(pk={self.pk}, name={self.name})'
-
-  def __str__(self) -> str | None | bool:
-    """Readable property"""
-    return self._readable
-
-  def __repr__(self) -> str | None | bool:
-    """Readable property"""
-    return self._readable

layrz_sdk/entities/repcom/__init__.py

@@ -1,2 +0,0 @@
-""" Repcom entities """
-from .transaction import Transaction

layrz_sdk/entities/repcom/transaction.py

@@ -1,54 +0,0 @@
-"""Transaction entity"""
-
-from datetime import datetime, timedelta
-
-from layrz_sdk.entities.general.asset import Asset
-
-
-class Transaction:
-  """
-  Transaction definition
-  ---
-  Attributes
-    pk : Transaction ID
-    asset : Asset related to the transaction
-    amount : Amount of the transaction
-    quantity : Quantity of the transaction
-    mileage : Mileage in kilometers
-    distance : Distance traveled in kilometers
-    engine_time : Time with the engine on
-    idle_time : Time with the engine on without movement
-    in_geofence : Flag to indicate if transaction occurred inside a geofence
-    geofence_name : Name of the geofence where transaction occurred
-    received_at : Transaction reception date and time
-    is_wildcard : Wildcard indicator for transaction
-  """
-
-  def __init__(
-    self,
-    pk: int,
-    asset: Asset,
-    amount: float,
-    quantity: float,
-    mileage: float,
-    distance: float,
-    engine_time: timedelta,
-    idle_time: timedelta,
-    in_geofence: bool,
-    geofence_name: str,
-    received_at: datetime,
-    is_wildcard: bool,
-  ) -> None:
-    """Constructor"""
-    self.pk = pk
-    self.asset = asset
-    self.amount = amount
-    self.quantity = quantity
-    self.mileage = mileage
-    self.distance = distance
-    self.engine_time = engine_time
-    self.idle_time = idle_time
-    self.in_geofence = in_geofence
-    self.geofence_name = geofence_name
-    self.received_at = received_at
-    self.is_wildcard = is_wildcard

layrz_sdk/entities/reports/__init__.py

@@ -1,7 +0,0 @@
-""" Init file """
-from .col import ReportCol, ReportDataType
-from .format import ReportFormat
-from .header import ReportHeader
-from .page import CustomReportPage, ReportPage
-from .report import Report, ReportConfiguration
-from .row import ReportRow