pySpeechModule 1.0.0__py3-none-any.whl

pySpeechModule/__init__.py

@@ -0,0 +1,15 @@
+from .speechd_server import SpeechServer
+from .speechd import SpeechDispatch
+from .speechd_action_worker import ActionWorker
+from .speechd_execution_worker import ExecutionWorker
+from .speechd_utilities import hdlc_escape, parse_ssml, strip_ssml
+
+__all__ = [
+    "SpeechServer",
+    "SpeechDispatch",
+    "ActionWorker",
+    "ExecutionWorker",
+    "hdlc_escape",
+    "parse_ssml",
+    "strip_ssml",
+    ]

pySpeechModule/speechd.py

@@ -0,0 +1,156 @@
+import logging
+import time
+import soundfile as sf
+
+class SpeechDispatch():
+    def __init__(self):
+        """
+        you should place the voices list here in __init__
+
+        .. code-block:: python
+
+            self.voices = [{"name": "Testing", "language": "en", "variant": "none"},
+            {"name": "Testing2", "language": "en", "variant": "none"}]
+        
+        You should also set your max_ahead and min_ahead here.
+
+        .. code-block:: python
+
+            self.max_ahead = 60 # this sets the max number of second your generation will get ahead of played audio.
+            self.min_ahead = 30 # this sets how small the ahead number maybe before starting generation again.
+
+        You can also place model init or what ever else you would like to init here.
+        """
+        pass
+    def _set_init(self,queue, server):
+        """
+        Set the action_queue and server.
+
+        :meta private:
+        """
+
+        self.action_queue = queue
+        self._server = server
+    def configure(self, configure_file: str):
+        """
+        This method get passed in the file path to the modules dot conf file
+        If you need to use it you should open the file and parse here.
+        """
+        pass
+    def change_voice(self, voice: str):
+        """
+        This method gets passed the name of a voice when the user has requested to change the voice.
+
+        :param voice: String containing the voice name.
+        :type String: String
+        """
+        pass
+    def change_language(self, language: str):
+        """
+        This method gets passed a language when the user has requested to change the language.
+
+        :param voice: String containing the language.
+        :type String: String
+        """
+        pass
+    def change_speed(self, speed: str):
+        """
+        This method gets passed a speed when the user requests to change the speed.
+        The speed will be between -100 and 100
+
+        :param voice: String containing the new speed.
+        :type String: String
+        """
+        pass
+    def change_pitch(self, pitch: str):
+        """
+        This method gets passed a pitch when the user requests to change the pitch
+
+        :param voice: String containing the new pitch.
+        :type String: String
+        """
+        pass
+    def _parse_settings(self,options: dict):
+        """
+        When passed the settings it calls the convenience methods associated with that setting.
+
+        :meta private:
+        """
+        if 'synthesis_voice' in options:
+            self.change_voice(options['synthesis_voice'])
+        if 'language' in options:
+            self.change_language(options['language'])
+        if 'rate' in options:
+            self.change_speed(options['rate'])
+        if 'pitch' in options:
+            self.change_pitch(options['pitch'])
+    def _settings(self,options):
+        """
+        Passed the setting, sends it to the parsers.
+
+        :meta private:
+        """
+        self._parse_settings(options)
+        self.settings(options)
+
+    def settings(self,options: dict):
+        """
+        This gets passed the full settings options
+
+        :param options: Dict containing all the settings options that were sent.
+        :type Dictionary: Dictionary.
+        """
+        pass
+    def _speak(self,text: str):
+        """
+        This is called to generate speech
+        It then iterate's through speech chunks returned by the user.
+
+        :meta private:
+        """
+        self._server.stop_set(False)
+        self._ahead = 0
+        self.action_queue.put({"command": "begin"})
+        it = self.speak(text)
+        while (True):
+            try:
+                if (self._server.stop_get()):
+                    break
+                start_time = time.time() 
+                item = next(it) # get the next audio chunk
+                end_time = time.time()
+                total_time = end_time-start_time # total time it took to generate that audio chunk
+                produced_time = (len(item['audio']) / item['rate']) # amount of audio generate
+                logging.debug(f"Speak chunk took {total_time} to produce {produced_time} for mark {item['mark']}")
+                self._ahead = self._ahead + produced_time
+                self._ahead = self._ahead - total_time
+                logging.debug(f"Ahead: {self._ahead}")
+                self.action_queue.put({"command": "speak", "val": item})
+                # sleep if we have too much audio generated, only do this is max_ahead and min_ahead are set.
+                if (hasattr(self, "max_ahead") and hasattr(self, "min_ahead")):
+                    if (self._ahead >= self.max_ahead):
+                        logging.debug(f"Ahead by too much sleeping")
+                        while (self._ahead >= self.min_ahead):
+                            time.sleep(1)
+                            self._ahead = self._ahead - 1
+                            if (self._server.stop_get()):
+                                break;
+            except StopIteration:
+                logging.debug("finished speak chunking")
+                break
+        self.action_queue.put({"command": "end"})
+    def speak(self,text: str):
+        """
+        This method get called to get the user to generate audio.
+        Data must be yield'ed in the format
+        
+        .. code-block:: python
+
+            yield {"audio": <data>, "rate": <samplerate>, "mark": <mark>}
+
+        :param text: String containing ssml text.
+        :type String: String
+        :yields: Dict containing keys for "audio", "rate", "mark"
+        :ytype: Dict
+        """
+        pass

pySpeechModule/speechd_action_worker.py

@@ -0,0 +1,41 @@
+import logging
+import threading
+import queue
+
+class ActionWorker(threading.Thread):
+    """
+    Worker for running speak commands on the server
+    
+    :meta private:
+    """
+    def __init__(self, server):
+        super().__init__()
+        self.queue = queue.Queue()
+        self.server = server
+        self.daemon = True
+
+    def begin(self):
+        self.server._begin()
+
+    def end(self):
+        self.server._end()
+
+    def speak(self,val):
+        self.server._send_audio(val)
+    
+    def stop(self):
+        """Sends the sentinel value to trigger a graceful shutdown."""
+        self.queue.put(None)
+
+    def run(self):
+        while True:
+            item = self.queue.get()
+            logging.debug(f"action worker: got item {item}")
+            if item is None:
+                break
+            if (item['command'] == 'begin'):
+                self.begin()
+            if (item['command'] == 'end'):
+                self.end()
+            if (item['command'] == 'speak'):
+                self.speak(item['val'])

pySpeechModule/speechd_execution_worker.py

@@ -0,0 +1,34 @@
+import logging
+import threading
+import queue
+
+class ExecutionWorker(threading.Thread):
+    """
+    Worker for running the execution callbacks.
+    
+    :meta private:
+    """
+    def __init__(self):
+        super().__init__()
+        self.queue = queue.Queue()
+        self.daemon = True
+
+    def set_callback(self,callback):
+        self._callback = callback
+
+    def stop(self):
+        """Sends the sentinel value to trigger a graceful shutdown."""
+        self.queue.put(None)
+
+    def run(self):
+        while True:
+            item = self.queue.get()
+            logging.debug(f"execution worker: got item {item}")
+            if item is None:
+                break
+            elif (item['command'] == 'speak'):
+                self._callback._speak(item['args'])
+            elif (item['command'] == 'settings'):
+                self._callback._settings(item['args'])
+            elif (item['command'] == 'configure'):
+                self._callback.configure(item['args'])

pySpeechModule/speechd_server.py

@@ -0,0 +1,396 @@
+import sys
+import logging
+import threading
+import select
+import soundfile as sf
+import queue
+import time
+
+from .speechd_action_worker import ActionWorker
+from .speechd_execution_worker import ExecutionWorker
+from .speechd_utilities import hdlc_escape
+
+stdout = sys.stdout
+stdin = sys.stdin
+sys.stdout = sys.stderr
+
+logging.basicConfig(
+    stream=sys.stderr,
+    level=logging.DEBUG,
+    format="[%(asctime)s] %(levelname)s: %(message)s",
+    datefmt="%Y-%m-%d %H:%M:%S"
+)
+
+class SpeechServer():
+    """
+    This is the server class, it handles running the protocal.
+
+    .. note:: we set ``sys.stdout = sys.stderr``, this is to ensure that users don't accedentally break the protocal. Anything printed to stdout may break the server.
+    """
+    def __init__(self):
+        """
+        :meta private:
+        """
+
+        self.line_count = 0
+
+        self.execution_worker = ExecutionWorker()
+        self.action_worker = ActionWorker(server=self)
+
+        self.voices = []
+        self.server_lock = threading.RLock()
+        self.stop_lock = threading.RLock()
+        self.stop = False # make sure you use stop_lock when using this.
+    
+    def _readline(self, block=True):
+        """
+        This is basically pythons readline but with the added ability to do it none blocking.
+
+        :meta private:
+        """
+
+        try:
+            if (not block):
+                timeout = 0.0
+                ready, _, _ = select.select([stdin], [], [], timeout)
+                if ready:
+                    output = stdin.readline()
+                    logging.debug(f"line {self.line_count}: {output[:-1]}")
+                    self.line_count = self.line_count + 1
+                    return output
+                return None
+            else:
+                output = stdin.readline()
+                logging.debug(f"line {self.line_count}: {output[:-1]}")
+                self.line_count = self.line_count + 1
+                return output
+        except Exception as e:
+            logging.error(f"_readline: {e}")
+
+
+    def _begin(self):
+        """
+        Send command telling speechd we are starting to send audio data.
+
+        :meta private:
+        """
+
+        with self.server_lock:
+            stdout.write("701 BEGIN\n")
+            stdout.flush()
+    def _end(self):
+        """
+        Tells speechd we are done sending audio data.
+
+        :meta private:
+        """
+
+        with self.server_lock:
+            stdout.write("702 END\n")
+            stdout.flush()
+    def _mark(self, mark):
+        """
+        Tells speechd which mark we are on.
+
+        :meta private:
+        """
+
+        if (mark==""):
+            return
+        
+        with self.server_lock:
+            stdout.write(f"700-{mark}\n700 INDEX MARK\n")
+            stdout.flush()
+
+    def _send_audio(self, val):
+        """
+        Send audio data to speechd.
+
+        :meta private:
+        """
+
+        with self.server_lock:
+            logging.debug("server: _send_audio")
+            data = val['audio']
+            sample_rate = val['rate']
+            mark = val['mark']
+
+            chunk_size = 5000
+            for i in range(0, len(data), chunk_size):
+                start_time = time.time()
+                tmp_data = data[i : i + chunk_size]
+                num_samples = len(tmp_data)
+                tmp_data = tmp_data.tobytes()
+                stdout.write(f"705-bits=16\n")
+                stdout.flush()
+                stdout.write(f"705-num_channels=1\n")
+                stdout.flush()
+                stdout.write(f"705-sample_rate={sample_rate}\n")
+                stdout.flush()
+                stdout.write(f"705-num_samples={num_samples}\n")
+                stdout.flush()
+                stdout.write(f"705-big_endian=0\n")
+                stdout.flush()
+                stdout.write(f"705-AUDIO")
+                stdout.flush()
+                stdout.buffer.write(b'\x00')
+
+                tmp_data2 = hdlc_escape(tmp_data)
+                stdout.buffer.write(tmp_data2)
+                stdout.write("\n")
+                stdout.write("705 AUDIO\n")
+                stdout.flush()
+                end_time = time.time()
+                total_time = end_time-start_time
+                self._process(block=False)
+            self._mark(mark)
+
+    def _configure(self):
+        """
+        Get the config file path and send it to the client.
+
+        :meta private:
+        """
+
+        if len(sys.argv) > 1:
+            configfile = sys.argv[1]
+            self.execution_worker.queue.put({"command": "configure", "args": configfile})
+
+    def parse_set_params(self,ack: int, param_type: str):
+        """
+        Get a settings string.
+
+        :meta private:
+        """
+
+        with self.server_lock:
+            stdout.write(f"{ack} OK RECEIVING {param_type} SETTINGS\n")
+            stdout.flush()
+
+        output = {}
+
+        while (True):
+            line = self._readline()
+            if (line == ".\n"):
+                break
+            line_clean = line.rstrip("\n")
+            var, val = line_clean.split("=", 1)
+            output[var] = val
+
+        return output
+    
+    def _audio(self):
+        """
+        :meta private:
+        """
+
+        tmp = self.parse_set_params(207, "AUDIO")
+        with self.server_lock:
+            stdout.write("203 OK AUDIO INITIALIZED\n")
+            stdout.flush()
+
+    def _loglevel(self):
+        """
+        Sets the logging level from a settings string.
+
+        The logging levels don't quit match up with speechd but we try and get them as close as possible.
+        see this link for the speechd logging levels.
+        https://htmlpreview.github.io/?https://github.com/brailcom/speechd/blob/master/doc/speech-dispatcher.html#Log-Levels
+
+        :meta private:
+        """
+
+        levels = {'5': logging.DEBUG, '4': logging.INFO, '3': logging.WARNING, '2': logging.ERROR, '1': logging.CRITICAL}
+
+        tmp = self.parse_set_params(207, "LOGLEVEL")
+        logging.critical(f"Changing log level to {tmp['log_level']}")
+        if (tmp['log_level'] == '0'):
+            logging.disable(logging.CRITICAL) # Disable all logging globally.
+        else:
+            logging.disable(logging.NOTSET) # Enable all logging globally.
+            logging.getLogger().setLevel(levels[tmp['log_level']]) # set the logging level.
+        
+        with self.server_lock:
+            stdout.write("203 OK LOGLEVEL SET\n")
+            stdout.flush()
+    
+    def _list_voices(self):
+        """
+        List the voices and send them back to speechd.
+
+        :meta private:
+        """
+        voices = self.voices
+        with self.server_lock:
+            for voice in voices:
+                name = voice['name'] if 'name' in voice else "none"
+                language = voice['language'] if 'language' in voice else "none"
+                variant = voice['variant'] if 'variant' in voice else "none"
+                stdout.write(f"200-{name}\t{language}\t{variant}\n")
+
+            stdout.write("200 OK VOICE LIST SENT\n")
+            stdout.flush()
+
+    def _setting(self):
+        """
+        Receive setting from speechd.
+
+        :meta private:
+        """
+        tmp = self.parse_set_params(203, "")
+        self.execution_worker.queue.put({"command": "settings", "args": tmp})
+        with self.server_lock:
+            stdout.write("203 OK SETTINGS RECEIVED\n")
+            stdout.flush()
+    
+    # def _speak_test(self):
+    #     data, samplerate = sf.read("deep_learning.wav", dtype='int16')
+    #     val = {"audio": data, "rate": samplerate, "mark": ""}
+    #     self._begin()
+    #     self._send_audio(val)
+    #     self._end()
+
+    def _speak(self):
+        """
+        Get a speak command from speechd.
+
+        :meta private:
+        """
+        with self.server_lock:
+            stdout.write("202 OK RECEIVING MESSAGE\n")
+            stdout.flush()
+        
+        full_text = ""
+
+        while (True):
+            line = self._readline()
+            if (line == ".\n"):
+                break
+            else:
+                full_text = full_text + line[:-1] + " "
+            
+        self.execution_worker.queue.put({"command": "speak", "args": full_text})
+
+        with self.server_lock:
+            stdout.write("200 OK SPEAKING\n")
+            stdout.flush()
+    
+    def stop_get(self):
+        """
+        Get the value of the stop var.
+
+        :meta private:
+        """
+        with self.stop_lock:
+            return self.stop
+    def stop_set(self, val):
+        """
+        Set the value of the stop var.
+
+        :meta private:
+        """
+        with self.stop_lock:
+            self.stop = val
+    def _stop(self):
+        """
+        Stop the client.
+
+        :meta private:
+        """
+        self.stop_set(True)
+        with self.server_lock:
+            stdout.write("703 STOP\n")
+            stdout.flush()
+    def _pause(self):
+        """
+        Stop the client.
+
+        :meta private:
+        """
+
+        self.stop_set(True)
+        with self.server_lock:
+            stdout.write("704 PAUSE\n")
+            stdout.flush()
+
+    def _process(self, block=True):
+        """
+        Process commands from speechd.
+
+        :meta private:
+        """
+        while (True):
+            line = self._readline(block)
+            if (line == None):
+                break
+            if (line == ""):
+                break
+            if (line == "SPEAK\n"):
+                self._speak()
+            elif (line == "SOUND_ICON\n"):
+                self._speak()
+            elif (line == "CHAR\n"):
+                self._speak()
+            elif (line == "KEY\n"):
+                self._speak()
+            elif (line[:11] == "LIST VOICES"):
+                self._list_voices()
+            elif (line == "SET\n"):
+                self._setting()
+            elif (line == "AUDIO\n"):
+                self._audio()
+            elif (line == "LOGLEVEL\n"):
+                self._loglevel()
+            elif (line == "STOP\n"):
+                self._stop()
+            elif (line == "PAUSE\n"):
+                self._pause()
+            elif (line[:5] == "DEBUG"):
+                # TODO: not sure the diffrence between log level and debug
+                pass
+            elif (line == "QUIT\n"):
+                break
+            else:
+                logging.error("_process: unknown command")
+                logging.error(line)
+
+    def start(self, callback):
+        """
+        Starts the mainloop and sets the client callback.
+        """
+
+        self._callback = callback
+        # keep a local copy of the voices
+        # it should be set at the start and never changed.
+        if hasattr(callback, "voices"):
+            self.voices = callback.voices
+        else:
+            self.voices = [{"name": "GenericPythonModule", "language": "en", "variant": "none"}]
+
+        # Start the worker threads.
+        self.execution_worker.set_callback(callback)
+        self.execution_worker.start()
+        self.action_worker.start()
+        self._callback._set_init(self.action_worker.queue, self)
+
+        # run configure.
+        self._configure()
+
+        line = self._readline()
+        if (line != "INIT\n"):
+            logging.error("ERROR: Server did not start with INIT\n")
+
+        msg = "GOOD"
+        stdout.write(f"299-{msg}\n")
+        stdout.write("299 OK LOADED SUCCESSFULLY\n")
+        stdout.flush()
+
+        logging.info("server: Starting _process()")
+        self._process()
+
+        # let the workers stop before quitting
+        self.execution_worker.stop()
+        self.action_worker.stop()
+        self.execution_worker.join()
+        self.action_worker.join()
+        logging.debug("server: Quiting")

pySpeechModule/speechd_utilities.py

@@ -0,0 +1,93 @@
+import xml.etree.ElementTree as ET
+import logging
+
+def hdlc_escape(data: bytes) -> bytes:
+    """
+    hdlc_escape is for excaping newline chars using hdlc encoding. 
+    This function likely has little value to the users but is need internally.
+    
+    :meta private:
+    """
+    ESCAPE = 0x7D
+    INVERT = 1 << 5
+    out = bytearray()
+
+    for byte in data:
+        if byte == ESCAPE or byte == ord("\n"):
+            out.append(ESCAPE)
+            out.append(byte ^ INVERT)
+        else:
+            out.append(byte)
+
+    return bytes(out)
+
+def parse_ssml(data: bytes) -> list[dict]:
+    """
+    This is a convenience function for parsing SSML into a list of dicts in the format
+
+    .. code-block:: python
+
+        [{"mark": "<mark>", "text": "<text>"}]
+
+    :param data: The bytes string for your SSML text
+    :type bytes: bytes
+    :return: List of dicts each with mark and text
+    :rtype: list
+    """
+
+    output = []
+    buffer = []
+
+    # Parse the SSML XML data
+    try:
+        root = ET.fromstring(data)
+    except ET.ParseError:
+        logging.error("parse_ssml: Failed to parse XML")
+        return output
+
+    # Handle text directly inside <speak> before any child elements
+    if root.text:
+        buffer.append(root.text)
+
+    # Iterate through direct child elements of <speak>
+    for child in root:
+        # Check for <mark> element
+        if child.tag.endswith("mark"):
+            mark_name = child.attrib.get("name", "")
+
+            output.append(
+                {"mark": mark_name, "text": "".join(buffer)}
+            )
+
+            # Reset buffer after encountering a mark
+            buffer.clear()
+
+        # Append trailing text after a child node (XML tail text)
+        if child.tail:
+            buffer.append(child.tail)
+
+    # Add any remaining trailing text after the final mark
+    if buffer:
+        output.append({"mark": "", "text": "".join(buffer)})
+
+    return output
+
+def strip_ssml(ssml_string: bytes):
+    """
+    This is a convenience function for stripping out all SSML tags leaving just the text.
+
+    :param data: The bytes string for your SSML text
+    :type bytes: bytes
+    :return: extracted text
+    :rtype: string
+    """
+
+    # Wrap in a root element if the string is an XML fragment
+    try:
+        root = ET.fromstring(ssml_string)
+    except ET.ParseError:
+        # Wrap fragments in a temporary root node to ensure valid parsing
+        root = ET.fromstring(f"<root>{ssml_string}</root>")
+    
+    # itertext() yields all text within the element and its children
+    return "".join(root.itertext())

pyspeechmodule-1.0.0.dist-info/METADATA

@@ -0,0 +1,19 @@
+Metadata-Version: 2.4
+Name: pySpeechModule
+Version: 1.0.0
+Summary: A framework for creating speechd modules
+Author-email: John Settlemyer <author@example.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/jsett/py-speech-module
+Project-URL: Issues, https://github.com/jsett/py-speech-module/issues
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: soundfile>=0.14.0
+Dynamic: license-file
+
+# pySpeechModule
+A framework for writing python speechd modules.
+
+documentation: https://pyspeechmodule.readthedocs.io/en/latest/index.html

pyspeechmodule-1.0.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+pySpeechModule/__init__.py,sha256=HnUIZcruZdaU0_on1k4IaH-1Xi073xmIWqh3CCRQ-Xc,404
+pySpeechModule/speechd.py,sha256=ZpGiRSaD9GjAByvhO266tPCj7dafgBItM07GTkIJoTE,5605
+pySpeechModule/speechd_action_worker.py,sha256=BlDqY3unaKrJLvJ7sOMvIfxoYA1myBLsNpsAGfBjRFI,1028
+pySpeechModule/speechd_execution_worker.py,sha256=NdivW52SChodixhEzHxSFrw8Hv2RxYeofOk7Nyrx-Hs,981
+pySpeechModule/speechd_server.py,sha256=HXIibHkFvsWccg2JuGBdQ-_-qb3X7ppShlNXSFVehIY,11646
+pySpeechModule/speechd_utilities.py,sha256=4EAAOxo_Q0Kkl3HhT1UO5BwMK0JtFFCk_RtICQ_OUU8,2567
+pyspeechmodule-1.0.0.dist-info/licenses/LICENSE,sha256=OXwwpMpzCNpvI_zaXWLu9pjohqxzllI8ThD1U1UPGWQ,1072
+pyspeechmodule-1.0.0.dist-info/METADATA,sha256=Y44RiKk_FT8DdSvz2uAd_J4lSzLTLjHL5B3yE5NwZJg,648
+pyspeechmodule-1.0.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+pyspeechmodule-1.0.0.dist-info/top_level.txt,sha256=Z3uAt95enI7oQ1Fkf-jkTOuWHl-ad-5ls7gyZVYtu1k,15
+pyspeechmodule-1.0.0.dist-info/RECORD,,

pyspeechmodule-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pyspeechmodule-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 John Settlemyer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pyspeechmodule-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pySpeechModule