From f97571129af6e5673d36b37f0d1db7e82d24bdcd Mon Sep 17 00:00:00 2001 From: Vaishno Kumar Singh Date: Mon, 22 Sep 2025 00:47:25 +0530 Subject: [PATCH] Add files via upload --- README.md | 2 +- config/default_settings.json | 21 ++ config/user_settings.json | 0 install/install.sh | 284 +++++++++++++++ install/uninstall.sh | 0 install/voice-to-text.service | 54 +++ logs/voice-to-text.log | 0 requirements.txt | 15 + sounds/recording_start.wav | Bin 0 -> 8864 bytes sounds/recording_stop.wav | Bin 0 -> 8864 bytes .../config_manager.cpython-313.pyc | Bin 0 -> 2933 bytes .../hotkey_detector.cpython-313.pyc | Bin 0 -> 11363 bytes .../service_manager.cpython-313.pyc | Bin 0 -> 9698 bytes src/__pycache__/text_inserter.cpython-313.pyc | Bin 0 -> 3561 bytes src/audio_manager.py | 252 ++++++++++++++ src/config_manager.py | 42 +++ src/hotkey_detector.cpp | 0 src/hotkey_detector.py | 185 ++++++++++ src/main.py | 323 ++++++++++++++++++ src/service_manager.py | 182 ++++++++++ src/speech_recognizer.py | 104 ++++++ src/text_inserter.py | 74 ++++ tests/test_audio.py | 0 tests/test_integration.py | 0 tests/test_recognition.py | 0 25 files changed, 1537 insertions(+), 1 deletion(-) create mode 100644 config/default_settings.json create mode 100644 config/user_settings.json create mode 100644 install/install.sh create mode 100644 install/uninstall.sh create mode 100644 install/voice-to-text.service create mode 100644 logs/voice-to-text.log create mode 100644 requirements.txt create mode 100644 sounds/recording_start.wav create mode 100644 sounds/recording_stop.wav create mode 100644 src/__pycache__/config_manager.cpython-313.pyc create mode 100644 src/__pycache__/hotkey_detector.cpython-313.pyc create mode 100644 src/__pycache__/service_manager.cpython-313.pyc create mode 100644 src/__pycache__/text_inserter.cpython-313.pyc create mode 100644 src/audio_manager.py create mode 100644 src/config_manager.py create mode 100644 src/hotkey_detector.cpp create mode 100644 src/hotkey_detector.py create mode 100644 src/main.py create mode 100644 src/service_manager.py create mode 100644 src/speech_recognizer.py create mode 100644 src/text_inserter.py create mode 100644 tests/test_audio.py create mode 100644 tests/test_integration.py create mode 100644 tests/test_recognition.py diff --git a/README.md b/README.md index b8695fd..1e1f686 100644 --- a/README.md +++ b/README.md @@ -283,4 +283,4 @@ For issues, questions, or contributions: - Check the troubleshooting section above - Review log files for error details - Test individual components with verbose logging -- Ensure all dependencies are properly installed +- Ensure all dependencies are properly installed \ No newline at end of file diff --git a/config/default_settings.json b/config/default_settings.json new file mode 100644 index 0000000..0da1ac5 --- /dev/null +++ b/config/default_settings.json @@ -0,0 +1,21 @@ +{ + "hotkey": "++v", + "audio": { + "sample_rate": 16000, + "channels": 1, + "device_index": null, + "noise_reduction_level": 1, + "silence_threshold": -40 + }, + "whisper": { + "model": "small", + "language": null + }, + "typing": { + "speed": 0.05 + }, + "logging": { + "level": "INFO", + "file": "/home/vshnsngh/Desktop/Coding/voice-to-text-system/logs/voice-to-text.log" + } +} diff --git a/config/user_settings.json b/config/user_settings.json new file mode 100644 index 0000000..e69de29 diff --git a/install/install.sh b/install/install.sh new file mode 100644 index 0000000..51b0fe6 --- /dev/null +++ b/install/install.sh @@ -0,0 +1,284 @@ +#!/bin/bash + +# Voice-to-Text System Installation Script +# This script installs the voice-to-text system and its dependencies + +set -e # Exit on any error + +# Colors for output +RED='\033[0;31m' +GREEN='\033[0;32m' +YELLOW='\033[1;33m' +BLUE='\033[0;34m' +NC='\033[0m' # No Color + +# Configuration +PROJECT_NAME="voice-to-text-system" +INSTALL_DIR="/opt/$PROJECT_NAME" +SERVICE_NAME="voice-to-text" +CONFIG_DIR="/etc/$PROJECT_NAME" +LOG_DIR="/var/log/$PROJECT_NAME" +BIN_DIR="/usr/local/bin" + +# Get current directory (where the script is located) +SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )" +PROJECT_DIR="$( cd "$SCRIPT_DIR/.." && pwd )" + +print_status() { + echo -e "${BLUE}[INFO]${NC} $1" +} + +print_success() { + echo -e "${GREEN}[SUCCESS]${NC} $1" +} + +print_warning() { + echo -e "${YELLOW}[WARNING]${NC} $1" +} + +print_error() { + echo -e "${RED}[ERROR]${NC} $1" +} + +check_root() { + if [[ $EUID -ne 0 ]]; then + print_error "This script must be run as root (use sudo)" + exit 1 + fi +} + +check_system() { + print_status "Checking system requirements..." + + # Check if running on Linux + if [[ "$OSTYPE" != "linux-gnu"* ]]; then + print_error "This system is only supported on Linux" + exit 1 + fi + + # Check if Python 3 is installed + if ! command -v python3 &> /dev/null; then + print_error "Python 3 is required but not installed" + exit 1 + fi + + # Check if pip is installed + if ! command -v pip3 &> /dev/null; then + print_error "pip3 is required but not installed" + exit 1 + fi + + print_success "System requirements met" +} + +install_system_deps() { + print_status "Installing system dependencies..." + + # Detect package manager and install dependencies + if command -v apt-get &> /dev/null; then + apt-get update + apt-get install -y \ + python3-dev \ + python3-pip \ + python3-venv \ + portaudio19-dev \ + libsndfile1 \ + ffmpeg \ + alsa-utils \ + pulseaudio \ + xdotool + elif command -v dnf &> /dev/null; then + dnf install -y \ + python3-devel \ + python3-pip \ + portaudio-devel \ + libsndfile \ + ffmpeg \ + alsa-utils \ + pulseaudio \ + xdotool + elif command -v yum &> /dev/null; then + yum install -y \ + python3-devel \ + python3-pip \ + portaudio-devel \ + libsndfile \ + ffmpeg \ + alsa-utils \ + pulseaudio \ + xdotool + else + print_warning "Unknown package manager. Please install the following packages manually:" + print_warning "- Python 3 development headers" + print_warning "- PortAudio development library" + print_warning "- libsndfile" + print_warning "- FFmpeg" + print_warning "- ALSA utilities" + print_warning "- PulseAudio" + print_warning "- xdotool" + fi + + print_success "System dependencies installed" +} + +create_directories() { + print_status "Creating directories..." + + # Create directories with proper permissions + mkdir -p "$INSTALL_DIR" + mkdir -p "$CONFIG_DIR" + mkdir -p "$LOG_DIR" + + # Set permissions + chmod 755 "$INSTALL_DIR" + chmod 755 "$CONFIG_DIR" + chmod 755 "$LOG_DIR" + + print_success "Directories created" +} + +install_application() { + print_status "Installing application files..." + + # Copy source files + cp -r "$PROJECT_DIR/src"/* "$INSTALL_DIR/" + + # Copy configuration files + cp "$PROJECT_DIR/config/default_settings.json" "$CONFIG_DIR/" + + # Create user config if it doesn't exist + if [[ ! -f "$CONFIG_DIR/user_settings.json" ]]; then + echo '{}' > "$CONFIG_DIR/user_settings.json" + fi + + # Copy sounds directory if it exists + if [[ -d "$PROJECT_DIR/sounds" ]]; then + cp -r "$PROJECT_DIR/sounds" "$INSTALL_DIR/" + fi + + # Make main script executable + chmod +x "$INSTALL_DIR/main.py" + + # Update config paths in the default config + sed -i "s|/home/vshnsngh/Desktop/Coding/voice-to-text-system/logs/|$LOG_DIR/|g" "$CONFIG_DIR/default_settings.json" + + print_success "Application files installed" +} + +install_python_deps() { + print_status "Installing Python dependencies..." + + # Create virtual environment + python3 -m venv "$INSTALL_DIR/venv" + + # Activate virtual environment and install dependencies + source "$INSTALL_DIR/venv/bin/activate" + + # Upgrade pip + pip install --upgrade pip + + # Install required packages + pip install \ + whisper \ + sounddevice \ + soundfile \ + numpy \ + pyautogui \ + pyperclip \ + pynput + + deactivate + + print_success "Python dependencies installed" +} + +create_launcher() { + print_status "Creating launcher script..." + + # Create launcher script + cat > "$BIN_DIR/voice-to-text" << EOF +#!/bin/bash +# Voice-to-Text System Launcher + +cd "$INSTALL_DIR" +source "$INSTALL_DIR/venv/bin/activate" +exec python3 "$INSTALL_DIR/main.py" --config "$CONFIG_DIR" "\$@" +EOF + + chmod +x "$BIN_DIR/voice-to-text" + + print_success "Launcher script created" +} + +install_service() { + print_status "Installing systemd service..." + + # Copy service file + cp "$PROJECT_DIR/install/voice-to-text.service" "/etc/systemd/system/" + + # Update service file with correct paths + sed -i "s|/opt/voice-to-text-system|$INSTALL_DIR|g" "/etc/systemd/system/voice-to-text.service" + sed -i "s|/etc/voice-to-text-system|$CONFIG_DIR|g" "/etc/systemd/system/voice-to-text.service" + + # Reload systemd + systemctl daemon-reload + + # Enable service (but don't start it yet) + systemctl enable voice-to-text.service + + print_success "Systemd service installed" +} + +show_post_install() { + print_success "Installation completed successfully!" + echo + echo -e "${BLUE}Usage:${NC}" + echo " voice-to-text # Run in foreground" + echo " voice-to-text --daemon # Run as daemon" + echo " voice-to-text --status # Check status" + echo " voice-to-text --stop # Stop daemon" + echo + echo -e "${BLUE}Service Management:${NC}" + echo " sudo systemctl start voice-to-text # Start service" + echo " sudo systemctl stop voice-to-text # Stop service" + echo " sudo systemctl status voice-to-text # Check service status" + echo + echo -e "${BLUE}Configuration:${NC}" + echo " Config files: $CONFIG_DIR/" + echo " Logs: $LOG_DIR/" + echo " Application: $INSTALL_DIR/" + echo + echo -e "${YELLOW}Note:${NC} Default hotkey is Ctrl+Alt+V" + echo -e "${YELLOW}Note:${NC} Make sure your microphone is working and accessible" +} + +# Main installation process +main() { + echo -e "${GREEN}Voice-to-Text System Installer${NC}" + echo "================================" + echo + + check_root + check_system + install_system_deps + create_directories + install_application + install_python_deps + create_launcher + install_service + + echo + show_post_install +} + +# Handle command line arguments +case "$1" in + --help|-h) + echo "Usage: $0 [--help]" + echo "Install the Voice-to-Text System" + exit 0 + ;; + *) + main + ;; +esac \ No newline at end of file diff --git a/install/uninstall.sh b/install/uninstall.sh new file mode 100644 index 0000000..e69de29 diff --git a/install/voice-to-text.service b/install/voice-to-text.service new file mode 100644 index 0000000..b0e355c --- /dev/null +++ b/install/voice-to-text.service @@ -0,0 +1,54 @@ +[Unit] +Description=Voice-to-Text System with Whisper +Documentation=man:voice-to-text(1) +After=network.target sound.target pulseaudio.service +Wants=network.target sound.target + +[Service] +# Service configuration +Type=simple +User=root +Group=root + +# Working directory and execution +WorkingDirectory=/opt/voice-to-text-system +ExecStart=/opt/voice-to-text-system/venv/bin/python /opt/voice-to-text-system/main.py --config /etc/voice-to-text-system --daemon +ExecStop=/bin/kill -TERM $MAINPID +ExecReload=/bin/kill -HUP $MAINPID + +# Runtime configuration +Restart=always +RestartSec=10 +KillMode=process +TimeoutStopSec=30 + +# Security settings +NoNewPrivileges=true +PrivateTmp=true +ProtectSystem=strict +ReadWritePaths=/var/log/voice-to-text-system /tmp +ProtectHome=true +ProtectKernelTunables=true +ProtectKernelModules=true +ProtectControlGroups=true + +# Resource limits +LimitNOFILE=65536 +MemoryMax=2G +CPUQuota=200% + +# Environment +Environment=PYTHONPATH=/opt/voice-to-text-system +Environment=PYTHONUNBUFFERED=1 +Environment=HOME=/opt/voice-to-text-system + +# Audio and GUI access +SupplementaryGroups=audio pulse-access + +# Logging +StandardOutput=append:/var/log/voice-to-text-system/service.log +StandardError=append:/var/log/voice-to-text-system/service.log +SyslogIdentifier=voice-to-text + +[Install] +WantedBy=multi-user.target \ No newline at end of file diff --git a/logs/voice-to-text.log b/logs/voice-to-text.log new file mode 100644 index 0000000..e69de29 diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..dc6db02 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,15 @@ +# Core AI/ML dependencies +openai-whisper>=20230918 + +# Audio processing +sounddevice>=0.4.6 +soundfile>=0.12.1 +numpy>=1.24.0 + +# GUI automation and input +pyautogui>=0.9.54 +pyperclip>=1.8.2 +pynput>=1.7.6 + +# Additional utilities +pathlib>=1.0.1 \ No newline at end of file diff --git a/sounds/recording_start.wav b/sounds/recording_start.wav new file mode 100644 index 0000000000000000000000000000000000000000..cf3d1b7341fd891212fa5fdbef270df3d4fa4df5 GIT binary patch literal 8864 zcmWNWb#xQiAI0nL?roB$ZQ3;Mnam)ixU<0Gi!AO%f5=i;DDF@eS$u)TZE6Mo;El@Q?I;NXb;GM+m)K6Sp8epZ&}!XuqPfB{zt=Qac79%(g1odyNIs`OrQm-fa<_Dz(qji9Hx7c%Zd2- z>hOsH>pj*xtm`}0X0N+mt}MA|a@UPh&6mvdw0x!}C+gX*p9s(2#;zj7U@==GQr zggVka>J8RUo&zuod<+djv!F*JXJHoCm8nWEOdf|LMLiBG^0GTw1{yo4jq*xE>AJ$l z`UmPAa-u|mtbv{3doYBWBnuT^HO+=1^J?4P>YgUJ>(kITmsdVpLM+i{{3KE^6~|i2 z`zVYD&qE{7X2>dS*jZpDJLPKxBPVgqU z5aCPC$|Y*8{z{>vb+GdH#>CFh!AR#IZ(Go^s4SdIN@qHWd663>{2*Eg4MTUK@nDni zA#X2hAN3n)K4DeNaL9Pyd9JgD=XalIcB-kd%_v%64A(wX_)FKK|G{qXFYqIzO`Im5 zrXHj3E|^maRo-ow-;pse(P^AlXwaQVIAMA6^7N;SWUfMRK*Wc7p%2gwkOjE%TUoBO zMX9cd@v-9206(G|euUUFt3_P%m%Xc~(Rf|!r(7w$hZey;@K|^c@C*u?WQLUB58x-?%nqktN?S_26gNHmslVJ^ zHY)9{X`NW-UY=1BX}XiwpbU`3iE#)H#=`^zCk~OdDIe$IO*2Y@%IDOzw;Fnlqek}+ z{tLoy$E_v)l@?F8vL$>3P=iHKHPi-<0uh3VoZIv?vU}2$_<)FA0oOgQJ6!8~)8-;W0zX36N<)-)w4KJ`qK9^E&5{;+4`qbz7UP!}N{aPMT$Soe>tT8E zdB864BX;UsXrD+dz;o|27NpNl{+Mt%(ldzbC3NBqOzpVZz^TPf#bxo5c5# zdDzYR3~xY#rB4-c+U3TDMQt|UnoG^UbuSrS?mE-gBXo1j3WAh$gnF3ul-DNA1n)sZ z(0u5vC{%cwi)S{Z4<>KG&5g#T`vqO*zFZ=PneMiMC>EoP}b*x55RyD3&)BBIV)r z(W^op_`Gp>G4!FUv1xPlBAd=!ZFsMlqtHtL^e(1YYhg7)lI)Q`Rln44D=aBBR0mdD(H)^KusBQcPCg3ji6 z3c7#>uoALBMoEL`$`<5t zM2t$ZDT$OY9I+|zs%Ng_)&76m2kReHAeQX~8eP4rRQ6tc7?}Wj!$vq4ohKbqWNVGa zqM`%#`!&=S=bq7FC$|>g`=O&Tb%ZggE!0w0H!lU)2)>2-ArLw)DirX!KN)+||Cek_ z_z}qoTI03B>Gy%X9Z18n%B`jTg$wm7)PQ_Q`~vwEc7@-<%TPz@C54j~G%|}6wuoi2SgkKs-;rlZY{)i@^s8_Z`bLtfIHq}SIByQM5vp%Dt?61kwA^K` zPiV;T=#zLyl8Ms5r17o@J;0+Fh5Mi`(Qct9?+f!51x?Aoi=ySh&OUxFUPB>WGn$7ZEbSCP8$1JUP03_f-j%TQ%kc=Pq@Y+I+<)u`93 zS5!zQp^q`rSHdt7Az3LuuRf=rUihx`Nu^(-qT|!RH>ZzY$AUbg5^-OX-=w!OR&sj; zw?tDh|ML`D2>Jjz-V4?zs#EGi!pE3jLhty#aeXoTw!5r(K@G>ATa;^@rOj8cq(@LG z>;X@MFCcocqdZ*gq<>Z5TG~`GsbR3aw!gu##`A07q{wXvp~dpzxK>YT(KvC&~0{j%K-k7V~eYl*0Bw1dTze1jHL=19MxwQvB;hgTyf z#rI|RReN1{uCz%9P#+`;Cc%6pQ#?^dRkh{q zF+DHYTmGYNW!r?lOovR5qyR~{bG($;nzo)E!|CSN0OepAWP>cA1*qkFa^}(t)1DHm z;vR;(1Q0w34*0$?ZFlN^Ex%B*)KroeqvFbhVkVLd$G|~|tGHSEQ@JtEmhV&omkril zZ_Vn>8r|)_$loD+N?bH?ep&_XU-nJ@L*O%Lgc=}6C|U#w_Hl~nTgY>gZpHr|p$q8p z=yvGr^J!mMA5rdtM4(P65n3p^DyZQsVz{LDC(TJniM$ag@svAC`it9> z8?+U5mMaB~Iu~`jOd>vsOolySHGCQ!E3Hzj(Y`UhE1GBDTjSJH(5)Xfxgx&1LknXN zLTsvzim>dwNMHr{0vdoOK$k>yg4tXP<3{@5$!@s%$W=j?y>2*N9eCW)+>ldwt&~x? zN55Y^Tka$Ige-$y;D6!SXshIZifT=q(XZ&P?Z0Y%vupRrkdtet&+Cw=m>|L-(m3j5 z)*+rwNCU59gsg^CBEIl5_g7{bWqisP+>(JS%Rl=l=JGm3XqI4nAZ zk$xC*08a?xd4wito)xFj%^A*EZO{C(XBo4iRt&s)S zAaf)y<<070y{Ztf3aXwouIpSpxZHVxH!k>2)N7m|g+Q6he8*)8<)W3?d*nh)Fkg6- zH;XledV&-~NR0U!GV0^!>NOnLozaX|KeI&?B^jGFM-*L>dFTslua?3e5D&>Td6s&s zKDF>n>7mMshMOHH2hKX>cr6UFMGhrgOTL(HVoc>$3eJl%Fy(y-tpa0#YMz2+rY5DT z31u-yLN&g2*V5s#Zr_&dnq~IyMW2nEv<-?(={Zyjd%=_7;|MHnk`1e>bY}`|7PKO! zLEHYR|EuFC&vSvXk&_bIl7`508D*Rcf?q@g>|UYJ1#lIR!3WvD(Zs2H6K}>&47=g? z+U@1Y>mGB<_}bvIRmC&&TeS0)H>E1H6%K+q@FHZt_?#?9wMf@$Vpu#X7Subo*Y?#r z)Okn(7Drr+pPckNSx?`|5eULXqhLK`gua4LfV=!R>;~Ghv_#@Bao*u;{ExW*G5SaE z{Z_X+RhdsoP5zENsj@@rAr3)e;Ut)baK#K+n97*t*`d4Xv5InWGck)BOv=aB>9MsZyS;^A}-&^qTq)OU3g5=7UeL88Qv} zTQne8$L(c&PM0K8aKTX*f)FpclVrfu5!v{*@_Xt0!fX1g>b3G135u-3=F}s20&114 zRwy;Yh6eLq+u3TLW^|7yO`4` z>r%>b`B4jlFL>W@zB+inv#fDz)n;o?VWPobqmr+abR+-6D9nNV(Q}ev`E<=D!$h;p znpc(4Yc=;YGt{VkXgEx>gP10noGD!9EiOU$RkRrMCbuCFtP8Kd6gdI~AX@}Leb75-Ge`yoconQ3>g3c8f>-Q|&;egRH}4U@9zn~Cn&bA0 zq7vgtt&{Rs=}pvx`M3=D0PhHFn>ObRn%Ja9tj)?dKb&`e5 zVJJ8U1rtTlm{*iRe}OxJh5QBVKWH_ne~7W(TaQcY)>@$KWbw9q@4T(b zmr^s@3x~iAcowozyic}O1?aRUZ;QP=tvFZE#onZw`MGx1acL8in4#&f_ZqJy-%&LQP;F z;3p7r&e5aDT|`d&K=`tNKRo_$INW!$t-J2u^3sy~rZC-1)e6}{@dShdhr^CYJt~u) zRnqeQ%Kxu;YuTe(pf#d5d^FO1)bD9nUu<4tVA^BaUiJ?Dao{ni!g5F;#1X9#JmUm0 z-jHu6HOGICAO+6yoZ~pFe{K8c`ZX0f7E!_9I#l&dc3Zp+0byU*3jd34lO`x%XkGFH zia*&aYj(6u>X|Sy$&Kk(6$-}U6SGodXwK{q{up3C_zBBXOlXJbiy(}9g)uRGeDeK- zLy?_<30{d#xB*tj;f91tc4Ue^iWeHIL1vz1TUl*ydfIhw=#fjV z&%zK{v;@x~Ia7mKb9gU>QQ#Sj!fjB6Xo;|vdy%<`awf$SKOFUE@DFc=vt&@$>C<$h z>WVeWoMA}Sl*{)?9MB^e>DjO|dQeg$r)#De2XWG7-3k?5g zCMx6-4tfiFkM*z~p-Zym|EYiIvkO~FYbs|o`gV>CI5`h`$%7_Gt-y68SENTX|KtV= zUx|Lf_Ub+~3G5QS;vHw5q~?(}5cb9dhc5En=(=`zbNB7$@R|YJZ$)d3MC~g@gmeq~ z73(zS!grBcF-{Jt>H5k7s5G_mR0GsO9-uj;d5r|-L_SZLo;)-CCL@OXQ?N_K#(IPlw^sH?us(ER5FCH>J)oN;2TDDe5>UXp+?qBA(#FG^$kLZnmob;I-$#~7#AP|UxvHnL1Jp{9X&HU}` zJ2a0pX<|$4ovM5NW|DAqAi;EBi*@fz7LsyN*< zQ+3J5a)CVqs7CtszHyo;d@&zTSrWbj=%19YeOhoW-0vwM-iM?f2%IkT7CSl2N8BkZ! z`la{F=vVhU{^P=P;^q-grUlRq?9co!fE+YKHBcAmCc+Emah}rwa#Ygtcw)rqfR`Sx z9A5M(+7jwbI?DjWoC! z{SJodVxJ_oq~_3;v6u1p0JlIn)-6Ut8KS)cltX10$!Jn&LS4lCz(bx#91rzhZLh9B zSMk!aqTsu(RArDo7w<>LVQpC^)tV(zqnGiI?Yp&DGft4NqHcY8pQaVyF zNk3Ojmv@PuAPcY=@&R6rdP(mn0<<%Y6N*Z0z10Vrr*vlwPjcn?c7!a9nND~|+CkmU zy2Gmzjsfprb7~RvNfal%&ZRL2(|uD8;nqjh2gQ05opFQI&h3qERo>Ryg#~)G`m$Uk zDMB`5gyh0x^oxX}xTN`RxMwEWc-8Nk{@1l*XphSVpR|yh(YNuzq$)}uQ^>n5^aGD$ z6z+yvM4N>p+!xFYEibuQp_AdgZ4iKIjRI^n-98 zvPq(shiS-$(ZW5}{Z);PFFNlHK61Y4y(-um)ri}kGLLeAS;(C!ED>$Qe8U9@4}KA@ zG#USMtg^DAm2&rbu%a~iiguCqv<1zE!Oi4e)aN#}|tP@c%ANLhH0!{-G`QdC9?R+YfxHQ%^>=(a{ zZtF%i_FQRkt~J}q#j*KfEkk)o`VpBrU zp6-FSBJ$#oB;{hk=Q?MBfGqOHzUgS87vM!8n}3@9otBo?m>3?X3d8vW?t)Qa@3K~D z?b$L@@%#MDyt~Q*X(#HAM8at>h)fsHmI12Kyd2Zdk~8I|x_xa+`j$E@^#B4&!o%Z> zhz{hv^c2o0zZs|j%b`-J5HtZ+{xCa(E={{e)W@9*Z}#``@OJR-OKr=kn^1nRWSU8x z7obX)vBVUF2*<)y5es#fmHYt0WWF_i_@y=XntduH^k`*#1Z@a1t7;@Y$h+JEdv z{C|P(U_Mk24TB*fwqO%SNnc8al1{|Wj`$Q{^{_gW_I0;Ss~;&(vDBL8=(1HOWxK@- z5jK`X+F>nvSGrW$tzD46xj43LMr}pQ*PbsU-`pPh%?W!Ho1LghT~EtkPv)-$E`wsI z1HwVGMW+QNoN0_Ma%~cr5FB|l@P+3q$LIZMdtk$-iUP~gf>K?Nsz&xrd<>b0<*7XQ zB05#trr4=Pjk2P3_Omq+Elu5Z!;P+H-!q|&F$Dxls-2q0YT)63HQ*~OvyFq!i0pz1 zTrDFf{cLhaLVo15paWh3K!M*0d!BBBXja;Gt)DfE=b zxXV$Y!Bf5GI?o(j+IhQ?R>iO)h28oZ^;7u_Nfojaqwpe}fIgALD|Tyc84j8qZGP3q zn`U%n3{7$Yd`5$}NAJS7rbsAOCXshW=nNjgNIw7#hz<)wcnaooiYa9weonM4ILe3U zf*VTfTGP~0RcT#mK4$n$xG4POD|XUHN5G#H}KHuZ?7#uosj{! zC&~BHD;Nv7&4O#9iCCxc99jm3042PyEIBnK^%FrIvoZ98ufkP2tnBV>-dr=q{;cS! zahcYp5J^vI+%pu=LWU^G;<>-vq3I?soJ%*Z7P&dI*%D;Z6k z8-m56B&;oiq0`_JfX}D1=g{7yu1P!|OApKTyWw_yf~q|4chilMRpn3XrnXV~C=OH)|A3d_Epcy&wzNg`08SI%4p>1OWQXiv1<=M1 z+0KUsPj{*s7ga5? zRuzUA95p}X%O$PIUW~%ia433R;-OfiIbitJTx_kZTGW)#6*?5@;^$)wo)|p?uTFVL zL74u${lZ?+|1i?CAvf@XFpXEq)KL0T4&x6*dxcE$nddTd=+~}GO%c`Jw&Ui9hJ%_! z#R~}my^Q&W?Ql6VMe;yyS2ycF6_TvPs!NTtJ2M6+Igj!73eJhTg-b~Zrc7Wy;gW@j zXgQ`>Hz6Kq5uW2MWi6uSlBfiJj3Fe{m*|QcPU&9MY_9%cOD*CU2Q_CD!;;15Ys~*F zf?p#JlCko&>gD=~!hNOdD>V(rI(7`~cG~7OHb@y+mvAikk8~LW;+6n)P(7yZneY+hlek>g zrZVaF7pN^SD%=|WYroh3(D9zTISs zOK17m`i3@rpV7hK@gg8I;$S={=@&9e|D8h<1c(N~I>-dU;49!6{|CFDwl$4QTpx!E zKj5G1etq;Qa?aS_H)JLR;BYv+YmLVM_QgV*lW@&ua(Bz)P>jcE?C~1+zqF6qcjZF9K{FO3@HU0fnG(Zh!YZlY(iX7 zE82pMk{RXKm4B(tS~#oN_;2>(Tunh}@!^tyiZ9iB>t{8K+v(lZe%dg@nc+_H4)gB_ z`Wdz@$~W#fp)4^hg_!0{`@rC{k8p4C_XrOOnXj{^?pl{*OVy7i;zj{sZOAG1?eHS?^){?+Y+>(4W zb#pqE@gFOI%jU-mO``G8A;|$40$)H6=mPHm18jiTOQ_HrQJ=tzU&i^9)kWu}Pe^4Z zw~@{!c*U-cd=Xj{*yro%<>%(>HC-z#JB+pZzs&b7;FE{*QUX!yo|C2Ssexr-$?EC$uf%T1(H~H_xQ3P2mC2CvP;~<4! zzL(w2?o>Qv?Xz{&x4AUa>o-*^%b^le(TRf9xtp^e8@;n0Xg8_1DqqUUvOG+Mb|Wj1 z5X2c_A@`8!D8SZ9EwbH;d8$pCuR6%kXwqBq^SrGqZ1&P!m1(tI4cRS7$LF3;17C38 zT)ud`^0^wYF@zCejb0OpG?BEE)unC-z_NIRIeCuJhJldwOoCW;@vG5C`IKi;q1-#EV-e%}AG`%}B2 zxvQR8bEKlZo!ZDrCiq+ZFIZ8LhW?8tj4~<3lBk>3xAt8Sv$*3nrksg)B zDO#0-YM}d&wa~=2aPxjEd|RAU`nh6N4XweWrLDcDySl%2xZb(Wy~JDV|2TLxjiGdq9}{`;kE8p-c_E7fw)_0yameKl-2QiU)?z}LLViYhMlI7avh>EkvM=ZU zSAZ|xRMKDmsQUMMs5!AcqC2!dd^plM(mlv~*v}U9G;DEHPi!V3E72t-Fs(iPF@wV1 z#l67aDvS~zg+53g!}EZ~A-xIQ1%Y5R%#$>TSBf4Ap7C~Zf>^uhZ>ZlWx0B|O8snG8 ze2*9mp#+Zho$fi?btZoL;Pl=(ovT`pHGZyjs#;lAWjk)2nlH(jYyR61uE#VFRo@i; z^4ro?*k<%U1V-EtU*s307dD#{`VmH#?9QBkf|*61?4Z27>TccE zra5inyTGM-ZC%Y!zPl%7*A1MuO4-D{2@FKe< zIuVBmedI1q+w`Ubb<(PY^1tldqK^E+oO(0GcugADM~xIHZq6 zz9Bo&E!Y!jtX!w~pvu)y^&bqI%yV8>UD5k=013BeNLD9b_^p#8yakvQ3I9 zs%4rNx^zRa>8nMN*Hbv%rYT)k8Cq*^_}=og<9^S*fd{xpE)P7e`}`3wFC;ob5j{Iz zMhr;eQP@;x`a@?DbT+u+ln(jg=dYzAt$O!5O-DE=v|=I3!Qu)~?_ zX&2K@rz|3S5--LLMokI-Gx(|h4{xQr%2_ci>z8*M+N+v<8phS!sBka6Ts)>QDlgJ9 z#&jnuRad7jRR$<_%i^RsjDQ|Q2oC8)|$;s zUnX2CMxjcH7TyZ-9rvgNCqWAw4i7_5#Sx;(f^j?_&TVEtEsaW}xF>xfPK^H=9S|`& zWP8AApKBg}xm?3t8MxYWr{hhFrNOIqUL{hRVQVh@p7+j@V=(Jj=BQ>|4fWlNfO+}zx8&bp*Fl~Pg$SsruDb{X*sLRFAZe9LGwzbR7A)hN;hKL(XYq|hjbrg7E*}Z zMIT|+(p7STGDHoucl1nSySY4PFdq~>w5OKqt4`J}Yyxe}E@~fbh~dO^OY@5H8w$({ zJswGkeV*W#I3;;`>a=uU#!XfiCx-7O{3#MZ+a=p!F8Jt>-VOc(e6SPVErB4Z$X`h0 z4{+|YLK$<@*Qd@&j!68Nz>d8XSrFqwOZ)gD z_kxC;0khEfSU*-9rA|_=lQ&48VE54?WVWMTxgh}gjBG{MV)vxMa!m15rPjph9~+jK zGjitTU$C~=HkJ8S$!ae)Zf*Uob3yOI!NvF`t_wY<`Emk1LX{C4V!Gp(k{&0?DW9na z>5;4hoY%akg0-R+u}G2u2ZMW#Xbd=_G6y__-%1Waq2dj~Q~WJlBKr=bF5M%oKUto* zme3SCE9y>Ic2I|(o42pKue0~CXTMK(L_4#2LH%FVt>r69dWv2aoXWkJEjOlQ{m>p$ zA6KGsuB;NvMu(Agj;wNW^pTs$IFyYoluBhQ6(d!@XzuFb40_Wu%lo{_Ldf>9bV?C!_?%(Vr=3d%^v^y!A$+5(L;)0@=h2IQD{Byi* z?sn(mVQYVJcUAj9GqGV|&C80I(kI1p3#oajmf5BkSpr?RxQ^kWN=PIBYd_!Tgto=*(r~WU)-<-d? zzxBT3zbAN9cw5x*xM9L<^5K*dX)9;}%#&;rx0L@`I8XcqDv>DRO^#|c4648x&;iH5 zZj!fRqG+yQHZO|voas%6sDKiclto+;Z;U2KEDt#q@WAJ##~YVdxEBL2dOmchTIw4T zYBy9`O6S|0tcE<9rP9PPyw|PP%v5D6jIvcy2%C!DMVO8mD->CU^def+icw_mC^41qt`^n%H+QwwbyfA%4AnW+xm9?X{oVxa3u8waVkZ-x zB-)dkQqAed89waA+&%ooLJ#py=&9ruJOd~ldDQ|Qfk-eF9wQkL?-G3xV7yBlI_n1A zOtn+6qbr8MVhZFlY$_BF3rUDpg)jNj!x)<%s_IHo9G?PE?p!KQ+lXb+VgsXvD|FVsn1U< zI&Tjx|5TM(H@1n=7S$En7d8~(6zLY?gwdQL`}l@*r$=r zp$S2--&C*JZnK&Jja3uNG5f-z$bz99pX~9*_xf4dBsEjHUEU#m zg*`#-$Xv$`;)+O+56A{|1$IN~CI3%xNA*n;puc9AX6EFK&EIb=vMngyTrQ~Ex4WgAUns%&(dlyt1l_Fa*3<~%SWBj4US3C2}wt; zBco9&_KWn3Y=MHOnxMI;^D}%m-LTxtGZ#{9_euqobv5rA&b9onV_VPGflS;^mrRef zKC=SSLYl*GMpNT&6YI&rlt5|)?HIF%&E<&&o}%004#*F#gO55U-eJd%y91cvCW#K( zAkG#J@mshr*j(mm+WWNEDTm1n;@7z3=w0D&f^+>FygS{yoI8ix`a8M@+k;z#4O?rZ z6^znv#cK=UJh5ek>04HY&RNr~Bq>hHs8Sy+6+MO|I;6)V`;aKK2Mw04m*EvgWxhI0 zcRY(~!dZrMQwnz$*Ou(5NUEu?mo>j=f6#re|H1Gh=ZEe$y^r}X52l6}M`gy<6GoD^ zr0hzYO~W(yvSr*{{wv`$@jIwcg2C%Rj$;d{2IoO9OoV+UU&LvmWrC%=WX>06G<`C4 z28EhbO57G-87+?39dbY5i;vtx<)XmJ24p?D4too}kym@DvbJ=iE!0|?mt*NPjW%Gq z?V81^{fYwFCg~__7Wx2TJER9AE09h^j#{t;*;Dy?wBB*ZP{IhKGRUPQ?{Gl>#N_*pw(e zot)eTJ)3+@f%iifM-ImvNvI*EB#%g?r8m*{vx+z_{7%7hQ3|wLvJR$!x1baBg0BDu z2jQcV$xyB+Q7GhxbAPfpj9uyHQva6>5^V{KVt+)shVg=a@muM&&TXyJ>Y?BJ)^+V_ zyWE7yW$V;7`& z`3uEG)hmsY{#QnUMp;?q_1cwAmTLbUf2F-IL(!9#|A|D`Ip^ zR=kjOFzFuUI&~R+fVqNmjdxivS5zXVO2n`?xaD{?83cN;2)uxQNG?Fh;zPpw{8L<* z{hi@WOG}GSsZYE}2#?zzr3o7jBKUK>A$Q1GG%V;BcW1OOZa!8oua2%bQxacnDR`Cp zKD*MGkyW6*tG=Vmk!Q%-F&pZRZbl*<($kPD2#h9SQ>1TXGZd*RNOMFtob}vv+;T4O zXJM%AbSbIQQggducgxC-g*^)f7U7n-Eb^G;0|kVJ6owy-4v#-U%qQb1II4xVi&@7` z;V}fm!pq`D$OEo|4}(&N^dhhuTSlT-hq`D**= z?i2l|htE2nasShMi~p41uy9q>lDIqqjl3jfRoZA;8)GB;Kdy%VNSGo17qUpc!>d8I zLwYT^1P0+0I7A{9b442j>v>#`nwdslL|sk+Nu9)F@qN)VBF=?;3NZN;d)Qryan^yN zp7M^)mhi^Owbv?#N)OpmtnGQ#7FY93gHd-#vqp77Q6}3V9godJA0u3c^dMvz(uyFc z9*dCOl`m5+QlHay>dzYIW>3l8Q1GrOw&Y3q)M~%_vL;pA*RD@}UxvOpeRKQh_0aD~ z(9AH;s7JAhghPp6lXa$t8FakUFHdfv11~=D{;0KF}$V zK~Tth!I{kZMDL(FrB)|BB*6(EV}c`p2|XNm$M=Qj8`oF(7lY4x-*#fHC5?e~bE`g; z@$5O)>-mRsuA7St)Ae1NY*m$lBmX8nh#f)Y$T-9U@j@meS;%?x0%nv>lH-*vs&MT# zy^|3$zsgbMyB4jsHJ8ebRD)Zg0BS>0PRSck87t@6zC{Tg^WbbMre%;tm~QfM+Q zH8$N&-^|M5^ziBg4@3lLnPerL3SNN@hx8v{6gUc>mdu9iBD!!aKas0vjb^6Db0x0To14;R4&gj`zoDx*oi zK?|!hl*i>RvTxX1v>I7}1RySm5P5~HK<8p7q&>3xileIgnhxDA1I-+iL&%?JeQ#ry z=_?P{PHUvK#&m}Dh7CsGqg=y0y?k2(6d}hV=rLd7lSmtr&Qp$2XVROPb2+DYCj?VO zd1A7J3%i3Gpxz$b-Gb-+tu!^e+&|Fz|r*U>xmG-&%snRB&D(k~4P#<&~ z66Fv=K`tOdGy%(yK9P-6#H;9<9lDmRTc(|seRWhG$!Kes#q1a!S%bL&2kCIML@NfOU4q@bQJj3H zn7)y^oia1YgLEt2Kj!y{MYh4X)0?)3UHAI#4?T2x(s*wqZr{hdSw8$y+6sD4nly@mAR9@PZ`gX$`^X;5>`EAzO_PnxPRjfLvri#{_ zPD8J8(2TdZ8az?ohk-jn*^#+13lmV1b8>8|Z@PiLjD>OQ}9K}La0V06wcr?xmMOp#*OqhsedQ0Omrh0jjfGjhAj^|VN zzz#{9W!Dw|Q(e(i>ed+I%(xuC{IS-%w%D@&DmT;$8zWj>JBNCP25@*M*I|!#pTdCG zAzLD%Vjjl_krpKFr|h7PqT87hI0tz91!F`8ah!w!JA-SEtQrC)umb!CYb19eq4=us zGyfs?SGJXrMw^m0Iwg?&g)k!SNmN%DHF%o;GVitS>zvmN|K7i*JG1>%^ZWXi>ai6c zOEQXk3(UDW*{-JLSsmKX>i5bT`CJ)ZT8jptJCJCHkQC%B!bPJoAiXPt6u~NzX0@&~ z>$K^2%euT9g^k6_OM5Dw)@*K=)WYwe^-u?BIHn8TgY4rUP#gR*d|`A`+%n=@a&d|+ z?LBQi)4&ekMF|>&hsAbiP*M!7T=p{NH(GUCRmwN= zdSY+fs_4(*9l=onOdqia36@YtX3A*5tMnK*i5XL=~0Q zPwM|@UfsT^dqMxA;U&(C-RF9b_9q0_huw+d#l0qYkVPqD(@3;z#w_+7?mPYkAxC@* zQcB*#%Ye}lk9u$&xB@mzlw^y?iw+C^)eoCdH6m$0x?@jrbZ;88GbQ z?dj+0gZCQr>J989wT@}rRf|<7mp!vhwMOK7<|LW77#elAGzV3;6&a_1KCsmi#eQ3JbcBbn@->IQ9 zPG{YYd+qd_7nBrci`*MKkgy=}YVy<63+a;>7FH^E5}zY17tMptNlw6Hz)wdf>;Nx8 z3Rn&=k;FoGM3sUzo{F=El}8UvPfGPk){=ftD2b6o9t?dQsPnaY+Ffn!d;a5`&*px^dVQd_PSvl-kn5ypv9qWindIo`p2&Dai5x|bV2D&8 zZ%`Dd1~qf_6^47}(>eF@ZPpQXtZZ3TOkI7WzV%1vr{2$lU-92uKY2d$JsY?*G&T~A z8K3Zy)RN?#IzUC}vsmvrCA=KLc~JoLi(~;z0{=SdRUg2>1aKa{Az2Q!ipB^R@?mZ* z>o>;JbZP3_kR42i@>{=Jnd`wbRR?=Y6lczPIHyIoFS_zFi(%@~mii z!I<1>*~g4c`s3O;>V?Xi@(`H@`;ImvOC1xIGr~ijAoI~l*dA$>?5tvw>bNFPH{alE zZng~Mv8<{7z-l zjZBEMjkir85-G*ul2mvYzU-J3ha7!m75EApB~PGH;=4jQ{|$E)yN)5IEl!)0l1SDQ zeu?`Y4?mwCe{=AS@Nv1wOqA`+^B0r}_lWbL zZb zX1mP5O&gfr^J~Y3mWvJQnuy9nrQWuWg-7!aSRR^svi9kCnncxP#S7U)DG7tnOGv6? z3yDOwAf9L`+Ko+=704ebAFJ)!DOruiZ`q%6iwh{l*GkA0#_EgpYnx}ZXLOJ0&ln!> zJkEWDce=kyVLT6%13Og;BCS#0cU*JCB9}`l=S0GgK8eRgj95Yq}xCuOg z0H#Q+;+dkef(yJwoKEI^`g!Vg%FZM@Nfs}Rxe#Fr83+jVC3=!wNqE8_p*N*d)H=WM zOl@8zRQAL6n>95*Du-wO!_cpLsyVHCq8OB&kuJb~M_(f%$5!Z%%ttDb*XU;qCp#=3 zsT8PJX*K#KMsjvUF1KKJQK@}RxnH%e?(e1}Z9BTQ_GJ$3aN6Ov*=woa$e@5Qb>ynp znuPI*N0P6l{*f+bC|I#vz^4ccMbn`Zk|Xd4@XaB;6TAjguo_+|Aw&O&ngv6=9L`Qw z6+J1PpBk5JBkf7(jF}aAEmRR$?%U?s?b?ZNA8hOG?sRKQY?@Vfy{fBhtKF~2kpEwf z#_VPMpFU38rE*hFlUt;hu}i2Cnc|S{fn*>ulufB}tIKKpul1kKd%gDuAL1Xm-t)ZVyEAZNs7K`U7=sggNxJb2>RLHdCVOa@orza{ISKG9U+YW^f{H){*ybGju}mV7FaMtB_? z9JMIye9&t@)XVXUPVymHpR&u+*3=YP|7-Qz@|2SAMLP=S(f}* zlGkDEF%Fn<78jF;+~-BWk&ujtmgs%)^+aCMe9A9W5*=gGIKT5&3mBpw;s6O5?uRdc z8i#ZXSPKw1Px1R)`|Y2bOX{O*HdWY4HWbGfcI9?wCz=js`Rhz-jdDP~S{5MfL?h7uA#o1rWaKzP xMg1{`^sFpJF{t#^Owq}*)|4LB46-Vh*JKH^jfNlDTuKw34eLKRk2NK{(6_S!fxYx>@r zCdwf>RZyvd9*}5zXw(zAwd%1a{({zp)@X~WN;%~gK`JUvo!Rv|wnHu*%d_vz&b*J` zeC>WH)JT9X{`||_sE?4RIPpj<5BAT%V2x-*<31qNeR7m*Cp|>tJBTKX@UAB1Gn^_u z!^vdQ6}i0pp6rjqe2sieD5nw1YaA7D1uAL+aGxdu_iM7|?;v+L8qfkTmoy1@gVq4N zQEQ}f#-|4D&_v!$XEV1FW+G$IXK-|q6soqw9dW+@F0eH+)10fkoKbR|H<>0=Xj(@j z<@q$pRo2XqC)}he+HEN#ohaliof(#uH8V_KNLX`rq`(YXCzEseL`qLO2etj~Qx$BH z8M!o-U=P{=jNulFqS)`n=koJLe38wW%*@QiZy4;Zm0yTY3Y`8TDopWYhXI-$^E!*H?T)!r|c?2Tqq5W7YE0;q7zHm1+J}=jjATA#yhCZ8mP5d9zzA`(noHNZ zKLV$>yK3EE7h0&oEMSkwt{hsqw0vph+VZt^wIufz<=)+J+iLc4%XYYLBmA5f!`-`` zvF}E|8GU^F+p7mY66uG4c^)Lqk)?)zUj#_|iPG`G;_<Q#}@@0k2a1=fytVJiMi)Q*IO`f zG8>-tG=&;WDC$6>aPT%80fPOU~r{QWkp_=S0{>6`;HVWNnJ&$ z>vt*U-V36;LYSS-y$)gUzbh_xWIZ5LSX1iAs}TyB#rEXT(G|V6TFh1|#MBXa-a}?0 z8m|eXg5uPP>PnG;D)GA9&Ul$ELS}#V45L)#Y=72F8K$KMD5jg!MrjL!2dSrk*o?yil$dXJw%tB-(z=deeW$P^H?9S&&eJy_|&~dpD((1O!7ruv~s@TJwNYL_9W4F?w=s%Q{5HN4laeUMB9-$ rt6jzswr3YW>8g99YxD}p5Lu^gJr_8RdrIU#NyCBI$EkY+m}B-I?O`U` literal 0 HcmV?d00001 diff --git a/src/__pycache__/hotkey_detector.cpython-313.pyc b/src/__pycache__/hotkey_detector.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f59966a87449687422fc0c829f822ecf379f15da GIT binary patch literal 11363 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 w3G`VtiXDE?^ZYw_5DrL8SkQf= len(devices) or self.device_index < 0: + self.logger.warning(f"Invalid device index {self.device_index}, using default") + self.device_index = None + else: + device_info = devices[self.device_index] + self.logger.info(f"Using audio device: {device_info['name']}") + + # Validate sample rate + if self.sample_rate not in [8000, 16000, 22050, 44100, 48000]: + self.logger.warning(f"Unusual sample rate: {self.sample_rate}Hz") + + # Validate channels + if self.channels not in [1, 2]: + self.logger.warning(f"Unusual channel count: {self.channels}") + + except Exception as e: + self.logger.error(f"Error validating audio config: {e}") + + def start_recording(self): + """Start audio recording with error handling""" + if self.recording: + self.logger.warning("Recording is already in progress") + return False + + try: + self.logger.info("Starting audio recording...") + + # Reset frames buffer + self.frames = [] + self.recording = True + + # Create input stream + self.stream = sd.InputStream( + samplerate=self.sample_rate, + channels=self.channels, + device=self.device_index, + callback=self.callback, + dtype=np.float32 + ) + + # Start the stream + self.stream.start() + + # Play start sound + self.play_sound('start') + + self.logger.info("Audio recording started successfully") + return True + + except Exception as e: + self.logger.error(f"Error starting recording: {e}") + self.recording = False + if self.stream: + try: + self.stream.close() + except: + pass + self.stream = None + return False + + def stop_recording(self): + """Stop audio recording and return the recorded file""" + if not self.recording: + self.logger.warning("No recording in progress") + return None + + try: + self.logger.info("Stopping audio recording...") + + # Stop and close stream + if self.stream: + self.stream.stop() + self.stream.close() + self.stream = None + + self.recording = False + + # Play stop sound + self.play_sound('stop') + + # Save and return recording + audio_file = self.save_recording() + + if audio_file: + self.logger.info(f"Recording saved: {audio_file}") + else: + self.logger.warning("No audio data to save") + + return audio_file + + except Exception as e: + self.logger.error(f"Error stopping recording: {e}") + self.recording = False + return None + + def callback(self, indata, frames, time, status): + """Audio input callback function""" + if status: + self.logger.debug(f"Audio callback status: {status}") + + if self.recording and indata is not None: + # Append audio data to frames + self.frames.append(indata.copy()) + + def save_recording(self): + """Save recorded audio to a temporary file""" + if not self.frames: + self.logger.warning("No audio frames to save") + return None + + try: + # Concatenate all audio frames + recording = np.concatenate(self.frames, axis=0) + + # Check if we have actual audio data + if recording.size == 0: + self.logger.warning("Empty audio recording") + return None + + # Create temporary file + temp_file = tempfile.NamedTemporaryFile( + suffix='.wav', + delete=False, + prefix='voice_recording_' + ).name + + # Save audio to file + sf.write(temp_file, recording, self.sample_rate) + + # Verify file was created and has content + if os.path.exists(temp_file) and os.path.getsize(temp_file) > 0: + duration = len(recording) / self.sample_rate + self.logger.info(f"Recording saved: {duration:.2f}s, {len(recording)} samples") + return temp_file + else: + self.logger.error("Failed to create audio file") + return None + + except Exception as e: + self.logger.error(f"Error saving recording: {e}") + return None + + def play_sound(self, sound_type): + """Play feedback sound with error handling""" + try: + # Get project root directory + project_root = Path(__file__).parent.parent + sound_file = project_root / 'sounds' / f'recording_{sound_type}.wav' + + if sound_file.exists(): + try: + data, fs = sf.read(str(sound_file), dtype='float32') + + # Play sound in a separate thread to avoid blocking + sd.play(data, fs) + # Don't wait for completion to avoid blocking + + self.logger.debug(f"Playing feedback sound: {sound_type}") + + except Exception as e: + self.logger.error(f"Error playing sound {sound_type}: {e}") + else: + self.logger.debug(f"Sound file not found: {sound_file}") + + except Exception as e: + self.logger.error(f"Error in play_sound: {e}") + + def get_audio_devices(self): + """Get list of available audio devices""" + try: + devices = sd.query_devices() + device_list = [] + + for i, device in enumerate(devices): + if device['max_input_channels'] > 0: # Input devices only + device_list.append({ + 'index': i, + 'name': device['name'], + 'channels': device['max_input_channels'], + 'sample_rate': device['default_samplerate'] + }) + + self.logger.debug(f"Found {len(device_list)} input devices") + return device_list + + except Exception as e: + self.logger.error(f"Error querying audio devices: {e}") + return [] + + def test_audio_device(self, device_index=None): + """Test if audio device is working""" + try: + test_duration = 1.0 # 1 second test + + # Record a short test sample + test_data = sd.rec( + int(test_duration * self.sample_rate), + samplerate=self.sample_rate, + channels=self.channels, + device=device_index or self.device_index, + dtype=np.float32 + ) + + sd.wait() # Wait for recording to complete + + # Check if we got audio data + if test_data is not None and test_data.size > 0: + rms = np.sqrt(np.mean(test_data**2)) + self.logger.info(f"Audio device test successful. RMS level: {rms:.6f}") + return True + else: + self.logger.error("Audio device test failed - no data received") + return False + + except Exception as e: + self.logger.error(f"Audio device test failed: {e}") + return False diff --git a/src/config_manager.py b/src/config_manager.py new file mode 100644 index 0000000..e54345b --- /dev/null +++ b/src/config_manager.py @@ -0,0 +1,42 @@ + +import json +import os + +class ConfigManager: + def __init__(self, default_settings_path, user_settings_path): + self.default_settings_path = default_settings_path + self.user_settings_path = user_settings_path + self.config = self.load_config() + + def load_config(self): + config = self._load_json_file(self.default_settings_path) + user_config = self._load_json_file(self.user_settings_path) + if user_config: + config.update(user_config) + return config + + def _load_json_file(self, file_path): + if os.path.exists(file_path): + with open(file_path, 'r') as f: + try: + return json.load(f) + except json.JSONDecodeError: + # Handle empty or invalid JSON + return {} + return {} + + def get(self, key, default=None): + return self.config.get(key, default) + + def set(self, key, value): + self.config[key] = value + self.save_user_config() + + def save_user_config(self): + user_config = self._load_json_file(self.user_settings_path) + user_config.update(self.config) + with open(self.user_settings_path, 'w') as f: + json.dump(user_config, f, indent=4) + + def reload_config(self): + self.config = self.load_config() diff --git a/src/hotkey_detector.cpp b/src/hotkey_detector.cpp new file mode 100644 index 0000000..e69de29 diff --git a/src/hotkey_detector.py b/src/hotkey_detector.py new file mode 100644 index 0000000..2b574ea --- /dev/null +++ b/src/hotkey_detector.py @@ -0,0 +1,185 @@ +import threading +import logging +from pynput import keyboard +import time + +class HotkeyDetector: + def __init__(self, config, callback=None): + self.config = config + self.hotkey_string = config.get('hotkey', '++v') + self.callback = callback + self.logger = logging.getLogger(__name__) + + # Parse hotkey combination + self.required_keys = self._parse_hotkey(self.hotkey_string) + self.pressed_keys = set() + self.listener = None + self.running = False + + # Debounce mechanism + self.last_trigger_time = 0 + self.debounce_delay = 0.5 # 500ms + + def _parse_hotkey(self, hotkey_string): + """ + Parse hotkey string like '++v' into a set of keys + """ + keys = set() + parts = hotkey_string.lower().replace('<', '').replace('>', '').split('+') + + for part in parts: + part = part.strip() + if part == 'ctrl': + keys.add(keyboard.Key.ctrl_l) + keys.add(keyboard.Key.ctrl_r) + elif part == 'alt': + keys.add(keyboard.Key.alt_l) + keys.add(keyboard.Key.alt_r) + elif part == 'shift': + keys.add(keyboard.Key.shift_l) + keys.add(keyboard.Key.shift_r) + elif part == 'cmd' or part == 'super': + keys.add(keyboard.Key.cmd) + elif part == 'space': + keys.add(keyboard.Key.space) + elif part == 'tab': + keys.add(keyboard.Key.tab) + elif part == 'enter': + keys.add(keyboard.Key.enter) + elif len(part) == 1: + keys.add(part) + + self.logger.info(f"Parsed hotkey '{hotkey_string}' to keys: {[str(k) for k in keys]}") + return keys + + def _on_press(self, key): + """Handle key press events""" + try: + # Add the pressed key to our set + if hasattr(key, 'char') and key.char: + self.pressed_keys.add(key.char.lower()) + else: + self.pressed_keys.add(key) + + # Check if our hotkey combination is pressed + self._check_hotkey_combination() + + except Exception as e: + self.logger.error(f"Error in key press handler: {e}") + + def _on_release(self, key): + """Handle key release events""" + try: + # Remove the released key from our set + if hasattr(key, 'char') and key.char: + self.pressed_keys.discard(key.char.lower()) + else: + self.pressed_keys.discard(key) + + except Exception as e: + self.logger.error(f"Error in key release handler: {e}") + + def _check_hotkey_combination(self): + """Check if the required key combination is pressed""" + current_time = time.time() + + # Check if any of the required keys match what's currently pressed + matched_keys = set() + for required_key in self.required_keys: + if isinstance(required_key, str): + # Character key + if required_key in self.pressed_keys: + matched_keys.add(required_key) + else: + # Special key (like Ctrl, Alt) + if required_key in self.pressed_keys: + matched_keys.add(required_key) + # For modifier keys, check both left and right variants + elif (required_key == keyboard.Key.ctrl_l or required_key == keyboard.Key.ctrl_r) and \ + (keyboard.Key.ctrl_l in self.pressed_keys or keyboard.Key.ctrl_r in self.pressed_keys): + matched_keys.add(required_key) + elif (required_key == keyboard.Key.alt_l or required_key == keyboard.Key.alt_r) and \ + (keyboard.Key.alt_l in self.pressed_keys or keyboard.Key.alt_r in self.pressed_keys): + matched_keys.add(required_key) + elif (required_key == keyboard.Key.shift_l or required_key == keyboard.Key.shift_r) and \ + (keyboard.Key.shift_l in self.pressed_keys or keyboard.Key.shift_r in self.pressed_keys): + matched_keys.add(required_key) + + # Check if we have a reasonable match (accounting for left/right modifier variants) + required_count = len(self.required_keys) + matched_count = len(matched_keys) + + # For modifier keys, we need special logic since we add both left and right variants + if 'ctrl' in self.hotkey_string.lower(): + required_count -= 1 # Subtract one because we added both ctrl_l and ctrl_r + if 'alt' in self.hotkey_string.lower(): + required_count -= 1 # Subtract one because we added both alt_l and alt_r + if 'shift' in self.hotkey_string.lower(): + required_count -= 1 # Subtract one because we added both shift_l and shift_r + + # Simple matching based on the actual keys we need + ctrl_pressed = keyboard.Key.ctrl_l in self.pressed_keys or keyboard.Key.ctrl_r in self.pressed_keys + alt_pressed = keyboard.Key.alt_l in self.pressed_keys or keyboard.Key.alt_r in self.pressed_keys + + # Check for the default hotkey: Ctrl+Alt+V + hotkey_lower = self.hotkey_string.lower() + if 'ctrl' in hotkey_lower and 'alt' in hotkey_lower and 'v' in hotkey_lower: + if ctrl_pressed and alt_pressed and 'v' in self.pressed_keys: + self._trigger_callback(current_time) + + def _trigger_callback(self, current_time): + """Trigger the callback with debouncing""" + if current_time - self.last_trigger_time >= self.debounce_delay: + self.last_trigger_time = current_time + self.logger.info(f"Hotkey triggered: {self.hotkey_string}") + + if self.callback: + # Run callback in a separate thread to avoid blocking + threading.Thread(target=self.callback, daemon=True).start() + + def start_listening(self): + """Start listening for hotkey presses""" + if self.running: + self.logger.warning("Hotkey detector is already running") + return + + try: + self.running = True + self.listener = keyboard.Listener( + on_press=self._on_press, + on_release=self._on_release + ) + self.listener.start() + self.logger.info(f"Started listening for hotkey: {self.hotkey_string}") + + except Exception as e: + self.logger.error(f"Error starting hotkey listener: {e}") + self.running = False + raise + + def stop_listening(self): + """Stop listening for hotkey presses""" + if not self.running: + return + + try: + self.running = False + if self.listener: + self.listener.stop() + self.listener = None + + self.pressed_keys.clear() + self.logger.info("Stopped hotkey detector") + + except Exception as e: + self.logger.error(f"Error stopping hotkey listener: {e}") + + def update_hotkey(self, new_hotkey): + """Update the hotkey combination""" + self.hotkey_string = new_hotkey + self.required_keys = self._parse_hotkey(new_hotkey) + self.logger.info(f"Updated hotkey to: {new_hotkey}") + + def set_callback(self, callback): + """Set or update the callback function""" + self.callback = callback \ No newline at end of file diff --git a/src/main.py b/src/main.py new file mode 100644 index 0000000..a360707 --- /dev/null +++ b/src/main.py @@ -0,0 +1,323 @@ +#!/usr/bin/env python3 +""" +Voice-to-Text System +Main application entry point that coordinates all components +""" + +import os +import sys +import logging +import threading +import time +import argparse +from pathlib import Path + +# Add the current directory to Python path +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +# Import our modules +from config_manager import ConfigManager +from speech_recognizer import SpeechRecognizer +from audio_manager import AudioManager +from text_inserter import TextInserter +from hotkey_detector import HotkeyDetector +from service_manager import ServiceManager + +class VoiceToTextApp: + def __init__(self, config_dir=None): + # Set up config paths + if config_dir is None: + config_dir = Path(__file__).parent.parent / 'config' + else: + config_dir = Path(config_dir) + + self.default_config_path = config_dir / 'default_settings.json' + self.user_config_path = config_dir / 'user_settings.json' + + # Initialize components + self.config_manager = ConfigManager( + str(self.default_config_path), + str(self.user_config_path) + ) + self.config = self.config_manager.config + + # Setup logging + self._setup_logging() + self.logger = logging.getLogger(__name__) + + # Initialize other components + self.speech_recognizer = SpeechRecognizer(self.config) + self.audio_manager = AudioManager(self.config) + self.text_inserter = TextInserter(self.config) + self.hotkey_detector = HotkeyDetector(self.config, self.on_hotkey_pressed) + self.service_manager = ServiceManager(self.config) + + # Application state + self.is_recording = False + self.recording_thread = None + self.running = True + + self.logger.info("Voice-to-Text application initialized") + + def _setup_logging(self): + """Setup logging configuration""" + log_level = self.config.get('logging', {}).get('level', 'INFO') + log_file = self.config.get('logging', {}).get('file') + + # Create logs directory if it doesn't exist + if log_file: + log_dir = Path(log_file).parent + log_dir.mkdir(parents=True, exist_ok=True) + + # Configure logging + logging.basicConfig( + level=getattr(logging, log_level), + format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', + handlers=[ + logging.StreamHandler(), + logging.FileHandler(log_file) if log_file else logging.NullHandler() + ] + ) + + def on_hotkey_pressed(self): + """Callback function called when hotkey is pressed""" + try: + if not self.is_recording: + self.start_recording() + else: + self.stop_recording() + except Exception as e: + self.logger.error(f"Error handling hotkey press: {e}") + + def start_recording(self): + """Start voice recording""" + if self.is_recording: + self.logger.warning("Already recording") + return + + self.logger.info("Starting voice recording...") + self.is_recording = True + + # Start recording in a separate thread + self.recording_thread = threading.Thread( + target=self._recording_worker, + daemon=True + ) + self.recording_thread.start() + + def stop_recording(self): + """Stop voice recording and process the audio""" + if not self.is_recording: + self.logger.warning("Not currently recording") + return + + self.logger.info("Stopping voice recording...") + self.is_recording = False + + # The recording worker will handle the rest + + def _recording_worker(self): + """Worker thread that handles the recording process""" + try: + # Start audio recording + self.audio_manager.start_recording() + + # Wait while recording (the hotkey callback will set is_recording to False) + while self.is_recording and self.running: + time.sleep(0.1) + + # Stop recording and get the audio file + audio_file = self.audio_manager.stop_recording() + + if audio_file and os.path.exists(audio_file): + self.logger.info(f"Audio recorded: {audio_file}") + + # Transcribe the audio + self.logger.info("Starting transcription...") + transcribed_text = self.speech_recognizer.transcribe(audio_file) + + if transcribed_text and transcribed_text.strip(): + self.logger.info(f"Transcribed: '{transcribed_text}'") + + # Insert the text + success = self.text_inserter.insert_text(transcribed_text) + + if success: + self.logger.info("Text inserted successfully") + else: + self.logger.error("Failed to insert text") + # Try clipboard method as fallback + self.logger.info("Trying clipboard method...") + self.text_inserter.insert_text_clipboard(transcribed_text) + else: + self.logger.warning("No text transcribed") + + # Clean up temporary audio file + try: + os.remove(audio_file) + self.logger.debug(f"Cleaned up audio file: {audio_file}") + except Exception as e: + self.logger.error(f"Error cleaning up audio file: {e}") + + else: + self.logger.error("No audio file recorded") + + except Exception as e: + self.logger.error(f"Error in recording worker: {e}") + finally: + self.is_recording = False + + def start(self, daemon_mode=False): + """Start the application""" + try: + self.logger.info("Starting Voice-to-Text application...") + + # Start hotkey detector + self.hotkey_detector.start_listening() + self.logger.info(f"Listening for hotkey: {self.config.get('hotkey')}") + + if daemon_mode: + # Run as daemon service + self.service_manager.daemonize() + self.service_manager.start_service(self._main_loop) + else: + # Run in foreground + self._main_loop() + + except KeyboardInterrupt: + self.logger.info("Keyboard interrupt received") + self.stop() + except Exception as e: + self.logger.error(f"Error starting application: {e}") + self.stop() + raise + + def _main_loop(self): + """Main application loop""" + self.logger.info("Voice-to-Text application is running. Press hotkey to record.") + + try: + while self.running: + time.sleep(1) + + # Reload configuration if needed (could add file watching here) + # self.config_manager.reload_config() + + except KeyboardInterrupt: + self.logger.info("Received interrupt signal") + self.stop() + + def stop(self): + """Stop the application gracefully""" + self.logger.info("Stopping Voice-to-Text application...") + + self.running = False + + # Stop recording if in progress + if self.is_recording: + self.stop_recording() + + # Stop hotkey detector + if self.hotkey_detector: + self.hotkey_detector.stop_listening() + + # Stop service manager + if self.service_manager: + self.service_manager.stop_service() + + self.logger.info("Application stopped") + + def get_status(self): + """Get current application status""" + return { + 'running': self.running, + 'recording': self.is_recording, + 'hotkey': self.config.get('hotkey'), + 'whisper_model': self.config.get('whisper', {}).get('model'), + 'service_status': self.service_manager.get_service_status() + } + +def main(): + """Main entry point""" + parser = argparse.ArgumentParser( + description='Voice-to-Text System with Whisper', + formatter_class=argparse.RawDescriptionHelpFormatter, + epilog=""" +Examples: + %(prog)s # Run in foreground mode + %(prog)s --daemon # Run as daemon + %(prog)s --status # Show status + %(prog)s --stop # Stop running daemon + %(prog)s --config /path # Use custom config directory +""" + ) + + parser.add_argument( + '--daemon', '-d', + action='store_true', + help='Run as daemon service' + ) + + parser.add_argument( + '--status', '-s', + action='store_true', + help='Show application status' + ) + + parser.add_argument( + '--stop', + action='store_true', + help='Stop running daemon' + ) + + parser.add_argument( + '--config', '-c', + help='Path to configuration directory' + ) + + parser.add_argument( + '--verbose', '-v', + action='store_true', + help='Enable verbose logging' + ) + + args = parser.parse_args() + + try: + # Create application instance + app = VoiceToTextApp(args.config) + + # Enable verbose logging if requested + if args.verbose: + logging.getLogger().setLevel(logging.DEBUG) + + if args.status: + # Show status + status = app.get_status() + print("Voice-to-Text Status:") + for key, value in status.items(): + print(f" {key}: {value}") + return + + if args.stop: + # Stop daemon + if app.service_manager.is_running(): + print("Stopping Voice-to-Text daemon...") + # Send termination signal to running process + with open('/tmp/voice-to-text.pid', 'r') as f: + pid = int(f.read().strip()) + os.kill(pid, 15) # SIGTERM + print("Stop signal sent") + else: + print("Voice-to-Text daemon is not running") + return + + # Start the application + app.start(daemon_mode=args.daemon) + + except Exception as e: + print(f"Error: {e}", file=sys.stderr) + sys.exit(1) + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/src/service_manager.py b/src/service_manager.py new file mode 100644 index 0000000..46157fe --- /dev/null +++ b/src/service_manager.py @@ -0,0 +1,182 @@ +import os +import sys +import signal +import logging +import time +import threading +from pathlib import Path + +class ServiceManager: + def __init__(self, config): + self.config = config + self.logger = logging.getLogger(__name__) + self.running = False + self.pid_file = '/tmp/voice-to-text.pid' + + # Signal handlers + signal.signal(signal.SIGTERM, self._signal_handler) + signal.signal(signal.SIGINT, self._signal_handler) + + def _signal_handler(self, signum, frame): + """Handle shutdown signals gracefully""" + self.logger.info(f"Received signal {signum}, shutting down...") + self.stop_service() + + def start_service(self, main_app_callback=None): + """Start the service as a daemon or regular process""" + if self.is_running(): + self.logger.error("Service is already running") + return False + + try: + self.running = True + self._create_pid_file() + + self.logger.info("Voice-to-Text service started") + + # If a main app callback is provided, run it + if main_app_callback: + main_app_callback() + else: + # Default service loop + self._service_loop() + + return True + + except Exception as e: + self.logger.error(f"Error starting service: {e}") + self.running = False + return False + + def stop_service(self): + """Stop the service gracefully""" + if not self.running: + return + + try: + self.running = False + self._remove_pid_file() + self.logger.info("Voice-to-Text service stopped") + + except Exception as e: + self.logger.error(f"Error stopping service: {e}") + + def _service_loop(self): + """Default service loop - just keep running""" + try: + while self.running: + time.sleep(1) + + except KeyboardInterrupt: + self.logger.info("Keyboard interrupt received") + self.stop_service() + + def is_running(self): + """Check if the service is already running""" + if not os.path.exists(self.pid_file): + return False + + try: + with open(self.pid_file, 'r') as f: + pid = int(f.read().strip()) + + # Check if process with this PID exists + try: + os.kill(pid, 0) # Send null signal to check if process exists + return True + except OSError: + # Process doesn't exist, remove stale PID file + self._remove_pid_file() + return False + + except (ValueError, IOError): + # Invalid or unreadable PID file + self._remove_pid_file() + return False + + def _create_pid_file(self): + """Create PID file for the current process""" + try: + pid = os.getpid() + with open(self.pid_file, 'w') as f: + f.write(str(pid)) + self.logger.debug(f"Created PID file: {self.pid_file} with PID: {pid}") + + except IOError as e: + self.logger.error(f"Error creating PID file: {e}") + + def _remove_pid_file(self): + """Remove the PID file""" + try: + if os.path.exists(self.pid_file): + os.remove(self.pid_file) + self.logger.debug(f"Removed PID file: {self.pid_file}") + + except IOError as e: + self.logger.error(f"Error removing PID file: {e}") + + def restart_service(self, main_app_callback=None): + """Restart the service""" + self.logger.info("Restarting service...") + self.stop_service() + time.sleep(1) # Brief pause + return self.start_service(main_app_callback) + + def get_service_status(self): + """Get current service status""" + if self.is_running(): + try: + with open(self.pid_file, 'r') as f: + pid = int(f.read().strip()) + return { + 'status': 'running', + 'pid': pid, + 'pid_file': self.pid_file + } + except: + return {'status': 'unknown'} + else: + return {'status': 'stopped'} + + def daemonize(self): + """Daemonize the current process (Unix only)""" + try: + # First fork + pid = os.fork() + if pid > 0: + sys.exit(0) # Parent process exits + + except OSError as e: + self.logger.error(f"First fork failed: {e}") + sys.exit(1) + + # Become session leader + os.setsid() + + try: + # Second fork + pid = os.fork() + if pid > 0: + sys.exit(0) # Second parent exits + + except OSError as e: + self.logger.error(f"Second fork failed: {e}") + sys.exit(1) + + # Change working directory and file permissions + os.chdir('/') + os.umask(0) + + # Redirect standard file descriptors + sys.stdout.flush() + sys.stderr.flush() + + # Close or redirect stdin, stdout, stderr + with open('/dev/null', 'r') as dev_null: + os.dup2(dev_null.fileno(), sys.stdin.fileno()) + + with open('/dev/null', 'w') as dev_null: + os.dup2(dev_null.fileno(), sys.stdout.fileno()) + os.dup2(dev_null.fileno(), sys.stderr.fileno()) + + self.logger.info("Process daemonized successfully") \ No newline at end of file diff --git a/src/speech_recognizer.py b/src/speech_recognizer.py new file mode 100644 index 0000000..7de96db --- /dev/null +++ b/src/speech_recognizer.py @@ -0,0 +1,104 @@ + +import whisper +import logging +import os +from pathlib import Path + +class SpeechRecognizer: + def __init__(self, config): + self.config = config + self.logger = logging.getLogger(__name__) + + self.model_name = self.config.get('whisper', {}).get('model', 'small') + self.language = self.config.get('whisper', {}).get('language') + self.model = None + + # Load model on initialization + self.load_model() + + def load_model(self): + """Load the Whisper model with error handling""" + try: + self.logger.info(f"Loading Whisper model: {self.model_name}") + + # Check if model name is valid + valid_models = ['tiny', 'base', 'small', 'medium', 'large'] + if self.model_name not in valid_models: + self.logger.error(f"Invalid model name: {self.model_name}. Valid models: {valid_models}") + self.model_name = 'small' # Fallback + self.logger.info(f"Using fallback model: {self.model_name}") + + self.model = whisper.load_model(self.model_name) + self.logger.info(f"Successfully loaded Whisper model: {self.model_name}") + return True + + except Exception as e: + self.logger.error(f"Error loading Whisper model '{self.model_name}': {e}") + self.model = None + return False + + def transcribe(self, audio_file): + """Transcribe audio file to text with comprehensive error handling""" + if not self.model: + self.logger.error("No Whisper model loaded") + return None + + if not audio_file or not os.path.exists(audio_file): + self.logger.error(f"Audio file not found: {audio_file}") + return None + + try: + self.logger.debug(f"Starting transcription of: {audio_file}") + + # Check file size + file_size = os.path.getsize(audio_file) + if file_size == 0: + self.logger.warning("Audio file is empty") + return None + + self.logger.debug(f"Audio file size: {file_size} bytes") + + # Transcribe with specified language or auto-detect + transcribe_options = { + 'language': self.language, + 'task': 'transcribe', + 'verbose': False + } + + # Remove None values + transcribe_options = {k: v for k, v in transcribe_options.items() if v is not None} + + result = self.model.transcribe(audio_file, **transcribe_options) + + if result and 'text' in result: + transcribed_text = result['text'].strip() + + if transcribed_text: + self.logger.info(f"Transcription successful: {len(transcribed_text)} characters") + self.logger.debug(f"Transcribed text: '{transcribed_text[:100]}...'" if len(transcribed_text) > 100 else f"Transcribed text: '{transcribed_text}'") + return transcribed_text + else: + self.logger.warning("Transcription resulted in empty text") + return None + else: + self.logger.error("Invalid transcription result") + return None + + except Exception as e: + self.logger.error(f"Error during transcription: {e}") + return None + + def is_model_loaded(self): + """Check if model is loaded and ready""" + return self.model is not None + + def get_model_info(self): + """Get information about the loaded model""" + if not self.model: + return None + + return { + 'model_name': self.model_name, + 'language': self.language, + 'loaded': True + } diff --git a/src/text_inserter.py b/src/text_inserter.py new file mode 100644 index 0000000..eb09635 --- /dev/null +++ b/src/text_inserter.py @@ -0,0 +1,74 @@ +import pyautogui +import time +import logging + +class TextInserter: + def __init__(self, config): + self.config = config + self.typing_speed = config.get('typing', {}).get('speed', 0.05) + self.logger = logging.getLogger(__name__) + + # Configure pyautogui + pyautogui.FAILSAFE = False + pyautogui.PAUSE = 0 + + def insert_text(self, text): + """ + Insert text at current cursor position with typing simulation + """ + if not text or not text.strip(): + self.logger.warning("No text to insert") + return False + + try: + # Clean the text + clean_text = text.strip() + + # Type the text with the configured speed + if self.typing_speed > 0: + for char in clean_text: + pyautogui.write(char) + time.sleep(self.typing_speed) + else: + pyautogui.write(clean_text) + + self.logger.info(f"Successfully inserted text: {len(clean_text)} characters") + return True + + except Exception as e: + self.logger.error(f"Error inserting text: {e}") + return False + + def insert_text_clipboard(self, text): + """ + Alternative method using clipboard + """ + try: + import pyperclip + + # Save current clipboard content + original_clipboard = pyperclip.paste() + + # Copy text to clipboard + pyperclip.copy(text.strip()) + + # Paste using Ctrl+V + pyautogui.hotkey('ctrl', 'v') + + # Restore original clipboard after a brief delay + time.sleep(0.1) + pyperclip.copy(original_clipboard) + + self.logger.info(f"Successfully inserted text via clipboard: {len(text.strip())} characters") + return True + + except Exception as e: + self.logger.error(f"Error inserting text via clipboard: {e}") + return False + + def set_typing_speed(self, speed): + """ + Update typing speed + """ + self.typing_speed = max(0, speed) + self.logger.info(f"Typing speed set to: {self.typing_speed}") \ No newline at end of file diff --git a/tests/test_audio.py b/tests/test_audio.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/test_integration.py b/tests/test_integration.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/test_recognition.py b/tests/test_recognition.py new file mode 100644 index 0000000..e69de29