.gitattributes

@@ -1 +0,0 @@
-*.onnx filter=lfs diff=lfs merge=lfs -text

README.md

@@ -43,9 +43,7 @@ python main.py
   - `MICROPHONE_INDEX = -1` — индекс микрофона (`-1` означает устройство по умолчанию). Если микрофонов несколько и берётся не тот, поменяйте число.
   - `WAKE_WORDS = ('jarvis', 'джарвис')` — варианты транскрипции wake-word, которые принимает Vosk. Если ваш голос/акцент стабильно расшифровывается как, например, `жарвис` — добавьте этот вариант сюда (всё в нижнем регистре).
   - `GROQ_MODEL` — имя модели Groq (по умолчанию `llama-3.3-70b-versatile`).
-  - `INTENT_SIMILARITY_THRESHOLD = 0.45` — минимальная косинусная близость для срабатывания команды (см. ниже).
+- `commands.yaml` — набор голосовых команд и их вариантов для fuzzy-матчинга.
-  - `DENOISE_ENABLED = False` — шумоподавление перед Vosk (см. ниже).
-- `commands.yaml` — набор голосовых команд и их вариантов; матчится семантически по эмбеддингам.
 - `custom-commands/` — скомпилированные AHK-скрипты под конкретный сетап автора оригинала (переключение мониторов, управление Яндекс.Музыкой и т.п.). На вашей машине большая часть из них работать не будет, но ассистент запустится в любом случае.
 
 ## Использование
@@ -65,47 +63,6 @@ python main.py
 - `COMMAND_MIN_LISTEN_MS` — минимальное время записи, чтобы не закрыться мгновенно (1000 мс).
 - `COMMAND_MAX_LISTEN_MS` — жёсткий потолок (15000 мс).
 
-## Семантический матчинг команд
-
-Раньше распознанная фраза сравнивалась с фразами из `commands.yaml` через `fuzzywuzzy.fuzz.ratio` — это срабатывало только на формальное совпадение букв. Теперь используется sentence-transformer `all-MiniLM-L6-v2` (ONNX, CPU) — фраза кодируется в 384-мерный вектор, считается косинусная близость с фразами всех команд, побеждает самая близкая.
-
-Это означает, что фраза `«запусти браузер»` сматчится с командой `open_browser`, даже если в YAML записано только `«открой браузер»` — у них близкий смысл.
-
-- Модель лежит в `models/all-MiniLM-L6-v2/` (87 МБ, хранится через Git LFS — `git lfs pull` после клонирования).
-- Порог `INTENT_SIMILARITY_THRESHOLD = 0.45` (косинус, диапазон [-1; 1], для близких смыслов обычно 0.7+). Ниже порога — «команда не распознана», сработает `not_found.wav` (или ветка `«скажи …»` для LLM).
-- Все фразы из `commands.yaml` эмбеддятся один раз при старте; на каждой команде эмбеддится только распознанная пользователем фраза (~1-5 мс на CPU).
-
-## Шумоподавление перед STT
-
-Опциональный пре-процессинг аудио командного буфера через `noisereduce` (спектральное гейтирование). Помогает в шумных помещениях (кулер, кондиционер, фоновая музыка). К wake-word фазе не применяется — там важна отзывчивость.
-
-В `config.py`:
-
-- `DENOISE_ENABLED = False` — главный тумблер.
-- `DENOISE_PROP = 0.85` — доля подавления (0..1).
-- `DENOISE_STATIONARY = False` — `False` для меняющегося шума (рекомендуется), `True` для стабильного фона.
-
-## Эффекты под AI-ассистента
-
-Silero звучит естественно, но иногда хочется лёгкой «AI-окраски» в духе J.A.R.V.I.S. — узкую полосу, еле заметную реверберацию, при желании небольшой сдвиг высоты. Это тонкий постпроцессинг, голос и sample rate не меняются.
-
-По умолчанию эффекты **выключены**. Включаются в `config.py`:
-
-- `TTS_EFFECTS_ENABLED` — главный тумблер (`False` по умолчанию).
-- `TTS_BANDPASS_LOW_HZ` / `TTS_BANDPASS_HIGH_HZ` — полоса пропускания (по умолчанию 200–7000 Гц). Сужение полосы даёт ощущение «голоса по радио».
-- `TTS_REVERB_WET` (0..1) и `TTS_REVERB_DECAY_MS` — доля мокрого сигнала и длительность хвоста короткой реверберации (по умолчанию 0.20 и 100 мс).
-- `TTS_PITCH_SEMITONES` — сдвиг высоты в полутонах (по умолчанию 0, разумный диапазон ±2).
-
-Фильтры реализованы на `scipy.signal` (IIR, sosfiltfilt — нулевая фазовая задержка), реверберация — несколько затухающих задержанных копий, pitch — ресэмплинг по линейной интерполяции. Всё in-process, без временных файлов и лишних зависимостей.
-
-Быстрое A/B сравнение перед тем как переключать тумблер:
-
-```bash
-.venv\Scripts\python.exe utils\preview_effects.py
-```
-
-Скрипт сгенерирует `sound/_preview_silero_raw.wav` и `sound/_preview_silero_fx.wav` — откройте оба в плеере и решите, нравится ли эффект. Параметры fx-версии берутся из текущего `config.py` (независимо от `TTS_EFFECTS_ENABLED`).
-
 ## Схема commands.yaml
 
 Каждая команда — это пара `phrases` + `action`:

commands.yaml

@@ -2,23 +2,23 @@ open_browser:
   phrases:
     - открой браузер
     - запусти браузер
-    - открой яндекс
+    - открой гугл хром
-    - яндекс браузер
+    - гугл хром
-  action: {type: url, href: "about:blank", browser: "yandex"}
+  action: {type: exe, file: "Run browser.exe"}
 
 open_youtube:
   phrases:
     - открой ютуб
     - ютуб
     - запусти ютуб
-  action: {type: url, href: "https://www.youtube.com", browser: "yandex"}
+  action: {type: exe, file: "Run youtube.exe"}
 
 open_google:
   phrases:
     - открой гугл
     - гугл
     - запусти гугл
-  action: {type: url, href: "https://www.google.com", browser: "yandex"}
+  action: {type: exe, file: "Run google.exe"}
 
 music:
   phrases:

config.py

@@ -6,7 +6,7 @@ load_dotenv("dev.env")
 
 # Конфигурация
 VA_NAME = 'Jarvis'
-VA_VER = "0.4.1"
+VA_VER = "0.3.0"
 VA_ALIAS = ('джарвис',)
 VA_TBR = ('скажи', 'покажи', 'ответь', 'произнеси', 'расскажи', 'сколько', 'слушай')
 
@@ -19,12 +19,8 @@ WAKE_WORDS = ('jarvis', 'джарвис')
 # -1 это стандартное записывающее устройство
 MICROPHONE_INDEX = -1
 
-BROWSER_PATHS = {
+# Путь к браузеру Google Chrome
-    'yandex':  'C:/Program Files/Yandex/YandexBrowser/Application/browser.exe',
+CHROME_PATH = 'C:/Program Files (x86)/Google/Chrome/Application/chrome.exe %s'
-    'chrome':  'C:/Program Files/Google/Chrome/Application/chrome.exe',
-    'firefox': 'C:/Program Files/Mozilla Firefox/firefox.exe',
-    'edge':    'C:/Program Files (x86)/Microsoft/Edge/Application/msedge.exe',
-}
 
 # Токен Groq
 GROQ_TOKEN = os.getenv('GROQ_TOKEN')
@@ -38,23 +34,3 @@ COMMAND_END_SILENCE_MS = 1200
 COMMAND_MIN_SPEECH_MS = 500
 COMMAND_MIN_LISTEN_MS = 1000
 COMMAND_MAX_LISTEN_MS = 15000
-
-TTS_EFFECTS_ENABLED = False
-TTS_BANDPASS_LOW_HZ = 200
-TTS_BANDPASS_HIGH_HZ = 7000
-TTS_REVERB_WET = 0.20
-TTS_REVERB_DECAY_MS = 100
-TTS_PITCH_SEMITONES = 0
-
-# Семантический матчинг команд через эмбеддинги MiniLM-L6-v2 (ONNX, CPU).
-# Порог — косинусная близость [0..1]. На вход поступает уже отфильтрованная
-# фраза (без алиасов и vа_tbr); 0.45 эмпирически отделяет валидные команды
-# от шума, оставляя запас на разговорные перефразировки.
-INTENT_SIMILARITY_THRESHOLD = 0.45
-
-# Шумоподавление аудио перед Vosk на этапе захвата команды (после wake-word).
-# Спектральное гейтирование через noisereduce; даёт небольшую латентность,
-# поэтому выключено по умолчанию и применяется только к буферу команды.
-DENOISE_ENABLED = False
-DENOISE_PROP = 0.85
-DENOISE_STATIONARY = False

effects.py

@@ -1,71 +0,0 @@
-import numpy as np
-from scipy.signal import butter, sosfiltfilt
-
-
-def _ensure_float32_mono(audio):
-    arr = np.asarray(audio, dtype=np.float32)
-    if arr.ndim > 1:
-        arr = arr.mean(axis=1).astype(np.float32)
-    return arr
-
-
-def apply_bandpass(audio, sr, low_hz=200, high_hz=7000, order=4):
-    arr = _ensure_float32_mono(audio)
-    nyq = 0.5 * sr
-    low = max(low_hz, 1) / nyq
-    high = min(high_hz, int(nyq) - 1) / nyq
-    if not (0 < low < high < 1):
-        return arr
-    sos = butter(order, [low, high], btype='band', output='sos')
-    return sosfiltfilt(sos, arr).astype(np.float32)
-
-
-def apply_reverb(audio, sr, wet=0.20, decay_ms=100, taps=4):
-    arr = _ensure_float32_mono(audio)
-    if wet <= 0 or decay_ms <= 0:
-        return arr
-    dry = max(0.0, 1.0 - wet)
-    out = dry * arr
-    gap = max(1, int(sr * (decay_ms / 1000.0) / taps))
-    gain = wet
-    for i in range(1, taps + 1):
-        delay = gap * i
-        gain *= 0.6
-        if delay >= len(arr):
-            break
-        padded = np.zeros_like(arr)
-        padded[delay:] = arr[:len(arr) - delay]
-        out += gain * padded
-    peak = float(np.max(np.abs(out))) if out.size else 0.0
-    if peak > 0.99:
-        out *= 0.99 / peak
-    return out.astype(np.float32)
-
-
-def apply_pitch(audio, sr, semitones=0):
-    arr = _ensure_float32_mono(audio)
-    if semitones == 0:
-        return arr
-    factor = 2.0 ** (semitones / 12.0)
-    n_out = int(round(len(arr) / factor))
-    if n_out <= 1:
-        return arr
-    src_idx = np.linspace(0, len(arr) - 1, num=n_out).astype(np.float32)
-    lo = np.floor(src_idx).astype(np.int64)
-    hi = np.clip(lo + 1, 0, len(arr) - 1)
-    frac = (src_idx - lo).astype(np.float32)
-    resampled = (1.0 - frac) * arr[lo] + frac * arr[hi]
-    return resampled.astype(np.float32)
-
-
-def process(audio, sr, bandpass=None, reverb=None, pitch_semitones=0):
-    out = _ensure_float32_mono(audio)
-    if bandpass is not None:
-        low, high = bandpass
-        out = apply_bandpass(out, sr, low, high)
-    if reverb is not None:
-        wet, decay_ms = reverb
-        out = apply_reverb(out, sr, wet=wet, decay_ms=decay_ms)
-    if pitch_semitones:
-        out = apply_pitch(out, sr, semitones=pitch_semitones)
-    return out

intent.py

@@ -1,79 +0,0 @@
-import os
-import numpy as np
-import onnxruntime as ort
-from tokenizers import Tokenizer
-
-import config
-
-
-MODEL_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "models", "all-MiniLM-L6-v2")
-MAX_TOKENS = 128
-
-
-def _mean_pool(last_hidden: np.ndarray, attention_mask: np.ndarray) -> np.ndarray:
-    mask = attention_mask.astype(np.float32)[..., None]
-    summed = (last_hidden * mask).sum(axis=1)
-    counts = np.clip(mask.sum(axis=1), a_min=1e-9, a_max=None)
-    return summed / counts
-
-
-def _l2_normalize(x: np.ndarray) -> np.ndarray:
-    norm = np.linalg.norm(x, axis=-1, keepdims=True)
-    return x / np.clip(norm, a_min=1e-12, a_max=None)
-
-
-class IntentClassifier:
-    def __init__(self, model_dir: str = MODEL_DIR):
-        tok_path = os.path.join(model_dir, "tokenizer.json")
-        onnx_path = os.path.join(model_dir, "model.onnx")
-        self._tokenizer = Tokenizer.from_file(tok_path)
-        self._tokenizer.enable_truncation(max_length=MAX_TOKENS)
-        self._tokenizer.enable_padding(pad_id=0, pad_token="[PAD]")
-        so = ort.SessionOptions()
-        so.intra_op_num_threads = max(1, (os.cpu_count() or 2) // 2)
-        so.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
-        self._session = ort.InferenceSession(onnx_path, sess_options=so, providers=["CPUExecutionProvider"])
-        self._input_names = {inp.name for inp in self._session.get_inputs()}
-        self._cache: dict[str, np.ndarray] = {}
-
-    def embed(self, texts: list[str]) -> np.ndarray:
-        if not texts:
-            return np.zeros((0, 384), dtype=np.float32)
-        encs = self._tokenizer.encode_batch(texts)
-        ids = np.array([e.ids for e in encs], dtype=np.int64)
-        mask = np.array([e.attention_mask for e in encs], dtype=np.int64)
-        feeds = {"input_ids": ids, "attention_mask": mask}
-        if "token_type_ids" in self._input_names:
-            feeds["token_type_ids"] = np.zeros_like(ids)
-        outputs = self._session.run(None, feeds)
-        last_hidden = outputs[0]
-        pooled = _mean_pool(last_hidden, mask)
-        return _l2_normalize(pooled).astype(np.float32)
-
-    def prime(self, candidates: dict[str, list[str]]) -> None:
-        self._cache.clear()
-        for cmd_id, phrases in candidates.items():
-            if not phrases:
-                continue
-            self._cache[cmd_id] = self.embed(list(phrases))
-
-    def match(self, utterance: str, candidates: dict[str, list[str]]) -> dict:
-        utterance = (utterance or "").strip()
-        if not utterance:
-            return {"cmd": "", "score": 0.0}
-        for cmd_id, phrases in candidates.items():
-            if cmd_id not in self._cache and phrases:
-                self._cache[cmd_id] = self.embed(list(phrases))
-        query = self.embed([utterance])[0]
-        best_cmd = ""
-        best_score = -1.0
-        for cmd_id, mat in self._cache.items():
-            sims = mat @ query
-            top = float(sims.max()) if sims.size else -1.0
-            if top > best_score:
-                best_score = top
-                best_cmd = cmd_id
-        threshold = getattr(config, "INTENT_SIMILARITY_THRESHOLD", 0.45)
-        if best_score < threshold:
-            return {"cmd": "", "score": max(0.0, best_score)}
-        return {"cmd": best_cmd, "score": max(0.0, best_score)}

main.py

@@ -10,7 +10,6 @@ import time
 import webbrowser
 from ctypes import POINTER, cast
 
-import numpy as np
 import openai
 from openai import OpenAI
 import simpleaudio as sa
@@ -28,7 +27,6 @@ from rich import print
 
 import config
 import tts
-from intent import IntentClassifier
 
 # some consts
 CDIR = os.getcwd()
@@ -62,28 +60,6 @@ VAD_FRAME_MS = 30
 VAD_FRAME_BYTES = int(samplerate * VAD_FRAME_MS / 1000) * 2
 vad = webrtcvad.Vad(config.VAD_AGGRESSIVENESS)
 
-intent_classifier = IntentClassifier()
-intent_classifier.prime({c: v['phrases'] for c, v in VA_CMD_LIST.items()})
-
-if config.DENOISE_ENABLED:
-    import noisereduce as nr
-else:
-    nr = None
-
-
-def denoise_pcm(raw: bytes) -> bytes:
-    if not raw or nr is None:
-        return raw
-    samples = np.frombuffer(raw, dtype=np.int16).astype(np.float32) / 32768.0
-    reduced = nr.reduce_noise(
-        y=samples,
-        sr=samplerate,
-        prop_decrease=config.DENOISE_PROP,
-        stationary=config.DENOISE_STATIONARY,
-    )
-    clipped = np.clip(reduced * 32768.0, -32768, 32767).astype(np.int16)
-    return clipped.tobytes()
-
 
 def gpt_answer():
     global message_log
@@ -164,10 +140,9 @@ def va_respond(voice: str):
 
     print(cmd)
 
-    min_percent = int(round(config.INTENT_SIMILARITY_THRESHOLD * 100))
     if len(cmd['cmd'].strip()) <= 0:
         return False
-    elif cmd['percent'] < min_percent or cmd['cmd'] not in VA_CMD_LIST.keys():
+    elif cmd['percent'] < 70 or cmd['cmd'] not in VA_CMD_LIST.keys():
         # play("not_found")
         # tts.va_speak("Что?")
         if fuzz.ratio(voice.join(voice.split()[:1]).strip(), "скажи") > 75:
@@ -204,9 +179,15 @@ def filter_cmd(raw_voice: str):
 
 
 def recognize_cmd(cmd: str):
-    candidates = {c: v['phrases'] for c, v in VA_CMD_LIST.items()}
+    rc = {'cmd': '', 'percent': 0}
-    res = intent_classifier.match(cmd, candidates)
+    for c, v in VA_CMD_LIST.items():
-    return {'cmd': res['cmd'], 'percent': int(round(res['score'] * 100))}
+        for x in v['phrases']:
+            vrt = fuzz.ratio(cmd, x)
+            if vrt > rc['percent']:
+                rc['cmd'] = c
+                rc['percent'] = vrt
+
+    return rc
 
 
 def _set_mute(state: int):
@@ -252,12 +233,6 @@ def run_action(action):
         else:
             subprocess.Popen(action['cmd'], shell=True)
     elif t == 'url':
-        browser = action.get('browser')
-        if browser:
-            exe = config.BROWSER_PATHS.get(browser)
-            if exe and os.path.isfile(exe):
-                subprocess.Popen([exe, action['href']])
-                return
         webbrowser.open(action['href'])
     elif t == 'keys':
         import pyautogui
@@ -320,7 +295,6 @@ while True:
         silence_ms = 0
         vad_buf = b""
         finalize = False
-        cmd_buf = b"" if config.DENOISE_ENABLED else None
 
         while True:
             elapsed_ms = (time.time() - listen_started) * 1000
@@ -329,10 +303,7 @@ while True:
 
             pcm = recorder.read()
             sp = struct.pack("h" * len(pcm), *pcm)
-            if cmd_buf is None:
             kaldi_rec.AcceptWaveform(sp)
-            else:
-                cmd_buf += sp
 
             vad_buf += sp
             while len(vad_buf) >= VAD_FRAME_BYTES:
@@ -351,8 +322,6 @@ while True:
                 break
 
         if finalize or speech_ms > 0:
-            if cmd_buf is not None:
-                kaldi_rec.AcceptWaveform(denoise_pcm(cmd_buf))
             text = json.loads(kaldi_rec.FinalResult()).get("text", "")
             if text:
                 va_respond(text)

models/all-MiniLM-L6-v2/README.md

@@ -1,35 +0,0 @@
----
-license: apache-2.0
-pipeline_tag: sentence-similarity
----
-
-ONNX port of [sentence-transformers/all-MiniLM-L6-v2](https://huggingface.co/sentence-transformers/all-MiniLM-L6-v2) for text classification and similarity searches.
-
-### Usage
-
-Here's an example of performing inference using the model with [FastEmbed](https://github.com/qdrant/fastembed).
-
-```py
-from fastembed import TextEmbedding
-
-documents = [
-    "You should stay, study and sprint.",
-    "History can only prepare us to be surprised yet again.",
-]
-
-model = TextEmbedding(model_name="sentence-transformers/all-MiniLM-L6-v2")
-embeddings = list(model.embed(documents))
-
-# [
-#     array([
-#         0.00611658, 0.00068912, -0.0203846, ..., -0.01751488, -0.01174267,
-#         0.01463472
-#     ],
-#           dtype=float32),
-#     array([
-#         0.00173448, -0.00329958, 0.01557874, ..., -0.01473586, 0.0281806,
-#         -0.00448205
-#     ],
-#           dtype=float32)
-# ]
-```

models/all-MiniLM-L6-v2/config.json

@@ -1,25 +0,0 @@
-{
-  "_name_or_path": "sentence-transformers/all-MiniLM-L6-v2",
-  "architectures": [
-    "BertModel"
-  ],
-  "attention_probs_dropout_prob": 0.1,
-  "classifier_dropout": null,
-  "gradient_checkpointing": false,
-  "hidden_act": "gelu",
-  "hidden_dropout_prob": 0.1,
-  "hidden_size": 384,
-  "initializer_range": 0.02,
-  "intermediate_size": 1536,
-  "layer_norm_eps": 1e-12,
-  "max_position_embeddings": 512,
-  "model_type": "bert",
-  "num_attention_heads": 12,
-  "num_hidden_layers": 6,
-  "pad_token_id": 0,
-  "position_embedding_type": "absolute",
-  "transformers_version": "4.36.2",
-  "type_vocab_size": 2,
-  "use_cache": true,
-  "vocab_size": 30522
-}

models/all-MiniLM-L6-v2/special_tokens_map.json

@@ -1,37 +0,0 @@
-{
-  "cls_token": {
-    "content": "[CLS]",
-    "lstrip": false,
-    "normalized": false,
-    "rstrip": false,
-    "single_word": false
-  },
-  "mask_token": {
-    "content": "[MASK]",
-    "lstrip": false,
-    "normalized": false,
-    "rstrip": false,
-    "single_word": false
-  },
-  "pad_token": {
-    "content": "[PAD]",
-    "lstrip": false,
-    "normalized": false,
-    "rstrip": false,
-    "single_word": false
-  },
-  "sep_token": {
-    "content": "[SEP]",
-    "lstrip": false,
-    "normalized": false,
-    "rstrip": false,
-    "single_word": false
-  },
-  "unk_token": {
-    "content": "[UNK]",
-    "lstrip": false,
-    "normalized": false,
-    "rstrip": false,
-    "single_word": false
-  }
-}

models/all-MiniLM-L6-v2/tokenizer_config.json

@@ -1,64 +0,0 @@
-{
-  "added_tokens_decoder": {
-    "0": {
-      "content": "[PAD]",
-      "lstrip": false,
-      "normalized": false,
-      "rstrip": false,
-      "single_word": false,
-      "special": true
-    },
-    "100": {
-      "content": "[UNK]",
-      "lstrip": false,
-      "normalized": false,
-      "rstrip": false,
-      "single_word": false,
-      "special": true
-    },
-    "101": {
-      "content": "[CLS]",
-      "lstrip": false,
-      "normalized": false,
-      "rstrip": false,
-      "single_word": false,
-      "special": true
-    },
-    "102": {
-      "content": "[SEP]",
-      "lstrip": false,
-      "normalized": false,
-      "rstrip": false,
-      "single_word": false,
-      "special": true
-    },
-    "103": {
-      "content": "[MASK]",
-      "lstrip": false,
-      "normalized": false,
-      "rstrip": false,
-      "single_word": false,
-      "special": true
-    }
-  },
-  "clean_up_tokenization_spaces": true,
-  "cls_token": "[CLS]",
-  "do_basic_tokenize": true,
-  "do_lower_case": true,
-  "mask_token": "[MASK]",
-  "max_length": 128,
-  "model_max_length": 512,
-  "never_split": null,
-  "pad_to_multiple_of": null,
-  "pad_token": "[PAD]",
-  "pad_token_type_id": 0,
-  "padding_side": "right",
-  "sep_token": "[SEP]",
-  "stride": 0,
-  "strip_accents": null,
-  "tokenize_chinese_chars": true,
-  "tokenizer_class": "BertTokenizer",
-  "truncation_side": "right",
-  "truncation_strategy": "longest_first",
-  "unk_token": "[UNK]"
-}

requirements.txt

@@ -27,13 +27,6 @@ sounddevice
 PyYAML
 python-dotenv
 
-# Semantic intent classifier (MiniLM-L6-v2 ONNX)
-onnxruntime>=1.17
-tokenizers>=0.15
-
-# Noise suppression before STT (optional, off by default)
-noisereduce>=3.0
-
 # GUI command constructor (tools/command_builder)
 ruamel.yaml
 pywebview

tools/command_builder/schema.py

@@ -65,20 +65,13 @@ class ShellAction:
         return out
 
 
-KNOWN_BROWSERS = ("yandex", "chrome", "firefox", "edge")
-
-
 @dataclass
 class UrlAction:
     href: str
-    browser: Optional[str] = None
     type: str = "url"
 
     def to_dict(self) -> dict:
-        out: dict = {"type": "url", "href": self.href}
+        return {"type": "url", "href": self.href}
-        if self.browser:
-            out["browser"] = self.browser
-        return out
 
 
 @dataclass
@@ -164,10 +157,7 @@ def action_from_dict(data: Any) -> Action:
         href = data.get("href")
         if not href or not isinstance(href, str):
             raise SchemaError("url action requires non-empty 'href' string")
-        browser = data.get("browser")
+        return UrlAction(href=href)
-        if browser is not None and browser not in KNOWN_BROWSERS:
-            raise SchemaError(f"url.browser must be one of {KNOWN_BROWSERS} or omitted")
-        return UrlAction(href=href, browser=browser)
     if t == "keys":
         sequence = data.get("sequence")
         text = data.get("text")

tools/command_builder/web/app.js

@@ -191,25 +191,10 @@
                     <label>URL</label>
                     <input type="text" id="url-href" placeholder="https://example.com">
                 </div>
-                <div class="field">
-                    <label>Браузер</label>
-                    <select id="url-browser">
-                        <option value="">по умолчанию (системный)</option>
-                        <option value="yandex">Yandex Browser</option>
-                        <option value="chrome">Google Chrome</option>
-                        <option value="firefox">Mozilla Firefox</option>
-                        <option value="edge">Microsoft Edge</option>
-                    </select>
-                </div>
             `;
             const inp = f.querySelector("#url-href");
-            const sel = f.querySelector("#url-browser");
+            if (state.action) inp.value = state.action.href || "";
-            if (state.action) {
-                inp.value = state.action.href || "";
-                sel.value = state.action.browser || "";
-            }
             inp.addEventListener("input", () => updateAction());
-            sel.addEventListener("change", () => updateAction());
             return;
         }
 
@@ -496,23 +481,8 @@
                 inp.type = "text";
                 inp.value = step.href || "";
                 inp.placeholder = "https://...";
-                const sel = document.createElement("select");
+                inp.addEventListener("input", () => onChange({ type: "url", href: inp.value }));
-                sel.innerHTML = `
-                    <option value="">по умолчанию (системный)</option>
-                    <option value="yandex">Yandex Browser</option>
-                    <option value="chrome">Google Chrome</option>
-                    <option value="firefox">Mozilla Firefox</option>
-                    <option value="edge">Microsoft Edge</option>`;
-                sel.value = step.browser || "";
-                const apply = () => {
-                    const next = { type: "url", href: inp.value };
-                    if (sel.value) next.browser = sel.value;
-                    onChange(next);
-                };
-                inp.addEventListener("input", apply);
-                sel.addEventListener("change", apply);
                 body.appendChild(wrapField("URL", inp));
-                body.appendChild(wrapField("Браузер", sel));
             } else if (t === "keys") {
                 const inp = document.createElement("input");
                 inp.type = "text";
@@ -599,10 +569,7 @@
             if (delay && delay.value) a.delay_ms = parseInt(delay.value, 10);
             state.action = a;
         } else if (t === "url") {
-            const a = { type: "url", href: (document.getElementById("url-href")||{}).value || "" };
+            state.action = { type: "url", href: (document.getElementById("url-href")||{}).value || "" };
-            const b = (document.getElementById("url-browser")||{}).value;
-            if (b) a.browser = b;
-            state.action = a;
         } else if (t === "keys") {
             const mode = (document.getElementById("keys-mode")||{}).value;
             if (mode === "text") {

tts.py

@@ -1,12 +1,8 @@
 import time
 
-import numpy as np
 import sounddevice as sd
 import torch
 
-import config
-import effects
-
 language = 'ru'
 model_id = 'ru_v3'
 sample_rate = 48000  # 48000
@@ -23,39 +19,18 @@ model, _ = torch.hub.load(repo_or_dir='snakers4/silero-models',
 model.to(device)
 
 
-def _post_process(audio):
+# воспроизводим
-    if not getattr(config, 'TTS_EFFECTS_ENABLED', False):
+def va_speak(what: str):
-        return audio
-
-    arr = np.asarray(audio, dtype=np.float32)
-    low = getattr(config, 'TTS_BANDPASS_LOW_HZ', 0)
-    high = getattr(config, 'TTS_BANDPASS_HIGH_HZ', 0)
-    bandpass = (low, high) if low and high and high > low else None
-
-    wet = float(getattr(config, 'TTS_REVERB_WET', 0.0))
-    decay = int(getattr(config, 'TTS_REVERB_DECAY_MS', 0))
-    reverb = (wet, decay) if wet > 0 and decay > 0 else None
-
-    pitch = int(getattr(config, 'TTS_PITCH_SEMITONES', 0))
-
-    return effects.process(arr, sample_rate,
-                           bandpass=bandpass,
-                           reverb=reverb,
-                           pitch_semitones=pitch)
-
-
-def synthesize(what: str):
     audio = model.apply_tts(text=what + "..",
                             speaker=speaker,
                             sample_rate=sample_rate,
                             put_accent=put_accent,
                             put_yo=put_yo)
-    return _post_process(audio)
-
-
-def va_speak(what: str):
-    audio = synthesize(what)
 
     sd.play(audio, sample_rate * 1.05)
     time.sleep((len(audio) / sample_rate) + 0.5)
     sd.stop()
+
+# sd.play(audio, sample_rate)
+# time.sleep(len(audio) / sample_rate)
+# sd.stop()

utils/preview_effects.py

@@ -1,55 +0,0 @@
-import os
-import sys
-
-import numpy as np
-import soundfile as sf
-
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-import config
-import effects
-import tts
-
-
-PHRASE = "Приветствую, сэр. Все системы в норме."
-OUT_RAW = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
-                      'sound', '_preview_silero_raw.wav')
-OUT_FX = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
-                     'sound', '_preview_silero_fx.wav')
-
-
-def _render_raw(text: str) -> np.ndarray:
-    audio = tts.model.apply_tts(text=text + "..",
-                                speaker=tts.speaker,
-                                sample_rate=tts.sample_rate,
-                                put_accent=tts.put_accent,
-                                put_yo=tts.put_yo)
-    return np.asarray(audio, dtype=np.float32)
-
-
-def _render_fx(raw: np.ndarray) -> np.ndarray:
-    return effects.process(
-        raw, tts.sample_rate,
-        bandpass=(config.TTS_BANDPASS_LOW_HZ, config.TTS_BANDPASS_HIGH_HZ),
-        reverb=(config.TTS_REVERB_WET, config.TTS_REVERB_DECAY_MS),
-        pitch_semitones=config.TTS_PITCH_SEMITONES,
-    )
-
-
-def main():
-    print(f"Synthesizing: {PHRASE!r}")
-    raw = _render_raw(PHRASE)
-    fx = _render_fx(raw)
-
-    sf.write(OUT_RAW, raw, tts.sample_rate, subtype='PCM_16')
-    sf.write(OUT_FX, fx, tts.sample_rate, subtype='PCM_16')
-
-    dur_raw = len(raw) / tts.sample_rate
-    dur_fx = len(fx) / tts.sample_rate
-    print(f"raw: {OUT_RAW}  ({len(raw)} samples, {dur_raw:.2f}s)")
-    print(f"fx : {OUT_FX}  ({len(fx)} samples, {dur_fx:.2f}s)")
-    print("Open both in a media player and A/B compare.")
-
-
-if __name__ == '__main__':
-    main()