layrz-sdk 3.0.14__py3-none-any.whl → 3.1.1__py3-none-any.whl

layrz_sdk/entities/{reports/report.py → report.py}

@@ -1,286 +1,257 @@
-"""Report class"""
-
-import logging
-import os
-import time
-import warnings
-from typing import Any, Dict, List
-
-import xlsxwriter
-
-from layrz_sdk.helpers.color import use_black
-
-from .col import ReportDataType
-from .format import ReportFormat
-from .page import CustomReportPage, ReportPage
-
-log = logging.getLogger(__name__)
-
-
-class Report:
-  """
-  Report definition
-  ---
-  Attributes
-    - name : Report name. The exported name will have an timestamp to prevent duplicity in our servers.
-    - pages : List of pages to append into report
-    - export_format : Format to export the report
-  """
-
-  def __init__(
-    self,
-    name: str,
-    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,
-        stacklevel=2,
-      )
-
-    self.export_format = export_format
-
-  @property
-  def filename(self) -> str | None | bool:
-    """Report filename"""
-    return f'{self.name}_{int(time.time() * 1000)}.xlsx'
-
-  @property
-  def _readable(self) -> str | None | bool:
-    """Readable property"""
-    return f'Report(name={self.name}, pages={len(self.pages)})'
-
-  def __repr__(self) -> str | None | bool:
-    """Readable property"""
-    return self._readable
-
-  def __str__(self) -> str | None | bool:
-    """Readable property"""
-    return self._readable
-
-  def export(
-    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=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=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[str, Any]:
-    """Returns the report as a JSON dict"""
-    return self._export_json()
-
-  def _export_json(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,
-          }
-        )
-      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,
-        }
-      )
-
-    return {
-      'name': self.name,
-      'pages': json_pages,
-    }
-
-  def _export_xlsx(
-    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: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
-      sheet_name = ''.join(e for e in sheet_name if e.isalnum() or e in [' ', '_', '-'])
-      sheet = book.add_worksheet(sheet_name)
-
-      if isinstance(page, CustomReportPage):
-        page.builder(sheet)
-        sheet.autofit()
-        continue
-
-      if page.freeze_header:
-        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',
-          }
-        )
-        sheet.write(0, i, header.content, style)
-
-      for i, row in enumerate(page.rows):
-        for j, cell in enumerate(row.content):
-          style = {
-            'align': cell.align.value,
-            'font_color': '#000000' if use_black(cell.color) else '#ffffff',
-            'bg_color': cell.color,
-            'bold': cell.bold,
-            'valign': 'vcenter',
-            'font_size': 11,
-            'top': 1,
-            'left': 1,
-            'right': 1,
-            'bottom': 1,
-            'font_name': 'Aptos Narrow',
-          }
-
-          if cell.data_type == ReportDataType.BOOL:
-            value = 'Yes' if cell.value else 'No'
-          elif cell.data_type == ReportDataType.DATETIME:
-            value = cell.content.strftime(cell.datetime_format)
-          elif cell.data_type == ReportDataType.INT:
-            value = int(cell.content)
-          elif cell.data_type == ReportDataType.FLOAT:
-            value = float(cell.content)
-            style.update({'num_format': '0.00'})
-          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'}
-            )
-          else:
-            value = cell.content
-
-          sheet.write(i + 1, j, value, book.add_format(style))
-
-          if row.compact:
-            sheet.set_row(i + 1, None, None, {'level': 1, 'hidden': True})
-          else:
-            sheet.set_row(i + 1, None, None, {'collapsed': True})
-
-      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
-    - title : Report title
-    - pages_count : Number of pages in the report
-  """
-
-  def __init__(self, title: str, pages_count: int) -> None:
-    self.title = title
-    self.pages_count = pages_count
-
-  @property
-  def _readable(self) -> str | None | bool:
-    """Readable property"""
-    return f'ReportConfiguration(title={self.title}, pages_count={self.pages_count})'
-
-  def __repr__(self) -> str | None | bool:
-    """Readable property"""
-    return self._readable
-
-  def __str__(self) -> str | None | bool:
-    """Readable property"""
-    return self._readable
+"""Report class"""
+
+import logging
+import os
+import time
+import warnings
+from typing import Any, Dict, List, Optional
+
+import xlsxwriter
+from pydantic import BaseModel, Field, field_validator
+
+from layrz_sdk.helpers.color import use_black
+
+from .custom_report_page import CustomReportPage
+from .report_data_type import ReportDataType
+from .report_format import ReportFormat
+from .report_page import ReportPage
+
+log = logging.getLogger(__name__)
+
+
+class Report(BaseModel):
+  """Report definition"""
+
+  name: str = Field(description='Name of the report. Length should be less than 60 characters')
+  pages: List[ReportPage | CustomReportPage] = Field(
+    description='List of report pages',
+    default_factory=list,
+  )
+  export_format: Optional[ReportFormat] = Field(description='Export format of the report', default=None)
+
+  @field_validator('export_format', mode='before')
+  def _validate_export_format(cls, value: Any) -> Any:
+    if value is not None:
+      warnings.warn(
+        'export_format is deprecated, use the export method instead',
+        DeprecationWarning,
+        stacklevel=2,
+      )
+
+    return value
+
+  @property
+  def filename(self) -> str:
+    """Report filename"""
+    return f'{self.name}_{int(time.time() * 1000)}.xlsx'
+
+  def export(
+    self,
+    path: str,
+    export_format: Optional[ReportFormat] = None,
+    password: Optional[str] = None,
+    msoffice_crypt_path: str = '/opt/msoffice/bin/msoffice-crypt.exe',
+  ) -> str | Dict[str, Any]:
+    """
+    Export report to file
+
+    :param path: Path to save the report
+    :param export_format: Format to export the report
+    :param password: Password to protect the file (Only works with Microsoft Excel format)
+    :param msoffice_crypt_path: Path to the msoffice-crypt.exe executable, used to encrypt the file
+    :return: Full path of the exported file or JSON representation of the report
+    :rtype: str | dict
+    :raises AttributeError: If the export format is not supported
+    """
+    if export_format:
+      if export_format == ReportFormat.MICROSOFT_EXCEL:
+        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=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[str, Any]:
+    """Returns the report as a JSON dict"""
+    return self._export_json()
+
+  def _export_json(self) -> Dict[str, Any]:
+    """Returns a JSON dict of the report"""
+    json_pages = []
+    for page in self.pages:
+      if isinstance(page, CustomReportPage):
+        continue
+
+      headers = []
+      for header in page.headers:
+        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,
+        }
+      )
+
+    return {
+      'name': self.name,
+      'pages': json_pages,
+    }
+
+  def _export_xlsx(
+    self,
+    path: str,
+    password: Optional[str] = None,
+    msoffice_crypt_path: Optional[str] = None,
+  ) -> str:
+    """
+    Export to Microsoft Excel (.xslx)
+    :param path: Path to save the report
+    :param password: Password to protect the file
+    :param msoffice_crypt_path: Path to the msoffice-crypt.exe executable, used to encrypt the file
+    :return: Full path of the exported file
+    """
+
+    full_path = os.path.join(path, self.filename)
+    book = xlsxwriter.Workbook(full_path)
+
+    pages_name: List[str] = []
+
+    for page in self.pages:
+      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
+      sheet_name = ''.join(e for e in sheet_name if e.isalnum() or e in [' ', '_', '-'])
+      sheet = book.add_worksheet(sheet_name)
+
+      if isinstance(page, CustomReportPage):
+        page.builder(sheet)
+        sheet.autofit()
+        continue
+
+      if page.freeze_header:
+        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',
+          }
+        )
+        sheet.write(0, i, header.content, style)
+
+      for i, row in enumerate(page.rows):
+        for j, cell in enumerate(row.content):
+          style = {
+            'align': cell.align.value,
+            'font_color': '#000000' if use_black(cell.color) else '#ffffff',
+            'bg_color': cell.color,
+            'bold': cell.bold,
+            'valign': 'vcenter',
+            'font_size': 11,
+            'top': 1,
+            'left': 1,
+            'right': 1,
+            'bottom': 1,
+            'font_name': 'Aptos Narrow',
+          }
+
+          value: Any = None
+
+          if cell.data_type == ReportDataType.BOOL:
+            value = 'Yes' if cell.content else 'No'
+          elif cell.data_type == ReportDataType.DATETIME:
+            value = cell.content.strftime(cell.datetime_format)
+          elif cell.data_type == ReportDataType.INT:
+            try:
+              value = int(cell.content)
+            except ValueError:
+              value = cell.content
+              log.warning(f'Invalid int value: {cell.content} in cell {i + 1}, {j}')
+          elif cell.data_type == ReportDataType.FLOAT:
+            try:
+              value = float(cell.content)
+              style.update({'num_format': '0.00'})
+            except ValueError:
+              value = cell.content
+              log.warning(f'Invalid float value: {cell.content} in cell {i + 1}, {j}')
+          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'}
+            )
+          else:
+            value = cell.content
+
+          sheet.write(i + 1, j, value, book.add_format(style))
+
+          if row.compact:
+            sheet.set_row(i + 1, None, None, {'level': 1, 'hidden': True})
+          else:
+            sheet.set_row(i + 1, None, None, {'collapsed': True})
+
+      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

layrz_sdk/entities/report_col.py

@@ -0,0 +1,40 @@
+"""Report col"""
+
+import sys
+import warnings
+from typing import Any, Optional
+
+from pydantic import BaseModel, Field, field_validator
+
+from .report_data_type import ReportDataType
+from .text_alignment import TextAlignment
+
+if sys.version_info >= (3, 11):
+  from typing import Self
+else:
+  from typing_extensions import Self
+
+
+class ReportCol(BaseModel):
+  """Report column entity"""
+
+  content: Any = Field(description='Column content')
+  color: str = Field(description='Column color', default='#ffffff')
+  text_color: Optional[str] = Field(description='Column text color', default=None)
+  align: TextAlignment = Field(description='Column text alignment', default=TextAlignment.LEFT)
+  data_type: ReportDataType = Field(description='Column data type', default=ReportDataType.STR)
+  datetime_format: str = Field(description='Datetime format', default='%Y-%m-%d %H:%M:%S')
+  currency_symbol: str = Field(description='Currency symbol', default='')
+  bold: bool = Field(description='Bold text', default=False)
+
+  @field_validator('text_color', mode='before')
+  def _validate_text_color(cls: Self, value: Any) -> Any:
+    """Validate text color"""
+    if value is not None:
+      warnings.warn(
+        'text_color is deprecated, the algorithm will calculate the rigth text color instead',
+        DeprecationWarning,
+        stacklevel=2,
+      )
+
+    return value

layrz_sdk/entities/report_configuration.py

@@ -0,0 +1,8 @@
+from pydantic import BaseModel, Field
+
+
+class ReportConfiguration(BaseModel):
+  """Report configuration entity"""
+
+  title: str = Field(description='Report title')
+  pages_count: int = Field(description='Number of pages in the report')

layrz_sdk/entities/report_data_type.py

@@ -0,0 +1,28 @@
+import sys
+from enum import Enum
+
+if sys.version_info >= (3, 11):
+  from typing import Self
+else:
+  from typing_extensions import Self
+
+
+class ReportDataType(Enum):
+  """
+  Report date type
+  """
+
+  STR = 'str'
+  INT = 'int'
+  FLOAT = 'float'
+  DATETIME = 'datetime'
+  BOOL = 'bool'
+  CURRENCY = 'currency'
+
+  def __str__(self: Self) -> str:
+    """Readable property"""
+    return self.name
+
+  def __repr__(self: Self) -> str:
+    """Readable property"""
+    return f'ReportDataType.{self.value}'