fix ruff check

Author: elong0527

src/rtflite/__init__.py

@@ -1,6 +1,7 @@
 """rtflite: A Python library for creating RTF documents."""
 
 from .attributes import TableAttributes
+from .convert import LibreOfficeConverter
 from .encode import RTFDocument
 from .encoding import RTFEncodingEngine
 from .input import (
@@ -17,7 +18,6 @@
 )
 from .pagination import PageBreakCalculator, RTFPagination
 from .strwidth import get_string_width
-from .convert import LibreOfficeConverter
 
 __version__ = "0.0.1"
 

src/rtflite/encoding/engine.py

@@ -2,7 +2,6 @@
 
 from typing import TYPE_CHECKING
 
-from .base import EncodingStrategy
 from .unified_encoder import UnifiedRTFEncoder
 
 if TYPE_CHECKING:

src/rtflite/encoding/renderer.py

@@ -93,7 +93,7 @@ def render(self, document: Any, page: PageContext) -> list[str]:
             )
         ):
             col_idx = 0
-            # Try to find column index for legacy reasons, though likely unused if we handle spanning cleanly
+            # Find col index for legacy reasons; likely unused with clean spanning.
             if document.rtf_body.page_by and isinstance(document.df, pl.DataFrame):
                 try:
                     col_idx = document.df.columns.index(document.rtf_body.page_by[0])
@@ -223,15 +223,15 @@ def _render_column_headers(self, document: Any, page: PageContext) -> list[str]:
 
                     # Adjust col_rel_width if needed (logic from PaginatedStrategy)
                     # Since we are using page.data which is already sliced/processed,
-                    # we might need to adjust widths if they were originally defined for full table
+                    # Might need to adjust widths if defined for full table.
                     if document.rtf_body.col_rel_width is not None:
                         # If body has specific widths, try to map them.
-                        # For simplicity in this refactor, if we have header text now, we proceed.
+                        # If header text exists, proceed.
                         pass
 
             # Remove columns if necessary (page_by/subline_by)
-            # Note: If we just populated from page.data, page.data already has columns removed!
-            # So we only need to filter if text came from original document and has extra columns.
+            # Note: page.data already has columns removed if populated from it.
+            # Filter only if text is from original document with extra columns.
             if isinstance(header_copy.text, pl.DataFrame):
                 cols_remove = set()
                 if document.rtf_body.page_by:
@@ -299,7 +299,7 @@ def _render_body(self, document: Any, page: PageContext) -> list[str]:
 
                 if page_rel_row > prev_row:
                     segment = page_df[prev_row:page_rel_row]
-                    # We must use internal _encode method of TableAttributes (attrs are already finalized)
+                    # Use internal _encode method (attributes already finalized).
                     # Note: We need to ensure page_attrs is the TableAttributes object
                     elements.extend(
                         page_attrs._encode(segment, col_widths, row_offset=prev_row)

src/rtflite/encoding/unified_encoder.py

@@ -1,9 +1,10 @@
+from __future__ import annotations
+
 from typing import Any
 
-import polars as pl
+from rtflite import RTFDocument
 
 from ..attributes import BroadcastValue
-from .base import EncodingStrategy
 from ..pagination.processor import PageFeatureProcessor
 from ..pagination.strategies import PageContext, PaginationContext, StrategyRegistry
 from ..pagination.strategies.defaults import DefaultPaginationStrategy
@@ -15,6 +16,7 @@
 from ..services.figure_service import RTFFigureService
 from ..services.grouping_service import grouping_service
 from ..type_guards import is_single_body
+from .base import EncodingStrategy
 from .renderer import PageRenderer
 
 
@@ -40,7 +42,7 @@ def encode(self, document: Any) -> str:
         # 1. Figure-only handling
         if document.df is None:
             # Reuse the logic from previous implementation, adapted slightly
-            # For now, we can't easily unify figure-only documents into the same pipeline
+            # Unifying figure-only documents into one pipeline is not straightforward.
             # without a "FigurePaginationStrategy".
             # So we defer to a helper method similar to the old one.
             return self._encode_figure_only(document)
@@ -112,7 +114,7 @@ def encode(self, document: Any) -> str:
 
         # Handle case where no pages are generated (e.g. empty dataframe)
         if not pages:
-            # Create a single empty page to ensure document structure (title, etc.) is rendered
+            # Create empty page to ensure document structure (title, etc.) is rendered.
             # We use processed_df which might be empty but has correct schema
             pages = [
                 PageContext(
@@ -127,7 +129,7 @@ def encode(self, document: Any) -> str:
             ]
 
         # Post-pagination fixup: Replace data with processed data (sliced correctly)
-        # The strategy used original_df for calculation, but we want to render processed_df
+        # Strategy used original_df, but we render processed_df.
         # (which has removed columns).
         if is_single_body(document.rtf_body):
             self._apply_data_post_processing(pages, processed_df, document.rtf_body)
@@ -205,13 +207,14 @@ def _apply_data_post_processing(self, pages, processed_df, rtf_body):
                 p.data = restored.slice(curr, rows)
                 curr += rows
 
-    def _encode_figure_only(self, document):
+    def _encode_figure_only(self, document: RTFDocument):
         # (Legacy support for figure only)
         # For brevity, I will rely on the existing FigureService logic if possible
         # or just reproduce the simple loop.
-        # ... (Implementation omitted for brevity, would match PaginatedStrategy._encode_figure_only_document_with_pagination)
+        # Matches PaginatedStrategy._encode_figure_only_document_with_pagination.
         # Since the user wants a WORKING system, I must implement it.
         from copy import deepcopy
+
         from ..figure import rtf_read_figure
 
         if not document.rtf_figure or not document.rtf_figure.figures:
@@ -318,7 +321,7 @@ def _encode_figure_only(self, document):
         parts.append("\n\n}")
         return "".join([p for p in parts if p])
 
-    def _encode_multi_section(self, document: "RTFDocument") -> str:
+    def _encode_multi_section(self, document: RTFDocument) -> str:
         """Encode a multi-section document where sections are concatenated row by row.
 
         Args:
@@ -329,7 +332,6 @@ def _encode_multi_section(self, document: "RTFDocument") -> str:
         """
         from copy import deepcopy
 
-        from ..attributes import BroadcastValue
         from ..input import RTFColumnHeader
         from ..type_guards import (
             is_flat_header_list,

src/rtflite/pagination/core.py

@@ -1,5 +1,4 @@
 from collections.abc import Mapping, Sequence
-from typing import Any
 
 import polars as pl
 from pydantic import BaseModel, ConfigDict, Field

src/rtflite/pagination/processor.py

@@ -19,14 +19,12 @@ def process(self, document: Any, page: PageContext) -> PageContext:
 
     def _should_show_element(self, element_location: str, page: PageContext) -> bool:
         """Determine if an element should be shown on a specific page."""
-        if element_location == "all":
-            return True
-        elif element_location == "first":
-            return page.is_first_page
-        elif element_location == "last":
-            return page.is_last_page
-        else:
-            return False
+        logic = {
+            "all": True,
+            "first": page.is_first_page,
+            "last": page.is_last_page,
+        }
+        return logic.get(element_location, False)
 
     def _apply_pagination_borders(self, document, page: PageContext) -> Any:
         """Apply proper borders for paginated context following r2rtf design."""

src/rtflite/pagination/strategies/base.py

@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from typing import Any, Protocol
+from typing import Any
 
 import polars as pl
 from pydantic import BaseModel, ConfigDict, Field

src/rtflite/pagination/strategies/defaults.py

@@ -1,5 +1,3 @@
-import polars as pl
-
 from ..core import PageBreakCalculator, RTFPagination
 from .base import PageContext, PaginationContext, PaginationStrategy
 

src/rtflite/pagination/strategies/grouping.py

@@ -1,4 +1,5 @@
-from typing import Any, Sequence
+from collections.abc import Sequence
+from typing import Any
 
 import polars as pl
 
@@ -38,7 +39,7 @@ def paginate(self, context: PaginationContext) -> list[PageContext]:
             page_df = context.df.slice(start_row, end_row - start_row + 1)
 
             is_first = page_num == 0
-            # Logic for repeating headers: if pageby_header is True, or if it's the first page
+            # Repeating headers: if pageby_header is True, or if it's the first page.
             needs_header = context.rtf_body.pageby_header or is_first
 
             page_ctx = PageContext(
@@ -117,7 +118,7 @@ class SublineStrategy(PageByStrategy):
     """Pagination strategy for subline_by (forces new pages and special headers)."""
 
     def paginate(self, context: PaginationContext) -> list[PageContext]:
-        # Subline strategy acts like page_by but uses subline_by columns and forces new_page=True
+        # Subline strategy uses subline_by columns and forces new_page=True.
         subline_by = context.rtf_body.subline_by
 
         # Initialize calculator

src/rtflite/pagination/strategies/registry.py

@@ -1,20 +1,18 @@
-from typing import Type
-
 from .base import PaginationStrategy
 
 
 class StrategyRegistry:
     """Registry for pagination strategies."""
 
-    _strategies: dict[str, Type[PaginationStrategy]] = {}
+    _strategies: dict[str, type[PaginationStrategy]] = {}
 
     @classmethod
-    def register(cls, name: str, strategy_cls: Type[PaginationStrategy]) -> None:
+    def register(cls, name: str, strategy_cls: type[PaginationStrategy]) -> None:
         """Register a new strategy."""
         cls._strategies[name] = strategy_cls
 
     @classmethod
-    def get(cls, name: str) -> Type[PaginationStrategy]:
+    def get(cls, name: str) -> type[PaginationStrategy]:
         """Get a strategy by name."""
         if name not in cls._strategies:
             raise ValueError(f"Strategy '{name}' not found in registry.")