👍️[Update] Controller : 文言を修正

inpurt -> mic
output -> speaker

src-python/config.py

@@ -459,7 +459,7 @@ class Config:
 
     @SELECTED_MIC_HOST.setter
     def SELECTED_MIC_HOST(self, value):
-        if value in [host for host in device_manager.getInputDevices().keys()]:
+        if value in [host for host in device_manager.getMicDevices().keys()]:
             self._SELECTED_MIC_HOST = value
             saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
 
@@ -470,7 +470,7 @@ class Config:
 
     @SELECTED_MIC_DEVICE.setter
     def SELECTED_MIC_DEVICE(self, value):
-        if value in [device["name"] for device in device_manager.getInputDevices()[self.SELECTED_MIC_HOST]]:
+        if value in [device["name"] for device in device_manager.getMicDevices()[self.SELECTED_MIC_HOST]]:
             self._SELECTED_MIC_DEVICE = value
             saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
 
@@ -580,7 +580,7 @@ class Config:
 
     @SELECTED_SPEAKER_DEVICE.setter
     def SELECTED_SPEAKER_DEVICE(self, value):
-        if value in [device["name"] for device in device_manager.getOutputDevices()]:
+        if value in [device["name"] for device in device_manager.getSpeakerDevices()]:
             self._SELECTED_SPEAKER_DEVICE = value
             saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
 
@@ -1101,8 +1101,8 @@ class Config:
             "height": "654",
         }
         self._AUTO_MIC_SELECT = True
-        self._SELECTED_MIC_HOST = device_manager.getDefaultInputDevice()["host"]["name"]
+        self._SELECTED_MIC_HOST = device_manager.getDefaultMicDevice()["host"]["name"]
-        self._SELECTED_MIC_DEVICE = device_manager.getDefaultInputDevice()["device"]["name"]
+        self._SELECTED_MIC_DEVICE = device_manager.getDefaultMicDevice()["device"]["name"]
         self._MIC_THRESHOLD = 300
         self._MIC_AUTOMATIC_THRESHOLD = False
         self._MIC_RECORD_TIMEOUT = 3
@@ -1112,7 +1112,7 @@ class Config:
         self._MIC_AVG_LOGPROB=-0.8
         self._MIC_NO_SPEECH_PROB=0.6
         self._AUTO_SPEAKER_SELECT = True
-        self._SELECTED_SPEAKER_DEVICE = device_manager.getDefaultOutputDevice()["device"]["name"]
+        self._SELECTED_SPEAKER_DEVICE = device_manager.getDefaultSpeakerDevice()["device"]["name"]
         self._SPEAKER_ENERGY_THRESHOLD = 300
         self._SPEAKER_AUTOMATIC_THRESHOLD = False
         self._SPEAKER_RECORD_TIMEOUT = 3

src-python/model.py

@@ -407,32 +407,32 @@ class Model:
         command = [os_path.join(current_directory, batch_name), program_name]
         Popen(command, cwd=current_directory)
 
-    def getListInputHost(self):
+    def getListMicHost(self):
-        result = [host for host in device_manager.getInputDevices().keys()]
+        result = [host for host in device_manager.getMicDevices().keys()]
         return result
 
-    def getInputDefaultDevice(self):
+    def getMicDefaultDevice(self):
-        result = device_manager.getInputDevices().get(config.SELECTED_MIC_HOST, [{"name": "NoDevice"}])[0]["name"]
+        result = device_manager.getMicDevices().get(config.SELECTED_MIC_HOST, [{"name": "NoDevice"}])[0]["name"]
         return result
 
-    def getListInputDevice(self):
+    def getListMicDevice(self):
-        result = [device["name"] for device in device_manager.getInputDevices().get(config.SELECTED_MIC_HOST, [{"name": "NoDevice"}])]
+        result = [device["name"] for device in device_manager.getMicDevices().get(config.SELECTED_MIC_HOST, [{"name": "NoDevice"}])]
         return result
 
-    def getListOutputDevice(self):
+    def getListSpeakerDevice(self):
-        result = [device["name"] for device in device_manager.getOutputDevices()]
+        result = [device["name"] for device in device_manager.getSpeakerDevices()]
         return result
 
     def startMicTranscript(self, fnc):
         if config.AUTO_MIC_SELECT is True:
-            default_device = device_manager.getDefaultInputDevice()
+            default_device = device_manager.getDefaultMicDevice()
             mic_host_name = default_device["host"]["name"]
             mic_device_name = default_device["device"]["name"]
         else:
             mic_host_name = config.SELECTED_MIC_HOST
             mic_device_name = config.SELECTED_MIC_DEVICE
 
-        mic_device_list = device_manager.getInputDevices().get(mic_host_name, [{"name": "NoDevice"}])
+        mic_device_list = device_manager.getMicDevices().get(mic_host_name, [{"name": "NoDevice"}])
         selected_mic_device = [device for device in mic_device_list if device["name"] == mic_device_name]
 
         if len(selected_mic_device) == 0:
@@ -559,14 +559,14 @@ class Model:
             self.check_mic_energy_fnc = fnc
 
         if config.AUTO_MIC_SELECT is True:
-            default_device = device_manager.getDefaultInputDevice()
+            default_device = device_manager.getDefaultMicDevice()
             mic_host_name = default_device["host"]["name"]
             mic_device_name = default_device["device"]["name"]
         else:
             mic_host_name = config.SELECTED_MIC_HOST
             mic_device_name = config.SELECTED_MIC_DEVICE
 
-        mic_device_list = device_manager.getInputDevices().get(mic_host_name, [{"name": "NoDevice"}])
+        mic_device_list = device_manager.getMicDevices().get(mic_host_name, [{"name": "NoDevice"}])
         selected_mic_device = [device for device in mic_device_list if device["name"] == mic_device_name]
 
         if len(selected_mic_device) == 0:
@@ -601,12 +601,12 @@ class Model:
 
     def startSpeakerTranscript(self, fnc):
         if config.AUTO_SPEAKER_SELECT is True:
-            default_device = device_manager.getDefaultOutputDevice()
+            default_device = device_manager.getDefaultSpeakerDevice()
             speaker_device_name = default_device["device"]["name"]
         else:
             speaker_device_name = config.SELECTED_SPEAKER_DEVICE
 
-        speaker_device_list = device_manager.getOutputDevices()
+        speaker_device_list = device_manager.getSpeakerDevices()
         selected_speaker_device = [device for device in speaker_device_list if device["name"] == speaker_device_name]
 
         if len(selected_speaker_device) == 0:
@@ -693,12 +693,12 @@ class Model:
             self.check_speaker_energy_fnc = fnc
 
         if config.AUTO_SPEAKER_SELECT is True:
-            default_device = device_manager.getDefaultOutputDevice()
+            default_device = device_manager.getDefaultSpeakerDevice()
             speaker_device_name = default_device["device"]["name"]
         else:
             speaker_device_name = config.SELECTED_SPEAKER_DEVICE
 
-        speaker_device_list = device_manager.getOutputDevices()
+        speaker_device_list = device_manager.getSpeakerDevices()
         selected_speaker_device = [device for device in speaker_device_list if device["name"] == speaker_device_name]
 
         if len(selected_speaker_device) == 0:

src-python/models/transcription/transcription_utils.py

@@ -29,26 +29,26 @@ class DeviceManager:
         return cls._instance
 
     def init(self):
-        self.input_devices = {"NoHost": [{"name": "NoDevice"}]}
+        self.mic_devices = {"NoHost": [{"name": "NoDevice"}]}
-        self.default_input_device = {"host": {"name": "NoHost"}, "device": {"name": "NoDevice"}}
+        self.default_mic_device = {"host": {"name": "NoHost"}, "device": {"name": "NoDevice"}}
-        self.output_devices = [{"name": "NoDevice"}]
+        self.speaker_devices = [{"name": "NoDevice"}]
-        self.default_output_device = {"device": {"name": "NoDevice"}}
+        self.default_speaker_device = {"device": {"name": "NoDevice"}}
         self.update()
 
-        self.callback_default_input_device = None
+        self.callback_default_mic_device = None
-        self.callback_default_output_device = None
+        self.callback_default_speaker_device = None
         self.callback_host_list = None
-        self.callback_input_device_list = None
+        self.callback_mic_device_list = None
-        self.callback_output_device_list = None
+        self.callback_speaker_device_list = None
 
         self.monitoring_flag = False
         self.startMonitoring()
 
     def update(self):
-        buffer_input_devices = {}
+        buffer_mic_devices = {}
-        buffer_default_input_device = {"host": {"name": "NoHost"}, "device": {"name": "NoDevice"}}
+        buffer_default_mic_device = {"host": {"name": "NoHost"}, "device": {"name": "NoDevice"}}
-        buffer_output_devices = []
+        buffer_speaker_devices = []
-        buffer_default_output_device = {"device": {"name": "NoDevice"}}
+        buffer_default_speaker_device = {"device": {"name": "NoDevice"}}
 
         with PyAudio() as p:
             for host_index in range(p.get_host_api_count()):
@@ -57,26 +57,26 @@ class DeviceManager:
                 for device_index in range(device_count):
                     device = p.get_device_info_by_host_api_device_index(host_index, device_index)
                     if device.get("maxInputChannels", 0) > 0 and not device.get("isLoopbackDevice", True):
-                        buffer_input_devices.setdefault(host["name"], []).append(device)
+                        buffer_mic_devices.setdefault(host["name"], []).append(device)
-            if not buffer_input_devices:
+            if not buffer_mic_devices:
-                buffer_input_devices = {"NoHost": [{"name": "NoDevice"}]}
+                buffer_mic_devices = {"NoHost": [{"name": "NoDevice"}]}
 
             api_info = p.get_default_host_api_info()
-            default_input_device = api_info["defaultInputDevice"]
+            default_mic_device = api_info["defaultInputDevice"]
 
             for host_index in range(p.get_host_api_count()):
                 host = p.get_host_api_info_by_index(host_index)
                 device_count = host.get('deviceCount', 0)
                 for device_index in range(device_count):
                     device = p.get_device_info_by_host_api_device_index(host_index, device_index)
-                    if device["index"] == default_input_device:
+                    if device["index"] == default_mic_device:
-                        buffer_default_input_device = {"host": host, "device": device}
+                        buffer_default_mic_device = {"host": host, "device": device}
                         break
                 else:
                     continue
                 break
 
-            output_devices = []
+            speaker_devices = []
             wasapi_info = p.get_host_api_info_by_type(paWASAPI)
             wasapi_name = wasapi_info["name"]
             for host_index in range(p.get_host_api_count()):
@@ -88,34 +88,34 @@ class DeviceManager:
                         if not device.get("isLoopbackDevice", True):
                             for loopback in p.get_loopback_device_info_generator():
                                 if device["name"] in loopback["name"]:
-                                    output_devices.append(loopback)
+                                    speaker_devices.append(loopback)
-            output_devices = [dict(t) for t in {tuple(d.items()) for d in output_devices}] or [{"name": "NoDevice"}]
+            speaker_devices = [dict(t) for t in {tuple(d.items()) for d in speaker_devices}] or [{"name": "NoDevice"}]
-            buffer_output_devices = sorted(output_devices, key=lambda d: d['index'])
+            buffer_speaker_devices = sorted(speaker_devices, key=lambda d: d['index'])
 
             wasapi_info = p.get_host_api_info_by_type(paWASAPI)
-            default_output_device_index = wasapi_info["defaultOutputDevice"]
+            default_speaker_device_index = wasapi_info["defaultOutputDevice"]
 
             for host_index in range(p.get_host_api_count()):
                 host_info = p.get_host_api_info_by_index(host_index)
                 device_count = host_info.get('deviceCount', 0)
                 for device_index in range(0, device_count):
                     device = p.get_device_info_by_host_api_device_index(host_index, device_index)
-                    if device["index"] == default_output_device_index:
+                    if device["index"] == default_speaker_device_index:
                         default_speakers = device
                         if not default_speakers.get("isLoopbackDevice", True):
                             for loopback in p.get_loopback_device_info_generator():
                                 if default_speakers["name"] in loopback["name"]:
-                                    buffer_default_output_device = {"device": loopback}
+                                    buffer_default_speaker_device = {"device": loopback}
                                     break
                         break
 
-                if buffer_default_output_device["device"]["name"] != "NoDevice":
+                if buffer_default_speaker_device["device"]["name"] != "NoDevice":
                     break
 
-        self.input_devices = buffer_input_devices
+        self.mic_devices = buffer_mic_devices
-        self.default_input_device = buffer_default_input_device
+        self.default_mic_device = buffer_default_mic_device
-        self.output_devices = buffer_output_devices
+        self.speaker_devices = buffer_speaker_devices
-        self.default_output_device = buffer_default_output_device
+        self.default_speaker_device = buffer_default_speaker_device
 
     def monitoring(self):
         comtypes.CoInitialize()
@@ -147,17 +147,17 @@ class DeviceManager:
         self.monitoring_flag = False
         self.th_monitoring.join()
 
-    def setCallbackDefaultInputDevice(self, callback):
+    def setCallbackDefaultMicDevice(self, callback):
-        self.callback_default_input_device = callback
+        self.callback_default_mic_device = callback
 
-    def clearCallbackDefaultInputDevice(self):
+    def clearCallbackDefaultMicDevice(self):
-        self.callback_default_input_device = None
+        self.callback_default_mic_device = None
 
-    def setCallbackDefaultOutputDevice(self, callback):
+    def setCallbackDefaultSpeakerDevice(self, callback):
-        self.callback_default_output_device = callback
+        self.callback_default_speaker_device = callback
 
-    def clearCallbackDefaultOutputDevice(self):
+    def clearCallbackDefaultSpeakerDevice(self):
-        self.callback_default_output_device = None
+        self.callback_default_speaker_device = None
 
     def setCallbackHostList(self, callback):
         self.callback_host_list = callback
@@ -165,49 +165,49 @@ class DeviceManager:
     def clearCallbackHostList(self):
         self.callback_host_list = None
 
-    def setCallbackInputDeviceList(self, callback):
+    def setCallbackMicDeviceList(self, callback):
-        self.callback_input_device_list = callback
+        self.callback_mic_device_list = callback
 
-    def clearCallbackInputDeviceList(self):
+    def clearCallbackMicDeviceList(self):
-        self.callback_input_device_list = None
+        self.callback_mic_device_list = None
 
-    def setCallbackOutputDeviceList(self, callback):
+    def setCallbackSpeakerDeviceList(self, callback):
-        self.callback_output_device_list = callback
+        self.callback_speaker_device_list = callback
 
-    def clearCallbackOutputDeviceList(self):
+    def clearCallbackSpeakerDeviceList(self):
-        self.callback_output_device_list = None
+        self.callback_speaker_device_list = None
 
     def noticeDefaultDevice(self):
-        if self.callback_default_input_device is not None:
+        if self.callback_default_mic_device is not None:
-            self.callback_default_input_device(self.default_input_device["host"]["name"], self.default_input_device["device"]["name"])
+            self.callback_default_mic_device(self.default_mic_device["host"]["name"], self.default_mic_device["device"]["name"])
-        if self.callback_default_output_device is not None:
+        if self.callback_default_speaker_device is not None:
-            self.callback_default_output_device(self.default_output_device["device"]["name"])
+            self.callback_default_speaker_device(self.default_speaker_device["device"]["name"])
         if self.callback_host_list is not None:
             self.callback_host_list()
-        if self.callback_input_device_list is not None:
+        if self.callback_mic_device_list is not None:
-            self.callback_input_device_list()
+            self.callback_mic_device_list()
-        if self.callback_output_device_list is not None:
+        if self.callback_speaker_device_list is not None:
-            self.callback_output_device_list()
+            self.callback_speaker_device_list()
 
-    def getInputDevices(self):
+    def getMicDevices(self):
-        return self.input_devices
+        return self.mic_devices
 
-    def getDefaultInputDevice(self):
+    def getDefaultMicDevice(self):
-        return self.default_input_device
+        return self.default_mic_device
 
-    def getOutputDevices(self):
+    def getSpeakerDevices(self):
-        return self.output_devices
+        return self.speaker_devices
 
-    def getDefaultOutputDevice(self):
+    def getDefaultSpeakerDevice(self):
-        return self.default_output_device
+        return self.default_speaker_device
 
 device_manager = DeviceManager()
 
 if __name__ == "__main__":
-    # print("getInputDevices()", device_manager.getInputDevices())
+    # print("getMicDevices()", device_manager.getMicDevices())
-    # print("getDefaultInputDevice()", device_manager.getDefaultInputDevice())
+    # print("getDefaultMicDevice()", device_manager.getDefaultMicDevice())
-    # print("getOutputDevices()", device_manager.getOutputDevices())
+    # print("getSpeakerDevices()", device_manager.getSpeakerDevices())
-    # print("getDefaultOutputDevice()", device_manager.getDefaultOutputDevice())
+    # print("getDefaultSpeakerDevice()", device_manager.getDefaultSpeakerDevice())
 
     while True:
         sleep(1)

src-python/webui_controller.py

@@ -38,21 +38,21 @@ class Controller:
         self.run(
             200,
             self.run_mapping["mic_host_list"],
-            model.getListInputHost(),
+            model.getListMicHost(),
         )
 
     def updateMicDeviceList(self) -> None:
         self.run(
             200,
             self.run_mapping["mic_device_list"],
-            model.getListInputDevice(),
+            model.getListMicDevice(),
         )
 
     def updateSpeakerDeviceList(self) -> None:
         self.run(
             200,
             self.run_mapping["speaker_device_list"],
-            model.getListOutputDevice(),
+            model.getListSpeakerDevice(),
         )
 
     def updateSelectedMicDevice(self, host, device) -> None:
@@ -411,15 +411,15 @@ class Controller:
 
     @staticmethod
     def getMicHostList(*args, **kwargs) -> dict:
-        return {"status":200, "result": model.getListInputHost()}
+        return {"status":200, "result": model.getListMicHost()}
 
     @staticmethod
     def getMicDeviceList(*args, **kwargs) -> dict:
-        return {"status":200, "result": model.getListInputDevice()}
+        return {"status":200, "result": model.getListMicDevice()}
 
     @staticmethod
     def getSpeakerDeviceList(*args, **kwargs) -> dict:
-        return {"status":200, "result": model.getListOutputDevice()}
+        return {"status":200, "result": model.getListSpeakerDevice()}
 
     @staticmethod
     def getSelectedTranslationEngines(*args, **kwargs) -> dict:
@@ -601,13 +601,13 @@ class Controller:
 
     def setEnableAutoMicSelect(self, *args, **kwargs) -> dict:
         config.AUTO_MIC_SELECT = True
-        device_manager.setCallbackDefaultInputDevice(self.updateSelectedMicDevice)
+        device_manager.setCallbackDefaultMicDevice(self.updateSelectedMicDevice)
         device_manager.noticeDefaultDevice()
         return {"status":200, "result":config.AUTO_MIC_SELECT}
 
     @staticmethod
     def setDisableAutoMicSelect(*args, **kwargs) -> dict:
-        device_manager.clearCallbackDefaultInputDevice()
+        device_manager.clearCallbackDefaultMicDevice()
         config.AUTO_MIC_SELECT = False
         return {"status":200, "result":config.AUTO_MIC_SELECT}
 
@@ -618,7 +618,7 @@ class Controller:
     @staticmethod
     def setSelectedMicHost(data, *args, **kwargs) -> dict:
         config.SELECTED_MIC_HOST = data
-        config.SELECTED_MIC_DEVICE = model.getInputDefaultDevice()
+        config.SELECTED_MIC_DEVICE = model.getMicDefaultDevice()
         if config.ENABLE_CHECK_ENERGY_SEND is True:
             model.stopCheckMicEnergy()
             model.startCheckMicEnergy()
@@ -783,13 +783,13 @@ class Controller:
 
     def setEnableAutoSpeakerSelect(self, *args, **kwargs) -> dict:
         config.AUTO_SPEAKER_SELECT = True
-        device_manager.setCallbackDefaultOutputDevice(self.updateSelectedSpeakerDevice)
+        device_manager.setCallbackDefaultSpeakerDevice(self.updateSelectedSpeakerDevice)
         device_manager.noticeDefaultDevice()
         return {"status":200, "result":config.AUTO_SPEAKER_SELECT}
 
     @staticmethod
     def setDisableAutoSpeakerSelect(*args, **kwargs) -> dict:
-        device_manager.clearCallbackDefaultInputDevice()
+        device_manager.clearCallbackDefaultSpeakerDevice()
         config.AUTO_SPEAKER_SELECT = False
         return {"status":200, "result":config.AUTO_SPEAKER_SELECT}
 
@@ -1582,13 +1582,13 @@ class Controller:
         # init Auto device selection
         printLog("Init Auto Device Selection")
         if config.AUTO_MIC_SELECT is True:
-            device_manager.setCallbackDefaultInputDevice(self.updateSelectedMicDevice)
+            device_manager.setCallbackDefaultMicDevice(self.updateSelectedMicDevice)
 
         if config.AUTO_SPEAKER_SELECT is True:
-            device_manager.setCallbackDefaultOutputDevice(self.updateSelectedSpeakerDevice)
+            device_manager.setCallbackDefaultSpeakerDevice(self.updateSelectedSpeakerDevice)
 
         device_manager.setCallbackHostList(self.updateMicHostList)
-        device_manager.setCallbackInputDeviceList(self.updateMicDeviceList)
+        device_manager.setCallbackMicDeviceList(self.updateMicDeviceList)
-        device_manager.setCallbackOutputDeviceList(self.updateSpeakerDeviceList)
+        device_manager.setCallbackSpeakerDeviceList(self.updateSpeakerDeviceList)
 
         printLog("End Initialization")