A few minor tweaks in preparation for release.

README.md

@@ -12,6 +12,8 @@ This software is licensed under the LGPL v3.
 - **Multiple Interface Support**: Works in Linux TTY, and terminal emulators
 - **Flexible Driver System**: Modular architecture with multiple drivers for speech, sound, input, and screen
 - **Review Mode**: Navigate and review screen content without moving the edit cursor
+- **Table Navigation**: Advanced table mode with column headers, cell-by-cell navigation, and boundary feedback
+- **Progress Bar Monitoring**: Automatic detection and audio feedback for progress indicators with ascending tones
 - **Multiple Clipboard Support**: Manage multiple clipboard entries
 - **Configurable Key Bindings**: Desktop and laptop keyboard layouts
 - **Sound Icons**: Audio feedback for various events
@@ -156,6 +158,7 @@ By default Fenrir uses:
    - `Keypad 2` - Read current character
    - `Fenrir + T` - Announce time
    - `Fenrir + S` - Spell check current word
+   - `Fenrir + Keypad *` - Toggle table mode / highlight tracking
 
 ### Keyboard Layouts
 
@@ -402,6 +405,176 @@ setting <action> [parameters]
 - `time#delaySec=seconds` - Announcement interval
 - `time#onMinutes=00,30` - Specific minutes to announce
 
+## Table Navigation
+
+Fenrir includes advanced table navigation capabilities for working with tabular data in terminal applications, CSV files, and formatted text output.
+
+### Entering Table Mode
+
+Table mode is activated through the **toggle_highlight_tracking** command, which cycles through three focus modes:
+
+1. **Highlight tracking mode** (default) - Follows text highlighting
+2. **Cursor tracking mode** - Follows text cursor movement
+3. **Table mode** - Enables table navigation
+
+**Key bindings:**
+- **Desktop layout**: `Fenrir + Keypad *` (asterisk)
+- **Laptop layout**: `Fenrir + Y`
+
+Press the key combination repeatedly to cycle through modes until you hear "table mode enabled".
+
+### Table Navigation Commands
+
+#### Column Navigation (Desktop Layout)
+- **Next column**: `Keypad 6` - Move to next table column
+- **Previous column**: `Keypad 4` - Move to previous table column
+- **First column**: `Fenrir + Keypad 4` - Jump to first column of current row
+- **Last column**: `Fenrir + Keypad 6` - Jump to last column of current row
+
+#### Column Navigation (Laptop Layout)
+- **Next column**: `Fenrir + L` - Move to next table column
+- **Previous column**: `Fenrir + J` - Move to previous table column
+- **First column**: `Fenrir + Shift + J` - Jump to first column of current row
+- **Last column**: `Fenrir + Shift + L` - Jump to last column of current row
+
+#### Cell Character Navigation
+- **First character in cell**: `Fenrir + Keypad 1` (desktop) or `Fenrir + Ctrl + J` (laptop)
+- **Last character in cell**: `Fenrir + Keypad 3` (desktop) or `Fenrir + Ctrl + L` (laptop)
+
+### Setting Column Headers
+
+For better navigation experience, you can set column headers:
+
+1. **Navigate to header row**: Use normal navigation to reach the row containing column headers
+2. **Set headers**: Press `Fenrir + X` to mark the current line as the header row
+3. **Navigation feedback**: Column headers will be announced along with cell content
+
+### Table Detection
+
+Fenrir automatically detects table structures using multiple strategies:
+- **Delimited text**: CSV, pipe-separated (`|`), semicolon-separated (`;`), tab-separated
+- **Aligned columns**: Space-aligned columns (2+ spaces between columns)
+- **Flexible parsing**: Handles various table formats commonly found in terminal applications
+
+### Table Mode Features
+
+- **Cell-by-cell navigation**: Navigate through table cells with precise positioning
+- **Column header support**: Set and announce column headers for better context
+- **Boundary feedback**: Audio cues when reaching start/end of rows
+- **Empty cell handling**: Blank cells are announced as "blank"
+- **Independent tracking**: Table position is maintained independently of cursor movement
+
+### Speech Output in Table Mode
+
+When navigating in table mode, Fenrir announces:
+- **Cell content** followed by **column header/name**
+- **Boundary notifications**: "end of line", "start of line"
+- **Position indicators**: "first character in cell [column name]"
+
+### Example Usage
+
+```bash
+# Working with CSV data
+cat data.csv
+Name,Age,City
+Alice,30,New York
+Bob,25,Los Angeles
+
+# 1. Press Fenrir + Keypad * until "table mode enabled"
+# 2. Navigate to "Name,Age,City" line
+# 3. Press Fenrir + X to set headers
+# 4. Use Keypad 4/6 to navigate between columns
+# 5. Each cell will be announced with its column header
+```
+
+## Progress Bar Monitoring
+
+Fenrir provides intelligent progress bar detection and audio feedback for various progress indicators commonly found in terminal applications.
+
+### Enabling Progress Monitoring
+
+**Command**: `progress_bar_monitor` (no default key binding - assign manually)
+
+To enable progress monitoring:
+1. Add a key binding in your keyboard layout file
+2. Or use the remote control system: `echo "command progress_bar_monitor" | socat - UNIX-CLIENT:/tmp/fenrirscreenreader-deamon.sock`
+
+### Progress Detection Patterns
+
+Fenrir automatically detects various progress indicator formats:
+
+#### 1. Percentage Progress
+```
+Download: 45%
+Processing: 67.5%
+Installing: 100%
+```
+
+#### 2. Fraction Progress
+```
+Files: 15/100
+Progress: 3 of 10
+Step 7/15
+```
+
+#### 3. Progress Bars
+```
+[####      ] 40%
+[====>     ] 50%
+[**********] 100%
+```
+
+#### 4. Activity Indicators
+```
+Loading...
+Processing...
+Working...
+Installing...
+Downloading...
+Compiling...
+Building...
+```
+
+### Audio Feedback
+
+#### Progress Tones
+- **Ascending tones**: 400Hz to 1200Hz frequency range
+- **Percentage mapping**: 0% = 400Hz, 100% = 1200Hz
+- **Smooth progression**: Frequency increases proportionally with progress
+
+#### Activity Indicators
+- **Steady beep**: 800Hz tone every 2 seconds for ongoing activity
+- **Non-intrusive**: Beeps don't interrupt speech or other audio
+
+### Progress Monitoring Features
+
+- **Automatic detection**: No manual configuration required
+- **Multiple format support**: Handles various progress indicator styles
+- **Prompt awareness**: Automatically pauses when command prompts are detected
+- **Non-blocking**: Progress tones don't interrupt speech or other functionality
+- **Configurable**: Can be enabled/disabled as needed
+
+### Usage Examples
+
+```bash
+# Enable progress monitoring
+echo "command progress_bar_monitor" | socat - UNIX-CLIENT:/tmp/fenrirscreenreader-deamon.sock
+
+# Common scenarios where progress monitoring is useful:
+wget https://example.com/large-file.zip    # Download progress
+tar -xvf archive.tar.gz                    # Extraction progress
+make -j4                                   # Compilation progress
+pacman -S package                          # Package installation
+rsync -av source/ destination/             # File synchronization
+```
+
+### Customization
+
+Progress monitoring can be configured through settings:
+- **Default enabled**: Set `progressMonitoring=True` in sound section
+- **Sound integration**: Works with all sound drivers (sox, gstreamer)
+- **Remote control**: Enable/disable through remote commands
+
 ### Scripting Examples
 
 #### Bash Script for Speech Notifications

check-dependencies.py

@@ -50,7 +50,7 @@ def check_dependency(dep: Dependency) -> bool:
 dependencyList = [
     # Core dependencies
     Dependency('FenrirCore', 'core', 'core', 
-              pythonImports=['daemonize', 'enchant']),
+              pythonImports=['daemonize', 'enchant', 'pyperclip', 'setproctitle']),
     
     # Screen drivers
     Dependency('DummyScreen', 'screen', 'dummyDriver'),
@@ -58,7 +58,7 @@ dependencyList = [
               pythonImports=['dbus'],
               devicePaths=['/dev/vcsa']),
     Dependency('PTY', 'screen', 'ptyDriver',
-              pythonImports=['pyte']),
+              pythonImports=['pyte', 'xdg']),
               
     # Input drivers
     Dependency('DummyInput', 'input', 'dummyDriver'),
@@ -82,7 +82,11 @@ dependencyList = [
     Dependency('Speechd', 'speech', 'speechdDriver',
               pythonImports=['speechd']),
     Dependency('GenericSpeech', 'speech', 'genericDriver',
-              checkCommands=['espeak-ng'])
+              checkCommands=['espeak-ng']),
+              
+    # Additional dependencies
+    Dependency('Pexpect', 'core', 'pexpectDriver',
+              pythonImports=['pexpect'])
 ]
 
 defaultModules = {
@@ -90,7 +94,8 @@ defaultModules = {
     'VCSA',
     'Evdev',
     'GenericSpeech',
-    'GenericSound'
+    'GenericSound',
+    'Pexpect'
 }
 
 def check_all_dependencies():

config/keyboard/Readme.md

@@ -1,4 +1,46 @@
 
+# Fenrir Keyboard Configuration
+
+This directory contains keyboard layout files for Fenrir screen reader.
+
+## Available Layouts
+
+- **desktop.conf** - Desktop layout using numeric keypad (recommended)
+- **laptop.conf** - Laptop layout for keyboards without numeric keypad
+- **nvda-desktop.conf** - NVDA-compatible desktop layout
+- **nvda-laptop.conf** - NVDA-compatible laptop layout
+- **pty.conf** - PTY emulation layout for terminal use
+- **pty2.conf** - Alternative PTY emulation layout
+
+## Key Features
+
+### Table Navigation
+- **Toggle table mode**: `Fenrir + Keypad *` (desktop) or `Fenrir + Y` (laptop)
+- **Column navigation**: `Keypad 4/6` (desktop) or `Fenrir + J/L` (laptop)
+- **Row boundaries**: `Fenrir + Keypad 4/6` (desktop) or `Fenrir + Shift + J/L` (laptop)
+- **Set headers**: `Fenrir + X` in table mode
+
+### Progress Bar Monitoring
+- **Monitor progress**: `progress_bar_monitor` command (assign key binding manually)
+- **Auto-detection**: Percentage, fractions, progress bars, activity indicators
+- **Audio feedback**: Ascending tones (400Hz-1200Hz) for progress
+
+### Review Mode
+- **Basic navigation**: `Keypad 7/8/9` (lines), `Keypad 4/5/6` (words), `Keypad 1/2/3` (characters)
+- **Exit review**: `Fenrir + Keypad .`
+- **Screen reading**: `Fenrir + Keypad 5` (current screen)
+
+## Configuration
+
+To change keyboard layout, edit `/etc/fenrir/settings/settings.conf`:
+
+```ini
+[keyboard]
+keyboardLayout=desktop  # or laptop, nvda-desktop, nvda-laptop, pty, pty2
+```
+
+## Available Key Constants
+
 Keymap for Fenrir
 KEY_RESERVED
 KEY_ESC

config/keyboard/desktop.conf

@@ -74,7 +74,7 @@ KEY_FENRIR,KEY_0=bookmark_10
 KEY_FENRIR,KEY_KPSLASH=set_window_application
 2,KEY_FENRIR,KEY_KPSLASH=clear_window_application
 KEY_KPPLUS=progress_bar_monitor
-KEY_FENRIR,KEY_KPPLUS=silence_until_prompt
+#KEY_FENRIR,KEY_KPPLUS=silence_until_prompt
 KEY_FENRIR,KEY_F2=toggle_braille
 KEY_FENRIR,KEY_F3=toggle_sound
 KEY_FENRIR,KEY_F4=toggle_speech

config/keyboard/laptop.conf

@@ -76,12 +76,11 @@ KEY_FENRIR,KEY_F3=toggle_sound
 KEY_FENRIR,KEY_F4=toggle_speech
 KEY_FENRIR,KEY_ENTER=temp_disable_speech
 KEY_FENRIR,KEY_SHIFT,KEY_P=progress_bar_monitor
-KEY_FENRIR,KEY_SHIFT,KEY_ENTER=silence_until_prompt
+KEY_FENRIR,KEY_SHIFT,KEY_ENTER=toggle_auto_read
 KEY_FENRIR,KEY_SHIFT,KEY_CTRL,KEY_P=toggle_punctuation_level
 KEY_FENRIR,KEY_RIGHTBRACE=toggle_auto_spell_check
 KEY_FENRIR,KEY_CTRL,KEY_SHIFT,KEY_ENTER=toggle_output
 KEY_FENRIR,KEY_SHIFT,KEY_E=toggle_emoticons
-KEY_FENRIR,KEY_ENTER=toggle_auto_read
 KEY_FENRIR,KEY_CTRL,KEY_T=toggle_auto_time
 KEY_FENRIR,KEY_Y=toggle_highlight_tracking
 #=toggle_barrier

config/settings/settings.conf

@@ -124,7 +124,9 @@ interruptOnKeyPressFilter=
 doubleTapTimeout=0.2
 
 [general]
-debugLevel=0
+# Debug levels: 0=DEACTIVE, 1=ERROR, 2=WARNING, 3=INFO (most verbose)
+# For production use, WARNING (2) provides good balance of useful info without spam
+debugLevel=2
 # debugMode sets where the debug output should send to:
 # debugMode=File writes to debugFile (Default:/tmp/fenrir-PID.log)
 # debugMode=Print just prints on the screen
@@ -133,6 +135,9 @@ debugFile=
 punctuationProfile=default
 punctuationLevel=some
 respectPunctuationPause=True
+# Replace undefined punctuation with spaces instead of removing them
+# This improves readability of text with punctuation like [X]mute, IP addresses, etc.
+replaceUndefinedPunctuationWithSpace=True
 newLinePause=True
 numberOfClipboards=50
 # used path for "export_clipboard_to_file"

docs/user.md

@@ -50,6 +50,12 @@ Navigate the screen without moving the text cursor. Essential for examining cont
 - `Keypad 1/3` - Previous/next character
 - `Fenrir + Keypad dot` - Exit review mode
 
+### Table Navigation
+- `Fenrir + Keypad *` - Toggle table mode / highlight tracking
+- `Keypad 4/6` - Previous/next column (in table mode)
+- `Fenrir + Keypad 4/6` - First/last column (in table mode)
+- `Fenrir + X` - Set column headers (in table mode)
+
 ### Information
 - `Fenrir + T` - Announce time
 - `Fenrir + T T` - Announce date
@@ -240,6 +246,47 @@ send_fenrir_command("command say Process complete")
 
 ## Advanced Features
 
+### Table Navigation Mode
+
+Fenrir includes advanced table navigation capabilities for working with tabular data in terminal applications, CSV files, and formatted text output.
+
+#### Entering Table Mode
+1. Press `Fenrir + Keypad *` (desktop) or `Fenrir + Y` (laptop)
+2. Cycle through: Highlight tracking → Cursor tracking → Table mode
+3. Listen for "table mode enabled" announcement
+
+#### Table Navigation Commands
+- **Column navigation**: `Keypad 4/6` - Move between columns
+- **Row boundaries**: `Fenrir + Keypad 4/6` - Jump to first/last column
+- **Cell characters**: `Fenrir + Keypad 1/3` - First/last character in cell
+- **Set headers**: `Fenrir + X` - Mark current line as column headers
+
+#### Table Features
+- **Automatic detection**: Supports CSV, pipe-separated, space-aligned columns
+- **Column headers**: Set and announce headers for better context
+- **Boundary feedback**: Audio cues when reaching row boundaries
+- **Cell-by-cell navigation**: Precise positioning within tables
+
+### Progress Bar Monitoring
+
+Fenrir automatically detects and provides audio feedback for progress indicators.
+
+#### Progress Detection
+- **Percentage**: 45%, 67.5%, 100%
+- **Fractions**: 15/100, 3 of 10, Step 7/15
+- **Progress bars**: [####    ], [====>   ]
+- **Activity indicators**: Loading..., Processing...
+
+#### Audio Feedback
+- **Progress tones**: Ascending 400Hz-1200Hz frequency range
+- **Activity beeps**: 800Hz tone every 2 seconds
+- **Non-intrusive**: Doesn't interrupt speech or other audio
+
+#### Usage
+- **Enable**: Use `progress_bar_monitor` command (assign key binding)
+- **Automatic**: Works with downloads, compilations, installations
+- **Remote control**: Enable via socket commands
+
 ### Spell Checking
 - `Fenrir + S` - Spell check current word
 - `Fenrir + S S` - Add word to dictionary

requirements.txt

@@ -1,4 +1,5 @@
 daemonize
+dbus-python
 evdev
 pexpect
 pyenchant

setup.py

@@ -37,7 +37,7 @@ for directory in directories:
         if not forceSettingsFlag:
             try:
                 files = [f for f in files if not f.endswith('settings.conf')]
-            except:
+            except Exception as e:
                 pass
     elif 'config/scripts' in directory:
         destDir = '/usr/share/fenrirscreenreader/scripts'

src/fenrir

@@ -4,19 +4,22 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributors.
 
+import argparse
+import inspect
 import os
 import sys
-import inspect
-import argparse
+
 from daemonize import Daemonize
 
+from fenrirscreenreader import fenrirVersion
+from fenrirscreenreader.core import fenrirManager
+
 # Get the fenrir installation path
-fenrirPath = os.path.dirname(os.path.realpath(os.path.abspath(inspect.getfile(inspect.currentframe()))))
-if not fenrirPath in sys.path:
+fenrirPath = os.path.dirname(os.path.realpath(
+    os.path.abspath(inspect.getfile(inspect.currentframe()))))
+if fenrirPath not in sys.path:
     sys.path.append(fenrirPath)
 
-from fenrirscreenreader.core import fenrirManager
-from fenrirscreenreader import fenrirVersion
 
 def create_argument_parser():
     """Create and return the argument parser for Fenrir"""
@@ -27,7 +30,7 @@ def create_argument_parser():
     argumentParser.add_argument(
         '-v', '--version',
         action='version',
-        version=f'Fenrir screen reader version {fenrirVersion.version}-{fenrirVersion.codeName}',
+        version=f'Fenrir screen reader version {fenrirVersion.version}-{fenrirVersion.code_name}',
         help='Show version information and exit'
     )
     argumentParser.add_argument(
@@ -68,10 +71,10 @@ def create_argument_parser():
         help='Use PTY emulation with evdev for input (single instance)'
     )
     argumentParser.add_argument(
-        '-F', '--force-all-screens',
+        '-F',
+        '--force-all-screens',
         action='store_true',
-        help='Force Fenrir to respond on all screens, ignoring ignoreScreen setting'
-    )
+        help='Force Fenrir to respond on all screens, ignoring ignoreScreen setting')
     argumentParser.add_argument(
         '-i', '-I', '--ignore-screen',
         metavar='SCREEN',
@@ -80,29 +83,52 @@ def create_argument_parser():
     )
     return argumentParser
 
+
 def validate_arguments(cliArgs):
     """Validate command line arguments"""
     if cliArgs.options:
         for option in cliArgs.options.split(';'):
             if option and ('#' not in option or '=' not in option):
                 return False, f"Invalid option format: {option}\nExpected format: SECTION#SETTING=VALUE"
-    
+
     if cliArgs.emulated_pty and cliArgs.emulated_evdev:
         return False, "Cannot use both --emulated-pty and --emulated-evdev simultaneously"
-    
+
     return True, None
 
+
 def run_fenrir():
     """Main function that runs Fenrir"""
-    fenrirApp = fenrirManager.fenrirManager(cliArgs)
-    fenrirApp.proceed()
-    del fenrirApp
+    fenrirApp = None
+    try:
+        fenrirApp = fenrirManager.FenrirManager(cliArgs)
+        fenrirApp.proceed()
+    except Exception as e:
+        print(f"Error starting Fenrir: {e}", file=sys.stderr)
+        if fenrirApp and hasattr(fenrirApp, 'cleanup_on_error'):
+            try:
+                fenrirApp.cleanup_on_error()
+            except Exception as cleanup_error:
+                print(
+                    f"Error during cleanup: {cleanup_error}", file=sys.stderr)
+        sys.exit(1)
+    finally:
+        if fenrirApp:
+            del fenrirApp
+        # Clean up PID file if it exists
+        pidFile = "/run/fenrir.pid"
+        if os.path.exists(pidFile):
+            try:
+                os.remove(pidFile)
+            except Exception:
+                pass
+
 
 def main():
     global cliArgs
     argumentParser = create_argument_parser()
     cliArgs = argumentParser.parse_args()
-    
+
     # Validate arguments
     isValid, errorMsg = validate_arguments(cliArgs)
     if not isValid:
@@ -123,5 +149,6 @@ def main():
         )
         daemonProcess.start()
 
+
 if __name__ == "__main__":
     main()

src/fenrirscreenreader/commands/command_template.py

@@ -2,19 +2,27 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
         pass
-    def getDescription(self):
-        return 'No description found'         
+
+    def get_description(self):
+        return "No description found"
+
     def run(self):
         pass
-    def setCallback(self, callback):
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/00_init_commands.py

@@ -2,24 +2,38 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
 
 # this command is just to initialize stuff.
-# like init index lists in memoryManager
+# like init index lists in MemoryManager
 # it is not useful to execute it
-class command():
+
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
         # clipboard
-        self.env['runtime']['memoryManager'].addIndexList('clipboardHistory', self.env['runtime']['settingsManager'].getSettingAsInt('general', 'numberOfClipboards'))
+        self.env["runtime"]["MemoryManager"].add_index_list(
+            "clipboardHistory",
+            self.env["runtime"]["SettingsManager"].get_setting_as_int(
+                "general", "numberOfClipboards"
+            ),
+        )
+
     def shutdown(self):
         pass
-    def getDescription(self):
-        return 'No description found'         
+
+    def get_description(self):
+        return "No description found"
+
     def run(self):
         pass
-    def setCallback(self, callback):
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/add_word_to_spell_check.py

@@ -2,52 +2,92 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.utils import word_utils
 import string
+
+from fenrirscreenreader.core.i18n import _
+from fenrirscreenreader.utils import word_utils
+
 initialized = False
 try:
     import enchant
+
     initialized = True
-except:
+except Exception as e:
     pass
-    
-class command():
+
+
+class command:
     def __init__(self):
-        self.language = ''
+        self.language = ""
         self.spellChecker = None
+
     def initialize(self, environment):
         self.env = environment
-        self.updateSpellLanguage()
+        self.update_spell_language()
+
     def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('adds the current word to the exceptions dictionary')        
-    def updateSpellLanguage(self):  
-        self.spellChecker = enchant.Dict(self.env['runtime']['settingsManager'].getSetting('general', 'spellCheckLanguage'))
-        self.language = self.env['runtime']['settingsManager'].getSetting('general', 'spellCheckLanguage')      
-    
+        pass
+
+    def get_description(self):
+        return _("adds the current word to the exceptions dictionary")
+
+    def update_spell_language(self):
+        self.spellChecker = enchant.Dict(
+            self.env["runtime"]["SettingsManager"].get_setting(
+                "general", "spellCheckLanguage"
+            )
+        )
+        self.language = self.env["runtime"]["SettingsManager"].get_setting(
+            "general", "spellCheckLanguage"
+        )
+
     def run(self):
         if not initialized:
-           return
-        if self.env['runtime']['settingsManager'].getSetting('general', 'spellCheckLanguage') != self.language:
+            return
+        if (
+            self.env["runtime"]["SettingsManager"].get_setting(
+                "general", "spellCheckLanguage"
+            )
+            != self.language
+        ):
             try:
-                self.updateSpellLanguage()
+                self.update_spell_language()
             except Exception as e:
-                return    
-        cursorPos = self.env['runtime']['cursorManager'].getReviewOrTextCursor()
+                return
+        cursor_pos = self.env["runtime"][
+            "CursorManager"
+        ].get_review_or_text_cursor()
         # get the word
-        newContent = self.env['screen']['newContentText'].split('\n')[cursorPos['y']]
-        x, y, currWord, endOfScreen, lineBreak =  word_utils.getCurrentWord(cursorPos['x'], 0, newContent)
-        currWord = currWord.strip(string.whitespace + r'!"#$%&\()*+,-./:;<=Â?@[\\]^_{|}~')
+        new_content = self.env["screen"]["new_content_text"].split("\n")[
+            cursor_pos["y"]
+        ]
+        x, y, curr_word, end_of_screen, line_break = (
+            word_utils.get_current_word(cursor_pos["x"], 0, new_content)
+        )
+        curr_word = curr_word.strip(
+            string.whitespace + r'!"#$%&\()*+,-./:;<=Â?@[\\]^_{|}~'
+        )
 
-        if currWord != '':
-            if self.spellChecker.is_added(currWord):
-                self.env['runtime']['outputManager'].presentText(_('{0} is already in dictionary').format(currWord,), soundIcon='Cancel', interrupt=True)                
+        if curr_word != "":
+            if self.spellChecker.is_added(curr_word):
+                self.env["runtime"]["OutputManager"].present_text(
+                    _("{0} is already in dictionary").format(
+                        curr_word,
+                    ),
+                    sound_icon="Cancel",
+                    interrupt=True,
+                )
             else:
-                self.spellChecker.add(currWord)             
-                self.env['runtime']['outputManager'].presentText(_('{0} added to dictionary').format(currWord,), soundIcon='Accept', interrupt=True)               
+                self.spellChecker.add(curr_word)
+                self.env["runtime"]["OutputManager"].present_text(
+                    _("{0} added to dictionary").format(
+                        curr_word,
+                    ),
+                    sound_icon="Accept",
+                    interrupt=True,
+                )
 
-    def setCallback(self, callback):
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/adjustment_base.py

@@ -2,45 +2,51 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
 import math
 
-class AdjustmentCommand():
+from fenrirscreenreader.core.i18n import _
+
+
+class adjustment_command:
     """Base class for speech and sound adjustment commands"""
+
     def __init__(self, section, setting, direction, step=0.1):
         self.section = section  # 'speech' or 'sound'
         self.setting = setting  # 'rate', 'pitch', 'volume'
         self.direction = direction  # 'inc' or 'dec'
         self.step = step
-        
+
     def initialize(self, environment):
         self.env = environment
-        
+
     def shutdown(self):
         pass
-        
-    def getDescription(self):
-        action = "Increase" if self.direction == 'inc' else "Decrease"
-        if self.section == 'speech':
-            return _(f'{action} the speech {self.setting}')
+
+    def get_description(self):
+        action = "Increase" if self.direction == "inc" else "Decrease"
+        if self.section == "speech":
+            return _(f"{action} the speech {self.setting}")
         else:
-            return _(f'{action} the {self.section} {self.setting}')
-    
+            return _(f"{action} the {self.section} {self.setting}")
+
     def run(self):
-        if self.section == 'sound' and self.setting == 'volume':
+        if self.section == "sound" and self.setting == "volume":
             # Sound volume uses different method
             self._adjust_sound_volume()
         else:
             # Speech rate, pitch, volume use standard method
             self._adjust_speech_setting()
-        
+
     def _adjust_speech_setting(self):
         """Adjust speech settings (rate, pitch, volume)"""
-        value = self.env['runtime']['settingsManager'].getSettingAsFloat(self.section, self.setting)
-        
+        value = self.env["runtime"]["SettingsManager"].get_setting_as_float(
+            self.section, self.setting
+        )
+
         # Apply adjustment with rounding
-        if self.direction == 'inc':
+        if self.direction == "inc":
             value = round((math.ceil(10 * value) / 10) + self.step, 2)
             if value > 1.0:
                 value = 1.0
@@ -48,25 +54,35 @@ class AdjustmentCommand():
             value = round((math.ceil(10 * value) / 10) - self.step, 2)
             if value < 0.0:
                 value = 0.0
-        
+
         # Set the new value
-        self.env['runtime']['settingsManager'].setSetting(self.section, self.setting, str(value))
-        
+        self.env["runtime"]["SettingsManager"].set_setting(
+            self.section, self.setting, str(value)
+        )
+
         # Present feedback
         percentage = int(value * 100)
-        if self.section == 'speech':
-            feedback = _("{0} percent speech {1}").format(percentage, self.setting)
+        if self.section == "speech":
+            feedback = _("{0} percent speech {1}").format(
+                percentage, self.setting
+            )
         else:
-            feedback = _("{0} percent {1} {2}").format(percentage, self.section, self.setting)
-            
-        self.env['runtime']['outputManager'].presentText(feedback, soundIcon='', interrupt=True)
-    
+            feedback = _("{0} percent {1} {2}").format(
+                percentage, self.section, self.setting
+            )
+
+        self.env["runtime"]["OutputManager"].present_text(
+            feedback, sound_icon="", interrupt=True
+        )
+
     def _adjust_sound_volume(self):
         """Adjust sound volume using same logic as speech"""
-        value = self.env['runtime']['settingsManager'].getSettingAsFloat(self.section, self.setting)
-        
+        value = self.env["runtime"]["SettingsManager"].get_setting_as_float(
+            self.section, self.setting
+        )
+
         # Sound volume uses same math as speech settings
-        if self.direction == 'inc':
+        if self.direction == "inc":
             value = round((math.ceil(10 * value) / 10) + self.step, 2)
             if value > 1.0:
                 value = 1.0
@@ -74,15 +90,19 @@ class AdjustmentCommand():
             value = round((math.ceil(10 * value) / 10) - self.step, 2)
             if value < 0.0:
                 value = 0.0
-        
+
         # Set the new value
-        self.env['runtime']['settingsManager'].setSetting(self.section, self.setting, str(value))
-        
+        self.env["runtime"]["SettingsManager"].set_setting(
+            self.section, self.setting, str(value)
+        )
+
         # Present feedback with appropriate sound icon
         percentage = int(value * 100)
-        sound_icon = 'SoundOn' if self.direction == 'inc' else 'SoundOff'
+        sound_icon = "SoundOn" if self.direction == "inc" else "SoundOff"
         feedback = _("{0} percent sound volume").format(percentage)
-        self.env['runtime']['outputManager'].presentText(feedback, soundIcon=sound_icon, interrupt=True)
-        
-    def setCallback(self, callback):
-        pass
+        self.env["runtime"]["OutputManager"].present_text(
+            feedback, sound_icon=sound_icon, interrupt=True
+        )
+
+    def set_callback(self, callback):
+        pass

src/fenrirscreenreader/commands/commands/announce_fenrir_version.py

@@ -2,25 +2,37 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
 from fenrirscreenreader import fenrirVersion
+from fenrirscreenreader.core.i18n import _
 
-class command():
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
         pass
-    def getDescription(self):
-        return _('Present the version of Fenrir currrrently in use.')
-    
+
+    def get_description(self):
+        return _("Present the version of Fenrir currently in use.")
+
     def run(self):
         try:
-            self.env['runtime']['outputManager'].presentText(f'Fenrir screen reader version {fenrirVersion.version}-{fenrirVersion.codeName}', interrupt=True)
-        except exception as e:
-            self.env['runtime']['outputManager'].presentText(_('Version information is unavailable.'), interrupt=True)
-            
-    def setCallback(self, callback):
+            self.env["runtime"]["OutputManager"].present_text(
+                f"Fenrir screen reader version {
+                    fenrirVersion.version}-{
+                    fenrirVersion.code_name}",
+                interrupt=True,
+            )
+        except Exception as e:
+            self.env["runtime"]["OutputManager"].present_text(
+                _("Version information is unavailable."), interrupt=True
+            )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/apply_tested_voice.py

@@ -1,71 +1,94 @@
 #!/usr/bin/env python3
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
-    
+
     def initialize(self, environment):
         self.env = environment
-    
+
     def shutdown(self):
         pass
-    
-    def getDescription(self):
+
+    def get_description(self):
         return "Apply the last tested voice from safe voice browser"
-    
+
     def run(self):
         try:
             # Check if we have a tested voice
-            if ('commandBuffer' not in self.env or 
-                'lastTestedModule' not in self.env['commandBuffer'] or
-                'lastTestedVoice' not in self.env['commandBuffer']):
-                self.env['runtime']['outputManager'].presentText("No voice has been tested yet", interrupt=True)
-                self.env['runtime']['outputManager'].presentText("Use voice browser first", interrupt=True)
+            if (
+                "commandBuffer" not in self.env
+                or "lastTestedModule" not in self.env["commandBuffer"]
+                or "lastTestedVoice" not in self.env["commandBuffer"]
+            ):
+                self.env["runtime"]["OutputManager"].present_text(
+                    "No voice has been tested yet", interrupt=True
+                )
+                self.env["runtime"]["OutputManager"].present_text(
+                    "Use voice browser first", interrupt=True
+                )
                 return
-            
-            module = self.env['commandBuffer']['lastTestedModule']
-            voice = self.env['commandBuffer']['lastTestedVoice']
-            
-            self.env['runtime']['outputManager'].presentText(f"Applying {voice} from {module}", interrupt=True)
-            
+
+            module = self.env["commandBuffer"]["lastTestedModule"]
+            voice = self.env["commandBuffer"]["lastTestedVoice"]
+
+            self.env["runtime"]["OutputManager"].present_text(
+                f"Applying {voice} from {module}", interrupt=True
+            )
+
             # Apply to runtime settings only (temporary until saved)
-            settingsManager = self.env['runtime']['settingsManager']
-            
+            SettingsManager = self.env["runtime"]["SettingsManager"]
+
             # Store old values for safety
-            oldDriver = settingsManager.getSetting('speech', 'driver')
-            oldModule = settingsManager.getSetting('speech', 'module')
-            oldVoice = settingsManager.getSetting('speech', 'voice')
-            
+            old_driver = SettingsManager.get_setting("speech", "driver")
+            old_module = SettingsManager.get_setting("speech", "module")
+            old_voice = SettingsManager.get_setting("speech", "voice")
+
             try:
-                # Apply new settings to runtime only (use setSetting to update settingArgDict)
-                settingsManager.setSetting('speech', 'driver', 'speechdDriver')
-                settingsManager.setSetting('speech', 'module', module)
-                settingsManager.setSetting('speech', 'voice', voice)
-                
+                # Apply new settings to runtime only (use set_setting to update
+                # settingArgDict)
+                SettingsManager.set_setting(
+                    "speech", "driver", "speechdDriver"
+                )
+                SettingsManager.set_setting("speech", "module", module)
+                SettingsManager.set_setting("speech", "voice", voice)
+
                 # Apply to speech driver instance directly
-                if 'speechDriver' in self.env['runtime']:
-                    speechDriver = self.env['runtime']['speechDriver']
-                    
+                if "SpeechDriver" in self.env["runtime"]:
+                    SpeechDriver = self.env["runtime"]["SpeechDriver"]
+
                     # Set the module and voice on the driver instance
-                    speechDriver.setModule(module)
-                    speechDriver.setVoice(voice)
-                    
-                    self.env['runtime']['outputManager'].presentText("Voice applied successfully!", interrupt=True)
-                    self.env['runtime']['outputManager'].presentText("Use save settings to make permanent", interrupt=True)
-                    self.env['runtime']['outputManager'].playSound('Accept')
-                    
+                    SpeechDriver.set_module(module)
+                    SpeechDriver.set_voice(voice)
+
+                    self.env["runtime"]["OutputManager"].present_text(
+                        "Voice applied successfully!", interrupt=True
+                    )
+                    self.env["runtime"]["OutputManager"].present_text(
+                        "Use save settings to make permanent", interrupt=True
+                    )
+                    self.env["runtime"]["OutputManager"].play_sound("Accept")
+
             except Exception as e:
                 # Revert on failure
-                settingsManager.setSetting('speech', 'driver', oldDriver)
-                settingsManager.setSetting('speech', 'module', oldModule)
-                settingsManager.setSetting('speech', 'voice', oldVoice)
-                
-                self.env['runtime']['outputManager'].presentText(f"Failed to apply voice, reverted: {str(e)}", interrupt=True)
-                self.env['runtime']['outputManager'].playSound('Error')
-                
+                SettingsManager.set_setting("speech", "driver", old_driver)
+                SettingsManager.set_setting("speech", "module", old_module)
+                SettingsManager.set_setting("speech", "voice", old_voice)
+
+                self.env["runtime"]["OutputManager"].present_text(
+                    f"Failed to apply voice, reverted: {str(e)}",
+                    interrupt=True,
+                )
+                self.env["runtime"]["OutputManager"].play_sound("Error")
+
         except Exception as e:
-            self.env['runtime']['outputManager'].presentText(f"Apply voice error: {str(e)}", interrupt=True)
-            self.env['runtime']['outputManager'].playSound('Error')
-    
-    def setCallback(self, callback):
-        pass
+            self.env["runtime"]["OutputManager"].present_text(
+                f"Apply voice error: {str(e)}", interrupt=True
+            )
+            self.env["runtime"]["OutputManager"].play_sound("Error")
+
+    def set_callback(self, callback):
+        pass

src/fenrirscreenreader/commands/commands/attribute_cursor.py

@@ -2,28 +2,45 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
+from fenrirscreenreader.core.i18n import _
 from fenrirscreenreader.utils import screen_utils
 
-class command():
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
         pass
-    def getDescription(self):
-        return _('Reads attributes of current cursor position')         
+
+    def get_description(self):
+        return _("Reads attributes of current cursor position")
+
     def run(self):
-        cursorPos = self.env['runtime']['cursorManager'].getReviewOrTextCursor()
+        cursor_pos = self.env["runtime"][
+            "CursorManager"
+        ].get_review_or_text_cursor()
         try:
-            attributes = self.env['runtime']['attributeManager'].getAttributeByXY( cursorPos['x'], cursorPos['y'])
+            attributes = self.env["runtime"][
+                "AttributeManager"
+            ].get_attribute_by_xy(cursor_pos["x"], cursor_pos["y"])
         except Exception as e:
-            print(e)        
-        attributeFormatString = self.env['runtime']['settingsManager'].getSetting('general', 'attributeFormatString')
-        attributeFormatString = self.env['runtime']['attributeManager'].formatAttributes(attributes, attributeFormatString)
-        
-        self.env['runtime']['outputManager'].presentText(attributeFormatString, soundIcon='', interrupt=True)
-    def setCallback(self, callback):
+            print(e)
+        attribute_format_string = self.env["runtime"][
+            "SettingsManager"
+        ].get_setting("general", "attribute_format_string")
+        attribute_format_string = self.env["runtime"][
+            "AttributeManager"
+        ].format_attributes(attributes, attribute_format_string)
+
+        self.env["runtime"]["OutputManager"].present_text(
+            attribute_format_string, sound_icon="", interrupt=True
+        )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/bookmark_1.py

@@ -2,16 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-import os
 import importlib.util
-_base_path = os.path.join(os.path.dirname(__file__), 'bookmark_base.py')
+import os
+
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "bookmark_base.py")
 _spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
 _module = importlib.util.module_from_spec(_spec)
 _spec.loader.exec_module(_module)
-BookmarkCommand = _module.BookmarkCommand
+bookmark_command = _module.bookmark_command
 
-class command(BookmarkCommand):
+
+class command(bookmark_command):
     def __init__(self):
-        super().__init__(1, 'read')
+        super().__init__(1, "read")

src/fenrirscreenreader/commands/commands/bookmark_10.py

@@ -2,16 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-import os
 import importlib.util
-_base_path = os.path.join(os.path.dirname(__file__), 'bookmark_base.py')
+import os
+
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "bookmark_base.py")
 _spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
 _module = importlib.util.module_from_spec(_spec)
 _spec.loader.exec_module(_module)
-BookmarkCommand = _module.BookmarkCommand
+bookmark_command = _module.bookmark_command
 
-class command(BookmarkCommand):
+
+class command(bookmark_command):
     def __init__(self):
-        super().__init__(10, 'read')
+        super().__init__(10, "read")

src/fenrirscreenreader/commands/commands/bookmark_2.py

@@ -2,16 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-import os
 import importlib.util
-_base_path = os.path.join(os.path.dirname(__file__), 'bookmark_base.py')
+import os
+
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "bookmark_base.py")
 _spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
 _module = importlib.util.module_from_spec(_spec)
 _spec.loader.exec_module(_module)
-BookmarkCommand = _module.BookmarkCommand
+bookmark_command = _module.bookmark_command
 
-class command(BookmarkCommand):
+
+class command(bookmark_command):
     def __init__(self):
-        super().__init__(2, 'read')
+        super().__init__(2, "read")

src/fenrirscreenreader/commands/commands/bookmark_3.py

@@ -2,16 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-import os
 import importlib.util
-_base_path = os.path.join(os.path.dirname(__file__), 'bookmark_base.py')
+import os
+
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "bookmark_base.py")
 _spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
 _module = importlib.util.module_from_spec(_spec)
 _spec.loader.exec_module(_module)
-BookmarkCommand = _module.BookmarkCommand
+bookmark_command = _module.bookmark_command
 
-class command(BookmarkCommand):
+
+class command(bookmark_command):
     def __init__(self):
-        super().__init__(3, 'read')
+        super().__init__(3, "read")

src/fenrirscreenreader/commands/commands/bookmark_4.py

@@ -2,16 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-import os
 import importlib.util
-_base_path = os.path.join(os.path.dirname(__file__), 'bookmark_base.py')
+import os
+
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "bookmark_base.py")
 _spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
 _module = importlib.util.module_from_spec(_spec)
 _spec.loader.exec_module(_module)
-BookmarkCommand = _module.BookmarkCommand
+bookmark_command = _module.bookmark_command
 
-class command(BookmarkCommand):
+
+class command(bookmark_command):
     def __init__(self):
-        super().__init__(4, 'read')
+        super().__init__(4, "read")

src/fenrirscreenreader/commands/commands/bookmark_5.py

@@ -2,16 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-import os
 import importlib.util
-_base_path = os.path.join(os.path.dirname(__file__), 'bookmark_base.py')
+import os
+
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "bookmark_base.py")
 _spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
 _module = importlib.util.module_from_spec(_spec)
 _spec.loader.exec_module(_module)
-BookmarkCommand = _module.BookmarkCommand
+bookmark_command = _module.bookmark_command
 
-class command(BookmarkCommand):
+
+class command(bookmark_command):
     def __init__(self):
-        super().__init__(5, 'read')
+        super().__init__(5, "read")

src/fenrirscreenreader/commands/commands/bookmark_6.py

@@ -2,16 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-import os
 import importlib.util
-_base_path = os.path.join(os.path.dirname(__file__), 'bookmark_base.py')
+import os
+
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "bookmark_base.py")
 _spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
 _module = importlib.util.module_from_spec(_spec)
 _spec.loader.exec_module(_module)
-BookmarkCommand = _module.BookmarkCommand
+bookmark_command = _module.bookmark_command
 
-class command(BookmarkCommand):
+
+class command(bookmark_command):
     def __init__(self):
-        super().__init__(6, 'read')
+        super().__init__(6, "read")

src/fenrirscreenreader/commands/commands/bookmark_7.py

@@ -2,16 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-import os
 import importlib.util
-_base_path = os.path.join(os.path.dirname(__file__), 'bookmark_base.py')
+import os
+
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "bookmark_base.py")
 _spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
 _module = importlib.util.module_from_spec(_spec)
 _spec.loader.exec_module(_module)
-BookmarkCommand = _module.BookmarkCommand
+bookmark_command = _module.bookmark_command
 
-class command(BookmarkCommand):
+
+class command(bookmark_command):
     def __init__(self):
-        super().__init__(7, 'read')
+        super().__init__(7, "read")

src/fenrirscreenreader/commands/commands/bookmark_8.py

@@ -2,16 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-import os
 import importlib.util
-_base_path = os.path.join(os.path.dirname(__file__), 'bookmark_base.py')
+import os
+
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "bookmark_base.py")
 _spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
 _module = importlib.util.module_from_spec(_spec)
 _spec.loader.exec_module(_module)
-BookmarkCommand = _module.BookmarkCommand
+bookmark_command = _module.bookmark_command
 
-class command(BookmarkCommand):
+
+class command(bookmark_command):
     def __init__(self):
-        super().__init__(8, 'read')
+        super().__init__(8, "read")

src/fenrirscreenreader/commands/commands/bookmark_9.py

@@ -2,16 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-import os
 import importlib.util
-_base_path = os.path.join(os.path.dirname(__file__), 'bookmark_base.py')
+import os
+
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "bookmark_base.py")
 _spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
 _module = importlib.util.module_from_spec(_spec)
 _spec.loader.exec_module(_module)
-BookmarkCommand = _module.BookmarkCommand
+bookmark_command = _module.bookmark_command
 
-class command(BookmarkCommand):
+
+class command(bookmark_command):
     def __init__(self):
-        super().__init__(9, 'read')
+        super().__init__(9, "read")

src/fenrirscreenreader/commands/commands/bookmark_base.py

@@ -2,149 +2,210 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-import gettext
-_ = gettext.gettext
-
-from fenrirscreenreader.utils import mark_utils
+from fenrirscreenreader.core.i18n import _
 from fenrirscreenreader.utils import line_utils
+from fenrirscreenreader.utils import mark_utils
 
-class BookmarkCommand():
+
+class bookmark_command:
     """Base class for bookmark operations - read, set, clear"""
-    def __init__(self, bookmark_id, action='read'):
+
+    def __init__(self, bookmark_id, action="read"):
         self.ID = str(bookmark_id)
         self.action = action
-        
+
     def initialize(self, environment):
         self.env = environment
         # Always initialize bookmark structure - all commands need this
-        if self.ID not in self.env['commandBuffer']['bookMarks']:
-            self.env['commandBuffer']['bookMarks'][self.ID] = {}
-                
+        if self.ID not in self.env["commandBuffer"]["bookMarks"]:
+            self.env["commandBuffer"]["bookMarks"][self.ID] = {}
+
     def shutdown(self):
         pass
-        
-    def getDescription(self):
-        if self.action == 'read':
-            return _('read Bookmark {0}').format(self.ID)
-        elif self.action == 'set':
-            return _('set Bookmark {0}').format(self.ID)
-        elif self.action == 'clear':
-            return _('remove Bookmark {0}').format(self.ID)
-        return f'{self.action} Bookmark {self.ID}'
-    
+
+    def get_description(self):
+        if self.action == "read":
+            return _("read Bookmark {0}").format(self.ID)
+        elif self.action == "set":
+            return _("set Bookmark {0}").format(self.ID)
+        elif self.action == "clear":
+            return _("remove Bookmark {0}").format(self.ID)
+        return f"{self.action} Bookmark {self.ID}"
+
     def run(self):
-        if self.action == 'read':
+        if self.action == "read":
             self._read_bookmark()
-        elif self.action == 'set':
+        elif self.action == "set":
             self._set_bookmark()
-        elif self.action == 'clear':
+        elif self.action == "clear":
             self._clear_bookmark()
-    
+
     def _read_bookmark(self):
-        currApp = self.env['runtime']['applicationManager'].getCurrentApplication()
-        
-        if not self.env['commandBuffer']['bookMarks'][self.ID]:
-            self.env['runtime']['outputManager'].presentText('Bookmark {0} not set'.format(self.ID), interrupt=True)
+        curr_app = self.env["runtime"][
+            "ApplicationManager"
+        ].get_current_application()
+
+        if not self.env["commandBuffer"]["bookMarks"][self.ID]:
+            self.env["runtime"]["OutputManager"].present_text(
+                "Bookmark {0} not set".format(self.ID), interrupt=True
+            )
             return
-            
-        if currApp not in self.env['commandBuffer']['bookMarks'][self.ID]:
-            self.env['runtime']['outputManager'].presentText('Bookmark for application {0} not set'.format(currApp), interrupt=True)
+
+        if curr_app not in self.env["commandBuffer"]["bookMarks"][self.ID]:
+            self.env["runtime"]["OutputManager"].present_text(
+                "Bookmark for application {0} not set".format(curr_app),
+                interrupt=True,
+            )
             return
-            
-        if not self.env['commandBuffer']['bookMarks'][self.ID][currApp].get('1'):
-            self.env['runtime']['outputManager'].presentText('Bookmark for application {0} not set'.format(currApp), interrupt=True)
+
+        if not self.env["commandBuffer"]["bookMarks"][self.ID][curr_app].get(
+            "1"
+        ):
+            self.env["runtime"]["OutputManager"].present_text(
+                "Bookmark for application {0} not set".format(curr_app),
+                interrupt=True,
+            )
             return
 
         # Get bookmarked text
-        marked = ''
-        startMark = self.env['commandBuffer']['bookMarks'][self.ID][currApp]['1'].copy()
-        
-        if self.env['commandBuffer']['bookMarks'][self.ID][currApp]['2']:
-            endMark = self.env['commandBuffer']['bookMarks'][self.ID][currApp]['2'].copy()
-            marked = mark_utils.getTextBetweenMarks(startMark, endMark, self.env['screen']['newContentText'])
+        marked = ""
+        start_mark = self.env["commandBuffer"]["bookMarks"][self.ID][curr_app][
+            "1"
+        ].copy()
+
+        if self.env["commandBuffer"]["bookMarks"][self.ID][curr_app]["2"]:
+            end_mark = self.env["commandBuffer"]["bookMarks"][self.ID][
+                curr_app
+            ]["2"].copy()
+            marked = mark_utils.get_text_between_marks(
+                start_mark, end_mark, self.env["screen"]["new_content_text"]
+            )
         else:
-            x, y, marked = line_utils.getCurrentLine(startMark['x'], startMark['y'], self.env['screen']['newContentText'])
-            
+            x, y, marked = line_utils.get_current_line(
+                start_mark["x"],
+                start_mark["y"],
+                self.env["screen"]["new_content_text"],
+            )
+
         if marked.isspace():
-            self.env['runtime']['outputManager'].presentText(_('blank'), soundIcon='EmptyLine', interrupt=True)
+            self.env["runtime"]["OutputManager"].present_text(
+                _("blank"), sound_icon="EmptyLine", interrupt=True
+            )
         else:
-            self.env['runtime']['outputManager'].presentText(marked, interrupt=True)
-    
+            self.env["runtime"]["OutputManager"].present_text(
+                marked, interrupt=True
+            )
+
     def _set_bookmark(self):
-        if not self.env['commandBuffer']['Marks']['1']:
-            self.env['runtime']['outputManager'].presentText(_("No mark found"), interrupt=True)
+        if not self.env["commandBuffer"]["Marks"]["1"]:
+            self.env["runtime"]["OutputManager"].present_text(
+                _("No mark found"), interrupt=True
+            )
             return
-            
-        currApp = self.env['runtime']['applicationManager'].getCurrentApplication()
-        self.env['commandBuffer']['bookMarks'][self.ID][currApp] = {}
-        
-        self.env['commandBuffer']['bookMarks'][self.ID][currApp]['1'] = self.env['commandBuffer']['Marks']['1'].copy()
-        
-        if self.env['commandBuffer']['Marks']['2']:
-            self.env['commandBuffer']['bookMarks'][self.ID][currApp]['2'] = self.env['commandBuffer']['Marks']['2'].copy()
+
+        curr_app = self.env["runtime"][
+            "ApplicationManager"
+        ].get_current_application()
+        self.env["commandBuffer"]["bookMarks"][self.ID][curr_app] = {}
+
+        bookmarks = self.env["commandBuffer"]["bookMarks"][self.ID][curr_app]
+        bookmarks["1"] = self.env["commandBuffer"]["Marks"]["1"].copy()
+
+        if self.env["commandBuffer"]["Marks"]["2"]:
+            bookmarks["2"] = self.env["commandBuffer"]["Marks"]["2"].copy()
         else:
-            self.env['commandBuffer']['bookMarks'][self.ID][currApp]['2'] = None
-            
-        self.env['runtime']['outputManager'].presentText(_('Bookmark {0} set for application {1}').format(self.ID, currApp), interrupt=True)
-        
+            bookmarks["2"] = None
+
+        self.env["runtime"]["OutputManager"].present_text(
+            _("Bookmark {0} set for application {1}").format(
+                self.ID, curr_app
+            ),
+            interrupt=True,
+        )
+
         # Clear marks after setting bookmark
-        self.env['commandBuffer']['Marks']['1'] = None
-        self.env['commandBuffer']['Marks']['2'] = None
-    
+        self.env["commandBuffer"]["Marks"]["1"] = None
+        self.env["commandBuffer"]["Marks"]["2"] = None
+
     def _clear_bookmark(self):
-        currApp = self.env['runtime']['applicationManager'].getCurrentApplication()
-        
-        if self.ID in self.env['commandBuffer']['bookMarks'] and currApp in self.env['commandBuffer']['bookMarks'][self.ID]:
-            del self.env['commandBuffer']['bookMarks'][self.ID][currApp]
-            self.env['runtime']['outputManager'].presentText(_('Bookmark {0} removed for application {1}').format(self.ID, currApp), interrupt=True)
+        curr_app = self.env["runtime"][
+            "ApplicationManager"
+        ].get_current_application()
+
+        bookmarks = self.env["commandBuffer"]["bookMarks"]
+        if self.ID in bookmarks and curr_app in bookmarks[self.ID]:
+            del self.env["commandBuffer"]["bookMarks"][self.ID][curr_app]
+            self.env["runtime"]["OutputManager"].present_text(
+                _("Bookmark {0} removed for application {1}").format(
+                    self.ID, curr_app
+                ),
+                interrupt=True,
+            )
         else:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark {0} not set for application {1}').format(self.ID, currApp), interrupt=True)
-        
-    def setCallback(self, callback):
+            self.env["runtime"]["OutputManager"].present_text(
+                _("Bookmark {0} not set for application {1}").format(
+                    self.ID, curr_app
+                ),
+                interrupt=True,
+            )
+
+    def set_callback(self, callback):
         pass
 
+
 # Factory function to create bookmark command instances
+
+
 def create_bookmark_commands():
     """Create all bookmark command instances"""
     commands = {}
-    
+
     # Create read bookmark commands (bookmark_1 through bookmark_10)
     for i in range(1, 11):
-        commands[f'bookmark_{i}'] = lambda i=i: BookmarkCommand(i, 'read')
-    
+        commands[f"bookmark_{i}"] = lambda i=i: bookmark_command(i, "read")
+
     # Create set bookmark commands (set_bookmark_1 through set_bookmark_10)
     for i in range(1, 11):
-        commands[f'set_bookmark_{i}'] = lambda i=i: BookmarkCommand(i, 'set')
-    
-    # Create clear bookmark commands (clear_bookmark_1 through clear_bookmark_10)
+        commands[f"set_bookmark_{i}"] = lambda i=i: bookmark_command(i, "set")
+
+    # Create clear bookmark commands (clear_bookmark_1 through
+    # clear_bookmark_10)
     for i in range(1, 11):
-        commands[f'clear_bookmark_{i}'] = lambda i=i: BookmarkCommand(i, 'clear')
-        
+        commands[f"clear_bookmark_{i}"] = lambda i=i: bookmark_command(
+            i, "clear"
+        )
+
     return commands
 
+
 # For backwards compatibility, provide individual command classes
 # This allows the existing command loading system to work unchanged
 
+
 def _make_command_class(bookmark_id, action):
     """Create a command class for a specific bookmark and action"""
-    class command(BookmarkCommand):
+
+    class command(bookmark_command):
         def __init__(self):
             super().__init__(bookmark_id, action)
+
     return command
 
+
 # Generate individual command classes for each bookmark operation
 # These will be used by the existing command loading system
 
+
 # Read bookmarks (bookmark_1.py style)
 for i in range(1, 11):
-    globals()[f'bookmark_{i}_command'] = _make_command_class(i, 'read')
+    globals()[f"bookmark_{i}_command"] = _make_command_class(i, "read")
 
-# Set bookmarks (set_bookmark_1.py style)  
+# Set bookmarks (set_bookmark_1.py style)
 for i in range(1, 11):
-    globals()[f'set_bookmark_{i}_command'] = _make_command_class(i, 'set')
+    globals()[f"set_bookmark_{i}_command"] = _make_command_class(i, "set")
 
 # Clear bookmarks (clear_bookmark_1.py style)
 for i in range(1, 11):
-    globals()[f'clear_bookmark_{i}_command'] = _make_command_class(i, 'clear')
+    globals()[f"clear_bookmark_{i}_command"] = _make_command_class(i, "clear")

src/fenrirscreenreader/commands/commands/clear_bookmark_1.py

@@ -2,16 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-import os
 import importlib.util
-_base_path = os.path.join(os.path.dirname(__file__), 'bookmark_base.py')
+import os
+
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "bookmark_base.py")
 _spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
 _module = importlib.util.module_from_spec(_spec)
 _spec.loader.exec_module(_module)
-BookmarkCommand = _module.BookmarkCommand
+bookmark_command = _module.bookmark_command
 
-class command(BookmarkCommand):
+
+class command(bookmark_command):
     def __init__(self):
-        super().__init__(1, 'clear')
+        super().__init__(1, "clear")

src/fenrirscreenreader/commands/commands/clear_bookmark_10.py

@@ -2,16 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-import os
 import importlib.util
-_base_path = os.path.join(os.path.dirname(__file__), 'bookmark_base.py')
+import os
+
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "bookmark_base.py")
 _spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
 _module = importlib.util.module_from_spec(_spec)
 _spec.loader.exec_module(_module)
-BookmarkCommand = _module.BookmarkCommand
+bookmark_command = _module.bookmark_command
 
-class command(BookmarkCommand):
+
+class command(bookmark_command):
     def __init__(self):
-        super().__init__(10, 'clear')
+        super().__init__(10, "clear")

src/fenrirscreenreader/commands/commands/clear_bookmark_2.py

@@ -2,16 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-import os
 import importlib.util
-_base_path = os.path.join(os.path.dirname(__file__), 'bookmark_base.py')
+import os
+
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "bookmark_base.py")
 _spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
 _module = importlib.util.module_from_spec(_spec)
 _spec.loader.exec_module(_module)
-BookmarkCommand = _module.BookmarkCommand
+bookmark_command = _module.bookmark_command
 
-class command(BookmarkCommand):
+
+class command(bookmark_command):
     def __init__(self):
-        super().__init__(2, 'clear')
+        super().__init__(2, "clear")

src/fenrirscreenreader/commands/commands/clear_bookmark_3.py

@@ -2,16 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-import os
 import importlib.util
-_base_path = os.path.join(os.path.dirname(__file__), 'bookmark_base.py')
+import os
+
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "bookmark_base.py")
 _spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
 _module = importlib.util.module_from_spec(_spec)
 _spec.loader.exec_module(_module)
-BookmarkCommand = _module.BookmarkCommand
+bookmark_command = _module.bookmark_command
 
-class command(BookmarkCommand):
+
+class command(bookmark_command):
     def __init__(self):
-        super().__init__(3, 'clear')
+        super().__init__(3, "clear")

src/fenrirscreenreader/commands/commands/clear_bookmark_4.py

@@ -2,16 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-import os
 import importlib.util
-_base_path = os.path.join(os.path.dirname(__file__), 'bookmark_base.py')
+import os
+
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "bookmark_base.py")
 _spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
 _module = importlib.util.module_from_spec(_spec)
 _spec.loader.exec_module(_module)
-BookmarkCommand = _module.BookmarkCommand
+bookmark_command = _module.bookmark_command
 
-class command(BookmarkCommand):
+
+class command(bookmark_command):
     def __init__(self):
-        super().__init__(4, 'clear')
+        super().__init__(4, "clear")

src/fenrirscreenreader/commands/commands/clear_bookmark_5.py

@@ -2,16 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-import os
 import importlib.util
-_base_path = os.path.join(os.path.dirname(__file__), 'bookmark_base.py')
+import os
+
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "bookmark_base.py")
 _spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
 _module = importlib.util.module_from_spec(_spec)
 _spec.loader.exec_module(_module)
-BookmarkCommand = _module.BookmarkCommand
+bookmark_command = _module.bookmark_command
 
-class command(BookmarkCommand):
+
+class command(bookmark_command):
     def __init__(self):
-        super().__init__(5, 'clear')
+        super().__init__(5, "clear")

src/fenrirscreenreader/commands/commands/clear_bookmark_6.py

@@ -2,16 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-import os
 import importlib.util
-_base_path = os.path.join(os.path.dirname(__file__), 'bookmark_base.py')
+import os
+
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "bookmark_base.py")
 _spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
 _module = importlib.util.module_from_spec(_spec)
 _spec.loader.exec_module(_module)
-BookmarkCommand = _module.BookmarkCommand
+bookmark_command = _module.bookmark_command
 
-class command(BookmarkCommand):
+
+class command(bookmark_command):
     def __init__(self):
-        super().__init__(6, 'clear')
+        super().__init__(6, "clear")

src/fenrirscreenreader/commands/commands/clear_bookmark_7.py

@@ -2,16 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-import os
 import importlib.util
-_base_path = os.path.join(os.path.dirname(__file__), 'bookmark_base.py')
+import os
+
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "bookmark_base.py")
 _spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
 _module = importlib.util.module_from_spec(_spec)
 _spec.loader.exec_module(_module)
-BookmarkCommand = _module.BookmarkCommand
+bookmark_command = _module.bookmark_command
 
-class command(BookmarkCommand):
+
+class command(bookmark_command):
     def __init__(self):
-        super().__init__(7, 'clear')
+        super().__init__(7, "clear")

src/fenrirscreenreader/commands/commands/clear_bookmark_8.py

@@ -2,16 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-import os
 import importlib.util
-_base_path = os.path.join(os.path.dirname(__file__), 'bookmark_base.py')
+import os
+
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "bookmark_base.py")
 _spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
 _module = importlib.util.module_from_spec(_spec)
 _spec.loader.exec_module(_module)
-BookmarkCommand = _module.BookmarkCommand
+bookmark_command = _module.bookmark_command
 
-class command(BookmarkCommand):
+
+class command(bookmark_command):
     def __init__(self):
-        super().__init__(8, 'clear')
+        super().__init__(8, "clear")

src/fenrirscreenreader/commands/commands/clear_bookmark_9.py

@@ -2,16 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-import os
 import importlib.util
-_base_path = os.path.join(os.path.dirname(__file__), 'bookmark_base.py')
+import os
+
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "bookmark_base.py")
 _spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
 _module = importlib.util.module_from_spec(_spec)
 _spec.loader.exec_module(_module)
-BookmarkCommand = _module.BookmarkCommand
+bookmark_command = _module.bookmark_command
 
-class command(BookmarkCommand):
+
+class command(bookmark_command):
     def __init__(self):
-        super().__init__(9, 'clear')
+        super().__init__(9, "clear")

src/fenrirscreenreader/commands/commands/clear_clipboard.py

@@ -2,22 +2,33 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('clears the currently selected clipboard')     
+        pass
+
+    def get_description(self):
+        return _("clears the currently selected clipboard")
 
     def run(self):
-        self.env['runtime']['memoryManager'].clearCurrentIndexList('clipboardHistory')
-        self.env['runtime']['outputManager'].presentText(_('clipboard cleared'), interrupt=True)
-        return                
-    def setCallback(self, callback):
+        self.env["runtime"]["MemoryManager"].clear_current_index_list(
+            "clipboardHistory"
+        )
+        self.env["runtime"]["OutputManager"].present_text(
+            _("clipboard cleared"), interrupt=True
+        )
+        return
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/clear_window_application.py

@@ -2,25 +2,40 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('Turn off window mode for application')
-    
-    def run(self):
-        if self.env['runtime']['cursorManager'].clearWindowForApplication():
-            currApp = self.env['runtime']['applicationManager'].getCurrentApplication()    
-            self.env['runtime']['outputManager'].presentText(_('Window Mode off for application {0}').format(currApp,), interrupt=True)
-        else:
-            self.env['runtime']['outputManager'].presentText(_("Not in window Mode"), interrupt=True)
-        
-    def setCallback(self, callback):
+        pass
+
+    def get_description(self):
+        return _("Turn off window mode for application")
+
+    def run(self):
+        if self.env["runtime"]["CursorManager"].clear_window_for_application():
+            curr_app = self.env["runtime"][
+                "ApplicationManager"
+            ].get_current_application()
+            self.env["runtime"]["OutputManager"].present_text(
+                _("Window Mode off for application {0}").format(
+                    curr_app,
+                ),
+                interrupt=True,
+            )
+        else:
+            self.env["runtime"]["OutputManager"].present_text(
+                _("Not in window Mode"), interrupt=True
+            )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/copy_last_echo_to_clipboard.py

@@ -2,26 +2,35 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
+from fenrirscreenreader.core.i18n import _
 from fenrirscreenreader.utils import mark_utils
 
-class command():
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('copies last presented text to the clipboard')    
-    
-    def run(self):
-        lastEcho = self.env['runtime']['outputManager'].getLastEcho()
-        if lastEcho.rstrip() != "":
-            lastEcho = lastEcho.rstrip()
-        self.env['runtime']['memoryManager'].addValueToFirstIndex('clipboardHistory', lastEcho)
-        self.env['runtime']['outputManager'].presentText(lastEcho, soundIcon='CopyToClipboard', interrupt=True)
 
-    def setCallback(self, callback):
+    def shutdown(self):
+        pass
+
+    def get_description(self):
+        return _("copies last presented text to the clipboard")
+
+    def run(self):
+        last_echo = self.env["runtime"]["OutputManager"].get_last_echo()
+        if last_echo.rstrip() != "":
+            last_echo = last_echo.rstrip()
+        self.env["runtime"]["MemoryManager"].add_value_to_first_index(
+            "clipboardHistory", last_echo
+        )
+        self.env["runtime"]["OutputManager"].present_text(
+            last_echo, sound_icon="CopyToClipboard", interrupt=True
+        )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/copy_marked_to_clipboard.py

@@ -2,72 +2,81 @@
 # -*- coding: utf-8 -*-
 
 
+from fenrirscreenreader.core.i18n import _
 from fenrirscreenreader.utils import mark_utils
-class command():
+
+
+class command:
     def __init__(self):
         pass
-        
+
     def initialize(self, environment):
         self.env = environment
-        
+
     def shutdown(self):
-        pass 
-        
-    def getDescription(self):
-        return _('copies marked text to the currently selected clipboard')    
-    
-    def getTextFromScreen(self, startMark, endMark):
-        screenContent = self.env['screen']['newContentText']
-        screenLines = screenContent.split('\n')
-        
-        startY = min(startMark['y'], len(screenLines) - 1)
-        endY = min(endMark['y'], len(screenLines) - 1)
-        
+        pass
+
+    def get_description(self):
+        return _("copies marked text to the currently selected clipboard")
+
+    def get_text_from_screen(self, start_mark, end_mark):
+        screen_content = self.env["screen"]["new_content_text"]
+        screen_lines = screen_content.split("\n")
+
+        start_y = min(start_mark["y"], len(screen_lines) - 1)
+        end_y = min(end_mark["y"], len(screen_lines) - 1)
+
         # If marks are on the same line
-        if startY == endY:
-            line = screenLines[startY]
-            startX = min(startMark['x'], len(line))
-            endX = min(endMark['x'], len(line)) + 1
-            return line[startX:endX]
-            
+        if start_y == end_y:
+            line = screen_lines[start_y]
+            start_x = min(start_mark["x"], len(line))
+            end_x = min(end_mark["x"], len(line)) + 1
+            return line[start_x:end_x]
+
         # Handle multi-line selection
         result = []
-        
+
         # First line (from start mark to end of line)
-        firstLine = screenLines[startY]
-        startX = min(startMark['x'], len(firstLine))
-        result.append(firstLine[startX:].rstrip())
-        
+        first_line = screen_lines[start_y]
+        start_x = min(start_mark["x"], len(first_line))
+        result.append(first_line[start_x:].rstrip())
+
         # Middle lines (complete lines)
-        for lineNum in range(startY + 1, endY):
-            result.append(screenLines[lineNum].rstrip())
-            
+        for lineNum in range(start_y + 1, end_y):
+            result.append(screen_lines[lineNum].rstrip())
+
         # Last line (from start to end mark)
-        if endY > startY:
-            lastLine = screenLines[endY]
-            endX = min(endMark['x'], len(lastLine)) + 1
-            result.append(lastLine[:endX].rstrip())
-            
-        return '\n'.join(result)
-    
+        if end_y > start_y:
+            last_line = screen_lines[end_y]
+            end_x = min(end_mark["x"], len(last_line)) + 1
+            result.append(last_line[:end_x].rstrip())
+
+        return "\n".join(result)
+
     def run(self):
-        if not self.env['commandBuffer']['Marks']['1']:
-            self.env['runtime']['outputManager'].presentText(_("One or two marks are needed"), interrupt=True)
+        if not self.env["commandBuffer"]["Marks"]["1"]:
+            self.env["runtime"]["OutputManager"].present_text(
+                _("One or two marks are needed"), interrupt=True
+            )
             return
-        if not self.env['commandBuffer']['Marks']['2']:
-            self.env['runtime']['cursorManager'].setMark()
-            
+        if not self.env["commandBuffer"]["Marks"]["2"]:
+            self.env["runtime"]["CursorManager"].set_mark()
+
         # use the last first and the last setted mark as range
-        startMark = self.env['commandBuffer']['Marks']['1'].copy()
-        endMark = self.env['commandBuffer']['Marks']['2'].copy()         
-        
-        # Replace mark_utils.getTextBetweenMarks with our new method
-        marked = self.getTextFromScreen(startMark, endMark)
-        
-        self.env['runtime']['memoryManager'].addValueToFirstIndex('clipboardHistory', marked)
+        start_mark = self.env["commandBuffer"]["Marks"]["1"].copy()
+        end_mark = self.env["commandBuffer"]["Marks"]["2"].copy()
+
+        # Replace mark_utils.get_text_between_marks with our new method
+        marked = self.get_text_from_screen(start_mark, end_mark)
+
+        self.env["runtime"]["MemoryManager"].add_value_to_first_index(
+            "clipboardHistory", marked
+        )
         # reset marks
-        self.env['runtime']['cursorManager'].clearMarks()      
-        self.env['runtime']['outputManager'].presentText(marked, soundIcon='CopyToClipboard', interrupt=True)
-        
-    def setCallback(self, callback):
+        self.env["runtime"]["CursorManager"].clear_marks()
+        self.env["runtime"]["OutputManager"].present_text(
+            marked, sound_icon="CopyToClipboard", interrupt=True
+        )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/curr_clipboard.py

@@ -2,25 +2,39 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('speaks the contents of the currently selected clipboard')       
+        pass
+
+    def get_description(self):
+        return _("speaks the contents of the currently selected clipboard")
 
     def run(self):
-        if self.env['runtime']['memoryManager'].isIndexListEmpty('clipboardHistory'):
-            self.env['runtime']['outputManager'].presentText(_('clipboard empty'), interrupt=True)
-            return 
-        clipboard = self.env['runtime']['memoryManager'].getIndexListElement('clipboardHistory')
-        self.env['runtime']['outputManager'].presentText(clipboard , interrupt=True)
-               
-    def setCallback(self, callback):
+        if self.env["runtime"]["MemoryManager"].is_index_list_empty(
+            "clipboardHistory"
+        ):
+            self.env["runtime"]["OutputManager"].present_text(
+                _("clipboard empty"), interrupt=True
+            )
+            return
+        clipboard = self.env["runtime"][
+            "MemoryManager"
+        ].get_index_list_element("clipboardHistory")
+        self.env["runtime"]["OutputManager"].present_text(
+            clipboard, interrupt=True
+        )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/curr_screen.py

@@ -2,24 +2,34 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('reads the contents of the current screen')        
+        pass
+
+    def get_description(self):
+        return _("reads the contents of the current screen")
 
     def run(self):
-        if self.env['screen']['newContentText'].isspace():
-            self.env['runtime']['outputManager'].presentText(_("screen is empty"), soundIcon='EmptyLine', interrupt=True)
-        else:    
-           self.env['runtime']['outputManager'].presentText(self.env['screen']['newContentText'],interrupt=True)
- 
-    def setCallback(self, callback):
+        if self.env["screen"]["new_content_text"].isspace():
+            self.env["runtime"]["OutputManager"].present_text(
+                _("screen is empty"), sound_icon="EmptyLine", interrupt=True
+            )
+        else:
+            self.env["runtime"]["OutputManager"].present_text(
+                self.env["screen"]["new_content_text"], interrupt=True
+            )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/curr_screen_after_cursor.py

@@ -2,30 +2,43 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
+from fenrirscreenreader.core.i18n import _
 from fenrirscreenreader.utils import mark_utils
 
-class command():
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('reads from the cursor to the bottom of the screen')        
+        pass
+
+    def get_description(self):
+        return _("reads from the cursor to the bottom of the screen")
 
     def run(self):
         # Prefer review cursor over text cursor
-        cursorPos = self.env['runtime']['cursorManager'].getReviewOrTextCursor()
+        cursor_pos = self.env["runtime"][
+            "CursorManager"
+        ].get_review_or_text_cursor()
 
-        textAfterCursor = mark_utils.getTextAfterMark(cursorPos, self.env['screen']['newContentText'])
+        text_after_cursor = mark_utils.get_text_after_mark(
+            cursor_pos, self.env["screen"]["new_content_text"]
+        )
 
-        if textAfterCursor.isspace():
-            self.env['runtime']['outputManager'].presentText(_("blank"), soundIcon='EmptyLine', interrupt=True)
+        if text_after_cursor.isspace():
+            self.env["runtime"]["OutputManager"].present_text(
+                _("blank"), sound_icon="EmptyLine", interrupt=True
+            )
         else:
-            self.env['runtime']['outputManager'].presentText(textAfterCursor, interrupt=True)
+            self.env["runtime"]["OutputManager"].present_text(
+                text_after_cursor, interrupt=True
+            )
 
-    def setCallback(self, callback):
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/curr_screen_before_cursor.py

@@ -2,34 +2,44 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
+from fenrirscreenreader.core.i18n import _
 from fenrirscreenreader.utils import mark_utils
 
-class command():
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('Reads from the top of the screen to the cursor position')        
+        pass
+
+    def get_description(self):
+        return _("Reads from the top of the screen to the cursor position")
 
     def run(self):
         # Prefer review cursor over text cursor
-        if self.env['screen']['newCursorReview']:
-            cursorPos = self.env['screen']['newCursorReview'].copy()
+        if self.env["screen"]["newCursorReview"]:
+            cursor_pos = self.env["screen"]["newCursorReview"].copy()
         else:
-            cursorPos = self.env['screen']['newCursor'].copy()
+            cursor_pos = self.env["screen"]["new_cursor"].copy()
 
-        textBeforeCursor = mark_utils.getTextBeforeMark(cursorPos, self.env['screen']['newContentText'])
+        text_before_cursor = mark_utils.get_text_before_mark(
+            cursor_pos, self.env["screen"]["new_content_text"]
+        )
 
-        if textBeforeCursor.isspace():
-            self.env['runtime']['outputManager'].presentText(_("blank"), soundIcon='EmptyLine', interrupt=True)
+        if text_before_cursor.isspace():
+            self.env["runtime"]["OutputManager"].present_text(
+                _("blank"), sound_icon="EmptyLine", interrupt=True
+            )
         else:
-            self.env['runtime']['outputManager'].presentText(textBeforeCursor, interrupt=True)
-   
-    def setCallback(self, callback):
+            self.env["runtime"]["OutputManager"].present_text(
+                text_before_cursor, interrupt=True
+            )
+
+    def set_callback(self, callback):
         pass
-

src/fenrirscreenreader/commands/commands/current_quick_menu_entry.py

@@ -2,24 +2,34 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('get current quick menu entry')
-    def run(self):
-        menu = ''
-        value = ''
-        menu = self.env['runtime']['quickMenuManager'].getCurrentEntry()
-        if menu != '':
-            value = self.env['runtime']['quickMenuManager'].getCurrentValue()
-            self.env['runtime']['outputManager'].presentText(menu + ' ' + value, interrupt=True)
-    def setCallback(self, callback):
+        pass
+
+    def get_description(self):
+        return _("get current quick menu entry")
+
+    def run(self):
+        menu = ""
+        value = ""
+        menu = self.env["runtime"]["QuickMenuManager"].get_current_entry()
+        if menu != "":
+            value = self.env["runtime"]["QuickMenuManager"].get_current_value()
+            self.env["runtime"]["OutputManager"].present_text(
+                menu + " " + value, interrupt=True
+            )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/current_quick_menu_value.py

@@ -2,20 +2,30 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('get current quick menu value')
-    def run(self):
-        value = self.env['runtime']['quickMenuManager'].getCurrentValue()
-        self.env['runtime']['outputManager'].presentText(value, interrupt=True)
-    def setCallback(self, callback):
+        pass
+
+    def get_description(self):
+        return _("get current quick menu value")
+
+    def run(self):
+        value = self.env["runtime"]["QuickMenuManager"].get_current_value()
+        self.env["runtime"]["OutputManager"].present_text(
+            value, interrupt=True
+        )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/cursor_column.py

@@ -2,23 +2,36 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
         pass
-    def getDescription(self):
-        return _('Column number for cursor')       
+
+    def get_description(self):
+        return _("Column number for cursor")
+
     def run(self):
-        cursorPos = self.env['runtime']['cursorManager'].getReviewOrTextCursor()
-        self.env['runtime']['outputManager'].presentText(str(cursorPos['x'] + 1) , interrupt=True)
-        self.env['runtime']['outputManager'].announceActiveCursor()
-        self.env['runtime']['outputManager'].presentText(' column number' , interrupt=False)
-        
-    def setCallback(self, callback):
+        cursor_pos = self.env["runtime"][
+            "CursorManager"
+        ].get_review_or_text_cursor()
+        self.env["runtime"]["OutputManager"].present_text(
+            str(cursor_pos["x"] + 1), interrupt=True
+        )
+        self.env["runtime"]["OutputManager"].announce_active_cursor()
+        self.env["runtime"]["OutputManager"].present_text(
+            " column number", interrupt=False
+        )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/cursor_lineno.py

@@ -2,23 +2,36 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
         pass
-    def getDescription(self):
-        return _('Line number for cursor')         
+
+    def get_description(self):
+        return _("Line number for cursor")
+
     def run(self):
-        cursorPos = self.env['runtime']['cursorManager'].getReviewOrTextCursor()
-        self.env['runtime']['outputManager'].presentText(str(cursorPos['y'] + 1), interrupt=True)
-        self.env['runtime']['outputManager'].announceActiveCursor()
-        self.env['runtime']['outputManager'].presentText(' line number' , interrupt=False)
-        
-    def setCallback(self, callback):
+        cursor_pos = self.env["runtime"][
+            "CursorManager"
+        ].get_review_or_text_cursor()
+        self.env["runtime"]["OutputManager"].present_text(
+            str(cursor_pos["y"] + 1), interrupt=True
+        )
+        self.env["runtime"]["OutputManager"].announce_active_cursor()
+        self.env["runtime"]["OutputManager"].present_text(
+            " line number", interrupt=False
+        )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/cursor_position.py

@@ -2,24 +2,39 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('displays the position of the review cursor')        
+        pass
+
+    def get_description(self):
+        return _("displays the position of the review cursor")
 
     def run(self):
         # Prefer review cursor over text cursor
-        cursorPos = self.env['runtime']['cursorManager'].getReviewOrTextCursor()
+        cursor_pos = self.env["runtime"][
+            "CursorManager"
+        ].get_review_or_text_cursor()
 
-        self.env['runtime']['outputManager'].presentText(_("line {0}, column {1}, Terminal {2}").format(cursorPos['y']+1, cursorPos['x']+1, self.env['screen']['newTTY']), interrupt=True)
-   
-    def setCallback(self, callback):
+        self.env["runtime"]["OutputManager"].present_text(
+            _("line {0}, column {1}, Terminal {2}").format(
+                cursor_pos["y"] + 1,
+                cursor_pos["x"] + 1,
+                self.env["screen"]["newTTY"],
+            ),
+            interrupt=True,
+        )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/cursor_read_line_to_cursor.py

@@ -2,31 +2,48 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
+from fenrirscreenreader.core.i18n import _
 from fenrirscreenreader.utils import line_utils
 
-class command():
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('read line to cursor pos, use review cursor if you are in review mode, otherwhise use text cursor')
-    
-    def run(self):
-        cursorPos = self.env['runtime']['cursorManager'].getReviewOrTextCursor()
 
-        x, y, currLine = \
-          line_utils.getCurrentLine(cursorPos['x'], cursorPos['y'], self.env['screen']['newContentText'])
-        
-        if currLine.isspace():
-            self.env['runtime']['outputManager'].presentText(_("blank"), soundIcon='EmptyLine', interrupt=True)
-        else:
-            self.env['runtime']['outputManager'].presentText(currLine[:cursorPos['x']], interrupt=True) 
-        self.env['runtime']['outputManager'].announceActiveCursor()
-    def setCallback(self, callback):
+    def shutdown(self):
         pass
 
+    def get_description(self):
+        return _(
+            "read line to cursor pos, use review cursor if you are in review mode, "
+            "otherwhise use text cursor"
+        )
+
+    def run(self):
+        cursor_pos = self.env["runtime"][
+            "CursorManager"
+        ].get_review_or_text_cursor()
+
+        x, y, curr_line = line_utils.get_current_line(
+            cursor_pos["x"],
+            cursor_pos["y"],
+            self.env["screen"]["new_content_text"],
+        )
+
+        if curr_line.isspace():
+            self.env["runtime"]["OutputManager"].present_text(
+                _("blank"), sound_icon="EmptyLine", interrupt=True
+            )
+        else:
+            self.env["runtime"]["OutputManager"].present_text(
+                curr_line[: cursor_pos["x"]], interrupt=True
+            )
+        self.env["runtime"]["OutputManager"].announce_active_cursor()
+
+    def set_callback(self, callback):
+        pass

src/fenrirscreenreader/commands/commands/cursor_read_to_end_of_line.py

@@ -2,31 +2,48 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
+from fenrirscreenreader.core.i18n import _
 from fenrirscreenreader.utils import line_utils
 
-class command():
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('read to end of line, use review cursor if you are in review mode, otherwhise use text cursor')        
-    
-    def run(self):
-        cursorPos = self.env['runtime']['cursorManager'].getReviewOrTextCursor()
 
-        x, y, currLine = \
-          line_utils.getCurrentLine(cursorPos['x'], cursorPos['y'], self.env['screen']['newContentText'])
-        
-        if currLine.isspace():
-            self.env['runtime']['outputManager'].presentText(_("blank"), soundIcon='EmptyLine', interrupt=True)
-        else:
-            self.env['runtime']['outputManager'].presentText(currLine[cursorPos['x']:], interrupt=True) 
-        self.env['runtime']['outputManager'].announceActiveCursor()
-    def setCallback(self, callback):
+    def shutdown(self):
         pass
 
+    def get_description(self):
+        return _(
+            "read to end of line, use review cursor if you are in review mode, "
+            "otherwhise use text cursor"
+        )
+
+    def run(self):
+        cursor_pos = self.env["runtime"][
+            "CursorManager"
+        ].get_review_or_text_cursor()
+
+        x, y, curr_line = line_utils.get_current_line(
+            cursor_pos["x"],
+            cursor_pos["y"],
+            self.env["screen"]["new_content_text"],
+        )
+
+        if curr_line.isspace():
+            self.env["runtime"]["OutputManager"].present_text(
+                _("blank"), sound_icon="EmptyLine", interrupt=True
+            )
+        else:
+            self.env["runtime"]["OutputManager"].present_text(
+                curr_line[cursor_pos["x"] :], interrupt=True
+            )
+        self.env["runtime"]["OutputManager"].announce_active_cursor()
+
+    def set_callback(self, callback):
+        pass

src/fenrirscreenreader/commands/commands/cycle_keyboard_layout.py

@@ -2,60 +2,75 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
 import os
 
-class command():
+from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('cycles between available keyboard layouts')
-    
-    def getAvailableLayouts(self):
+        pass
+
+    def get_description(self):
+        return _("cycles between available keyboard layouts")
+
+    def get_available_layouts(self):
         """Get list of available keyboard layout files"""
         layouts = []
-        
+
         # Check standard locations for keyboard layouts
-        settingsRoot = '/etc/fenrirscreenreader/'
-        if not os.path.exists(settingsRoot):
+        settings_root = "/etc/fenrirscreenreader/"
+        if not os.path.exists(settings_root):
             # Fallback to source directory
             import fenrirscreenreader
-            fenrirPath = os.path.dirname(fenrirscreenreader.__file__)
-            settingsRoot = fenrirPath + '/../../config/'
-        
-        keyboardPath = settingsRoot + 'keyboard/'
-        
-        if os.path.exists(keyboardPath):
-            for file in os.listdir(keyboardPath):
-                if file.endswith('.conf') and not file.startswith('__') and not file.lower().startswith('pty'):
-                    layout_name = file.replace('.conf', '')
+
+            fenrir_path = os.path.dirname(fenrirscreenreader.__file__)
+            settings_root = fenrir_path + "/../../config/"
+
+        keyboard_path = settings_root + "keyboard/"
+
+        if os.path.exists(keyboard_path):
+            for file in os.listdir(keyboard_path):
+                if (
+                    file.endswith(".conf")
+                    and not file.startswith("__")
+                    and not file.lower().startswith("pty")
+                ):
+                    layout_name = file.replace(".conf", "")
                     if layout_name not in layouts:
                         layouts.append(layout_name)
-        
+
         # Ensure we have at least basic layouts
         if not layouts:
-            layouts = ['desktop', 'laptop']
+            layouts = ["desktop", "laptop"]
         else:
             layouts.sort()
-            
+
         return layouts
-    
+
     def run(self):
-        current_layout = self.env['runtime']['settingsManager'].getSetting('keyboard', 'keyboardLayout')
-        
+        current_layout = self.env["runtime"]["SettingsManager"].get_setting(
+            "keyboard", "keyboardLayout"
+        )
+
         # Extract layout name from full path if needed
-        if '/' in current_layout:
-            current_layout = os.path.basename(current_layout).replace('.conf', '')
-            
+        if "/" in current_layout:
+            current_layout = os.path.basename(current_layout).replace(
+                ".conf", ""
+            )
+
         # Get available layouts
-        available_layouts = self.getAvailableLayouts()
-        
+        available_layouts = self.get_available_layouts()
+
         # Find next layout in cycle
         try:
             current_index = available_layouts.index(current_layout)
@@ -63,28 +78,28 @@ class command():
         except ValueError:
             # If current layout not found, start from beginning
             next_index = 0
-            
+
         next_layout = available_layouts[next_index]
-        
+
         # Update setting and reload shortcuts
-        self.env['runtime']['settingsManager'].setSetting('keyboard', 'keyboardLayout', next_layout)
-        
+        self.env["runtime"]["SettingsManager"].set_setting(
+            "keyboard", "keyboardLayout", next_layout
+        )
+
         # Reload shortcuts with new layout
         try:
-            self.env['runtime']['inputManager'].reloadShortcuts()
-            self.env['runtime']['outputManager'].presentText(
-                _('Switched to {} keyboard layout').format(next_layout), 
-                interrupt=True
+            self.env["runtime"]["InputManager"].reload_shortcuts()
+            self.env["runtime"]["OutputManager"].present_text(
+                _("Switched to {} keyboard layout").format(next_layout),
+                interrupt=True,
             )
         except Exception as e:
-            self.env['runtime']['debug'].writeDebugOut(
-                "Error reloading shortcuts: " + str(e), 
-                debug.debugLevel.ERROR
+            self.env["runtime"]["DebugManager"].write_debug_out(
+                "Error reloading shortcuts: " + str(e), debug.DebugLevel.ERROR
             )
-            self.env['runtime']['outputManager'].presentText(
-                _('Error switching keyboard layout'), 
-                interrupt=True
+            self.env["runtime"]["OutputManager"].present_text(
+                _("Error switching keyboard layout"), interrupt=True
             )
 
-    def setCallback(self, callback):
-        pass
+    def set_callback(self, callback):
+        pass

src/fenrirscreenreader/commands/commands/date.py

@@ -2,28 +2,41 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
 import datetime
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('presents the date')        
-    
+        pass
+
+    def get_description(self):
+        return _("presents the date")
+
     def run(self):
-        dateFormat = self.env['runtime']['settingsManager'].getSetting('general', 'dateFormat')
+        date_format = self.env["runtime"]["SettingsManager"].get_setting(
+            "general", "date_format"
+        )
 
         # get the time formatted
-        dateString = datetime.datetime.strftime(datetime.datetime.now(), dateFormat)
+        date_string = datetime.datetime.strftime(
+            datetime.datetime.now(), date_format
+        )
 
-        # present the time via speak and braile, there is no soundicon, interrupt the current speech
-        self.env['runtime']['outputManager'].presentText(dateString , soundIcon='', interrupt=True)
+        # present the time via speak and braile, there is no soundicon,
+        # interrupt the current speech
+        self.env["runtime"]["OutputManager"].present_text(
+            date_string, sound_icon="", interrupt=True
+        )
 
-    def setCallback(self, callback):
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/dec_alsa_volume.py

@@ -2,16 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-import os
 import importlib.util
-_base_path = os.path.join(os.path.dirname(__file__), 'adjustment_base.py')
+import os
+
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "adjustment_base.py")
 _spec = importlib.util.spec_from_file_location("adjustment_base", _base_path)
 _module = importlib.util.module_from_spec(_spec)
 _spec.loader.exec_module(_module)
-AdjustmentCommand = _module.AdjustmentCommand
+adjustment_command = _module.adjustment_command
 
-class command(AdjustmentCommand):
+
+class command(adjustment_command):
     def __init__(self):
-        super().__init__('alsa', 'volume', 'dec')
+        super().__init__("alsa", "volume", "dec")

src/fenrirscreenreader/commands/commands/dec_sound_volume.py

@@ -2,16 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-import os
 import importlib.util
-_base_path = os.path.join(os.path.dirname(__file__), 'adjustment_base.py')
+import os
+
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "adjustment_base.py")
 _spec = importlib.util.spec_from_file_location("adjustment_base", _base_path)
 _module = importlib.util.module_from_spec(_spec)
 _spec.loader.exec_module(_module)
-AdjustmentCommand = _module.AdjustmentCommand
+adjustment_command = _module.adjustment_command
 
-class command(AdjustmentCommand):
+
+class command(adjustment_command):
     def __init__(self):
-        super().__init__('sound', 'volume', 'dec')
+        super().__init__("sound", "volume", "dec")

src/fenrirscreenreader/commands/commands/dec_speech_pitch.py

@@ -2,16 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-import os
 import importlib.util
-_base_path = os.path.join(os.path.dirname(__file__), 'adjustment_base.py')
+import os
+
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "adjustment_base.py")
 _spec = importlib.util.spec_from_file_location("adjustment_base", _base_path)
 _module = importlib.util.module_from_spec(_spec)
 _spec.loader.exec_module(_module)
-AdjustmentCommand = _module.AdjustmentCommand
+adjustment_command = _module.adjustment_command
 
-class command(AdjustmentCommand):
+
+class command(adjustment_command):
     def __init__(self):
-        super().__init__('speech', 'pitch', 'dec')
+        super().__init__("speech", "pitch", "dec")

src/fenrirscreenreader/commands/commands/dec_speech_rate.py

@@ -2,16 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-import os
 import importlib.util
-_base_path = os.path.join(os.path.dirname(__file__), 'adjustment_base.py')
+import os
+
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "adjustment_base.py")
 _spec = importlib.util.spec_from_file_location("adjustment_base", _base_path)
 _module = importlib.util.module_from_spec(_spec)
 _spec.loader.exec_module(_module)
-AdjustmentCommand = _module.AdjustmentCommand
+adjustment_command = _module.adjustment_command
 
-class command(AdjustmentCommand):
+
+class command(adjustment_command):
     def __init__(self):
-        super().__init__('speech', 'rate', 'dec')
+        super().__init__("speech", "rate", "dec")

src/fenrirscreenreader/commands/commands/dec_speech_volume.py

@@ -2,16 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-import os
 import importlib.util
-_base_path = os.path.join(os.path.dirname(__file__), 'adjustment_base.py')
+import os
+
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "adjustment_base.py")
 _spec = importlib.util.spec_from_file_location("adjustment_base", _base_path)
 _module = importlib.util.module_from_spec(_spec)
 _spec.loader.exec_module(_module)
-AdjustmentCommand = _module.AdjustmentCommand
+adjustment_command = _module.adjustment_command
 
-class command(AdjustmentCommand):
+
+class command(adjustment_command):
     def __init__(self):
-        super().__init__('speech', 'volume', 'dec')
+        super().__init__("speech", "volume", "dec")

src/fenrirscreenreader/commands/commands/exit_review.py

@@ -2,26 +2,36 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('exits review mode')        
-    
-    def run(self):
-        if not self.env['runtime']['cursorManager'].isReviewMode():
-            self.env['runtime']['outputManager'].presentText(_("Not in Review Mode"), interrupt=True)
-            return  
 
-        self.env['runtime']['cursorManager'].clearReviewCursor()
-        self.env['runtime']['outputManager'].presentText(_("Exiting Review Mode"), interrupt=True)
-   
-    def setCallback(self, callback):
+    def shutdown(self):
+        pass
+
+    def get_description(self):
+        return _("exits review mode")
+
+    def run(self):
+        if not self.env["runtime"]["CursorManager"].is_review_mode():
+            self.env["runtime"]["OutputManager"].present_text(
+                _("Not in Review Mode"), interrupt=True
+            )
+            return
+
+        self.env["runtime"]["CursorManager"].clear_review_cursor()
+        self.env["runtime"]["OutputManager"].present_text(
+            _("Exiting Review Mode"), interrupt=True
+        )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/export_clipboard_to_file.py

@@ -2,38 +2,66 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
 import os
 
-class command():
+from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
-    def initialize(self, environment, scriptPath=''):
+
+    def initialize(self, environment, script_path=""):
         self.env = environment
 
     def shutdown(self):
         pass
-    def getDescription(self):
-        return _('export the current fenrir clipboard to a file')
-    def run(self):  
-        clipboardFilePath = self.env['runtime']['settingsManager'].getSetting('general', 'clipboardExportPath')
-        clipboardFilePath = clipboardFilePath.replace('$user',self.env['general']['currUser'])        
-        clipboardFilePath = clipboardFilePath.replace('$USER',self.env['general']['currUser'])        
-        clipboardFilePath = clipboardFilePath.replace('$User',self.env['general']['currUser'])                        
-        clipboardFile = open(clipboardFilePath,'w')        
+
+    def get_description(self):
+        return _("export the current fenrir clipboard to a file")
+
+    def run(self):
+        clipboard_file_path = self.env["runtime"][
+            "SettingsManager"
+        ].get_setting("general", "clipboardExportPath")
+        clipboard_file_path = clipboard_file_path.replace(
+            "$user", self.env["general"]["curr_user"]
+        )
+        clipboard_file_path = clipboard_file_path.replace(
+            "$USER", self.env["general"]["curr_user"]
+        )
+        clipboard_file_path = clipboard_file_path.replace(
+            "$User", self.env["general"]["curr_user"]
+        )
+        clipboard_file = open(clipboard_file_path, "w")
         try:
-            if self.env['runtime']['memoryManager'].isIndexListEmpty('clipboardHistory'):
-                self.env['runtime']['outputManager'].presentText(_('clipboard empty'), interrupt=True)
-                return 
-            clipboard = self.env['runtime']['memoryManager'].getIndexListElement('clipboardHistory')                             
-            clipboardFile.write(clipboard)
-            clipboardFile.close()
-            os.chmod(clipboardFilePath, 0o666)
-            self.env['runtime']['outputManager'].presentText(_('clipboard exported to file'), interrupt=True)            
+            if self.env["runtime"]["MemoryManager"].is_index_list_empty(
+                "clipboardHistory"
+            ):
+                self.env["runtime"]["OutputManager"].present_text(
+                    _("clipboard empty"), interrupt=True
+                )
+                return
+            clipboard = self.env["runtime"][
+                "MemoryManager"
+            ].get_index_list_element("clipboardHistory")
+            clipboard_file.write(clipboard)
+            clipboard_file.close()
+            os.chmod(clipboard_file_path, 0o644)
+            self.env["runtime"]["OutputManager"].present_text(
+                _("clipboard exported to file"), interrupt=True
+            )
         except Exception as e:
-            self.env['runtime']['debug'].writeDebugOut('export_clipboard_to_file:run: Filepath:'+ clipboardFile +' trace:' + str(e),debug.debugLevel.ERROR)                                
-        
-    def setCallback(self, callback):
+            self.env["runtime"]["DebugManager"].write_debug_out(
+                "export_clipboard_to_file:run: Filepath:"
+                + clipboard_file
+                + " trace:"
+                + str(e),
+                debug.DebugLevel.ERROR,
+            )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/export_clipboard_to_x.py

@@ -2,69 +2,96 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-import os
-import importlib
 import _thread
+import importlib
+import os
+
 import pyperclip
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
-    def initialize(self, environment, scriptPath=''):
+
+    def initialize(self, environment, script_path=""):
         self.env = environment
-        self.scriptPath = scriptPath
+        self.script_path = script_path
+
     def shutdown(self):
         pass
-    def getDescription(self):
-        return _('Export current fenrir clipboard to X or GUI clipboard')
-    def run(self):                       
-       _thread.start_new_thread(self._threadRun , ())
-    def _threadRun(self):
+
+    def get_description(self):
+        return _("Export current fenrir clipboard to X or GUI clipboard")
+
+    def run(self):
+        _thread.start_new_thread(self._thread_run, ())
+
+    def _thread_run(self):
         try:
             # Check if clipboard is empty
-            if self.env['runtime']['memoryManager'].isIndexListEmpty('clipboardHistory'):
-                self.env['runtime']['outputManager'].presentText(_('clipboard empty'), interrupt=True)
+            if self.env["runtime"]["MemoryManager"].is_index_list_empty(
+                "clipboardHistory"
+            ):
+                self.env["runtime"]["OutputManager"].present_text(
+                    _("clipboard empty"), interrupt=True
+                )
                 return
-            
+
             # Get current clipboard content
-            clipboard = self.env['runtime']['memoryManager'].getIndexListElement('clipboardHistory')
-            
+            clipboard = self.env["runtime"][
+                "MemoryManager"
+            ].get_index_list_element("clipboardHistory")
+
             # Remember original display environment variable if it exists
-            originalDisplay = os.environ.get('DISPLAY', '')
+            original_display = os.environ.get("DISPLAY", "")
             success = False
-            
+
             # Try different display options
             for i in range(10):
                 display = f":{i}"
                 try:
                     # Set display environment variable
-                    os.environ['DISPLAY'] = display
+                    os.environ["DISPLAY"] = display
                     # Attempt to set clipboard content
-                    importlib.reload(pyperclip) # Weird workaround for some distros
+                    # Weird workaround for some distros
+                    importlib.reload(pyperclip)
                     pyperclip.copy(clipboard)
-                    # If we get here without exception, we found a working display
+                    # If we get here without exception, we found a working
+                    # display
                     success = True
                     break
                 except Exception:
                     # Failed for this display, try next one
                     continue
-            
+
             # Restore original display setting
-            if originalDisplay:
-                os.environ['DISPLAY'] = originalDisplay
+            if original_display:
+                os.environ["DISPLAY"] = original_display
             else:
-                os.environ.pop('DISPLAY', None)
-            
+                os.environ.pop("DISPLAY", None)
+
             # Notify the user of the result
             if success:
-                self.env['runtime']['outputManager'].presentText(_('exported to the X session.'), interrupt=True)
+                self.env["runtime"]["OutputManager"].present_text(
+                    _("exported to the X session."), interrupt=True
+                )
             else:
-                self.env['runtime']['outputManager'].presentText(_('failed to export to X clipboard. No available display found.'), interrupt=True)
-                
+                self.env["runtime"]["OutputManager"].present_text(
+                    _(
+                        "failed to export to X clipboard. No available display "
+                        "found."
+                    ),
+                    interrupt=True,
+                )
+
         except Exception as e:
-            self.env['runtime']['outputManager'].presentText(str(e), soundIcon='', interrupt=False)
-        
-    def setCallback(self, callback):
+            self.env["runtime"]["OutputManager"].present_text(
+                str(e), sound_icon="", interrupt=False
+            )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/first_clipboard.py

@@ -2,26 +2,42 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('selects the first clipboard')        
-    
-    def run(self):
-        if self.env['runtime']['memoryManager'].isIndexListEmpty('clipboardHistory'):
-            self.env['runtime']['outputManager'].presentText(_('clipboard empty'), interrupt=True)
-            return
-        self.env['runtime']['memoryManager'].setFirstIndex('clipboardHistory')     
-        clipboard = self.env['runtime']['memoryManager'].getIndexListElement('clipboardHistory')
-        self.env['runtime']['outputManager'].presentText(clipboard, interrupt=True)
-           
-    def setCallback(self, callback):
+        pass
+
+    def get_description(self):
+        return _("selects the first clipboard")
+
+    def run(self):
+        if self.env["runtime"]["MemoryManager"].is_index_list_empty(
+            "clipboardHistory"
+        ):
+            self.env["runtime"]["OutputManager"].present_text(
+                _("clipboard empty"), interrupt=True
+            )
+            return
+        self.env["runtime"]["MemoryManager"].set_first_index(
+            "clipboardHistory"
+        )
+        clipboard = self.env["runtime"][
+            "MemoryManager"
+        ].get_index_list_element("clipboardHistory")
+        self.env["runtime"]["OutputManager"].present_text(
+            clipboard, interrupt=True
+        )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/forward_keypress.py

@@ -2,22 +2,30 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('sends the following keypress to the terminal or application')        
-    
-    def run(self):
-        self.env['input']['keyForeward'] = 3
-        self.env['runtime']['outputManager'].presentText(_('Forward next keypress'), interrupt=True)
 
-    def setCallback(self, callback):
+    def shutdown(self):
+        pass
+
+    def get_description(self):
+        return _("sends the following keypress to the terminal or application")
+
+    def run(self):
+        self.env["input"]["keyForeward"] = 3
+        self.env["runtime"]["OutputManager"].present_text(
+            _("Forward next keypress"), interrupt=True
+        )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/import_clipboard_from_file.py

@@ -2,37 +2,58 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.utils import mark_utils
 import os
 
-class command():
+from fenrirscreenreader.core.i18n import _
+from fenrirscreenreader.utils import mark_utils
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('imports text from clipboard file to the clipboard')    
-    
-    def run(self):
-        clipboardFilePath = self.env['runtime']['settingsManager'].getSetting('general', 'clipboardExportPath')
-        clipboardFilePath = clipboardFilePath.replace('$user',self.env['general']['currUser'])        
-        clipboardFilePath = clipboardFilePath.replace('$USER',self.env['general']['currUser'])        
-        clipboardFilePath = clipboardFilePath.replace('$User',self.env['general']['currUser'])                        
-        if not os.path.exists(clipboardFilePath):
-            self.env['runtime']['outputManager'].presentText(_('File does not exist'), soundIcon='', interrupt=True)        
-            return
-        clipboardFile = open(clipboardFilePath,'r') 
-        imported = clipboardFile.read()
-        clipboardFile.close()
-        self.env['runtime']['memoryManager'].addValueToFirstIndex('clipboardHistory', imported)        
-
-        self.env['runtime']['outputManager'].presentText('Import to Clipboard', soundIcon='CopyToClipboard', interrupt=True)
-        self.env['runtime']['outputManager'].presentText(imported, soundIcon='', interrupt=False)        
-        
-
-    def setCallback(self, callback):
+        pass
+
+    def get_description(self):
+        return _("imports text from clipboard file to the clipboard")
+
+    def run(self):
+        clipboard_file_path = self.env["runtime"][
+            "SettingsManager"
+        ].get_setting("general", "clipboardExportPath")
+        clipboard_file_path = clipboard_file_path.replace(
+            "$user", self.env["general"]["curr_user"]
+        )
+        clipboard_file_path = clipboard_file_path.replace(
+            "$USER", self.env["general"]["curr_user"]
+        )
+        clipboard_file_path = clipboard_file_path.replace(
+            "$User", self.env["general"]["curr_user"]
+        )
+        if not os.path.exists(clipboard_file_path):
+            self.env["runtime"]["OutputManager"].present_text(
+                _("File does not exist"), sound_icon="", interrupt=True
+            )
+            return
+        clipboard_file = open(clipboard_file_path, "r")
+        imported = clipboard_file.read()
+        clipboard_file.close()
+        self.env["runtime"]["MemoryManager"].add_value_to_first_index(
+            "clipboardHistory", imported
+        )
+
+        self.env["runtime"]["OutputManager"].present_text(
+            "Import to Clipboard", sound_icon="CopyToClipboard", interrupt=True
+        )
+        self.env["runtime"]["OutputManager"].present_text(
+            imported, sound_icon="", interrupt=False
+        )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/import_clipboard_from_x.py

@@ -2,62 +2,86 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-import importlib
 import _thread
-import pyperclip
+import importlib
 import os
 
-class command():
+import pyperclip
+
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
-    def initialize(self, environment, scriptPath=''):
+
+    def initialize(self, environment, script_path=""):
         self.env = environment
-        self.scriptPath = scriptPath
+        self.script_path = script_path
+
     def shutdown(self):
         pass
-    def getDescription(self):
+
+    def get_description(self):
         return _("imports the graphical clipboard to Fenrir's clipboard")
-    def run(self):                       
-       _thread.start_new_thread(self._threadRun , ())
-    def _threadRun(self):
+
+    def run(self):
+        _thread.start_new_thread(self._thread_run, ())
+
+    def _thread_run(self):
         try:
             # Remember original display environment variable if it exists
-            originalDisplay = os.environ.get('DISPLAY', '')
-            clipboardContent = None
-            
+            original_display = os.environ.get("DISPLAY", "")
+            clipboard_content = None
+
             # Try different display options
             for i in range(10):
                 display = f":{i}"
                 try:
                     # Set display environment variable
-                    os.environ['DISPLAY'] = display
+                    os.environ["DISPLAY"] = display
                     # Attempt to get clipboard content
-                    importlib.reload(pyperclip) # Weird workaround for some distros
-                    clipboardContent = pyperclip.paste()
-                    # If we get here without exception, we found a working display
-                    if clipboardContent:
+                    # Weird workaround for some distros
+                    importlib.reload(pyperclip)
+                    clipboard_content = pyperclip.paste()
+                    # If we get here without exception, we found a working
+                    # display
+                    if clipboard_content:
                         break
                 except Exception:
                     # Failed for this display, try next one
                     continue
-            
+
             # Restore original display setting
-            if originalDisplay:
-                os.environ['DISPLAY'] = originalDisplay
+            if original_display:
+                os.environ["DISPLAY"] = original_display
             else:
-                os.environ.pop('DISPLAY', None)
-            
+                os.environ.pop("DISPLAY", None)
+
             # Process the clipboard content if we found any
-            if clipboardContent and isinstance(clipboardContent, str):
-                self.env['runtime']['memoryManager'].addValueToFirstIndex('clipboardHistory', clipboardContent)
-                self.env['runtime']['outputManager'].presentText('Import to Clipboard', soundIcon='CopyToClipboard', interrupt=True)
-                self.env['runtime']['outputManager'].presentText(clipboardContent, soundIcon='', interrupt=False)
+            if clipboard_content and isinstance(clipboard_content, str):
+                self.env["runtime"]["MemoryManager"].add_value_to_first_index(
+                    "clipboardHistory", clipboard_content
+                )
+                self.env["runtime"]["OutputManager"].present_text(
+                    "Import to Clipboard",
+                    sound_icon="CopyToClipboard",
+                    interrupt=True,
+                )
+                self.env["runtime"]["OutputManager"].present_text(
+                    clipboard_content, sound_icon="", interrupt=False
+                )
             else:
-                self.env['runtime']['outputManager'].presentText('No text found in clipboard or no accessible display', interrupt=True)
+                self.env["runtime"]["OutputManager"].present_text(
+                    "No text found in clipboard or no accessible display",
+                    interrupt=True,
+                )
         except Exception as e:
-            self.env['runtime']['outputManager'].presentText(str(e), soundIcon='', interrupt=False)
-        
-    def setCallback(self, callback):
+            self.env["runtime"]["OutputManager"].present_text(
+                str(e), sound_icon="", interrupt=False
+            )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/inc_alsa_volume.py

@@ -2,16 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-import os
 import importlib.util
-_base_path = os.path.join(os.path.dirname(__file__), 'adjustment_base.py')
+import os
+
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "adjustment_base.py")
 _spec = importlib.util.spec_from_file_location("adjustment_base", _base_path)
 _module = importlib.util.module_from_spec(_spec)
 _spec.loader.exec_module(_module)
-AdjustmentCommand = _module.AdjustmentCommand
+adjustment_command = _module.adjustment_command
 
-class command(AdjustmentCommand):
+
+class command(adjustment_command):
     def __init__(self):
-        super().__init__('alsa', 'volume', 'inc')
+        super().__init__("alsa", "volume", "inc")

src/fenrirscreenreader/commands/commands/inc_sound_volume.py

@@ -2,16 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-import os
 import importlib.util
-_base_path = os.path.join(os.path.dirname(__file__), 'adjustment_base.py')
+import os
+
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "adjustment_base.py")
 _spec = importlib.util.spec_from_file_location("adjustment_base", _base_path)
 _module = importlib.util.module_from_spec(_spec)
 _spec.loader.exec_module(_module)
-AdjustmentCommand = _module.AdjustmentCommand
+adjustment_command = _module.adjustment_command
 
-class command(AdjustmentCommand):
+
+class command(adjustment_command):
     def __init__(self):
-        super().__init__('sound', 'volume', 'inc')
+        super().__init__("sound", "volume", "inc")

src/fenrirscreenreader/commands/commands/inc_speech_pitch.py

@@ -2,16 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-import os
 import importlib.util
-_base_path = os.path.join(os.path.dirname(__file__), 'adjustment_base.py')
+import os
+
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "adjustment_base.py")
 _spec = importlib.util.spec_from_file_location("adjustment_base", _base_path)
 _module = importlib.util.module_from_spec(_spec)
 _spec.loader.exec_module(_module)
-AdjustmentCommand = _module.AdjustmentCommand
+adjustment_command = _module.adjustment_command
 
-class command(AdjustmentCommand):
+
+class command(adjustment_command):
     def __init__(self):
-        super().__init__('speech', 'pitch', 'inc')
+        super().__init__("speech", "pitch", "inc")

src/fenrirscreenreader/commands/commands/inc_speech_rate.py

@@ -2,16 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-import os
 import importlib.util
-_base_path = os.path.join(os.path.dirname(__file__), 'adjustment_base.py')
+import os
+
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "adjustment_base.py")
 _spec = importlib.util.spec_from_file_location("adjustment_base", _base_path)
 _module = importlib.util.module_from_spec(_spec)
 _spec.loader.exec_module(_module)
-AdjustmentCommand = _module.AdjustmentCommand
+adjustment_command = _module.adjustment_command
 
-class command(AdjustmentCommand):
+
+class command(adjustment_command):
     def __init__(self):
-        super().__init__('speech', 'rate', 'inc')
+        super().__init__("speech", "rate", "inc")

src/fenrirscreenreader/commands/commands/inc_speech_volume.py

@@ -2,16 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-import os
 import importlib.util
-_base_path = os.path.join(os.path.dirname(__file__), 'adjustment_base.py')
+import os
+
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "adjustment_base.py")
 _spec = importlib.util.spec_from_file_location("adjustment_base", _base_path)
 _module = importlib.util.module_from_spec(_spec)
 _spec.loader.exec_module(_module)
-AdjustmentCommand = _module.AdjustmentCommand
+adjustment_command = _module.adjustment_command
 
-class command(AdjustmentCommand):
+
+class command(adjustment_command):
     def __init__(self):
-        super().__init__('speech', 'volume', 'inc')
+        super().__init__("speech", "volume", "inc")

src/fenrirscreenreader/commands/commands/indent_curr_line.py

@@ -2,34 +2,49 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
+from fenrirscreenreader.core.i18n import _
 from fenrirscreenreader.utils import line_utils
 
-class command():
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('Presents the indentation level for the current line')        
+        pass
+
+    def get_description(self):
+        return _("Presents the indentation level for the current line")
 
     def run(self):
         # Prefer review cursor over text cursor
 
-        if self.env['screen']['newCursorReview']:
-            cursorPos = self.env['screen']['newCursorReview'].copy()
+        if self.env["screen"]["newCursorReview"]:
+            cursor_pos = self.env["screen"]["newCursorReview"].copy()
         else:
-            cursorPos = self.env['screen']['newCursor'].copy()
-        x, y, currLine = \
-          line_utils.getCurrentLine(cursorPos['x'], cursorPos['y'], self.env['screen']['newContentText'])
-        
-        if currLine.isspace():
-            self.env['runtime']['outputManager'].presentText(_("blank"), soundIcon='EmptyLine', interrupt=True)
-        else:        
-            self.env['runtime']['outputManager'].presentText(_("indent {0}").format(len(currLine) - len(currLine.lstrip())), interrupt=True)
+            cursor_pos = self.env["screen"]["new_cursor"].copy()
+        x, y, curr_line = line_utils.get_current_line(
+            cursor_pos["x"],
+            cursor_pos["y"],
+            self.env["screen"]["new_content_text"],
+        )
 
-    def setCallback(self, callback):
+        if curr_line.isspace():
+            self.env["runtime"]["OutputManager"].present_text(
+                _("blank"), sound_icon="EmptyLine", interrupt=True
+            )
+        else:
+            self.env["runtime"]["OutputManager"].present_text(
+                _("indent {0}").format(
+                    len(curr_line) - len(curr_line.lstrip())
+                ),
+                interrupt=True,
+            )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/last_clipboard.py

@@ -2,26 +2,40 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('selects the last clipboard')        
-    
-    def run(self):
-        if self.env['runtime']['memoryManager'].isIndexListEmpty('clipboardHistory'):
-            self.env['runtime']['outputManager'].presentText(_('clipboard empty'), interrupt=True)
-            return
-        self.env['runtime']['memoryManager'].setLastIndex('clipboardHistory')     
-        clipboard = self.env['runtime']['memoryManager'].getIndexListElement('clipboardHistory')
-        self.env['runtime']['outputManager'].presentText(clipboard, interrupt=True)
-            
-    def setCallback(self, callback):
+        pass
+
+    def get_description(self):
+        return _("selects the last clipboard")
+
+    def run(self):
+        if self.env["runtime"]["MemoryManager"].is_index_list_empty(
+            "clipboardHistory"
+        ):
+            self.env["runtime"]["OutputManager"].present_text(
+                _("clipboard empty"), interrupt=True
+            )
+            return
+        self.env["runtime"]["MemoryManager"].set_last_index("clipboardHistory")
+        clipboard = self.env["runtime"][
+            "MemoryManager"
+        ].get_index_list_element("clipboardHistory")
+        self.env["runtime"]["OutputManager"].present_text(
+            clipboard, interrupt=True
+        )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/marked_text.py

@@ -2,36 +2,54 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
+from fenrirscreenreader.core.i18n import _
 from fenrirscreenreader.utils import mark_utils
 
-class command():
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('Presents the currently selected text that will be copied to the clipboard')        
-    
+        pass
+
+    def get_description(self):
+        return _(
+            "Presents the currently selected text that will be copied to the "
+            "clipboard"
+        )
+
     def run(self):
-        if not (self.env['commandBuffer']['Marks']['1'] and \
-          self.env['commandBuffer']['Marks']['2']):
-            self.env['runtime']['outputManager'].presentText(_("please set begin and endmark"), interrupt=True)
+        if not (
+            self.env["commandBuffer"]["Marks"]["1"]
+            and self.env["commandBuffer"]["Marks"]["2"]
+        ):
+            self.env["runtime"]["OutputManager"].present_text(
+                _("please set begin and endmark"), interrupt=True
+            )
             return
 
         # use the last first and the last setted mark as range
-        startMark = self.env['commandBuffer']['Marks']['1'].copy()
-        endMark = self.env['commandBuffer']['Marks']['2'].copy() 
+        start_mark = self.env["commandBuffer"]["Marks"]["1"].copy()
+        end_mark = self.env["commandBuffer"]["Marks"]["2"].copy()
 
-        marked = mark_utils.getTextBetweenMarks(startMark, endMark, self.env['screen']['newContentText'])
+        marked = mark_utils.get_text_between_marks(
+            start_mark, end_mark, self.env["screen"]["new_content_text"]
+        )
 
         if marked.isspace():
-            self.env['runtime']['outputManager'].presentText(_("blank"), soundIcon='EmptyLine', interrupt=True)
+            self.env["runtime"]["OutputManager"].present_text(
+                _("blank"), sound_icon="EmptyLine", interrupt=True
+            )
         else:
-            self.env['runtime']['outputManager'].presentText(marked, interrupt=True)
-    
-    def setCallback(self, callback):
+            self.env["runtime"]["OutputManager"].present_text(
+                marked, interrupt=True
+            )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/next_clipboard.py

@@ -2,34 +2,56 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('selects the next clipboard')        
-    
-    def run(self):
-        if self.env['runtime']['memoryManager'].isIndexListEmpty('clipboardHistory'):
-            self.env['runtime']['outputManager'].presentText(_('clipboard empty'), interrupt=True)
-            return      
-        self.env['runtime']['memoryManager'].getNextIndex('clipboardHistory')               
-        isFirst = self.env['runtime']['memoryManager'].isFirstIndex('clipboardHistory')   
-        isLast = self.env['runtime']['memoryManager'].isLastIndex('clipboardHistory')               
-        clipboard = self.env['runtime']['memoryManager'].getIndexListElement('clipboardHistory')            
-        if isFirst:
-            self.env['runtime']['outputManager'].presentText(_('First clipboard '), interrupt=True)   
-        if isLast:
-            self.env['runtime']['outputManager'].presentText(_('Last clipboard '), interrupt=True)                     
-        
-        speechInterrupt = not(isLast or isFirst)
-        self.env['runtime']['outputManager'].presentText(clipboard, interrupt = speechInterrupt)
-             
-    def setCallback(self, callback):
+        pass
+
+    def get_description(self):
+        return _("selects the next clipboard")
+
+    def run(self):
+        if self.env["runtime"]["MemoryManager"].is_index_list_empty(
+            "clipboardHistory"
+        ):
+            self.env["runtime"]["OutputManager"].present_text(
+                _("clipboard empty"), interrupt=True
+            )
+            return
+        self.env["runtime"]["MemoryManager"].get_next_index("clipboardHistory")
+        is_first = self.env["runtime"]["MemoryManager"].is_first_index(
+            "clipboardHistory"
+        )
+        is_last = self.env["runtime"]["MemoryManager"].is_last_index(
+            "clipboardHistory"
+        )
+        clipboard = self.env["runtime"][
+            "MemoryManager"
+        ].get_index_list_element("clipboardHistory")
+        if is_first:
+            self.env["runtime"]["OutputManager"].present_text(
+                _("First clipboard "), interrupt=True
+            )
+        if is_last:
+            self.env["runtime"]["OutputManager"].present_text(
+                _("Last clipboard "), interrupt=True
+            )
+
+        speech_interrupt = not (is_last or is_first)
+        self.env["runtime"]["OutputManager"].present_text(
+            clipboard, interrupt=speech_interrupt
+        )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/next_quick_menu_entry.py

@@ -2,27 +2,41 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('get next quick menu entry')
-    def run(self):
-        menu = ''
-        value = ''
-        if self.env['runtime']['quickMenuManager'].nextEntry():
-            menu = self.env['runtime']['quickMenuManager'].getCurrentEntry()
-            if menu != '':
-                value = self.env['runtime']['quickMenuManager'].getCurrentValue()
-                self.env['runtime']['outputManager'].presentText(menu + ' ' + value, interrupt=True)
-        else:
-            self.env['runtime']['outputManager'].presentText(_('Quick menu not available'), interrupt=True)
-    def setCallback(self, callback):
+        pass
+
+    def get_description(self):
+        return _("get next quick menu entry")
+
+    def run(self):
+        menu = ""
+        value = ""
+        if self.env["runtime"]["QuickMenuManager"].next_entry():
+            menu = self.env["runtime"]["QuickMenuManager"].get_current_entry()
+            if menu != "":
+                value = self.env["runtime"][
+                    "QuickMenuManager"
+                ].get_current_value()
+                self.env["runtime"]["OutputManager"].present_text(
+                    menu + " " + value, interrupt=True
+                )
+        else:
+            self.env["runtime"]["OutputManager"].present_text(
+                _("Quick menu not available"), interrupt=True
+            )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/next_quick_menu_value.py

@@ -2,21 +2,31 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('get next quick menu value')
-    def run(self):
-        if self.env['runtime']['quickMenuManager'].nextValue():
-            value = self.env['runtime']['quickMenuManager'].getCurrentValue()
-            self.env['runtime']['outputManager'].presentText(value, interrupt=True)
-    def setCallback(self, callback):
+        pass
+
+    def get_description(self):
+        return _("get next quick menu value")
+
+    def run(self):
+        if self.env["runtime"]["QuickMenuManager"].next_value():
+            value = self.env["runtime"]["QuickMenuManager"].get_current_value()
+            self.env["runtime"]["OutputManager"].present_text(
+                value, interrupt=True
+            )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/paste_clipboard.py

@@ -2,28 +2,49 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
 import time
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
-        self.env['runtime']['memoryManager'].addIndexList('clipboardHistory', self.env['runtime']['settingsManager'].getSettingAsInt('general', 'numberOfClipboards'))
+        self.env["runtime"]["MemoryManager"].add_index_list(
+            "clipboardHistory",
+            self.env["runtime"]["SettingsManager"].get_setting_as_int(
+                "general", "numberOfClipboards"
+            ),
+        )
+
     def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('pastes the text from the currently selected clipboard')        
-    
-    def run(self):    
-        if self.env['runtime']['memoryManager'].isIndexListEmpty('clipboardHistory'):
-            self.env['runtime']['outputManager'].presentText(_('clipboard empty'), interrupt=True)
-            return                                          
-        self.env['runtime']['outputManager'].presentText('paste clipboard', soundIcon='PasteClipboardOnScreen', interrupt=True)
-        clipboard = self.env['runtime']['memoryManager'].getIndexListElement('clipboardHistory')
-        self.env['runtime']['screenManager'].injectTextToScreen(clipboard)
-              
-    def setCallback(self, callback):
+        pass
+
+    def get_description(self):
+        return _("pastes the text from the currently selected clipboard")
+
+    def run(self):
+        if self.env["runtime"]["MemoryManager"].is_index_list_empty(
+            "clipboardHistory"
+        ):
+            self.env["runtime"]["OutputManager"].present_text(
+                _("clipboard empty"), interrupt=True
+            )
+            return
+        self.env["runtime"]["OutputManager"].present_text(
+            "paste clipboard",
+            sound_icon="PasteClipboardOnScreen",
+            interrupt=True,
+        )
+        clipboard = self.env["runtime"][
+            "MemoryManager"
+        ].get_index_list_element("clipboardHistory")
+        self.env["runtime"]["ScreenManager"].inject_text_to_screen(clipboard)
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/present_first_line.py

@@ -2,28 +2,38 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
+from fenrirscreenreader.core.i18n import _
 from fenrirscreenreader.utils import line_utils
 
-class command():
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('present first line')        
-    
-    def run(self):
-        x, y, firstLine = \
-          line_utils.getCurrentLine(0, 0, self.env['screen']['newContentText'])
-        
-        if firstLine.isspace():
-            self.env['runtime']['outputManager'].presentText(_("blank"), soundIcon='EmptyLine', interrupt=True)
-        else:
-            self.env['runtime']['outputManager'].presentText(firstLine, interrupt=True) 
-    def setCallback(self, callback):
         pass
 
+    def get_description(self):
+        return _("present first line")
+
+    def run(self):
+        x, y, first_line = line_utils.get_current_line(
+            0, 0, self.env["screen"]["new_content_text"]
+        )
+
+        if first_line.isspace():
+            self.env["runtime"]["OutputManager"].present_text(
+                _("blank"), sound_icon="EmptyLine", interrupt=True
+            )
+        else:
+            self.env["runtime"]["OutputManager"].present_text(
+                first_line, interrupt=True
+            )
+
+    def set_callback(self, callback):
+        pass

src/fenrirscreenreader/commands/commands/present_last_line.py

@@ -2,28 +2,40 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
+from fenrirscreenreader.core.i18n import _
 from fenrirscreenreader.utils import line_utils
 
-class command():
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('current line')        
-    
-    def run(self):
-        x, y, lastLine = \
-          line_utils.getCurrentLine(0, self.env['screen']['lines'] -1, self.env['screen']['newContentText'])
 
-        if lastLine.isspace():
-            self.env['runtime']['outputManager'].presentText(_("blank"), soundIcon='EmptyLine', interrupt=True)
-        else:
-            self.env['runtime']['outputManager'].presentText(lastLine, interrupt=True) 
-    def setCallback(self, callback):
+    def shutdown(self):
         pass
 
+    def get_description(self):
+        return _("current line")
+
+    def run(self):
+        x, y, last_line = line_utils.get_current_line(
+            0,
+            self.env["screen"]["lines"] - 1,
+            self.env["screen"]["new_content_text"],
+        )
+
+        if last_line.isspace():
+            self.env["runtime"]["OutputManager"].present_text(
+                _("blank"), sound_icon="EmptyLine", interrupt=True
+            )
+        else:
+            self.env["runtime"]["OutputManager"].present_text(
+                last_line, interrupt=True
+            )
+
+    def set_callback(self, callback):
+        pass

src/fenrirscreenreader/commands/commands/prev_clipboard.py

@@ -2,33 +2,55 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('selects the previous clipboard')        
+        pass
+
+    def get_description(self):
+        return _("selects the previous clipboard")
 
     def run(self):
-        if self.env['runtime']['memoryManager'].isIndexListEmpty('clipboardHistory'):
-            self.env['runtime']['outputManager'].presentText(_('clipboard empty'), interrupt=True)
-            return      
-        self.env['runtime']['memoryManager'].setPrefIndex('clipboardHistory')               
-        isFirst = self.env['runtime']['memoryManager'].isFirstIndex('clipboardHistory')   
-        isLast = self.env['runtime']['memoryManager'].isLastIndex('clipboardHistory')               
-        clipboard = self.env['runtime']['memoryManager'].getIndexListElement('clipboardHistory')            
-        if isFirst:
-            self.env['runtime']['outputManager'].presentText(_('First clipboard '), interrupt=True)   
-        if isLast:
-            self.env['runtime']['outputManager'].presentText(_('Last clipboard '), interrupt=True)                     
-        speechInterrupt = not(isLast or isFirst)
-        self.env['runtime']['outputManager'].presentText(clipboard, interrupt = speechInterrupt)
-              
-    def setCallback(self, callback):
+        if self.env["runtime"]["MemoryManager"].is_index_list_empty(
+            "clipboardHistory"
+        ):
+            self.env["runtime"]["OutputManager"].present_text(
+                _("clipboard empty"), interrupt=True
+            )
+            return
+        self.env["runtime"]["MemoryManager"].set_pref_index("clipboardHistory")
+        is_first = self.env["runtime"]["MemoryManager"].is_first_index(
+            "clipboardHistory"
+        )
+        is_last = self.env["runtime"]["MemoryManager"].is_last_index(
+            "clipboardHistory"
+        )
+        clipboard = self.env["runtime"][
+            "MemoryManager"
+        ].get_index_list_element("clipboardHistory")
+        if is_first:
+            self.env["runtime"]["OutputManager"].present_text(
+                _("First clipboard "), interrupt=True
+            )
+        if is_last:
+            self.env["runtime"]["OutputManager"].present_text(
+                _("Last clipboard "), interrupt=True
+            )
+        speech_interrupt = not (is_last or is_first)
+        self.env["runtime"]["OutputManager"].present_text(
+            clipboard, interrupt=speech_interrupt
+        )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/prev_quick_menu_entry.py

@@ -2,27 +2,41 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('get previous quick menu entry')
-    def run(self):
-        menu = ''
-        value = ''
-        if self.env['runtime']['quickMenuManager'].prevEntry():
-            menu = self.env['runtime']['quickMenuManager'].getCurrentEntry()
-            if menu != '':
-                value = self.env['runtime']['quickMenuManager'].getCurrentValue()
-                self.env['runtime']['outputManager'].presentText(menu + ' ' + value, interrupt=True)
-        else:
-            self.env['runtime']['outputManager'].presentText(_('Quick menu not available'), interrupt=True)
-    def setCallback(self, callback):
+        pass
+
+    def get_description(self):
+        return _("get previous quick menu entry")
+
+    def run(self):
+        menu = ""
+        value = ""
+        if self.env["runtime"]["QuickMenuManager"].prev_entry():
+            menu = self.env["runtime"]["QuickMenuManager"].get_current_entry()
+            if menu != "":
+                value = self.env["runtime"][
+                    "QuickMenuManager"
+                ].get_current_value()
+                self.env["runtime"]["OutputManager"].present_text(
+                    menu + " " + value, interrupt=True
+                )
+        else:
+            self.env["runtime"]["OutputManager"].present_text(
+                _("Quick menu not available"), interrupt=True
+            )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/prev_quick_menu_value.py

@@ -2,21 +2,31 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('get previous quick menu value')
-    def run(self):
-        if self.env['runtime']['quickMenuManager'].prevValue():
-            value = self.env['runtime']['quickMenuManager'].getCurrentValue()
-            self.env['runtime']['outputManager'].presentText(value, interrupt=True)
-    def setCallback(self, callback):
+        pass
+
+    def get_description(self):
+        return _("get previous quick menu value")
+
+    def run(self):
+        if self.env["runtime"]["QuickMenuManager"].prev_value():
+            value = self.env["runtime"]["QuickMenuManager"].get_current_value()
+            self.env["runtime"]["OutputManager"].present_text(
+                value, interrupt=True
+            )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/progress_bar_monitor.py

@@ -2,208 +2,254 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
 import re
-import time
 import threading
+import time
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
-        
+
     def initialize(self, environment):
         self.env = environment
         # Use commandBuffer like other commands
-        if 'progressMonitoring' not in self.env['commandBuffer']:
-            # Check if progress monitoring should be enabled by default from settings
+        if "progressMonitoring" not in self.env["commandBuffer"]:
+            # Check if progress monitoring should be enabled by default from
+            # settings
             try:
-                defaultEnabled = self.env['runtime']['settingsManager'].getSettingAsBool('sound', 'progressMonitoring')
-            except:
+                default_enabled = self.env["runtime"][
+                    "SettingsManager"
+                ].get_setting_as_bool("sound", "progressMonitoring")
+            except Exception as e:
                 # If setting doesn't exist, default to False
-                defaultEnabled = False
-            self.env['commandBuffer']['progressMonitoring'] = defaultEnabled
-            self.env['commandBuffer']['lastProgressTime'] = 0
-            self.env['commandBuffer']['lastProgressValue'] = -1
-        
+                default_enabled = False
+            self.env["commandBuffer"]["progressMonitoring"] = default_enabled
+            self.env["commandBuffer"]["lastProgressTime"] = 0
+            self.env["commandBuffer"]["lastProgressValue"] = -1
+
     def shutdown(self):
-        self.stopProgressMonitoring()
-        
-    def getDescription(self):
-        return _('Toggle progress bar monitoring with ascending tones')
-        
+        self.stop_progress_monitoring()
+
+    def get_description(self):
+        return _("Toggle progress bar monitoring with ascending tones")
+
     def run(self):
         # Check if commandBuffer exists
-        if 'progressMonitoring' not in self.env['commandBuffer']:
-            self.env['commandBuffer']['progressMonitoring'] = False
-            self.env['commandBuffer']['lastProgressTime'] = 0
-            self.env['commandBuffer']['lastProgressValue'] = -1
-        
-        if self.env['commandBuffer']['progressMonitoring']:
-            self.stopProgressMonitoring()
-            self.env['runtime']['outputManager'].presentText(_("Progress monitoring disabled"), interrupt=True)
+        if "progressMonitoring" not in self.env["commandBuffer"]:
+            self.env["commandBuffer"]["progressMonitoring"] = False
+            self.env["commandBuffer"]["lastProgressTime"] = 0
+            self.env["commandBuffer"]["lastProgressValue"] = -1
+
+        if self.env["commandBuffer"]["progressMonitoring"]:
+            self.stop_progress_monitoring()
+            self.env["runtime"]["OutputManager"].present_text(
+                _("Progress monitoring disabled"), interrupt=True
+            )
         else:
-            self.startProgressMonitoring()
-            self.env['runtime']['outputManager'].presentText(_("Progress monitoring enabled"), interrupt=True)
-            
-    def startProgressMonitoring(self):
-        self.env['commandBuffer']['progressMonitoring'] = True
-        self.env['commandBuffer']['lastProgressTime'] = time.time()
-        self.env['commandBuffer']['lastProgressValue'] = -1
+            self.start_progress_monitoring()
+            self.env["runtime"]["OutputManager"].present_text(
+                _("Progress monitoring enabled"), interrupt=True
+            )
+
+    def start_progress_monitoring(self):
+        self.env["commandBuffer"]["progressMonitoring"] = True
+        self.env["commandBuffer"]["lastProgressTime"] = time.time()
+        self.env["commandBuffer"]["lastProgressValue"] = -1
         # Don't control speech - let user decide with silence_until_prompt
-        
-    def stopProgressMonitoring(self):
-        self.env['commandBuffer']['progressMonitoring'] = False
+
+    def stop_progress_monitoring(self):
+        self.env["commandBuffer"]["progressMonitoring"] = False
         # Don't control speech - progress monitor is beep-only
-            
-    def detectProgress(self, text):
-        if not self.env['commandBuffer']['progressMonitoring']:
+
+    def detect_progress(self, text):
+        if not self.env["commandBuffer"]["progressMonitoring"]:
             return
-            
+
         # Skip progress detection if current screen looks like a prompt
-        if self.isCurrentLinePrompt():
+        if self.is_current_line_prompt():
             return
-            
-        currentTime = time.time()
-        
+
+        current_time = time.time()
+
         # Pattern 1: Percentage (50%, 25.5%, etc.)
-        percentMatch = re.search(r'(\d+(?:\.\d+)?)\s*%', text)
-        if percentMatch:
-            percentage = float(percentMatch.group(1))
-            if percentage != self.env['commandBuffer']['lastProgressValue']:
-                self.playProgressTone(percentage)
-                self.env['commandBuffer']['lastProgressValue'] = percentage
-                self.env['commandBuffer']['lastProgressTime'] = currentTime
+        percent_match = re.search(r"(\d+(?:\.\d+)?)\s*%", text)
+        if percent_match:
+            percentage = float(percent_match.group(1))
+            if percentage != self.env["commandBuffer"]["lastProgressValue"]:
+                self.play_progress_tone(percentage)
+                self.env["commandBuffer"]["lastProgressValue"] = percentage
+                self.env["commandBuffer"]["lastProgressTime"] = current_time
             return
-            
+
         # Pattern 2: Fraction (15/100, 3 of 10, etc.)
-        fractionMatch = re.search(r'(\d+)\s*(?:of|/)\s*(\d+)', text)
-        if fractionMatch:
-            current = int(fractionMatch.group(1))
-            total = int(fractionMatch.group(2))
+        fraction_match = re.search(r"(\d+)\s*(?:of|/)\s*(\d+)", text)
+        if fraction_match:
+            current = int(fraction_match.group(1))
+            total = int(fraction_match.group(2))
             if total > 0:
                 percentage = (current / total) * 100
-                if percentage != self.env['commandBuffer']['lastProgressValue']:
-                    self.playProgressTone(percentage)
-                    self.env['commandBuffer']['lastProgressValue'] = percentage
-                    self.env['commandBuffer']['lastProgressTime'] = currentTime
+                if (
+                    percentage
+                    != self.env["commandBuffer"]["lastProgressValue"]
+                ):
+                    self.play_progress_tone(percentage)
+                    self.env["commandBuffer"]["lastProgressValue"] = percentage
+                    self.env["commandBuffer"][
+                        "lastProgressTime"
+                    ] = current_time
                 return
-                
+
         # Pattern 3: Progress bars ([####    ], [====>   ], etc.)
         # Improved pattern to avoid matching IRC channels like [#channel]
-        barMatch = re.search(r'\[([#=\-\*]+)([\s\.]*)\]', text)
-        if barMatch:
-            filled = len(barMatch.group(1))
-            unfilled = len(barMatch.group(2))
+        bar_match = re.search(r"\[([#=\-\*]+)([\s\.]*)\]", text)
+        if bar_match:
+            filled = len(bar_match.group(1))
+            unfilled = len(bar_match.group(2))
             total = filled + unfilled
-            # Require at least 2 progress chars total and unfilled portion must be spaces/dots
-            if total >= 2 and (not barMatch.group(2) or re.match(r'^[\s\.]*$', barMatch.group(2))):
+            # Require at least 2 progress chars total and unfilled portion must
+            # be spaces/dots
+            if total >= 2 and (
+                not bar_match.group(2)
+                or re.match(r"^[\s\.]*$", bar_match.group(2))
+            ):
                 percentage = (filled / total) * 100
-                if percentage != self.env['commandBuffer']['lastProgressValue']:
-                    self.playProgressTone(percentage)
-                    self.env['commandBuffer']['lastProgressValue'] = percentage
-                    self.env['commandBuffer']['lastProgressTime'] = currentTime
+                if (
+                    percentage
+                    != self.env["commandBuffer"]["lastProgressValue"]
+                ):
+                    self.play_progress_tone(percentage)
+                    self.env["commandBuffer"]["lastProgressValue"] = percentage
+                    self.env["commandBuffer"][
+                        "lastProgressTime"
+                    ] = current_time
                 return
-                
+
         # Pattern 4: Generic activity indicators (Loading..., Working..., etc.)
-        activityPattern = re.search(r'(loading|processing|working|installing|downloading|compiling|building).*\.{2,}', text, re.IGNORECASE)
-        if activityPattern:
+        activity_pattern = re.search(
+            (
+                r"(loading|processing|working|installing|downloading|"
+                r"compiling|building).*\.{2,}"
+            ),
+            text,
+            re.IGNORECASE,
+        )
+        if activity_pattern:
             # Play a steady beep every 2 seconds for ongoing activity
-            if currentTime - self.env['commandBuffer']['lastProgressTime'] >= 2.0:
-                self.playActivityBeep()
-                self.env['commandBuffer']['lastProgressTime'] = currentTime
-                
-    def playProgressTone(self, percentage):
+            if (
+                current_time - self.env["commandBuffer"]["lastProgressTime"]
+                >= 2.0
+            ):
+                self.play_activity_beep()
+                self.env["commandBuffer"]["lastProgressTime"] = current_time
+
+    def play_progress_tone(self, percentage):
         # Map 0-100% to 400-1200Hz frequency range
         frequency = 400 + (percentage * 8)
         frequency = max(400, min(1200, frequency))  # Clamp to safe range
-        self.env['runtime']['outputManager'].playFrequence(frequency, 0.15, interrupt=False)
-        
-    def playActivityBeep(self):
+        self.env["runtime"]["OutputManager"].play_frequence(
+            frequency, 0.15, interrupt=False
+        )
+
+    def play_activity_beep(self):
         # Single tone for generic activity
-        self.env['runtime']['outputManager'].playFrequence(800, 0.1, interrupt=False)
-    
-    def isCurrentLinePrompt(self):
+        self.env["runtime"]["OutputManager"].play_frequence(
+            800, 0.1, interrupt=False
+        )
+
+    def is_current_line_prompt(self):
         """Check if the current line looks like a standalone prompt (not command with progress)"""
         import re
-        
+
         try:
             # Get the current screen content
-            if not self.env['screen']['newContentText']:
+            if not self.env["screen"]["new_content_text"]:
                 return False
-                
-            lines = self.env['screen']['newContentText'].split('\n')
+
+            lines = self.env["screen"]["new_content_text"].split("\n")
             if not lines:
                 return False
-            
-            # Check the last line (most common) and current cursor line for prompt patterns
-            linesToCheck = []
-            
+
+            # Check the last line (most common) and current cursor line for
+            # prompt patterns
+            lines_to_check = []
+
             # Add last line (most common for prompts)
             if lines:
-                linesToCheck.append(lines[-1])
-            
+                lines_to_check.append(lines[-1])
+
             # Add current cursor line if different from last line
-            if (self.env['screen']['newCursor']['y'] < len(lines) and 
-                self.env['screen']['newCursor']['y'] != len(lines) - 1):
-                linesToCheck.append(lines[self.env['screen']['newCursor']['y']])
-            
+            if (
+                self.env["screen"]["new_cursor"]["y"] < len(lines)
+                and self.env["screen"]["new_cursor"]["y"] != len(lines) - 1
+            ):
+                lines_to_check.append(
+                    lines[self.env["screen"]["new_cursor"]["y"]]
+                )
+
             # Standalone prompt patterns (no commands mixed in)
-            standalonePromptPatterns = [
-                r'^\s*\$\s*$',  # Just $ (with whitespace)
-                r'^\s*#\s*$',   # Just # (with whitespace)  
-                r'^\s*>\s*$',   # Just > (with whitespace)
-                r'^\[.*\]\s*[\\\$#>]\s*$',  # [path]$ without commands
-                r'^[a-zA-Z0-9._-]+[\\\$#>]\s*$',  # bash-5.1$ without commands
-                
+            standalone_prompt_patterns = [
+                r"^\s*\$\s*$",  # Just $ (with whitespace)
+                r"^\s*#\s*$",  # Just # (with whitespace)
+                r"^\s*>\s*$",  # Just > (with whitespace)
+                r"^\[.*\]\s*[\\\$#>]\s*$",  # [path]$ without commands
+                r"^[a-zA-Z0-9._-]+[\\\$#>]\s*$",  # bash-5.1$ without commands
                 # Interactive prompt patterns (these ARE standalone)
-                r'.*\?\s*\[[YyNn]/[YyNn]\]\s*$',  # ? [Y/n] or ? [y/N] style
-                r'.*\?\s*\[[Yy]es/[Nn]o\]\s*$',  # ? [Yes/No] style
-                r'.*continue\?\s*\[[YyNn]/[YyNn]\].*$',  # "continue? [Y/n]" style
-                r'^::.*\?\s*\[[YyNn]/[YyNn]\].*$',  # pacman style prompts
-                
+                r".*\?\s*\[[YyNn]/[YyNn]\]\s*$",  # ? [Y/n] or ? [y/N] style
+                r".*\?\s*\[[Yy]es/[Nn]o\]\s*$",  # ? [Yes/No] style
+                # "continue? [Y/n]" style
+                r".*continue\?\s*\[[YyNn]/[YyNn]\].*$",
+                r"^::.*\?\s*\[[YyNn]/[YyNn]\].*$",  # pacman style prompts
                 # Authentication prompts (these ARE standalone)
-                r'^\[[Ss]udo\]\s*[Pp]assword\s*for\s+.*:\s*$',  # [sudo] password
-                r'^[Pp]assword\s*:\s*$',  # Password:
-                r'.*[Pp]assword\s*:\s*$',  # general password prompts
-                
+                r"^\[[Ss]udo\]\s*[Pp]assword\s*for\s+.*:\s*$",  # [sudo] password
+                r"^[Pp]assword\s*:\s*$",  # Password:
+                r".*[Pp]assword\s*:\s*$",  # general password prompts
                 # Continuation prompts (these ARE standalone)
-                r'^[Pp]ress\s+any\s+key\s+to\s+continue.*$',  # Press any key
-                r'^[Aa]re\s+you\s+sure\?\s*.*$',  # Are you sure?
+                r"^[Pp]ress\s+any\s+key\s+to\s+continue.*$",  # Press any key
+                r"^[Aa]re\s+you\s+sure\?\s*.*$",  # Are you sure?
             ]
-            
-            for line in linesToCheck:
+
+            for line in lines_to_check:
                 line = line.strip()
                 if not line:
                     continue
-                
+
                 # Check if this line contains both a prompt AND other content (like commands)
                 # If so, don't treat it as a standalone prompt
-                hasPromptMarker = bool(re.search(r'.*@.*[\\\$#>]', line) or re.search(r'^\[.*\]\s*[\\\$#>]', line))
-                if hasPromptMarker:
-                    # If line has prompt marker but also has significant content after it, 
+                has_prompt_marker = bool(
+                    re.search(r".*@.*[\\\$#>]", line)
+                    or re.search(r"^\[.*\]\s*[\\\$#>]", line)
+                )
+                if has_prompt_marker:
+                    # If line has prompt marker but also has significant content after it,
                     # it's a command line, not a standalone prompt
-                    promptEnd = max(
-                        line.rfind('$'), 
-                        line.rfind('#'), 
-                        line.rfind('>'),
-                        line.rfind('\\')
+                    prompt_end = max(
+                        line.rfind("$"),
+                        line.rfind("#"),
+                        line.rfind(">"),
+                        line.rfind("\\"),
                     )
-                    if promptEnd >= 0 and promptEnd < len(line) - 5:  # More than just whitespace after prompt
+                    if (
+                        prompt_end >= 0 and prompt_end < len(line) - 5
+                    ):  # More than just whitespace after prompt
                         continue  # This is a command line, not a standalone prompt
-                    
-                for pattern in standalonePromptPatterns:
+
+                for pattern in standalone_prompt_patterns:
                     try:
                         if re.search(pattern, line):
                             return True
                     except re.error:
                         continue
-                        
+
             return False
-            
-        except Exception:
+
+        except Exception as e:
             # If anything fails, assume it's not a prompt to be safe
             return False
-        
-    def setCallback(self, callback):
-        pass
+
+    def set_callback(self, callback):
+        pass

src/fenrirscreenreader/commands/commands/quit_fenrir.py

@@ -2,22 +2,27 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('exits Fenrir')        
-    
-    def run(self):
-        self.env['runtime']['eventManager'].stopMainEventLoop() 
 
-    def setCallback(self, callback):
+    def shutdown(self):
         pass
 
+    def get_description(self):
+        return _("exits Fenrir")
+
+    def run(self):
+        self.env["runtime"]["EventManager"].stop_main_event_loop()
+
+    def set_callback(self, callback):
+        pass

src/fenrirscreenreader/commands/commands/remove_marks.py

@@ -2,22 +2,30 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('Removes marks from selected text')        
-    
-    def run(self):
-        self.env['runtime']['cursorManager'].clearMarks()
-        self.env['runtime']['outputManager'].presentText(_('Remove marks'), interrupt=True)
 
-    def setCallback(self, callback):
+    def shutdown(self):
+        pass
+
+    def get_description(self):
+        return _("Removes marks from selected text")
+
+    def run(self):
+        self.env["runtime"]["CursorManager"].clear_marks()
+        self.env["runtime"]["OutputManager"].present_text(
+            _("Remove marks"), interrupt=True
+        )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/remove_word_from_spell_check.py

@@ -2,53 +2,96 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.utils import word_utils
 import string
+
+from fenrirscreenreader.core.i18n import _
+from fenrirscreenreader.utils import word_utils
+
 initialized = False
 try:
     import enchant
+
     initialized = True
-except:
+except Exception as e:
     pass
-    
-class command():
+
+
+class command:
     def __init__(self):
-        self.language = ''
+        self.language = ""
         self.spellChecker = None
+
     def initialize(self, environment):
         self.env = environment
-        self.updateSpellLanguage()
+        self.update_spell_language()
+
     def shutdown(self):
         pass
-    def getDescription(self):
-        return _('removes the current word from the exceptions dictionary')        
-    def updateSpellLanguage(self):  
-        self.spellChecker = enchant.Dict(self.env['runtime']['settingsManager'].getSetting('general', 'spellCheckLanguage'))
-        self.language = self.env['runtime']['settingsManager'].getSetting('general', 'spellCheckLanguage')      
-       
+
+    def get_description(self):
+        return _("removes the current word from the exceptions dictionary")
+
+    def update_spell_language(self):
+        self.spellChecker = enchant.Dict(
+            self.env["runtime"]["SettingsManager"].get_setting(
+                "general", "spellCheckLanguage"
+            )
+        )
+        self.language = self.env["runtime"]["SettingsManager"].get_setting(
+            "general", "spellCheckLanguage"
+        )
+
     def run(self):
         if not initialized:
-           self.env['runtime']['outputManager'].presentText(_('pyenchant is not installed'), interrupt=True) 
-           return
-        if self.env['runtime']['settingsManager'].getSetting('general', 'spellCheckLanguage') != self.language:
+            self.env["runtime"]["OutputManager"].present_text(
+                _("pyenchant is not installed"), interrupt=True
+            )
+            return
+        if (
+            self.env["runtime"]["SettingsManager"].get_setting(
+                "general", "spellCheckLanguage"
+            )
+            != self.language
+        ):
             try:
-                self.updateSpellLanguage()
-            except:
-                return    
+                self.update_spell_language()
+            except Exception as e:
+                return
+
+        cursor_pos = self.env["runtime"][
+            "CursorManager"
+        ].get_review_or_text_cursor()
 
-        cursorPos = self.env['runtime']['cursorManager'].getReviewOrTextCursor()
-            
         # get the word
-        newContent = self.env['screen']['newContentText'].split('\n')[cursorPos['y']]
-        x, y, currWord, endOfScreen, lineBreak =  word_utils.getCurrentWord(cursorPos['x'], 0, newContent)                  
-        currWord = currWord.strip(string.whitespace + r'!"#$%&()*+,-./:;<=Â?@[\\]^_{|}~')
-        if not currWord.isspace():
-            if self.spellChecker.is_removed(currWord):
-                self.env['runtime']['outputManager'].presentText(_('{0} is not in the dictionary').format(currWord,), soundIcon='Cancel', interrupt=True)                
+        new_content = self.env["screen"]["new_content_text"].split("\n")[
+            cursor_pos["y"]
+        ]
+        x, y, curr_word, end_of_screen, line_break = (
+            word_utils.get_current_word(cursor_pos["x"], 0, new_content)
+        )
+        curr_word = curr_word.strip(
+            string.whitespace + r'!"#$%&()*+,-./:;<=Â?@[\\]^_{|}~'
+        )
+        if not curr_word.isspace():
+            if self.spellChecker.is_removed(curr_word):
+                self.env["runtime"]["OutputManager"].present_text(
+                    _("{0} is not in the dictionary").format(
+                        curr_word,
+                    ),
+                    sound_icon="Cancel",
+                    interrupt=True,
+                )
             else:
-                self.spellChecker.remove(currWord)             
-                self.env['runtime']['outputManager'].presentText(_('{0} removed').format(currWord,), soundIcon='Accept', interrupt=True)                    
-    def setCallback(self, callback):
+                self.spellChecker.remove(curr_word)
+                self.env["runtime"]["OutputManager"].present_text(
+                    _("{0} removed").format(
+                        curr_word,
+                    ),
+                    sound_icon="Accept",
+                    interrupt=True,
+                )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/review_bottom.py

@@ -2,22 +2,33 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('Move review to the bottom of the screen')
+        pass
+
+    def get_description(self):
+        return _("Move review to the bottom of the screen")
 
     def run(self):
-        self.env['screen']['newCursorReview'] = { 'x': 0, 'y':self.env['screen']['lines'] -1}
-        self.env['runtime']['outputManager'].presentText(_("Bottom"), interrupt=True, flush=False)
+        self.env["screen"]["newCursorReview"] = {
+            "x": 0,
+            "y": self.env["screen"]["lines"] - 1,
+        }
+        self.env["runtime"]["OutputManager"].present_text(
+            _("Bottom"), interrupt=True, flush=False
+        )
 
-    def setCallback(self, callback):
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/review_curr_char.py

@@ -2,34 +2,82 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
+from fenrirscreenreader.core.i18n import _
 from fenrirscreenreader.utils import char_utils
 
-class command():
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('presents the current character.')        
-    
-    def run(self):
-        self.env['runtime']['cursorManager'].enterReviewModeCurrTextCursor()
 
-        self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], currChar = \
-          char_utils.getCurrentChar(self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], self.env['screen']['newContentText'])
-        
-        char_utils.presentCharForReview(self.env, currChar, interrupt=True, announceCapital=True, flush=False)
-        # is has attribute it enabled?    
-        if self.env['runtime']['settingsManager'].getSettingAsBool('general', 'hasAttributes'):
-            cursorPos = self.env['screen']['newCursorReview']
-            
-            if not self.env['runtime']['attributeManager'].hasAttributes(cursorPos):
-                return
-            self.env['runtime']['outputManager'].presentText('has attribute', soundIcon='HasAttributes', interrupt=False)        
-  
-    def setCallback(self, callback):
+    def shutdown(self):
+        pass
+
+    def get_description(self):
+        return _("presents the current character.")
+
+    def run(self):
+        self.env["runtime"][
+            "CursorManager"
+        ].enter_review_mode_curr_text_cursor()
+
+        # In table mode, sync to cell start if cursor is outside current cell
+        if self.env["runtime"]["TableManager"].is_table_mode():
+            table_info = self.env["runtime"]["TableManager"].get_current_table_cell_info()
+            if table_info:
+                cursor_pos = self.env["screen"]["newCursorReview"]
+                line_text = self.env["runtime"]["ScreenManager"].get_line_text(
+                    cursor_pos["y"]
+                )
+                if line_text:
+                    column_start = self.env["runtime"]["TableManager"].get_column_start_position(
+                        line_text, table_info["column_index"]
+                    )
+                    cell_content = table_info["cell_content"]
+                    cell_end = column_start + len(cell_content)
+                    
+                    # If cursor is outside the current cell, move to cell start
+                    if (
+                        cursor_pos["x"] < column_start or 
+                        cursor_pos["x"] >= cell_end
+                    ):
+                        self.env["screen"]["newCursorReview"]["x"] = column_start
+
+        (
+            self.env["screen"]["newCursorReview"]["x"],
+            self.env["screen"]["newCursorReview"]["y"],
+            curr_char,
+        ) = char_utils.get_current_char(
+            self.env["screen"]["newCursorReview"]["x"],
+            self.env["screen"]["newCursorReview"]["y"],
+            self.env["screen"]["new_content_text"],
+        )
+
+        char_utils.present_char_for_review(
+            self.env,
+            curr_char,
+            interrupt=True,
+            announce_capital=True,
+            flush=False,
+        )
+        # is has attribute it enabled?
+        if self.env["runtime"]["SettingsManager"].get_setting_as_bool(
+            "general", "hasattributes"
+        ):
+            cursor_pos = self.env["screen"]["newCursorReview"]
+
+            if not self.env["runtime"]["AttributeManager"].has_attributes(
+                cursor_pos
+            ):
+                return
+            self.env["runtime"]["OutputManager"].present_text(
+                "has attribute", sound_icon="HasAttributes", interrupt=False
+            )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/review_curr_char_phonetic.py

@@ -2,31 +2,49 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
+from fenrirscreenreader.core.i18n import _
 from fenrirscreenreader.utils import char_utils
 
-class command():
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('set review and phonetically presents the current character')    
-    
-    def run(self):
-        self.env['runtime']['cursorManager'].enterReviewModeCurrTextCursor()
 
-        self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], currChar = \
-          char_utils.getCurrentChar(self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], self.env['screen']['newContentText'])
-        
-        if currChar.isspace():
-            self.env['runtime']['outputManager'].presentText(_("blank"), interrupt=True, flush=False)
-        else:
-            currChar = char_utils.getPhonetic(currChar)
-            self.env['runtime']['outputManager'].presentText(currChar ,interrupt=True, announceCapital=True, flush=False)
-  
-    def setCallback(self, callback):
+    def shutdown(self):
+        pass
+
+    def get_description(self):
+        return _("set review and phonetically presents the current character")
+
+    def run(self):
+        self.env["runtime"][
+            "CursorManager"
+        ].enter_review_mode_curr_text_cursor()
+
+        (
+            self.env["screen"]["newCursorReview"]["x"],
+            self.env["screen"]["newCursorReview"]["y"],
+            curr_char,
+        ) = char_utils.get_current_char(
+            self.env["screen"]["newCursorReview"]["x"],
+            self.env["screen"]["newCursorReview"]["y"],
+            self.env["screen"]["new_content_text"],
+        )
+
+        if curr_char.isspace():
+            self.env["runtime"]["OutputManager"].present_text(
+                _("blank"), interrupt=True, flush=False
+            )
+        else:
+            curr_char = char_utils.get_phonetic(curr_char)
+            self.env["runtime"]["OutputManager"].present_text(
+                curr_char, interrupt=True, announce_capital=True, flush=False
+            )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/review_curr_line.py

@@ -2,30 +2,48 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
+from fenrirscreenreader.core.i18n import _
 from fenrirscreenreader.utils import line_utils
 
-class command():
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('current line')        
-    
-    def run(self):
-        self.env['runtime']['cursorManager'].enterReviewModeCurrTextCursor()
 
-        self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], currLine = \
-          line_utils.getCurrentLine(self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], self.env['screen']['newContentText'])
-        
-        if currLine.isspace():
-            self.env['runtime']['outputManager'].presentText(_("blank"), soundIcon='EmptyLine', interrupt=True, flush=False)
-        else:
-            self.env['runtime']['outputManager'].presentText(currLine, interrupt=True, flush=False) 
-    def setCallback(self, callback):
+    def shutdown(self):
         pass
 
+    def get_description(self):
+        return _("current line")
+
+    def run(self):
+        self.env["runtime"][
+            "CursorManager"
+        ].enter_review_mode_curr_text_cursor()
+
+        (
+            self.env["screen"]["newCursorReview"]["x"],
+            self.env["screen"]["newCursorReview"]["y"],
+            curr_line,
+        ) = line_utils.get_current_line(
+            self.env["screen"]["newCursorReview"]["x"],
+            self.env["screen"]["newCursorReview"]["y"],
+            self.env["screen"]["new_content_text"],
+        )
+
+        if curr_line.isspace():
+            self.env["runtime"]["OutputManager"].present_text(
+                _("blank"), sound_icon="EmptyLine", interrupt=True, flush=False
+            )
+        else:
+            self.env["runtime"]["OutputManager"].present_text(
+                curr_line, interrupt=True, flush=False
+            )
+
+    def set_callback(self, callback):
+        pass

src/fenrirscreenreader/commands/commands/review_curr_word.py

@@ -2,35 +2,99 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
+from fenrirscreenreader.core.i18n import _
 from fenrirscreenreader.utils import word_utils
+from fenrirscreenreader.core import debug
 
-class command():
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
-    def getDescription(self):
-            return _('current word.')        
+        pass
+
+    def get_description(self):
+        return _("current word.")
 
     def run(self):
-        self.env['runtime']['cursorManager'].enterReviewModeCurrTextCursor()
+        self.env["runtime"][
+            "CursorManager"
+        ].enter_review_mode_curr_text_cursor()
 
-        self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], currWord, endOfScreen, lineBreak = \
-          word_utils.getCurrentWord(self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], self.env['screen']['newContentText'])
-        
-        if currWord.isspace():
-            self.env['runtime']['outputManager'].presentText(_("blank"), interrupt=True, flush=False)
+        (
+            self.env["screen"]["newCursorReview"]["x"],
+            self.env["screen"]["newCursorReview"]["y"],
+            curr_word,
+            end_of_screen,
+            line_break,
+        ) = word_utils.get_current_word(
+            self.env["screen"]["newCursorReview"]["x"],
+            self.env["screen"]["newCursorReview"]["y"],
+            self.env["screen"]["new_content_text"],
+        )
+
+        # Check if we're in table mode and provide table-aware output
+        is_table_mode = self.env["runtime"]["TableManager"].is_table_mode()
+        self.env["runtime"]["DebugManager"].write_debug_out(
+            f"review_curr_word: is_table_mode={is_table_mode}",
+            debug.DebugLevel.INFO
+        )
+        if is_table_mode:
+            # Get current cell info using internal column tracking
+            table_info = (
+                self.env["runtime"]["TableManager"].get_current_table_cell_info()
+            )
+            if table_info:
+                # Announce with table context - cell content first, then header
+                output_text = (
+                    f"{table_info['cell_content']} {table_info['column_header']}"
+                )
+                self.env["runtime"]["OutputManager"].present_text(
+                    output_text, interrupt=True, flush=False
+                )
+                return  # Exit early for table mode
+            else:
+                # Fallback to regular word announcement
+                if curr_word.isspace():
+                    self.env["runtime"]["OutputManager"].present_text(
+                        _("blank"), interrupt=True, flush=False
+                    )
+                else:
+                    self.env["runtime"]["OutputManager"].present_text(
+                        curr_word, interrupt=True, flush=False
+                    )
         else:
-            self.env['runtime']['outputManager'].presentText(currWord, interrupt=True, flush=False)
-        if endOfScreen:
-            if self.env['runtime']['settingsManager'].getSettingAsBool('review', 'endOfScreen'):        
-                self.env['runtime']['outputManager'].presentText(_('end of screen'), interrupt=True, soundIcon='EndOfScreen')
-        if lineBreak:
-            if self.env['runtime']['settingsManager'].getSettingAsBool('review', 'lineBreak'):        
-                self.env['runtime']['outputManager'].presentText(_('line break'), interrupt=False, soundIcon='EndOfLine')
-    def setCallback(self, callback):
+            # Regular word announcement
+            if curr_word.isspace():
+                self.env["runtime"]["OutputManager"].present_text(
+                    _("blank"), interrupt=True, flush=False
+                )
+            else:
+                self.env["runtime"]["OutputManager"].present_text(
+                    curr_word, interrupt=True, flush=False
+                )
+        if end_of_screen:
+            if self.env["runtime"]["SettingsManager"].get_setting_as_bool(
+                "review", "end_of_screen"
+            ):
+                self.env["runtime"]["OutputManager"].present_text(
+                    _("end of screen"),
+                    interrupt=True,
+                    sound_icon="EndOfScreen",
+                )
+        if line_break:
+            if self.env["runtime"]["SettingsManager"].get_setting_as_bool(
+                "review", "line_break"
+            ):
+                self.env["runtime"]["OutputManager"].present_text(
+                    _("line break"), interrupt=False, sound_icon="EndOfLine"
+                )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/review_curr_word_phonetic.py

@@ -2,39 +2,73 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.utils import word_utils
+from fenrirscreenreader.core.i18n import _
 from fenrirscreenreader.utils import char_utils
+from fenrirscreenreader.utils import word_utils
 
-class command():
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('Phonetically spells the current word')        
-    
-    def run(self):
-        self.env['runtime']['cursorManager'].enterReviewModeCurrTextCursor()
-        self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], currWord, endOfScreen, lineBreak = \
-          word_utils.getCurrentWord(self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], self.env['screen']['newContentText'])
-        
-        if currWord.isspace():
-            self.env['runtime']['outputManager'].presentText(_("blank"), interrupt=True, flush=False)
-        else:
-            firstSequence = True
-            for c in currWord:
-                currChar = char_utils.getPhonetic(c) 
-                self.env['runtime']['outputManager'].presentText(currChar, interrupt=firstSequence, announceCapital=True, flush=False)
-                firstSequence = False
-        if endOfScreen:
-            if self.env['runtime']['settingsManager'].getSettingAsBool('review', 'endOfScreen'):        
-                self.env['runtime']['outputManager'].presentText(_('end of screen'), interrupt=True, soundIcon='EndOfScreen')                 
-        if lineBreak:
-            if self.env['runtime']['settingsManager'].getSettingAsBool('review', 'lineBreak'):        
-                self.env['runtime']['outputManager'].presentText(_('line break'), interrupt=False, soundIcon='EndOfLine')   
-    def setCallback(self, callback):
+        pass
+
+    def get_description(self):
+        return _("Phonetically spells the current word")
+
+    def run(self):
+        self.env["runtime"][
+            "CursorManager"
+        ].enter_review_mode_curr_text_cursor()
+        (
+            self.env["screen"]["newCursorReview"]["x"],
+            self.env["screen"]["newCursorReview"]["y"],
+            curr_word,
+            end_of_screen,
+            line_break,
+        ) = word_utils.get_current_word(
+            self.env["screen"]["newCursorReview"]["x"],
+            self.env["screen"]["newCursorReview"]["y"],
+            self.env["screen"]["new_content_text"],
+        )
+
+        if curr_word.isspace():
+            self.env["runtime"]["OutputManager"].present_text(
+                _("blank"), interrupt=True, flush=False
+            )
+        else:
+            first_sequence = True
+            for c in curr_word:
+                curr_char = char_utils.get_phonetic(c)
+                self.env["runtime"]["OutputManager"].present_text(
+                    curr_char,
+                    interrupt=first_sequence,
+                    announce_capital=True,
+                    flush=False,
+                )
+                first_sequence = False
+        if end_of_screen:
+            if self.env["runtime"]["SettingsManager"].get_setting_as_bool(
+                "review", "end_of_screen"
+            ):
+                self.env["runtime"]["OutputManager"].present_text(
+                    _("end of screen"),
+                    interrupt=True,
+                    sound_icon="EndOfScreen",
+                )
+        if line_break:
+            if self.env["runtime"]["SettingsManager"].get_setting_as_bool(
+                "review", "line_break"
+            ):
+                self.env["runtime"]["OutputManager"].present_text(
+                    _("line break"), interrupt=False, sound_icon="EndOfLine"
+                )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/review_down.py

@@ -2,27 +2,55 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
+from fenrirscreenreader.core.i18n import _
 from fenrirscreenreader.utils import char_utils
 
-class command():
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('Move review to the character below the current position')        
+        pass
+
+    def get_description(self):
+        return _("Move review to the character below the current position")
 
     def run(self):
-        cursorPos = self.env['runtime']['cursorManager'].getReviewOrTextCursor()
-        self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], downChar, endOfScreen = \
-          char_utils.getDownChar(self.env['screen']['newCursorReview']['x'],self.env['screen']['newCursorReview']['y'], self.env['screen']['newContentText'])
-        self.env['runtime']['outputManager'].presentText(downChar ,interrupt=True, ignorePunctuation=True, announceCapital=True, flush=False)
-        if endOfScreen:
-            if self.env['runtime']['settingsManager'].getSettingAsBool('review', 'endOfScreen'):        
-                self.env['runtime']['outputManager'].presentText(_('end of screen'), interrupt=True, soundIcon='EndOfScreen')                     
-    def setCallback(self, callback):
+        cursor_pos = self.env["runtime"][
+            "CursorManager"
+        ].get_review_or_text_cursor()
+        (
+            self.env["screen"]["newCursorReview"]["x"],
+            self.env["screen"]["newCursorReview"]["y"],
+            downChar,
+            end_of_screen,
+        ) = char_utils.get_down_char(
+            self.env["screen"]["newCursorReview"]["x"],
+            self.env["screen"]["newCursorReview"]["y"],
+            self.env["screen"]["new_content_text"],
+        )
+        self.env["runtime"]["OutputManager"].present_text(
+            downChar,
+            interrupt=True,
+            ignore_punctuation=True,
+            announce_capital=True,
+            flush=False,
+        )
+        if end_of_screen:
+            if self.env["runtime"]["SettingsManager"].get_setting_as_bool(
+                "review", "end_of_screen"
+            ):
+                self.env["runtime"]["OutputManager"].present_text(
+                    _("end of screen"),
+                    interrupt=True,
+                    sound_icon="EndOfScreen",
+                )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/review_line_begin.py

@@ -2,31 +2,80 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
+from fenrirscreenreader.core.i18n import _
 from fenrirscreenreader.utils import char_utils
 
-class command():
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('set review cursor to begin of current line and display the content')
+        pass
+
+    def get_description(self):
+        return _(
+            "set review cursor to begin of current line and display the content"
+        )
 
     def run(self):
-        cursorPos = self.env['runtime']['cursorManager'].getReviewOrTextCursor()
-        self.env['runtime']['cursorManager'].setReviewCursorPosition(0 ,cursorPos['y'])
-        self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], currChar = \
-          char_utils.getCurrentChar(self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], self.env['screen']['newContentText'])
+        # Check if we're in table mode first
+        is_table_mode = self.env["runtime"]["TableManager"].is_table_mode()
+        if is_table_mode:
+            table_info = self.env["runtime"]["TableManager"].move_to_first_cell()
+            if table_info:
+                output_text = (
+                    f"{table_info['cell_content']} {table_info['column_header']}"
+                )
+                self.env["runtime"]["OutputManager"].present_text(
+                    output_text, interrupt=True, flush=False
+                )
+                self.env["runtime"]["OutputManager"].present_text(
+                    _("first cell"), interrupt=False
+                )
+            else:
+                self.env["runtime"]["OutputManager"].present_text(
+                    _("no table data"), interrupt=True, flush=False
+                )
+            return
         
-        if currChar.isspace():
-            self.env['runtime']['outputManager'].presentText(_("blank"), interrupt=True, flush=False)
+        # Regular line begin navigation (when not in table mode)
+        cursor_pos = self.env["runtime"][
+            "CursorManager"
+        ].get_review_or_text_cursor()
+        self.env["runtime"]["CursorManager"].set_review_cursor_position(
+            0, cursor_pos["y"]
+        )
+        (
+            self.env["screen"]["newCursorReview"]["x"],
+            self.env["screen"]["newCursorReview"]["y"],
+            curr_char,
+        ) = char_utils.get_current_char(
+            self.env["screen"]["newCursorReview"]["x"],
+            self.env["screen"]["newCursorReview"]["y"],
+            self.env["screen"]["new_content_text"],
+        )
+
+        if curr_char.isspace():
+            self.env["runtime"]["OutputManager"].present_text(
+                _("blank"), interrupt=True, flush=False
+            )
         else:
-            self.env['runtime']['outputManager'].presentText(currChar ,interrupt=True, ignorePunctuation=True, announceCapital=True, flush=False)
-        self.env['runtime']['outputManager'].presentText(_("beginning of line"), interrupt=False)
-   
-    def setCallback(self, callback):
+            self.env["runtime"]["OutputManager"].present_text(
+                curr_char,
+                interrupt=True,
+                ignore_punctuation=True,
+                announce_capital=True,
+                flush=False,
+            )
+        self.env["runtime"]["OutputManager"].present_text(
+            _("beginning of line"), interrupt=False
+        )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/review_line_end.py

@@ -2,28 +2,75 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
+from fenrirscreenreader.core.i18n import _
 from fenrirscreenreader.utils import char_utils
 
-class command():
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('Move Review to the end of current line and display the content')        
+        pass
+
+    def get_description(self):
+        return _(
+            "Move Review to the end of current line and display the content"
+        )
 
     def run(self):
-        cursorPos = self.env['runtime']['cursorManager'].getReviewOrTextCursor()
-        self.env['runtime']['cursorManager'].setReviewCursorPosition(self.env['screen']['columns']-1 ,cursorPos['y'])
-        self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], currChar = \
-          char_utils.getCurrentChar(self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], self.env['screen']['newContentText'])
+        # Check if we're in table mode first
+        is_table_mode = self.env["runtime"]["TableManager"].is_table_mode()
+        if is_table_mode:
+            table_info = self.env["runtime"]["TableManager"].move_to_last_cell()
+            if table_info:
+                output_text = (
+                    f"{table_info['cell_content']} {table_info['column_header']}"
+                )
+                self.env["runtime"]["OutputManager"].present_text(
+                    output_text, interrupt=True, flush=False
+                )
+                self.env["runtime"]["OutputManager"].present_text(
+                    _("last cell"), interrupt=False
+                )
+            else:
+                self.env["runtime"]["OutputManager"].present_text(
+                    _("no table data"), interrupt=True, flush=False
+                )
+            return
         
-        self.env['runtime']['outputManager'].presentText(currChar ,interrupt=True, ignorePunctuation=True, announceCapital=True, flush=False)
-        self.env['runtime']['outputManager'].presentText(_("end of line"), interrupt=False)
-   
-    def setCallback(self, callback):
+        # Regular line end navigation (when not in table mode)
+        cursor_pos = self.env["runtime"][
+            "CursorManager"
+        ].get_review_or_text_cursor()
+        self.env["runtime"]["CursorManager"].set_review_cursor_position(
+            self.env["screen"]["columns"] - 1, cursor_pos["y"]
+        )
+        (
+            self.env["screen"]["newCursorReview"]["x"],
+            self.env["screen"]["newCursorReview"]["y"],
+            curr_char,
+        ) = char_utils.get_current_char(
+            self.env["screen"]["newCursorReview"]["x"],
+            self.env["screen"]["newCursorReview"]["y"],
+            self.env["screen"]["new_content_text"],
+        )
+
+        self.env["runtime"]["OutputManager"].present_text(
+            curr_char,
+            interrupt=True,
+            ignore_punctuation=True,
+            announce_capital=True,
+            flush=False,
+        )
+        self.env["runtime"]["OutputManager"].present_text(
+            _("end of line"), interrupt=False
+        )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/review_line_first_char.py

@@ -2,34 +2,89 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.utils import line_utils
+from fenrirscreenreader.core.i18n import _
 from fenrirscreenreader.utils import char_utils
+from fenrirscreenreader.utils import line_utils
 
-class command():
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('Move Review to the first character on the line')
+        pass
+
+    def get_description(self):
+        return _("Move Review to the first character on the line")
 
     def run(self):
-        cursorPos = self.env['runtime']['cursorManager'].getReviewOrTextCursor()
-        x, y, currLine = \
-          line_utils.getCurrentLine(cursorPos['x'], cursorPos['y'], self.env['screen']['newContentText'])
-        if currLine.isspace():
-            self.env['runtime']['outputManager'].presentText(_("line is empty"), interrupt=True)
-            return          
-        self.env['runtime']['cursorManager'].setReviewCursorPosition((len(currLine) - len(currLine.lstrip())), cursorPos['y'])
-        self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], currChar = \
-          char_utils.getCurrentChar(self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], self.env['screen']['newContentText'])       
+        # Check if we're in table mode first
+        is_table_mode = self.env["runtime"]["TableManager"].is_table_mode()
+        if is_table_mode:
+            table_info = self.env["runtime"]["TableManager"].move_to_first_char_in_cell()
+            if table_info:
+                char_utils.present_char_for_review(
+                    self.env,
+                    table_info['character'],
+                    interrupt=True,
+                    announce_capital=True,
+                    flush=False,
+                )
+                self.env["runtime"]["OutputManager"].present_text(
+                    _("first character in cell {0}").format(table_info['column_header']),
+                    interrupt=False,
+                )
+            else:
+                self.env["runtime"]["OutputManager"].present_text(
+                    _("no table data"), interrupt=True, flush=False
+                )
+            return
+        
+        # Regular line first character navigation (when not in table mode)
+        cursor_pos = self.env["runtime"][
+            "CursorManager"
+        ].get_review_or_text_cursor()
+        x, y, curr_line = line_utils.get_current_line(
+            cursor_pos["x"],
+            cursor_pos["y"],
+            self.env["screen"]["new_content_text"],
+        )
+        if curr_line.isspace():
+            self.env["runtime"]["OutputManager"].present_text(
+                _("line is empty"), interrupt=True
+            )
+            return
+        self.env["runtime"]["CursorManager"].set_review_cursor_position(
+            (len(curr_line) - len(curr_line.lstrip())), cursor_pos["y"]
+        )
+        (
+            self.env["screen"]["newCursorReview"]["x"],
+            self.env["screen"]["newCursorReview"]["y"],
+            curr_char,
+        ) = char_utils.get_current_char(
+            self.env["screen"]["newCursorReview"]["x"],
+            self.env["screen"]["newCursorReview"]["y"],
+            self.env["screen"]["new_content_text"],
+        )
 
-        char_utils.presentCharForReview(self.env, currChar, interrupt=True, announceCapital=True, flush=False)        
-        self.env['runtime']['outputManager'].presentText(_("first character in line indent {0}").format(str(len(currLine) - len(currLine.lstrip()))), interrupt=False)
-   
-    def setCallback(self, callback):
+        char_utils.present_char_for_review(
+            self.env,
+            curr_char,
+            interrupt=True,
+            announce_capital=True,
+            flush=False,
+        )
+        self.env["runtime"]["OutputManager"].present_text(
+            _("first character in line indent {0}").format(
+                str(len(curr_line) - len(curr_line.lstrip()))
+            ),
+            interrupt=False,
+        )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/review_line_last_char.py

@@ -2,28 +2,74 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
+from fenrirscreenreader.core.i18n import _
 from fenrirscreenreader.utils import char_utils
 
-class command():
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('Move Review to the last character on the line')
+        pass
+
+    def get_description(self):
+        return _("Move Review to the last character on the line")
 
     def run(self):
-        cursorPos = self.env['runtime']['cursorManager'].getReviewOrTextCursor()
-        self.env['runtime']['cursorManager'].setReviewCursorPosition(self.env['screen']['columns']-1 ,cursorPos['y'])
-        self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], lastChar = \
-          char_utils.getLastCharInLine(self.env['screen']['newCursorReview']['y'], self.env['screen']['newContentText'])
+        # Check if we're in table mode first
+        is_table_mode = self.env["runtime"]["TableManager"].is_table_mode()
+        if is_table_mode:
+            table_info = self.env["runtime"]["TableManager"].move_to_last_char_in_cell()
+            if table_info:
+                char_utils.present_char_for_review(
+                    self.env,
+                    table_info['character'],
+                    interrupt=True,
+                    announce_capital=True,
+                    flush=False,
+                )
+                self.env["runtime"]["OutputManager"].present_text(
+                    _("last character in cell {0}").format(table_info['column_header']),
+                    interrupt=False,
+                )
+            else:
+                self.env["runtime"]["OutputManager"].present_text(
+                    _("no table data"), interrupt=True, flush=False
+                )
+            return
         
-        char_utils.presentCharForReview(self.env, lastChar, interrupt=True, announceCapital=True, flush=False)        
-        self.env['runtime']['outputManager'].presentText(_("last character in line"), interrupt=False)
-   
-    def setCallback(self, callback):
+        # Regular line last character navigation (when not in table mode)
+        cursor_pos = self.env["runtime"][
+            "CursorManager"
+        ].get_review_or_text_cursor()
+        self.env["runtime"]["CursorManager"].set_review_cursor_position(
+            self.env["screen"]["columns"] - 1, cursor_pos["y"]
+        )
+        (
+            self.env["screen"]["newCursorReview"]["x"],
+            self.env["screen"]["newCursorReview"]["y"],
+            lastChar,
+        ) = char_utils.get_last_char_in_line(
+            self.env["screen"]["newCursorReview"]["y"],
+            self.env["screen"]["new_content_text"],
+        )
+
+        char_utils.present_char_for_review(
+            self.env,
+            lastChar,
+            interrupt=True,
+            announce_capital=True,
+            flush=False,
+        )
+        self.env["runtime"]["OutputManager"].present_text(
+            _("last character in line"), interrupt=False
+        )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/review_next_char.py

@@ -2,38 +2,134 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
+from fenrirscreenreader.core.i18n import _
 from fenrirscreenreader.utils import char_utils
 
-class command():
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('Moves review to the next character ')        
-    
-    def run(self):
-        self.env['runtime']['cursorManager'].enterReviewModeCurrTextCursor()
-        self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], nextChar, endOfScreen, lineBreak = \
-          char_utils.getNextChar(self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], self.env['screen']['newContentText'])
 
-        char_utils.presentCharForReview(self.env, nextChar, interrupt=True, announceCapital=True, flush=False)
-        if endOfScreen:
-            if self.env['runtime']['settingsManager'].getSettingAsBool('review', 'endOfScreen'):        
-                self.env['runtime']['outputManager'].presentText(_('end of screen'), interrupt=True, soundIcon='EndOfScreen')                 
-        if lineBreak:
-            if self.env['runtime']['settingsManager'].getSettingAsBool('review', 'lineBreak'):        
-                self.env['runtime']['outputManager'].presentText(_('line break'), interrupt=False, soundIcon='EndOfLine')      
-        # is has attribute it enabled?    
-        if self.env['runtime']['settingsManager'].getSettingAsBool('general', 'hasAttributes'):
-            cursorPos = self.env['screen']['newCursorReview']
-            
-            if not self.env['runtime']['attributeManager'].hasAttributes(cursorPos):
-                return
-            self.env['runtime']['outputManager'].presentText('has attribute', soundIcon='HasAttributes', interrupt=False)                     
-    def setCallback(self, callback):
+    def shutdown(self):
+        pass
+
+    def get_description(self):
+        return _("Moves review to the next character")
+
+    def run(self):
+        self.env["runtime"][
+            "CursorManager"
+        ].enter_review_mode_curr_text_cursor()
+        
+        # Check if we're in table mode for bounded navigation
+        if self.env["runtime"]["TableManager"].is_table_mode():
+            table_info = self.env["runtime"]["TableManager"].get_current_table_cell_info()
+            if table_info:
+                cursor_pos = self.env["screen"]["newCursorReview"]
+                line_text = self.env["runtime"]["ScreenManager"].get_line_text(
+                    cursor_pos["y"]
+                )
+                if line_text:
+                    column_start = self.env["runtime"]["TableManager"].get_column_start_position(
+                        line_text, table_info["column_index"]
+                    )
+                    cell_content = table_info["cell_content"]
+                    cell_end = column_start + len(cell_content)
+                    
+                    # Check if we're already at the end of the cell
+                    if cursor_pos["x"] >= cell_end - 1:
+                        # At cell boundary - announce end and don't move
+                        char_utils.present_char_for_review(
+                            self.env,
+                            cell_content[-1] if cell_content else "",
+                            interrupt=True,
+                            announce_capital=True,
+                            flush=False,
+                        )
+                        self.env["runtime"]["OutputManager"].present_text(
+                            _("end of cell"), 
+                            interrupt=False, 
+                            sound_icon="EndOfLine"
+                        )
+                        return
+                    
+                    # Move within cell bounds
+                    relative_pos = cursor_pos["x"] - column_start
+                    if relative_pos < len(cell_content) - 1:
+                        new_relative_pos = relative_pos + 1
+                        self.env["screen"]["newCursorReview"]["x"] = (
+                            column_start + new_relative_pos
+                        )
+                        
+                        # Get character at new position
+                        if new_relative_pos < len(cell_content):
+                            next_char = cell_content[new_relative_pos]
+                        else:
+                            next_char = ""
+                        
+                        char_utils.present_char_for_review(
+                            self.env,
+                            next_char,
+                            interrupt=True,
+                            announce_capital=True,
+                            flush=False,
+                        )
+                        return
+
+        # Regular navigation for non-table mode
+        (
+            self.env["screen"]["newCursorReview"]["x"],
+            self.env["screen"]["newCursorReview"]["y"],
+            next_char,
+            end_of_screen,
+            line_break,
+        ) = char_utils.get_next_char(
+            self.env["screen"]["newCursorReview"]["x"],
+            self.env["screen"]["newCursorReview"]["y"],
+            self.env["screen"]["new_content_text"],
+        )
+
+        char_utils.present_char_for_review(
+            self.env,
+            next_char,
+            interrupt=True,
+            announce_capital=True,
+            flush=False,
+        )
+        if end_of_screen:
+            if self.env["runtime"]["SettingsManager"].get_setting_as_bool(
+                "review", "end_of_screen"
+            ):
+                self.env["runtime"]["OutputManager"].present_text(
+                    _("end of screen"),
+                    interrupt=True,
+                    sound_icon="EndOfScreen",
+                )
+        if line_break:
+            if self.env["runtime"]["SettingsManager"].get_setting_as_bool(
+                "review", "line_break"
+            ):
+                self.env["runtime"]["OutputManager"].present_text(
+                    _("line break"), interrupt=False, sound_icon="EndOfLine"
+                )
+        # is has attribute it enabled?
+        if self.env["runtime"]["SettingsManager"].get_setting_as_bool(
+            "general", "hasattributes"
+        ):
+            cursor_pos = self.env["screen"]["newCursorReview"]
+
+            if not self.env["runtime"]["AttributeManager"].has_attributes(
+                cursor_pos
+            ):
+                return
+            self.env["runtime"]["OutputManager"].present_text(
+                "has attribute", sound_icon="HasAttributes", interrupt=False
+            )
+
+    def set_callback(self, callback):
         pass