relay-code 0.1.0__py3-none-any.whl

utils/paths.py

@@ -0,0 +1,44 @@
+from pathlib import Path
+
+
+def resolve_path(base: str | Path, path: str | Path) -> Path:
+    base_path = Path(base).resolve()
+    candidate = Path(path)
+    resolved = candidate.resolve() if candidate.is_absolute() else (base_path / candidate).resolve()
+    try:
+        resolved.relative_to(base_path)
+    except ValueError as exc:
+        raise ValueError(f"Path is outside the working directory: {path}") from exc
+    return resolved
+
+def display_path_relative_to_cwd(path: str, cwd: Path | None) -> str:
+    try:
+        p = Path(path)
+    except Exception:
+        return path
+    
+    if cwd:
+        try:
+            return str(p.relative_to(cwd))
+        except ValueError:
+            pass
+    
+    return str(p)
+
+def is_binary_file(path: str | Path) -> bool:
+    try:
+        with open(path, "rb") as f:
+            chunk = f.read(8192)
+        return b"\x00" in chunk
+    except (OSError, IOError):
+        return False
+    
+def ensure_parent_dir(path: str | Path) -> Path:
+    path = Path(path)
+
+    path.parent.mkdir(
+        parents=True,
+        exist_ok=True
+    )
+
+    return path

utils/text.py

@@ -0,0 +1,74 @@
+import tiktoken
+
+def get_tokenizer(model: str):
+    try:
+        return tiktoken.encoding_for_model(model)
+    except Exception:
+        return tiktoken.get_encoding("cl100k_base")
+
+def count_tokens(text: str, model: str = "") -> int:
+    tokenizer = get_tokenizer(model)
+
+    if tokenizer:
+        return len(tokenizer.encode(text))
+
+    return estimate_tokens(text)
+
+def estimate_tokens(text: str) -> int:
+    return max(1, len(text) // 4) # on avg 1 token is ~ 4 characters
+
+def truncate_text(
+        text: str, 
+        model: str, 
+        max_tokens: int, 
+        suffix: str = "\n...[truncated]",
+        preserve_lines: bool = True,
+    ):
+
+    current_tokens = count_tokens(text, model)
+
+    if current_tokens <= max_tokens:
+        return text
+    
+    suffix_tokens = count_tokens(suffix, model)
+    target_tokens = max_tokens - suffix_tokens
+
+    if target_tokens <= 0:
+        return suffix.strip()
+
+    if preserve_lines:
+        return _truncate_by_lines(text, target_tokens, suffix, model)
+    else:
+        return _truncate_by_chars(text, target_tokens, suffix, model)
+
+def _truncate_by_lines(text: str, target_tokens: int, suffix: str, model: str) -> str:
+    lines = text.split("\n")
+    result_lines: list[str] = []
+    current_tokens = 0
+
+    for line in lines:
+        line_tokens = count_tokens(line + "\n", model)
+        if current_tokens + line_tokens > target_tokens:
+            break
+        result_lines.append(line)
+        current_tokens += line_tokens
+
+    if not result_lines:
+        # Fall back to character truncation if no complete lines fit
+        return _truncate_by_chars(text, target_tokens, suffix, model)
+
+    return "\n".join(result_lines) + suffix
+
+
+def _truncate_by_chars(text: str, target_tokens: int, suffix: str, model: str) -> str:
+    # Binary search for the right length
+    low, high = 0, len(text)
+
+    while low < high:
+        mid = (low + high + 1) // 2
+        if count_tokens(text[:mid], model) <= target_tokens:
+            low = mid
+        else:
+            high = mid - 1
+
+    return text[:low] + suffix