pvleopard 1.2.2__tar.gz → 2.0.1__tar.gz

{pvleopard-1.2.2 → pvleopard-2.0.1}/MANIFEST.in

@@ -4,9 +4,8 @@ include pvleopard/_factory.py
 include pvleopard/_leopard.py
 include pvleopard/_util.py
 include pvleopard/lib/common/leopard_params.pv
+recursive-include pvleopard/lib/linux *
+recursive-include pvleopard/lib/mac *
+recursive-include pvleopard/lib/windows *
 recursive-include pvleopard/lib/jetson *
-include pvleopard/lib/linux/x86_64/libpv_leopard.so
-include pvleopard/lib/mac/x86_64/libpv_leopard.dylib
-include pvleopard/lib/mac/arm64/libpv_leopard.dylib
 recursive-include pvleopard/lib/raspberry-pi *
-include pvleopard/lib/windows/amd64/libpv_leopard.dll

pvleopard-2.0.1/PKG-INFO

@@ -0,0 +1,97 @@
+Metadata-Version: 2.1
+Name: pvleopard
+Version: 2.0.1
+Summary: Leopard Speech-to-Text Engine.
+Home-page: https://github.com/Picovoice/leopard
+Author: Picovoice
+Author-email: hello@picovoice.ai
+License: UNKNOWN
+Description: # Leopard Binding for Python
+        
+        ## Leopard Speech-to-Text Engine
+        
+        Made in Vancouver, Canada by [Picovoice](https://picovoice.ai)
+        
+        Leopard is an on-device speech-to-text engine. Leopard is:
+        
+        - Private; All voice processing runs locally.
+        - [Accurate](https://picovoice.ai/docs/benchmark/stt/)
+        - [Compact and Computationally-Efficient](https://github.com/Picovoice/speech-to-text-benchmark#rtf)
+        - Cross-Platform:
+          - Linux (x86_64), macOS (x86_64, arm64), Windows (x86_64)
+          - Android and iOS
+          - Chrome, Safari, Firefox, and Edge
+          - Raspberry Pi (4, 3) and NVIDIA Jetson Nano
+        
+        ## Compatibility
+        
+        - Python 3.5+
+        - Runs on Linux (x86_64), macOS (x86_64, arm64), Windows (x86_64), Raspberry Pi (4, 3), and NVIDIA Jetson Nano.
+        
+        ## Installation
+        
+        ```console
+        pip3 install pvleopard
+        ```
+        
+        ## AccessKey
+        
+        Leopard requires a valid Picovoice `AccessKey` at initialization. `AccessKey` acts as your credentials when using Leopard SDKs.
+        You can get your `AccessKey` for free. Make sure to keep your `AccessKey` secret.
+        Signup or Login to [Picovoice Console](https://console.picovoice.ai/) to get your `AccessKey`.
+        
+        ### Usage
+        
+        Create an instance of the engine and transcribe an audio file:
+        
+        ```python
+        import pvleopard
+        
+        leopard = pvleopard.create(access_key='${ACCESS_KEY}')
+        
+        transcript, words = leopard.process_file('${AUDIO_PATH}')
+        print(transcript)
+        for word in words:
+            print(
+              "{word=\"%s\" start_sec=%.2f end_sec=%.2f confidence=%.2f}"
+              % (word.word, word.start_sec, word.end_sec, word.confidence))
+        ```
+        
+        Replace `${ACCESS_KEY}` with yours obtained from [Picovoice Console](https://console.picovoice.ai/) and
+        `${AUDIO_PATH}` to the path an audio file.
+        
+        Finally, when done be sure to explicitly release the resources:
+        ```python
+        leopard.delete()
+        ```
+        
+        ## Language Model
+        
+        The Leopard Python SDK comes preloaded with a default English language model (`.pv` file).
+        Default models for other supported languages can be found in [lib/common](../../lib/common).
+        
+        Create custom language models using the [Picovoice Console](https://console.picovoice.ai/). Here you can train
+        language models with custom vocabulary and boost words in the existing vocabulary.
+        
+        Pass in the `.pv` file via the `model_path` argument:
+        ```python
+        leopard = pvleopard.create(
+            access_key='${ACCESS_KEY}',
+            model_path='${MODEL_PATH}')
+        ```
+        
+        ## Demos
+        
+        [pvleoparddemo](https://pypi.org/project/pvleoparddemo/) provides command-line utilities for processing audio using
+        Leopard.
+        
+Keywords: Speech-to-Text,Speech Recognition,Voice Recognition,ASR,Automatic Speech Recognition
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia :: Sound/Audio :: Speech
+Requires-Python: >=3.5
+Description-Content-Type: text/markdown

{pvleopard-1.2.2 → pvleopard-2.0.1}/README.md

@@ -1,10 +1,12 @@
-# Leopard Speech-to-Text Engine
+# Leopard Binding for Python
+
+## Leopard Speech-to-Text Engine
 
 Made in Vancouver, Canada by [Picovoice](https://picovoice.ai)
 
 Leopard is an on-device speech-to-text engine. Leopard is:
 
-- Private; All voice processing runs locally. 
+- Private; All voice processing runs locally.
 - [Accurate](https://picovoice.ai/docs/benchmark/stt/)
 - [Compact and Computationally-Efficient](https://github.com/Picovoice/speech-to-text-benchmark#rtf)
 - Cross-Platform:
@@ -37,9 +39,9 @@ Create an instance of the engine and transcribe an audio file:
 ```python
 import pvleopard
 
-handle = pvleopard.create(access_key='${ACCESS_KEY}')
+leopard = pvleopard.create(access_key='${ACCESS_KEY}')
 
-transcript, words = handle.process_file('${AUDIO_PATH}')
+transcript, words = leopard.process_file('${AUDIO_PATH}')
 print(transcript)
 for word in words:
     print(
@@ -48,20 +50,24 @@ for word in words:
 ```
 
 Replace `${ACCESS_KEY}` with yours obtained from [Picovoice Console](https://console.picovoice.ai/) and
-`${AUDIO_PATH}` to the path an audio file. Finally, when done be sure to explicitly release the resources using
-`handle.delete()`.
+`${AUDIO_PATH}` to the path an audio file.
+
+Finally, when done be sure to explicitly release the resources:
+```python
+leopard.delete()
+```
 
 ## Language Model
 
-The Leopard Python SDK comes preloaded with a default English language model (`.pv` file). 
-Default models for other supported languages can be found in [lib/common](../../lib/common). 
+The Leopard Python SDK comes preloaded with a default English language model (`.pv` file).
+Default models for other supported languages can be found in [lib/common](../../lib/common).
 
 Create custom language models using the [Picovoice Console](https://console.picovoice.ai/). Here you can train
 language models with custom vocabulary and boost words in the existing vocabulary.
 
 Pass in the `.pv` file via the `model_path` argument:
 ```python
-handle = pvleopard.create(
+leopard = pvleopard.create(
     access_key='${ACCESS_KEY}',
     model_path='${MODEL_PATH}')
 ```

{pvleopard-1.2.2 → pvleopard-2.0.1}/pvleopard/_factory.py

@@ -19,7 +19,8 @@ def create(
         access_key: str,
         model_path: Optional[str] = None,
         library_path: Optional[str] = None,
-        enable_automatic_punctuation: bool = False) -> Leopard:
+        enable_automatic_punctuation: bool = False,
+        enable_diarization: bool = False) -> Leopard:
     """
     Factory method for Leopard speech-to-text engine.
 
@@ -28,6 +29,9 @@ def create(
     :param model_path: Absolute path to the file containing model parameters. If not set it will be set to the default
     location.
     :param enable_automatic_punctuation Set to `True` to enable automatic punctuation insertion.
+    :param enable_diarization Set to `true` to enable speaker diarization, which allows Leopard to differentiate
+    speakers as part of the transcription process. Word metadata will include a `speaker_tag` to
+    identify unique speakers.
     :return: An instance of Leopard speech-to-text engine.
     """
 
@@ -41,7 +45,8 @@ def create(
         access_key=access_key,
         model_path=model_path,
         library_path=library_path,
-        enable_automatic_punctuation=enable_automatic_punctuation)
+        enable_automatic_punctuation=enable_automatic_punctuation,
+        enable_diarization=enable_diarization)
 
 
 __all__ = [

{pvleopard-1.2.2 → pvleopard-2.0.1}/pvleopard/_leopard.py

@@ -18,7 +18,27 @@ from typing import *
 
 
 class LeopardError(Exception):
-    pass
+    def __init__(self, message: str = '', message_stack: Sequence[str] = None):
+        super().__init__(message)
+
+        self._message = message
+        self._message_stack = list() if message_stack is None else message_stack
+
+    def __str__(self):
+        message = self._message
+        if len(self._message_stack) > 0:
+            message += ':'
+            for i in range(len(self._message_stack)):
+                message += '\n  [%d] %s' % (i, self._message_stack[i])
+        return message
+
+    @property
+    def message(self) -> str:
+        return self._message
+
+    @property
+    def message_stack(self) -> Sequence[str]:
+        return self._message_stack
 
 
 class LeopardMemoryError(LeopardError):
@@ -119,14 +139,16 @@ class Leopard(object):
             ("word", c_char_p),
             ("start_sec", c_float),
             ("end_sec", c_float),
-            ("confidence", c_float)]
+            ("confidence", c_float),
+            ("speaker_tag", c_int32)]
 
     def __init__(
             self,
             access_key: str,
             model_path: str,
             library_path: str,
-            enable_automatic_punctuation: bool = False) -> None:
+            enable_automatic_punctuation: bool = False,
+            enable_diarization: bool = False) -> None:
         """
         Constructor.
 
@@ -134,6 +156,9 @@ class Leopard(object):
         :param model_path: Absolute path to the file containing model parameters.
         :param library_path: Absolute path to Leopard's dynamic library.
         :param enable_automatic_punctuation Set to `True` to enable automatic punctuation insertion.
+        :param enable_diarization Set to `true` to enable speaker diarization, which allows Leopard to differentiate
+        speakers as part of the transcription process. Word metadata will include a `speaker_tag` to
+        identify unique speakers.
         """
 
         if not isinstance(access_key, str) or len(access_key) == 0:
@@ -147,15 +172,36 @@ class Leopard(object):
 
         library = cdll.LoadLibrary(library_path)
 
+        set_sdk_func = library.pv_set_sdk
+        set_sdk_func.argtypes = [c_char_p]
+        set_sdk_func.restype = None
+
+        set_sdk_func('python'.encode('utf-8'))
+
+        self._get_error_stack_func = library.pv_get_error_stack
+        self._get_error_stack_func.argtypes = [POINTER(POINTER(c_char_p)), POINTER(c_int)]
+        self._get_error_stack_func.restype = self.PicovoiceStatuses
+
+        self._free_error_stack_func = library.pv_free_error_stack
+        self._free_error_stack_func.argtypes = [POINTER(c_char_p)]
+        self._free_error_stack_func.restype = None
+
         init_func = library.pv_leopard_init
-        init_func.argtypes = [c_char_p, c_char_p, c_bool, POINTER(POINTER(self.CLeopard))]
+        init_func.argtypes = [c_char_p, c_char_p, c_bool, c_bool, POINTER(POINTER(self.CLeopard))]
         init_func.restype = self.PicovoiceStatuses
 
         self._handle = POINTER(self.CLeopard)()
 
-        status = init_func(access_key.encode(), model_path.encode(), enable_automatic_punctuation, byref(self._handle))
+        status = init_func(
+            access_key.encode(),
+            model_path.encode(),
+            enable_automatic_punctuation,
+            enable_diarization,
+            byref(self._handle))
         if status is not self.PicovoiceStatuses.SUCCESS:
-            raise self._PICOVOICE_STATUS_TO_EXCEPTION[status]()
+            raise self._PICOVOICE_STATUS_TO_EXCEPTION[status](
+                message='Initialization failed',
+                message_stack=self._get_error_stack())
 
         self._delete_func = library.pv_leopard_delete
         self._delete_func.argtypes = [POINTER(self.CLeopard)]
@@ -201,7 +247,7 @@ class Leopard(object):
         ]
         self._words_delete_func.restype = None
 
-    Word = namedtuple('Word', ['word', 'start_sec', 'end_sec', 'confidence'])
+    Word = namedtuple('Word', ['word', 'start_sec', 'end_sec', 'confidence', 'speaker_tag'])
 
     def process(self, pcm: Sequence[int]) -> Tuple[str, Sequence[Word]]:
         """
@@ -227,7 +273,9 @@ class Leopard(object):
             byref(num_words),
             byref(c_words))
         if status is not self.PicovoiceStatuses.SUCCESS:
-            raise self._PICOVOICE_STATUS_TO_EXCEPTION[status]()
+            raise self._PICOVOICE_STATUS_TO_EXCEPTION[status](
+                message='Process failed',
+                message_stack=self._get_error_stack())
 
         transcript = c_transcript.value.decode('utf-8')
         self._transcript_delete_func(c_transcript)
@@ -238,7 +286,8 @@ class Leopard(object):
                 word=c_words[i].word.decode('utf-8'),
                 start_sec=c_words[i].start_sec,
                 end_sec=c_words[i].end_sec,
-                confidence=c_words[i].confidence)
+                confidence=c_words[i].confidence,
+                speaker_tag=c_words[i].speaker_tag)
             words.append(word)
 
         self._words_delete_func(c_words)
@@ -267,12 +316,9 @@ class Leopard(object):
             byref(num_words),
             byref(c_words))
         if status is not self.PicovoiceStatuses.SUCCESS:
-            if status is self.PicovoiceStatuses.INVALID_ARGUMENT:
-                if not audio_path.lower().endswith(self._VALID_EXTENSIONS):
-                    raise self._PICOVOICE_STATUS_TO_EXCEPTION[status](
-                        "Specified file with extension '%s' is not supported" % pathlib.Path(audio_path).suffix
-                    )
-            raise self._PICOVOICE_STATUS_TO_EXCEPTION[status]()
+            raise self._PICOVOICE_STATUS_TO_EXCEPTION[status](
+                message='Process file failed',
+                message_stack=self._get_error_stack())
 
         transcript = c_transcript.value.decode('utf-8')
         self._transcript_delete_func(c_transcript)
@@ -283,7 +329,8 @@ class Leopard(object):
                 word=c_words[i].word.decode('utf-8'),
                 start_sec=c_words[i].start_sec,
                 end_sec=c_words[i].end_sec,
-                confidence=c_words[i].confidence)
+                confidence=c_words[i].confidence,
+                speaker_tag=c_words[i].speaker_tag)
             words.append(word)
 
         self._words_delete_func(c_words)
@@ -307,6 +354,21 @@ class Leopard(object):
 
         return self._sample_rate
 
+    def _get_error_stack(self) -> Sequence[str]:
+        message_stack_ref = POINTER(c_char_p)()
+        message_stack_depth = c_int()
+        status = self._get_error_stack_func(byref(message_stack_ref), byref(message_stack_depth))
+        if status is not self.PicovoiceStatuses.SUCCESS:
+            raise self._PICOVOICE_STATUS_TO_EXCEPTION[status](message='Unable to get Leopard error state')
+
+        message_stack = list()
+        for i in range(message_stack_depth.value):
+            message_stack.append(message_stack_ref[i].decode('utf-8'))
+
+        self._free_error_stack_func(message_stack_ref)
+
+        return message_stack
+
 
 __all__ = [
     'Leopard',

pvleopard-2.0.1/pvleopard.egg-info/PKG-INFO

@@ -0,0 +1,97 @@
+Metadata-Version: 2.1
+Name: pvleopard
+Version: 2.0.1
+Summary: Leopard Speech-to-Text Engine.
+Home-page: https://github.com/Picovoice/leopard
+Author: Picovoice
+Author-email: hello@picovoice.ai
+License: UNKNOWN
+Description: # Leopard Binding for Python
+        
+        ## Leopard Speech-to-Text Engine
+        
+        Made in Vancouver, Canada by [Picovoice](https://picovoice.ai)
+        
+        Leopard is an on-device speech-to-text engine. Leopard is:
+        
+        - Private; All voice processing runs locally.
+        - [Accurate](https://picovoice.ai/docs/benchmark/stt/)
+        - [Compact and Computationally-Efficient](https://github.com/Picovoice/speech-to-text-benchmark#rtf)
+        - Cross-Platform:
+          - Linux (x86_64), macOS (x86_64, arm64), Windows (x86_64)
+          - Android and iOS
+          - Chrome, Safari, Firefox, and Edge
+          - Raspberry Pi (4, 3) and NVIDIA Jetson Nano
+        
+        ## Compatibility
+        
+        - Python 3.5+
+        - Runs on Linux (x86_64), macOS (x86_64, arm64), Windows (x86_64), Raspberry Pi (4, 3), and NVIDIA Jetson Nano.
+        
+        ## Installation
+        
+        ```console
+        pip3 install pvleopard
+        ```
+        
+        ## AccessKey
+        
+        Leopard requires a valid Picovoice `AccessKey` at initialization. `AccessKey` acts as your credentials when using Leopard SDKs.
+        You can get your `AccessKey` for free. Make sure to keep your `AccessKey` secret.
+        Signup or Login to [Picovoice Console](https://console.picovoice.ai/) to get your `AccessKey`.
+        
+        ### Usage
+        
+        Create an instance of the engine and transcribe an audio file:
+        
+        ```python
+        import pvleopard
+        
+        leopard = pvleopard.create(access_key='${ACCESS_KEY}')
+        
+        transcript, words = leopard.process_file('${AUDIO_PATH}')
+        print(transcript)
+        for word in words:
+            print(
+              "{word=\"%s\" start_sec=%.2f end_sec=%.2f confidence=%.2f}"
+              % (word.word, word.start_sec, word.end_sec, word.confidence))
+        ```
+        
+        Replace `${ACCESS_KEY}` with yours obtained from [Picovoice Console](https://console.picovoice.ai/) and
+        `${AUDIO_PATH}` to the path an audio file.
+        
+        Finally, when done be sure to explicitly release the resources:
+        ```python
+        leopard.delete()
+        ```
+        
+        ## Language Model
+        
+        The Leopard Python SDK comes preloaded with a default English language model (`.pv` file).
+        Default models for other supported languages can be found in [lib/common](../../lib/common).
+        
+        Create custom language models using the [Picovoice Console](https://console.picovoice.ai/). Here you can train
+        language models with custom vocabulary and boost words in the existing vocabulary.
+        
+        Pass in the `.pv` file via the `model_path` argument:
+        ```python
+        leopard = pvleopard.create(
+            access_key='${ACCESS_KEY}',
+            model_path='${MODEL_PATH}')
+        ```
+        
+        ## Demos
+        
+        [pvleoparddemo](https://pypi.org/project/pvleoparddemo/) provides command-line utilities for processing audio using
+        Leopard.
+        
+Keywords: Speech-to-Text,Speech Recognition,Voice Recognition,ASR,Automatic Speech Recognition
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia :: Sound/Audio :: Speech
+Requires-Python: >=3.5
+Description-Content-Type: text/markdown

{pvleopard-1.2.2 → pvleopard-2.0.1}/setup.py

@@ -14,50 +14,41 @@ import shutil
 
 import setuptools
 
+INCLUDE_FILES = ('../../LICENSE', '__init__.py', '_factory.py', '_leopard.py', '_util.py')
+INCLUDE_LIBS = ('linux', 'mac', 'windows', 'jetson', 'raspberry-pi')
+
 os.system('git clean -dfx')
 
 package_folder = os.path.join(os.path.dirname(__file__), 'pvleopard')
 os.mkdir(package_folder)
+manifest_in = ""
 
-shutil.copy(os.path.join(os.path.dirname(__file__), '../../LICENSE'), package_folder)
-
-shutil.copy(os.path.join(os.path.dirname(__file__), '__init__.py'), os.path.join(package_folder, '__init__.py'))
-shutil.copy(os.path.join(os.path.dirname(__file__), '_factory.py'), os.path.join(package_folder, '_factory.py'))
-shutil.copy(os.path.join(os.path.dirname(__file__), '_leopard.py'), os.path.join(package_folder, '_leopard.py'))
-shutil.copy(os.path.join(os.path.dirname(__file__), '_util.py'), os.path.join(package_folder, '_util.py'))
+for rel_path in INCLUDE_FILES:
+    shutil.copy(os.path.join(os.path.dirname(__file__), rel_path), package_folder)
+    manifest_in += "include pvleopard/%s\n" % os.path.basename(rel_path)
 
-platforms = ('jetson', 'linux', 'mac', 'raspberry-pi', 'windows')
+model_file = 'lib/common/leopard_params.pv'
+os.makedirs(os.path.join(package_folder, os.path.split(model_file)[0]))
+shutil.copy(
+    os.path.join(os.path.dirname(__file__), '../..', model_file),
+    os.path.join(package_folder, model_file))
+manifest_in += "include pvleopard/%s\n" % model_file
 
-os.mkdir(os.path.join(package_folder, 'lib'))
-for platform in ('common',) + platforms:
+for platform in INCLUDE_LIBS:
     shutil.copytree(
         os.path.join(os.path.dirname(__file__), '../../lib', platform),
         os.path.join(package_folder, 'lib', platform))
-
-MANIFEST_IN = """
-include pvleopard/LICENSE
-include pvleopard/__init__.py
-include pvleopard/_factory.py
-include pvleopard/_leopard.py
-include pvleopard/_util.py
-include pvleopard/lib/common/leopard_params.pv
-recursive-include pvleopard/lib/jetson *
-include pvleopard/lib/linux/x86_64/libpv_leopard.so
-include pvleopard/lib/mac/x86_64/libpv_leopard.dylib
-include pvleopard/lib/mac/arm64/libpv_leopard.dylib
-recursive-include pvleopard/lib/raspberry-pi *
-include pvleopard/lib/windows/amd64/libpv_leopard.dll
-"""
+    manifest_in += "recursive-include pvleopard/lib/%s *\n" % platform
 
 with open(os.path.join(os.path.dirname(__file__), 'MANIFEST.in'), 'w') as f:
-    f.write(MANIFEST_IN.strip('\n '))
+    f.write(manifest_in)
 
 with open(os.path.join(os.path.dirname(__file__), 'README.md'), 'r') as f:
     long_description = f.read()
 
 setuptools.setup(
     name="pvleopard",
-    version="1.2.2",
+    version="2.0.1",
     author="Picovoice",
     author_email="hello@picovoice.ai",
     description="Leopard Speech-to-Text Engine.",

pvleopard-1.2.2/PKG-INFO

@@ -1,93 +0,0 @@
-Metadata-Version: 2.1
-Name: pvleopard
-Version: 1.2.2
-Summary: Leopard Speech-to-Text Engine.
-Home-page: https://github.com/Picovoice/leopard
-Author: Picovoice
-Author-email: hello@picovoice.ai
-License: UNKNOWN
-Keywords: Speech-to-Text,Speech Recognition,Voice Recognition,ASR,Automatic Speech Recognition
-Platform: UNKNOWN
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Classifier: Topic :: Multimedia :: Sound/Audio :: Speech
-Requires-Python: >=3.5
-Description-Content-Type: text/markdown
-
-# Leopard Speech-to-Text Engine
-
-Made in Vancouver, Canada by [Picovoice](https://picovoice.ai)
-
-Leopard is an on-device speech-to-text engine. Leopard is:
-
-- Private; All voice processing runs locally. 
-- [Accurate](https://picovoice.ai/docs/benchmark/stt/)
-- [Compact and Computationally-Efficient](https://github.com/Picovoice/speech-to-text-benchmark#rtf)
-- Cross-Platform:
-  - Linux (x86_64), macOS (x86_64, arm64), Windows (x86_64)
-  - Android and iOS
-  - Chrome, Safari, Firefox, and Edge
-  - Raspberry Pi (4, 3) and NVIDIA Jetson Nano
-
-## Compatibility
-
-- Python 3.5+
-- Runs on Linux (x86_64), macOS (x86_64, arm64), Windows (x86_64), Raspberry Pi (4, 3), and NVIDIA Jetson Nano.
-
-## Installation
-
-```console
-pip3 install pvleopard
-```
-
-## AccessKey
-
-Leopard requires a valid Picovoice `AccessKey` at initialization. `AccessKey` acts as your credentials when using Leopard SDKs.
-You can get your `AccessKey` for free. Make sure to keep your `AccessKey` secret.
-Signup or Login to [Picovoice Console](https://console.picovoice.ai/) to get your `AccessKey`.
-
-### Usage
-
-Create an instance of the engine and transcribe an audio file:
-
-```python
-import pvleopard
-
-handle = pvleopard.create(access_key='${ACCESS_KEY}')
-
-transcript, words = handle.process_file('${AUDIO_PATH}')
-print(transcript)
-for word in words:
-    print(
-      "{word=\"%s\" start_sec=%.2f end_sec=%.2f confidence=%.2f}"
-      % (word.word, word.start_sec, word.end_sec, word.confidence))
-```
-
-Replace `${ACCESS_KEY}` with yours obtained from [Picovoice Console](https://console.picovoice.ai/) and
-`${AUDIO_PATH}` to the path an audio file. Finally, when done be sure to explicitly release the resources using
-`handle.delete()`.
-
-## Language Model
-
-The Leopard Python SDK comes preloaded with a default English language model (`.pv` file). 
-Default models for other supported languages can be found in [lib/common](../../lib/common). 
-
-Create custom language models using the [Picovoice Console](https://console.picovoice.ai/). Here you can train
-language models with custom vocabulary and boost words in the existing vocabulary.
-
-Pass in the `.pv` file via the `model_path` argument:
-```python
-handle = pvleopard.create(
-    access_key='${ACCESS_KEY}',
-    model_path='${MODEL_PATH}')
-```
-
-## Demos
-
-[pvleoparddemo](https://pypi.org/project/pvleoparddemo/) provides command-line utilities for processing audio using
-Leopard.
-
-

pvleopard-1.2.2/pvleopard.egg-info/PKG-INFO

@@ -1,93 +0,0 @@
-Metadata-Version: 2.1
-Name: pvleopard
-Version: 1.2.2
-Summary: Leopard Speech-to-Text Engine.
-Home-page: https://github.com/Picovoice/leopard
-Author: Picovoice
-Author-email: hello@picovoice.ai
-License: UNKNOWN
-Keywords: Speech-to-Text,Speech Recognition,Voice Recognition,ASR,Automatic Speech Recognition
-Platform: UNKNOWN
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Classifier: Topic :: Multimedia :: Sound/Audio :: Speech
-Requires-Python: >=3.5
-Description-Content-Type: text/markdown
-
-# Leopard Speech-to-Text Engine
-
-Made in Vancouver, Canada by [Picovoice](https://picovoice.ai)
-
-Leopard is an on-device speech-to-text engine. Leopard is:
-
-- Private; All voice processing runs locally. 
-- [Accurate](https://picovoice.ai/docs/benchmark/stt/)
-- [Compact and Computationally-Efficient](https://github.com/Picovoice/speech-to-text-benchmark#rtf)
-- Cross-Platform:
-  - Linux (x86_64), macOS (x86_64, arm64), Windows (x86_64)
-  - Android and iOS
-  - Chrome, Safari, Firefox, and Edge
-  - Raspberry Pi (4, 3) and NVIDIA Jetson Nano
-
-## Compatibility
-
-- Python 3.5+
-- Runs on Linux (x86_64), macOS (x86_64, arm64), Windows (x86_64), Raspberry Pi (4, 3), and NVIDIA Jetson Nano.
-
-## Installation
-
-```console
-pip3 install pvleopard
-```
-
-## AccessKey
-
-Leopard requires a valid Picovoice `AccessKey` at initialization. `AccessKey` acts as your credentials when using Leopard SDKs.
-You can get your `AccessKey` for free. Make sure to keep your `AccessKey` secret.
-Signup or Login to [Picovoice Console](https://console.picovoice.ai/) to get your `AccessKey`.
-
-### Usage
-
-Create an instance of the engine and transcribe an audio file:
-
-```python
-import pvleopard
-
-handle = pvleopard.create(access_key='${ACCESS_KEY}')
-
-transcript, words = handle.process_file('${AUDIO_PATH}')
-print(transcript)
-for word in words:
-    print(
-      "{word=\"%s\" start_sec=%.2f end_sec=%.2f confidence=%.2f}"
-      % (word.word, word.start_sec, word.end_sec, word.confidence))
-```
-
-Replace `${ACCESS_KEY}` with yours obtained from [Picovoice Console](https://console.picovoice.ai/) and
-`${AUDIO_PATH}` to the path an audio file. Finally, when done be sure to explicitly release the resources using
-`handle.delete()`.
-
-## Language Model
-
-The Leopard Python SDK comes preloaded with a default English language model (`.pv` file). 
-Default models for other supported languages can be found in [lib/common](../../lib/common). 
-
-Create custom language models using the [Picovoice Console](https://console.picovoice.ai/). Here you can train
-language models with custom vocabulary and boost words in the existing vocabulary.
-
-Pass in the `.pv` file via the `model_path` argument:
-```python
-handle = pvleopard.create(
-    access_key='${ACCESS_KEY}',
-    model_path='${MODEL_PATH}')
-```
-
-## Demos
-
-[pvleoparddemo](https://pypi.org/project/pvleoparddemo/) provides command-line utilities for processing audio using
-Leopard.
-
-