ibm5250 0.1.0.dev5__tar.gz → 0.1.0.dev7__tar.gz

{ibm5250-0.1.0.dev5 → ibm5250-0.1.0.dev7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: ibm5250
-Version: 0.1.0.dev5
+Version: 0.1.0.dev7
 Summary: IBM 5250 terminal automation library
 License-File: LICENSE
 Requires-Python: >=3.11

{ibm5250-0.1.0.dev5 → ibm5250-0.1.0.dev7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ibm5250"
-version = "0.1.0.dev5"
+version = "0.1.0.dev7"
 description = "IBM 5250 terminal automation library"
 requires-python = ">=3.11"
 

{ibm5250-0.1.0.dev5 → ibm5250-0.1.0.dev7}/src/ibm5250/constants.py

@@ -541,10 +541,17 @@ def decode_addr(hi: int, lo: int, cols: int = SCREEN_COLS) -> int:
 
 
 def pos_to_rowcol(pos: int, cols: int = SCREEN_COLS) -> tuple[int, int]:
-    """Convert a linear position to (row, col), both 0-based."""
-    return divmod(pos, cols)
+    """Convert a zero-based linear position to a 1-based ``(row, col)``."""
+    if pos < 0:
+        raise ValueError("Buffer position must be non-negative")
+    row, col = divmod(pos, cols)
+    return row + 1, col + 1
 
 
 def rowcol_to_pos(row: int, col: int, cols: int = SCREEN_COLS) -> int:
-    """Convert (row, col) to a linear position (both 0-based)."""
-    return row * cols + col
+    """Convert a 1-based ``(row, col)`` to a zero-based linear position."""
+    if row < 1 or col < 1:
+        raise ValueError("Screen coordinates start at (1, 1)")
+    if col > cols:
+        raise ValueError(f"Column must be between 1 and {cols}")
+    return (row - 1) * cols + col - 1

{ibm5250-0.1.0.dev5 → ibm5250-0.1.0.dev7}/src/ibm5250/screen.py

@@ -66,6 +66,7 @@ class Field:
     )
     _saved_data: bytes = b""  # original content before user modification
     _explicit_length: int = 0
+    _screen_cols: int = SCREEN_COLS
 
     # ---- derived properties ----
 
@@ -114,13 +115,13 @@ class Field:
 
     @property
     def row(self) -> int:
-        """0-based screen row of the first data byte."""
-        return pos_to_rowcol(self.data_pos)[0]
+        """1-based screen row of the first data byte."""
+        return pos_to_rowcol(self.data_pos, self._screen_cols)[0]
 
     @property
     def col(self) -> int:
-        """0-based screen column of the first data byte."""
-        return pos_to_rowcol(self.data_pos)[1]
+        """1-based screen column of the first data byte."""
+        return pos_to_rowcol(self.data_pos, self._screen_cols)[1]
 
     def __repr__(self) -> str:
         protection_indicator = "P" if self.is_protected else "I"
@@ -281,11 +282,11 @@ class Screen:
 
     @property
     def cursor_row(self) -> int:
-        return self._cursor // self.cols
+        return pos_to_rowcol(self._cursor, self.cols)[0]
 
     @property
     def cursor_col(self) -> int:
-        return self._cursor % self.cols
+        return pos_to_rowcol(self._cursor, self.cols)[1]
 
     @property
     def keyboard_locked(self) -> bool:
@@ -308,21 +309,19 @@ class Screen:
 
         Wraps across row boundaries if needed.
         """
-        zero_based_row = row - 1
-        zero_based_col = col - 1
-        buffer_pos = rowcol_to_pos(zero_based_row, zero_based_col, self.cols)
+        buffer_pos = self._coordinate_to_pos(row, col)
         positions = [(buffer_pos + offset) % self._size for offset in range(length)]
         return ebcdic_decode(self._display_bytes(positions))
 
     def get_row(self, row: int) -> str:
-        """Return the full text of *row* (0-based) as a Python string."""
-        row_start_pos = row * self.cols
+        """Return the full text of *row* (1-based) as a Python string."""
+        row_start_pos = self._coordinate_to_pos(row, 1)
         positions = range(row_start_pos, row_start_pos + self.cols)
         return ebcdic_decode(self._display_bytes(positions))
 
     def get_all_rows(self) -> list[str]:
         """Return all rows as a list of strings."""
-        return [self.get_row(r) for r in range(self.rows)]
+        return [self.get_row(row) for row in range(1, self.rows + 1)]
 
     def get_screen_text(self) -> str:
         """Return the entire screen as a single newline-separated string."""
@@ -372,8 +371,8 @@ class Screen:
     # ---- field lookups ----
 
     def find_field_at(self, row: int, col: int) -> Field | None:
-        """Return the field whose data area contains *(row, col)*, or ``None``."""
-        pos = rowcol_to_pos(row, col, self.cols)
+        """Return the field at 1-based *(row, col)*, or ``None``."""
+        pos = self._coordinate_to_pos(row, col)
         for f in self._fields:
             if f.data_pos <= pos < f.data_pos + f.length:
                 return f
@@ -548,14 +547,14 @@ class Screen:
     def find_text(
         self, text: str, *, case_sensitive: bool = False
     ) -> tuple[int, int] | None:
-        """Return *(row, col)* (0-based) of the first occurrence of *text*, or ``None``."""
+        """Return 1-based *(row, col)* for the first occurrence, or ``None``."""
         rows = self.get_all_rows()
-        for r, row_text in enumerate(rows):
+        for row, row_text in enumerate(rows, start=1):
             s = row_text if case_sensitive else row_text.lower()
             t = text if case_sensitive else text.lower()
             idx = s.find(t)
             if idx >= 0:
-                return r, idx
+                return row, idx + 1
         return None
 
     # ---- modified fields (for AID response) ----
@@ -577,6 +576,11 @@ class Screen:
     # Internal helpers
     # ------------------------------------------------------------------
 
+    def _coordinate_to_pos(self, row: int, col: int) -> int:
+        if row > self.rows:
+            raise ValueError(f"Row must be between 1 and {self.rows}")
+        return rowcol_to_pos(row, col, self.cols)
+
     def _clear(self) -> None:
         self._chars[:] = bytearray([EBCDIC_SPACE] * self._size)
         self._attrs[:] = bytearray(self._size)
@@ -638,6 +642,7 @@ class Screen:
             field_format_word=event.field_format_word,
             field_control_words=event.field_control_words,
             _explicit_length=event.field_length,
+            _screen_cols=self.cols,
         )
         # Replace any existing field at this position (dedup, preserving order)
         for i, existing in enumerate(self._fields):
@@ -686,8 +691,8 @@ class Screen:
         """Pretty-print the screen with a border (useful for debugging)."""
         divider = "+" + "-" * self.cols + "+"
         lines = [divider]
-        for r in range(self.rows):
-            lines.append("|" + self.get_row(r) + "|")
+        for row in range(1, self.rows + 1):
+            lines.append("|" + self.get_row(row) + "|")
         lines.append(divider)
         return "\n".join(lines)
 
@@ -770,8 +775,7 @@ class Screen:
 
         rows = []
         for display_row in range(display_start_row, display_end_row + 1):
-            row_idx = display_row - 1
-            row_text = self.get_row(row_idx)
+            row_text = self.get_row(display_row)
             columns = [row_text[start:end].strip() for start, end in resolved]
             rows.append([] if all(c == "" for c in columns) else columns)
         return rows

{ibm5250-0.1.0.dev5 → ibm5250-0.1.0.dev7}/src/ibm5250/terminal.py

@@ -260,7 +260,9 @@ class Terminal:
             self._screen.set_field_text(f, existing + text)
 
     def move_cursor(self, row: int, col: int) -> None:
-        """Move the cursor to *(row, col)* (0-based) without sending a key."""
+        """Move the cursor to 1-based *(row, col)* without sending a key."""
+        if row > self._rows:
+            raise ValueError(f"Row must be between 1 and {self._rows}")
         pos = rowcol_to_pos(row, col, self._cols)
         self._screen._cursor = pos
 
@@ -331,7 +333,7 @@ class Terminal:
         *,
         timeout: float | None = None,
     ) -> None:
-        """Block until the cursor lands on *(row, col)* (0-based)."""
+        """Block until the cursor lands on 1-based *(row, col)*."""
         self._wait_for(
             lambda: self._screen.cursor_row == row and self._screen.cursor_col == col,
             desc=f"cursor at ({row},{col})",
@@ -385,7 +387,7 @@ class Terminal:
         return FieldProxy(self, f)
 
     def find_field_at(self, row: int, col: int) -> FieldProxy:
-        """Return the (unprotected) field at *(row, col)* (0-based).
+        """Return the unprotected field at 1-based *(row, col)*.
 
         Raises :class:`~ibm5250.exceptions.FieldNotFound` if none exists there.
         """

{ibm5250-0.1.0.dev5 → ibm5250-0.1.0.dev7}/uv.lock

@@ -13,7 +13,7 @@ wheels = [
 
 [[package]]
 name = "ibm5250"
-version = "0.1.0.dev5"
+version = "0.1.0.dev7"
 source = { editable = "." }
 
 [package.dev-dependencies]