layrz-sdk 3.0.7__py3-none-any.whl → 3.0.9__py3-none-any.whl

layrz_sdk/entities/reports/report.py

@@ -1,7 +1,10 @@
-""" Report class """
+"""Report class"""
+
+import logging
 import os
 import time
 import warnings
+from typing import Any, Dict, List, Self
 
 import xlsxwriter
 
@@ -11,6 +14,8 @@ from .col import ReportDataType
 from .format import ReportFormat
 from .page import CustomReportPage, ReportPage
 
+log = logging.getLogger(__name__)
+
 
 class Report:
   """
@@ -23,103 +28,147 @@ class Report:
   """
 
   def __init__(
-    self,
+    self: Self,
     name: str,
-    pages: list[ReportPage | CustomReportPage],
+    pages: List[ReportPage | CustomReportPage],
     export_format: ReportFormat = None,
   ) -> None:
     self.name = name
     self.pages = pages
 
     if export_format is not None:
-      warnings.warn('export_format is deprecated, submit the export format in the `export()` method instead',
-                    DeprecationWarning)
+      warnings.warn(
+        'export_format is deprecated, submit the export format in the `export()` method instead',
+        DeprecationWarning,
+        stacklevel=2,
+      )
 
     self.export_format = export_format
 
   @property
-  def filename(self) -> str:
-    """ Report filename """
+  def filename(self: Self) -> str | None | bool:
+    """Report filename"""
     return f'{self.name}_{int(time.time() * 1000)}.xlsx'
 
   @property
-  def _readable(self) -> str:
-    """ Readable property """
+  def _readable(self: Self) -> str | None | bool:
+    """Readable property"""
     return f'Report(name={self.name}, pages={len(self.pages)})'
 
-  def __repr__(self) -> str:
-    """ Readable property """
+  def __repr__(self: Self) -> str | None | bool:
+    """Readable property"""
     return self._readable
 
-  def __str__(self) -> str:
-    """ Readable property """
+  def __str__(self: Self) -> str | None | bool:
+    """Readable property"""
     return self._readable
 
-  def export(self, path, export_format: ReportFormat = None) -> str:
-    """ Export report to file """
+  def export(
+    self: Self,
+    path: str,
+    export_format: ReportFormat = None,
+    password: str = None,
+    msoffice_crypt_path: str = '/opt/msoffice/bin/msoffice-crypt.exe',
+  ) -> str | Dict[str, Any]:
+    """
+    Export report to file
+
+    Arguments
+      - path : Path to save the report
+      - export_format : Format to export the report
+      - password : Password to protect the file (Only works with Microsoft Excel format)
+      - msoffice_crypt_path : Path to the msoffice-crypt.exe executable, used to encrypt the file
+                              if is None, the file will not be encrypted
+
+    Returns
+      - str : Full path of the exported file
+      - dict : JSON representation of the report
+    """
     if export_format:
       if export_format == ReportFormat.MICROSOFT_EXCEL:
-        return self._export_xlsx(path)
+        return self._export_xlsx(path=path, password=password, msoffice_crypt_path=msoffice_crypt_path)
       elif export_format == ReportFormat.JSON:
+        if password:
+          return {'name': self.name, 'is_protected': True, 'pages': []}
         return self._export_json()
       else:
         raise AttributeError(f'Unsupported export format: {export_format}')
 
     if self.export_format == ReportFormat.MICROSOFT_EXCEL:
-      return self._export_xlsx(path)
+      return self._export_xlsx(path=path, password=password, msoffice_crypt_path=msoffice_crypt_path)
     elif self.export_format == ReportFormat.JSON:
+      if password:
+        return {'name': self.name, 'is_protected': True, 'pages': []}
       return self._export_json()
     else:
       raise AttributeError(f'Unsupported export format: {self.export_format}')
 
-  def export_as_json(self) -> dict:
-    """ Returns the report as a JSON dict"""
+  def export_as_json(self: Self) -> Dict[str, Any]:
+    """Returns the report as a JSON dict"""
     return self._export_json()
 
-  def _export_json(self) -> dict:
-    """ Returns a JSON dict of the report"""
+  def _export_json(self: Self) -> Dict[str, Any]:
+    """Returns a JSON dict of the report"""
     json_pages = []
     for page in self.pages:
       headers = []
       for header in page.headers:
-        headers.append({
-          'content': header.content,
-          'text_color': '#000000' if use_black(header.color) else '#ffffff',
-          'color': header.color,
-        })
+        headers.append(
+          {
+            'content': header.content,
+            'text_color': '#000000' if use_black(header.color) else '#ffffff',
+            'color': header.color,
+          }
+        )
       rows = []
       for row in page.rows:
         cells = []
         for cell in row.content:
-          cells.append({
-            'content': cell.content,
-            'text_color': '#000000' if use_black(cell.color) else '#ffffff',
-            'color': cell.color,
-            'data_type': cell.data_type.value,
-          })
-        rows.append({
-          'content': cells,
-          'compact': row.compact,
-        })
-      json_pages.append({
-        'name': page.name,
-        'headers': headers,
-        'rows': rows,
-      })
+          cells.append(
+            {
+              'content': cell.content,
+              'text_color': '#000000' if use_black(cell.color) else '#ffffff',
+              'color': cell.color,
+              'data_type': cell.data_type.value,
+            }
+          )
+        rows.append(
+          {
+            'content': cells,
+            'compact': row.compact,
+          }
+        )
+      json_pages.append(
+        {
+          'name': page.name,
+          'headers': headers,
+          'rows': rows,
+        }
+      )
 
     return {
       'name': self.name,
       'pages': json_pages,
     }
 
-  def _export_xlsx(self, path) -> str:
-    """ Export to Microsoft Excel (.xslx) """
+  def _export_xlsx(
+    self: Self,
+    path: str,
+    password: str = None,
+    msoffice_crypt_path: str = None,
+  ) -> str:
+    """Export to Microsoft Excel (.xslx)"""
 
     full_path = os.path.join(path, self.filename)
     book = xlsxwriter.Workbook(full_path)
 
+    pages_name = []
+
     for page in self.pages:
-      sheet_name = page.name[0:31]
+      sheet_name = page.name[0:20]
+
+      if sheet_name in pages_name:
+        sheet_name = f'{sheet_name} ({pages_name.count(sheet_name) + 1})'
 
       # Allow only numbers, letters, spaces and _ or - characters
       # Other characters will be removed
@@ -135,19 +184,21 @@ class Report:
         sheet.freeze_panes(1, 0)
 
       for i, header in enumerate(page.headers):
-        style = book.add_format({
-          'align': header.align.value,
-          'font_color': '#000000' if use_black(header.color) else '#ffffff',
-          'bg_color': header.color,
-          'bold': header.bold,
-          'valign': 'vcenter',
-          'font_size': 11,
-          'top': 1,
-          'left': 1,
-          'right': 1,
-          'bottom': 1,
-          'font_name': 'Aptos Narrow',
-        })
+        style = book.add_format(
+          {
+            'align': header.align.value,
+            'font_color': '#000000' if use_black(header.color) else '#ffffff',
+            'bg_color': header.color,
+            'bold': header.bold,
+            'valign': 'vcenter',
+            'font_size': 11,
+            'top': 1,
+            'left': 1,
+            'right': 1,
+            'bottom': 1,
+            'font_name': 'Aptos Narrow',
+          }
+        )
         sheet.write(0, i, header.content, style)
 
       for i, row in enumerate(page.rows):
@@ -178,7 +229,8 @@ class Report:
           elif cell.data_type == ReportDataType.CURRENCY:
             value = float(cell.content)
             style.update(
-              {'num_format': f'"{cell.currency_symbol}" * #,##0.00;[Red]"{cell.currency_symbol}" * #,##0.00'})
+              {'num_format': f'"{cell.currency_symbol}" * #,##0.00;[Red]"{cell.currency_symbol}" * #,##0.00'}
+            )
           else:
             value = cell.content
 
@@ -192,11 +244,23 @@ class Report:
       sheet.autofit()
     book.close()
 
+    if password and msoffice_crypt_path:
+      new_path = os.path.join(path, f'encrypted_{self.filename}')
+      log.debug(f'Executing `{msoffice_crypt_path} -e -p "{password}" "{full_path}" "{new_path}"`')
+      os.system(f'{msoffice_crypt_path} -e -p "{password}" "{full_path}" "{new_path}"')
+      os.remove(full_path)
+
+      with open(new_path, 'rb') as f:
+        with open(full_path, 'wb') as f2:
+          f2.write(f.read())
+
+      os.remove(new_path)
+
     return full_path
 
 
 class ReportConfiguration:
-  """ 
+  """
   Report Configuration class
   ---
   Attributes
@@ -204,19 +268,19 @@ class ReportConfiguration:
     - pages_count : Number of pages in the report
   """
 
-  def __init__(self, title: str, pages_count: int) -> None:
+  def __init__(self: Self, title: str, pages_count: int) -> None:
     self.title = title
     self.pages_count = pages_count
 
   @property
-  def _readable(self) -> str:
-    """ Readable property """
+  def _readable(self: Self) -> str | None | bool:
+    """Readable property"""
     return f'ReportConfiguration(title={self.title}, pages_count={self.pages_count})'
 
-  def __repr__(self) -> str:
-    """ Readable property """
+  def __repr__(self: Self) -> str | None | bool:
+    """Readable property"""
     return self._readable
 
-  def __str__(self) -> str:
-    """ Readable property """
+  def __str__(self: Self) -> str | None | bool:
+    """Readable property"""
     return self._readable

layrz_sdk/entities/reports/row.py

@@ -1,5 +1,7 @@
 """ Report row """
 
+from typing import List, Self
+
 from .col import ReportCol
 
 
@@ -15,8 +17,8 @@ class ReportRow:
   """
 
   def __init__(
-    self,
-    content: list[ReportCol],
+    self: Self,
+    content: List[ReportCol],
     height: float = None,
     compact: bool = False,
   ) -> None:
@@ -28,14 +30,14 @@ class ReportRow:
       raise DeprecationWarning('height is deprecated.')
 
   @property
-  def _readable(self) -> str:
+  def _readable(self: Self) -> str | None | bool:
     """ Readable property """
     return f'ReportRow(content={self.content})'
 
-  def __str__(self) -> str:
+  def __str__(self: Self) -> str | None | bool:
     """ Readable property """
     return self._readable
 
-  def __repr__(self) -> str:
+  def __repr__(self: Self) -> str | None | bool:
     """ Readable property """
     return self._readable

layrz_sdk/entities/telemetry/message.py

@@ -1,5 +1,6 @@
 """ Message entity """
-from datetime import datetime
+from datetime import datetime, timezone
+from typing import Any, Self
 
 from .position import Position
 
@@ -18,12 +19,12 @@ class Message:
   """
 
   def __init__(
-    self,
+    self: Self,
     pk: int,
     asset_id: int,
     position: Position = None,
-    payload: dict = None,
-    sensors: dict = None,
+    payload: Any = None,
+    sensors: Any = None,
     received_at: datetime = None,
   ) -> None:
     """ Constructor """
@@ -32,4 +33,4 @@ class Message:
     self.position = position or Position()
     self.payload = payload or {}
     self.sensors = sensors or {}
-    self.received_at = received_at or datetime.now()
+    self.received_at = received_at or datetime.now(timezone.utc)

layrz_sdk/entities/telemetry/position.py

@@ -1,4 +1,5 @@
 """ Position entity """
+from typing import Self
 
 
 class Position:
@@ -16,7 +17,7 @@ class Position:
   """
 
   def __init__(
-    self,
+    self: Self,
     latitude: float = None,
     longitude: float = None,
     altitude: float = None,
@@ -35,15 +36,15 @@ class Position:
     self.satellites = satellites
 
   @property
-  def _readable(self) -> str:
+  def _readable(self: Self) -> str | None | bool:
     """ Readable """
     return f'Position(latitude={self.latitude}, longitude={self.longitude}, altitude={self.altitude}, ' +\
            f'speed={self.speed}, direction={self.direction}, hdop={self.hdop}, satellites={self.satellites})'
 
-  def __str__(self) -> str:
+  def __str__(self: Self) -> str | None | bool:
     """ Readable property """
     return self._readable
 
-  def __repr__(self) -> str:
+  def __repr__(self: Self) -> str | None | bool:
     """ Readable property """
     return self._readable

layrz_sdk/helpers/color.py

@@ -2,27 +2,28 @@
 Color helpers
 """
 
+from typing import Tuple
 
-def convert_to_rgba(hex_color: str) -> tuple[int, int, int, int]:
+
+def convert_to_rgba(hex_color: str) -> Tuple[int, int, int, int]:
   """
   Convert Hex (or Hexa) color to RGB (or RGBA) color
-  
   Arguments
   ---------
     hex_color (str): Hex (or Hexa) color
   Returns
   -------
     tuple(r,g,b,a): Combination of colors. When the argument (hex_color) is Hex, the alpha channel is set to 1.
-	"""
+  """
 
   if not hex_color.startswith('#'):
     raise ValueError('Invalid color, must starts with #')
 
   hex_color = hex_color.replace('#', '')
   if len(hex_color) == 6:
-    return tuple(int(hex_color[i:i + 2], 16) for i in (0, 2, 4)) + (1, )
+    return tuple(int(hex_color[i : i + 2], 16) for i in (0, 2, 4)) + (1,)
 
-  return tuple(int(hex_color[i:i + 2], 16) for i in (0, 2, 4, 6))
+  return tuple(int(hex_color[i : i + 2], 16) for i in (0, 2, 4, 6))
 
 
 def use_black(color: str) -> bool: