borse 0.1.0__py3-none-any.whl

borse/__about__.py

@@ -0,0 +1,3 @@
+__version__ = "0.1.0"
+__author__ = "Evan Chen"
+__license__ = "MIT"

borse/__init__.py

@@ -0,0 +1,3 @@
+"""Borse - A terminal game for practicing Morse code, Braille, and flag semaphore."""
+
+__version__ = "0.1.0"

borse/a1z26.py

@@ -0,0 +1,41 @@
+"""A1Z26 encoding module (A=1, B=2, ..., Z=26)."""
+
+
+def encode_char(char: str) -> str:
+    """Encode a single character to A1Z26.
+
+    Args:
+        char: A single character to encode.
+
+    Returns:
+        The number representation (1-26) or empty string for invalid chars.
+    """
+    upper = char.upper()
+    if not upper.isalpha() or len(upper) != 1:
+        return ""
+    return str(ord(upper) - ord("A") + 1)
+
+
+def encode_word(word: str) -> str:
+    """Encode a word to A1Z26.
+
+    Args:
+        word: The word to encode.
+
+    Returns:
+        The A1Z26 representation with dashes between numbers.
+    """
+    numbers = [encode_char(c) for c in word if c.isalpha()]
+    return " ".join(numbers)
+
+
+def get_display_lines(word: str) -> list[str]:
+    """Get the display lines for a word in A1Z26.
+
+    Args:
+        word: The word to encode.
+
+    Returns:
+        A list containing a single line with the A1Z26 encoding.
+    """
+    return [encode_word(word)]

borse/braille.py

@@ -0,0 +1,106 @@
+"""Braille encoding module with ASCII art display."""
+
+# Braille patterns for letters a-z
+# Dots are numbered:
+# 1 4
+# 2 5
+# 3 6
+# We store which dots are raised for each letter
+BRAILLE_PATTERNS: dict[str, tuple[int, ...]] = {
+    "A": (1,),
+    "B": (1, 2),
+    "C": (1, 4),
+    "D": (1, 4, 5),
+    "E": (1, 5),
+    "F": (1, 2, 4),
+    "G": (1, 2, 4, 5),
+    "H": (1, 2, 5),
+    "I": (2, 4),
+    "J": (2, 4, 5),
+    "K": (1, 3),
+    "L": (1, 2, 3),
+    "M": (1, 3, 4),
+    "N": (1, 3, 4, 5),
+    "O": (1, 3, 5),
+    "P": (1, 2, 3, 4),
+    "Q": (1, 2, 3, 4, 5),
+    "R": (1, 2, 3, 5),
+    "S": (2, 3, 4),
+    "T": (2, 3, 4, 5),
+    "U": (1, 3, 6),
+    "V": (1, 2, 3, 6),
+    "W": (2, 4, 5, 6),
+    "X": (1, 3, 4, 6),
+    "Y": (1, 3, 4, 5, 6),
+    "Z": (1, 3, 5, 6),
+}
+
+# Filled and unfilled circles for display
+FILLED = "●"
+UNFILLED = "○"
+
+
+def encode_char(char: str) -> list[str]:
+    """Encode a single character to Braille ASCII art.
+
+    Args:
+        char: A single character to encode.
+
+    Returns:
+        A list of 3 strings representing the 3 rows of the Braille cell.
+    """
+    upper = char.upper()
+    if upper not in BRAILLE_PATTERNS:
+        return ["   ", "   ", "   "]
+
+    dots = set(BRAILLE_PATTERNS[upper])
+
+    # Build the 3x2 grid
+    # Row 1: dots 1, 4
+    # Row 2: dots 2, 5
+    # Row 3: dots 3, 6
+    rows = []
+    for _row_idx, (left_dot, right_dot) in enumerate([(1, 4), (2, 5), (3, 6)], start=1):
+        left = FILLED if left_dot in dots else UNFILLED
+        right = FILLED if right_dot in dots else UNFILLED
+        # Add space between left and right columns
+        rows.append(f"{left} {right}")
+
+    return rows
+
+
+def encode_word(word: str) -> list[list[str]]:
+    """Encode a word to Braille ASCII art.
+
+    Args:
+        word: The word to encode.
+
+    Returns:
+        A list of character encodings, each being a list of 3 row strings.
+    """
+    return [encode_char(c) for c in word if c.upper() in BRAILLE_PATTERNS]
+
+
+def get_display_lines(word: str) -> list[str]:
+    """Get the display lines for a word in Braille.
+
+    Args:
+        word: The word to encode.
+
+    Returns:
+        A list of 5 strings (3 rows with blank lines between for vertical spacing).
+    """
+    chars = encode_word(word)
+    if not chars:
+        return ["", "", "", "", ""]
+
+    # Combine all characters horizontally with space between
+    # Add blank lines between rows for vertical spacing
+    lines = []
+    for row in range(3):
+        line = "   ".join(char[row] for char in chars)
+        lines.append(line)
+        if row < 2:  # Add blank line after first two rows
+            lines.append("")
+
+    return lines

borse/config.py

@@ -0,0 +1,130 @@
+"""Configuration management for Borse."""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+
+try:
+    import tomllib
+except ImportError:
+    import tomli as tomllib  # type: ignore[import-not-found,no-redef]
+
+import tomli_w
+
+
+def get_default_config_dir() -> Path:
+    """Get the default configuration directory following XDG spec.
+
+    Returns:
+        Path to the configuration directory ($XDG_CONFIG_HOME/borse/ or ~/.config/borse/).
+    """
+    xdg_config_home = os.environ.get("XDG_CONFIG_HOME")
+    if xdg_config_home:
+        return Path(xdg_config_home) / "borse"
+    return Path.home() / ".config" / "borse"
+
+
+def get_default_config_path() -> Path:
+    """Get the default configuration file path.
+
+    Returns:
+        Path to the configuration file (~/.config/borse/config.toml).
+    """
+    return get_default_config_dir() / "config.toml"
+
+
+def get_default_progress_path() -> Path:
+    """Get the default progress file path.
+
+    Returns:
+        Path to the progress file (~/.config/borse/progress.json).
+    """
+    return get_default_config_dir() / "progress.json"
+
+
+@dataclass
+class Config:
+    """Configuration settings for Borse.
+
+    Attributes:
+        progress_file: Path to the progress tracking file.
+        words_per_game: Number of words to show in each game session.
+        single_letter_probability: Probability (0-1) of showing a single letter instead of a word.
+    """
+
+    progress_file: str = field(default_factory=lambda: str(get_default_progress_path()))
+    words_per_game: int = 10
+    single_letter_probability: float = 0.3
+
+    def to_dict(self) -> dict[str, str | int | float]:
+        """Convert config to dictionary.
+
+        Returns:
+            Dictionary representation of the config.
+        """
+        return {
+            "progress_file": self.progress_file,
+            "words_per_game": self.words_per_game,
+            "single_letter_probability": self.single_letter_probability,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict[str, str | int | float]) -> Config:
+        """Create config from dictionary.
+
+        Args:
+            data: Dictionary with config values.
+
+        Returns:
+            Config instance.
+        """
+        return cls(
+            progress_file=str(
+                data.get("progress_file", str(get_default_progress_path()))
+            ),
+            words_per_game=int(data.get("words_per_game", 10)),
+            single_letter_probability=float(data.get("single_letter_probability", 0.3)),
+        )
+
+
+def load_config(config_path: Path | None = None) -> Config:
+    """Load configuration from file.
+
+    Args:
+        config_path: Path to config file. Defaults to $XDG_CONFIG_HOME/borse/config.toml.
+
+    Returns:
+        Config instance with loaded or default values.
+    """
+    if config_path is None:
+        config_path = get_default_config_path()
+
+    if not config_path.exists():
+        config = Config()
+        return config
+
+    try:
+        with open(config_path, "rb") as f:
+            data = tomllib.load(f)
+        return Config.from_dict(data)
+    except (tomllib.TOMLDecodeError, OSError):
+        return Config()
+
+
+def save_config(config: Config, config_path: Path | None = None) -> None:
+    """Save configuration to file.
+
+    Args:
+        config: Config instance to save.
+        config_path: Path to config file. Defaults to ~/.config/borse/config.toml.
+    """
+    if config_path is None:
+        config_path = get_default_config_path()
+
+    # Ensure directory exists
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+
+    with open(config_path, "wb") as f:
+        tomli_w.dump(config.to_dict(), f)