pveagle 0.1.0__tar.gz → 0.2.0__tar.gz

pveagle-0.2.0/PKG-INFO

@@ -0,0 +1,145 @@
+Metadata-Version: 2.1
+Name: pveagle
+Version: 0.2.0
+Summary: Eagle Speaker Recognition Engine
+Home-page: https://github.com/Picovoice/eagle
+Author: Picovoice
+Author-email: hello@picovoice.ai
+License: UNKNOWN
+Description: # Eagle Speaker Recognition Engine
+        
+        Made in Vancouver, Canada by [Picovoice](https://picovoice.ai)
+        
+        Eagle is an on-device speaker recognition engine. Eagle is:
+        
+        - Private; All voice processing runs locally.
+        - 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 or higher
+        - Runs on Linux (x86_64), macOS (x86_64, arm64), Windows (x86_64), Raspberry Pi (4, 3), and NVIDIA Jetson Nano.
+        
+        ## Installation
+        
+        ```console
+        pip3 install pveagle
+        ```
+        
+        ## AccessKey
+        
+        Eagle requires a valid Picovoice `AccessKey` at initialization. `AccessKey` acts as your credentials when using Eagle
+        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
+        
+        Eagle has two distinct steps: Enrollment and Recognition. In the enrollment step, Eagle analyzes a series of
+        utterances from a particular speaker to learn their unique voiceprint. This step produces an `EagleProfile` object,
+        which can be stored and utilized during inference. During the Recognition step, Eagle compares the incoming frames of
+        audio to the voiceprints of all enrolled speakers in real-time to determine the similarity between them.
+        
+        ### Speaker Enrollment
+        
+        Create an instance of the profiler:
+        
+        ```python
+        import pveagle
+        
+        # AccessKey obtained from Picovoice Console (https://console.picovoice.ai/)
+        access_key = "${ACCESS_KEY}"
+        eagle_profiler = pveagle.create_profiler(access_key)
+        ```
+        
+        `EagleProfiler` is responsible for processing and enrolling PCM audio data, with the valid audio sample rate determined
+        by `eagle_profiler.sample_rate`. The audio data must be 16-bit linearly-encoded and single-channel.
+        
+        When passing samples to `eagle_profiler.enroll`, the number of samples must be at
+        least `eagle_profiler.min_enroll_samples` to ensure sufficient data for enrollment. The percentage value
+        obtained from this process indicates the progress of enrollment, while the feedback value can be utilized to determine
+        the status of the enrollment process.
+        
+        ```python
+        def get_next_enroll_audio_data(num_samples):
+            pass
+        
+        
+        percentage = 0.0
+        while percentage < 100.0:
+            percentage, feedback = eagle_profiler.enroll(get_next_enroll_audio_data(eagle_profiler.min_enroll_samples))
+            print(feedback.name)
+        ```
+        
+        After the percentage reaches 100%, the enrollment process is considered complete. While it is possible to continue
+        providing additional audio data to the profiler to improve the accuracy of the voiceprint, it is not necessary to do so.
+        Moreover, if the audio data submitted is unsuitable for enrollment, the feedback value will indicate the reason, and the
+        enrollment progress will remain unchanged.
+        
+        ```python
+        speaker_profile = eagle_profiler.export()
+        ```
+        
+        The `eagle_profiler.export()` function produces an `EagleProfile` object, which can be converted into a binary form
+        using the `EagleProfile.to_bytes()` method. This binary representation can be saved and subsequently retrieved using
+        the `EagleProfile.from_bytes()` method.
+        
+        To reset the profiler and enroll a new speaker, the `eagle_profiler.reset()` method can be used. This method clears all
+        previously stored data, making it possible to start a new enrollment session with a different speaker.
+        
+        Finally, when done be sure to explicitly release the resources:
+        
+        ```python
+        eagle_profiler.delete()
+        ```
+        
+        ### Speaker Recognition
+        
+        Create an instance of the engine with one or more speaker profiles from the `EagleProfiler`:
+        
+        ```python
+        eagle = pveagle.create_recognizer(access_key, speaker_profile)
+        ```
+        
+        When initialized, `eagle.sample_rate` specifies the valid sample rate for Eagle. The expected length of a frame, or the
+        number of audio samples in an input array, is defined by `eagle.frame_length`.
+        
+        Like the profiler, Eagle is designed to work with single-channel audio that is encoded using 16-bit linear PCM.
+        
+        ```python
+        def get_next_audio_frame():
+            pass
+        
+        
+        while True:
+            scores = eagle.process(get_next_audio_frame())
+        ```
+        
+        The `scores` array contains floating-point numbers that indicate the similarity between the input audio frame and the
+        enrolled speakers. Each value in the array corresponds to a specific enrolled speaker, maintaining the same order as the
+        speaker profiles provided during initialization. The values in the array range from 0.0 to 1.0, where higher values
+        indicate a stronger degree of similarity.
+        
+        Finally, when done be sure to explicitly release the resources:
+        
+        ```python
+        eagle.delete()
+        ```
+        
+        ## Demos
+        [pveagledemo](https://pypi.org/project/pveagledemo/) provides command-line utilities for processing real-time
+        audio (i.e. microphone) and files using Eagle.
+        
+Keywords: Speaker Recognition,Speaker Identification,Voice Recognition,Voice Identification
+Platform: UNKNOWN
+Classifier: Development Status :: 4 - Beta
+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

{pveagle-0.1.0 → pveagle-0.2.0}/README.md

@@ -122,7 +122,5 @@ eagle.delete()
 ```
 
 ## Demos
-<!-- markdown-link-check-disable -->
 [pveagledemo](https://pypi.org/project/pveagledemo/) provides command-line utilities for processing real-time
 audio (i.e. microphone) and files using Eagle.
-<!-- markdown-link-check-enable -->

{pveagle-0.1.0 → pveagle-0.2.0}/pveagle/_eagle.py

@@ -16,7 +16,27 @@ from typing import Sequence, Tuple
 
 
 class EagleError(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 EagleMemoryError(EagleError):
@@ -183,6 +203,20 @@ class EagleProfiler(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 = 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
+
         # noinspection PyArgumentList
         self._eagle_profiler = POINTER(self.CEagleProfiler)()
 
@@ -198,7 +232,9 @@ class EagleProfiler(object):
             model_path.encode('utf-8'),
             byref(self._eagle_profiler))
         if status is not PicovoiceStatuses.SUCCESS:
-            raise _PICOVOICE_STATUS_TO_EXCEPTION[status]()
+            raise _PICOVOICE_STATUS_TO_EXCEPTION[status](
+                message='Profile initialization failed',
+                message_stack=self._get_error_stack())
 
         speaker_profile_size_func = library.pv_eagle_profiler_export_size
         speaker_profile_size_func.argtypes = [
@@ -209,7 +245,9 @@ class EagleProfiler(object):
         profile_size = c_int32()
         status = speaker_profile_size_func(self._eagle_profiler, byref(profile_size))
         if status is not PicovoiceStatuses.SUCCESS:
-            raise _PICOVOICE_STATUS_TO_EXCEPTION[status]()
+            raise _PICOVOICE_STATUS_TO_EXCEPTION[status](
+                message='Failed to get profile size',
+                message_stack=self._get_error_stack())
         self._profile_size = profile_size.value
 
         enroll_min_audio_length_sample_func = \
@@ -224,7 +262,9 @@ class EagleProfiler(object):
             self._eagle_profiler,
             byref(min_enroll_samples))
         if status is not PicovoiceStatuses.SUCCESS:
-            raise _PICOVOICE_STATUS_TO_EXCEPTION[status]()
+            raise _PICOVOICE_STATUS_TO_EXCEPTION[status](
+                message='Failed to get min audio length sample',
+                message_stack=self._get_error_stack())
         self._min_enroll_samples = min_enroll_samples.value
 
         self._delete_func = library.pv_eagle_profiler_delete
@@ -298,7 +338,9 @@ class EagleProfiler(object):
             byref(percentage))
         feedback = EagleProfilerEnrollFeedback(feedback_code.value)
         if status is not PicovoiceStatuses.SUCCESS:
-            raise _PICOVOICE_STATUS_TO_EXCEPTION[status]()
+            raise _PICOVOICE_STATUS_TO_EXCEPTION[status](
+                message='Enrollment failed',
+                message_stack=self._get_error_stack())
 
         return percentage.value, feedback
 
@@ -316,7 +358,9 @@ class EagleProfiler(object):
             byref(profile)
         )
         if status is not PicovoiceStatuses.SUCCESS:
-            raise _PICOVOICE_STATUS_TO_EXCEPTION[status]()
+            raise _PICOVOICE_STATUS_TO_EXCEPTION[status](
+                message='Export failed',
+                message_stack=self._get_error_stack())
 
         return EagleProfile(cast(profile, c_void_p), self._profile_size)
 
@@ -328,7 +372,9 @@ class EagleProfiler(object):
 
         status = self._reset_func(self._eagle_profiler)
         if status is not PicovoiceStatuses.SUCCESS:
-            raise _PICOVOICE_STATUS_TO_EXCEPTION[status]()
+            raise _PICOVOICE_STATUS_TO_EXCEPTION[status](
+                message='Profile reset failed',
+                message_stack=self._get_error_stack())
 
     def delete(self) -> None:
         """
@@ -361,6 +407,21 @@ class EagleProfiler(object):
 
         return self._version
 
+    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 PicovoiceStatuses.SUCCESS:
+            raise _PICOVOICE_STATUS_TO_EXCEPTION[status](message='Unable to get Eagle 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
+
 
 class Eagle(object):
     """
@@ -400,6 +461,20 @@ class Eagle(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 = 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
+
         # noinspection PyArgumentList
         self._eagle = POINTER(self.CEagle)()
 
@@ -423,7 +498,9 @@ class Eagle(object):
             profile_bytes,
             byref(self._eagle))
         if status is not PicovoiceStatuses.SUCCESS:
-            raise _PICOVOICE_STATUS_TO_EXCEPTION[status]()
+            raise _PICOVOICE_STATUS_TO_EXCEPTION[status](
+                message='Initialization failed',
+                message_stack=self._get_error_stack())
 
         self._delete_func = library.pv_eagle_delete
         self._delete_func.argtypes = [POINTER(self.CEagle)]
@@ -471,7 +548,9 @@ class Eagle(object):
 
         status = self._process_func(self._eagle, pcm, self._scores)
         if status is not PicovoiceStatuses.SUCCESS:
-            raise _PICOVOICE_STATUS_TO_EXCEPTION[status]()
+            raise _PICOVOICE_STATUS_TO_EXCEPTION[status](
+                message='Process failed',
+                message_stack=self._get_error_stack())
 
         # noinspection PyTypeChecker
         return [float(score) for score in self._scores]
@@ -485,7 +564,9 @@ class Eagle(object):
 
         status = self._reset_func(self._eagle)
         if status is not PicovoiceStatuses.SUCCESS:
-            raise _PICOVOICE_STATUS_TO_EXCEPTION[status]()
+            raise _PICOVOICE_STATUS_TO_EXCEPTION[status](
+                message='Reset failed',
+                message_stack=self._get_error_stack())
 
     def delete(self) -> None:
         """
@@ -518,6 +599,21 @@ class Eagle(object):
 
         return self._version
 
+    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 PicovoiceStatuses.SUCCESS:
+            raise _PICOVOICE_STATUS_TO_EXCEPTION[status](message='Unable to get Eagle 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__ = [
     'Eagle',

pveagle-0.2.0/pveagle.egg-info/PKG-INFO

@@ -0,0 +1,145 @@
+Metadata-Version: 2.1
+Name: pveagle
+Version: 0.2.0
+Summary: Eagle Speaker Recognition Engine
+Home-page: https://github.com/Picovoice/eagle
+Author: Picovoice
+Author-email: hello@picovoice.ai
+License: UNKNOWN
+Description: # Eagle Speaker Recognition Engine
+        
+        Made in Vancouver, Canada by [Picovoice](https://picovoice.ai)
+        
+        Eagle is an on-device speaker recognition engine. Eagle is:
+        
+        - Private; All voice processing runs locally.
+        - 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 or higher
+        - Runs on Linux (x86_64), macOS (x86_64, arm64), Windows (x86_64), Raspberry Pi (4, 3), and NVIDIA Jetson Nano.
+        
+        ## Installation
+        
+        ```console
+        pip3 install pveagle
+        ```
+        
+        ## AccessKey
+        
+        Eagle requires a valid Picovoice `AccessKey` at initialization. `AccessKey` acts as your credentials when using Eagle
+        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
+        
+        Eagle has two distinct steps: Enrollment and Recognition. In the enrollment step, Eagle analyzes a series of
+        utterances from a particular speaker to learn their unique voiceprint. This step produces an `EagleProfile` object,
+        which can be stored and utilized during inference. During the Recognition step, Eagle compares the incoming frames of
+        audio to the voiceprints of all enrolled speakers in real-time to determine the similarity between them.
+        
+        ### Speaker Enrollment
+        
+        Create an instance of the profiler:
+        
+        ```python
+        import pveagle
+        
+        # AccessKey obtained from Picovoice Console (https://console.picovoice.ai/)
+        access_key = "${ACCESS_KEY}"
+        eagle_profiler = pveagle.create_profiler(access_key)
+        ```
+        
+        `EagleProfiler` is responsible for processing and enrolling PCM audio data, with the valid audio sample rate determined
+        by `eagle_profiler.sample_rate`. The audio data must be 16-bit linearly-encoded and single-channel.
+        
+        When passing samples to `eagle_profiler.enroll`, the number of samples must be at
+        least `eagle_profiler.min_enroll_samples` to ensure sufficient data for enrollment. The percentage value
+        obtained from this process indicates the progress of enrollment, while the feedback value can be utilized to determine
+        the status of the enrollment process.
+        
+        ```python
+        def get_next_enroll_audio_data(num_samples):
+            pass
+        
+        
+        percentage = 0.0
+        while percentage < 100.0:
+            percentage, feedback = eagle_profiler.enroll(get_next_enroll_audio_data(eagle_profiler.min_enroll_samples))
+            print(feedback.name)
+        ```
+        
+        After the percentage reaches 100%, the enrollment process is considered complete. While it is possible to continue
+        providing additional audio data to the profiler to improve the accuracy of the voiceprint, it is not necessary to do so.
+        Moreover, if the audio data submitted is unsuitable for enrollment, the feedback value will indicate the reason, and the
+        enrollment progress will remain unchanged.
+        
+        ```python
+        speaker_profile = eagle_profiler.export()
+        ```
+        
+        The `eagle_profiler.export()` function produces an `EagleProfile` object, which can be converted into a binary form
+        using the `EagleProfile.to_bytes()` method. This binary representation can be saved and subsequently retrieved using
+        the `EagleProfile.from_bytes()` method.
+        
+        To reset the profiler and enroll a new speaker, the `eagle_profiler.reset()` method can be used. This method clears all
+        previously stored data, making it possible to start a new enrollment session with a different speaker.
+        
+        Finally, when done be sure to explicitly release the resources:
+        
+        ```python
+        eagle_profiler.delete()
+        ```
+        
+        ### Speaker Recognition
+        
+        Create an instance of the engine with one or more speaker profiles from the `EagleProfiler`:
+        
+        ```python
+        eagle = pveagle.create_recognizer(access_key, speaker_profile)
+        ```
+        
+        When initialized, `eagle.sample_rate` specifies the valid sample rate for Eagle. The expected length of a frame, or the
+        number of audio samples in an input array, is defined by `eagle.frame_length`.
+        
+        Like the profiler, Eagle is designed to work with single-channel audio that is encoded using 16-bit linear PCM.
+        
+        ```python
+        def get_next_audio_frame():
+            pass
+        
+        
+        while True:
+            scores = eagle.process(get_next_audio_frame())
+        ```
+        
+        The `scores` array contains floating-point numbers that indicate the similarity between the input audio frame and the
+        enrolled speakers. Each value in the array corresponds to a specific enrolled speaker, maintaining the same order as the
+        speaker profiles provided during initialization. The values in the array range from 0.0 to 1.0, where higher values
+        indicate a stronger degree of similarity.
+        
+        Finally, when done be sure to explicitly release the resources:
+        
+        ```python
+        eagle.delete()
+        ```
+        
+        ## Demos
+        [pveagledemo](https://pypi.org/project/pveagledemo/) provides command-line utilities for processing real-time
+        audio (i.e. microphone) and files using Eagle.
+        
+Keywords: Speaker Recognition,Speaker Identification,Voice Recognition,Voice Identification
+Platform: UNKNOWN
+Classifier: Development Status :: 4 - Beta
+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

{pveagle-0.1.0 → pveagle-0.2.0}/setup.py

@@ -42,7 +42,7 @@ with open(os.path.join(os.path.dirname(__file__), 'README.md'), 'r') as f:
 
 setuptools.setup(
     name="pveagle",
-    version="0.1.0",
+    version="0.2.0",
     author="Picovoice",
     author_email="hello@picovoice.ai",
     description="Eagle Speaker Recognition Engine",

pveagle-0.1.0/PKG-INFO

@@ -1,145 +0,0 @@
-Metadata-Version: 2.1
-Name: pveagle
-Version: 0.1.0
-Summary: Eagle Speaker Recognition Engine
-Home-page: https://github.com/Picovoice/eagle
-Author: Picovoice
-Author-email: hello@picovoice.ai
-Keywords: Speaker Recognition,Speaker Identification,Voice Recognition,Voice Identification
-Classifier: Development Status :: 4 - Beta
-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
-
-# Eagle Speaker Recognition Engine
-
-Made in Vancouver, Canada by [Picovoice](https://picovoice.ai)
-
-Eagle is an on-device speaker recognition engine. Eagle is:
-
-- Private; All voice processing runs locally.
-- 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 or higher
-- Runs on Linux (x86_64), macOS (x86_64, arm64), Windows (x86_64), Raspberry Pi (4, 3), and NVIDIA Jetson Nano.
-
-## Installation
-
-```console
-pip3 install pveagle
-```
-
-## AccessKey
-
-Eagle requires a valid Picovoice `AccessKey` at initialization. `AccessKey` acts as your credentials when using Eagle
-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
-
-Eagle has two distinct steps: Enrollment and Recognition. In the enrollment step, Eagle analyzes a series of
-utterances from a particular speaker to learn their unique voiceprint. This step produces an `EagleProfile` object,
-which can be stored and utilized during inference. During the Recognition step, Eagle compares the incoming frames of
-audio to the voiceprints of all enrolled speakers in real-time to determine the similarity between them.
-
-### Speaker Enrollment
-
-Create an instance of the profiler:
-
-```python
-import pveagle
-
-# AccessKey obtained from Picovoice Console (https://console.picovoice.ai/)
-access_key = "${ACCESS_KEY}"
-eagle_profiler = pveagle.create_profiler(access_key)
-```
-
-`EagleProfiler` is responsible for processing and enrolling PCM audio data, with the valid audio sample rate determined
-by `eagle_profiler.sample_rate`. The audio data must be 16-bit linearly-encoded and single-channel.
-
-When passing samples to `eagle_profiler.enroll`, the number of samples must be at
-least `eagle_profiler.min_enroll_samples` to ensure sufficient data for enrollment. The percentage value
-obtained from this process indicates the progress of enrollment, while the feedback value can be utilized to determine
-the status of the enrollment process.
-
-```python
-def get_next_enroll_audio_data(num_samples):
-    pass
-
-
-percentage = 0.0
-while percentage < 100.0:
-    percentage, feedback = eagle_profiler.enroll(get_next_enroll_audio_data(eagle_profiler.min_enroll_samples))
-    print(feedback.name)
-```
-
-After the percentage reaches 100%, the enrollment process is considered complete. While it is possible to continue
-providing additional audio data to the profiler to improve the accuracy of the voiceprint, it is not necessary to do so.
-Moreover, if the audio data submitted is unsuitable for enrollment, the feedback value will indicate the reason, and the
-enrollment progress will remain unchanged.
-
-```python
-speaker_profile = eagle_profiler.export()
-```
-
-The `eagle_profiler.export()` function produces an `EagleProfile` object, which can be converted into a binary form
-using the `EagleProfile.to_bytes()` method. This binary representation can be saved and subsequently retrieved using
-the `EagleProfile.from_bytes()` method.
-
-To reset the profiler and enroll a new speaker, the `eagle_profiler.reset()` method can be used. This method clears all
-previously stored data, making it possible to start a new enrollment session with a different speaker.
-
-Finally, when done be sure to explicitly release the resources:
-
-```python
-eagle_profiler.delete()
-```
-
-### Speaker Recognition
-
-Create an instance of the engine with one or more speaker profiles from the `EagleProfiler`:
-
-```python
-eagle = pveagle.create_recognizer(access_key, speaker_profile)
-```
-
-When initialized, `eagle.sample_rate` specifies the valid sample rate for Eagle. The expected length of a frame, or the
-number of audio samples in an input array, is defined by `eagle.frame_length`.
-
-Like the profiler, Eagle is designed to work with single-channel audio that is encoded using 16-bit linear PCM.
-
-```python
-def get_next_audio_frame():
-    pass
-
-
-while True:
-    scores = eagle.process(get_next_audio_frame())
-```
-
-The `scores` array contains floating-point numbers that indicate the similarity between the input audio frame and the
-enrolled speakers. Each value in the array corresponds to a specific enrolled speaker, maintaining the same order as the
-speaker profiles provided during initialization. The values in the array range from 0.0 to 1.0, where higher values
-indicate a stronger degree of similarity.
-
-Finally, when done be sure to explicitly release the resources:
-
-```python
-eagle.delete()
-```
-
-## Demos
-<!-- markdown-link-check-disable -->
-[pveagledemo](https://pypi.org/project/pveagledemo/) provides command-line utilities for processing real-time
-audio (i.e. microphone) and files using Eagle.
-<!-- markdown-link-check-enable -->

pveagle-0.1.0/pveagle.egg-info/PKG-INFO

@@ -1,145 +0,0 @@
-Metadata-Version: 2.1
-Name: pveagle
-Version: 0.1.0
-Summary: Eagle Speaker Recognition Engine
-Home-page: https://github.com/Picovoice/eagle
-Author: Picovoice
-Author-email: hello@picovoice.ai
-Keywords: Speaker Recognition,Speaker Identification,Voice Recognition,Voice Identification
-Classifier: Development Status :: 4 - Beta
-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
-
-# Eagle Speaker Recognition Engine
-
-Made in Vancouver, Canada by [Picovoice](https://picovoice.ai)
-
-Eagle is an on-device speaker recognition engine. Eagle is:
-
-- Private; All voice processing runs locally.
-- 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 or higher
-- Runs on Linux (x86_64), macOS (x86_64, arm64), Windows (x86_64), Raspberry Pi (4, 3), and NVIDIA Jetson Nano.
-
-## Installation
-
-```console
-pip3 install pveagle
-```
-
-## AccessKey
-
-Eagle requires a valid Picovoice `AccessKey` at initialization. `AccessKey` acts as your credentials when using Eagle
-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
-
-Eagle has two distinct steps: Enrollment and Recognition. In the enrollment step, Eagle analyzes a series of
-utterances from a particular speaker to learn their unique voiceprint. This step produces an `EagleProfile` object,
-which can be stored and utilized during inference. During the Recognition step, Eagle compares the incoming frames of
-audio to the voiceprints of all enrolled speakers in real-time to determine the similarity between them.
-
-### Speaker Enrollment
-
-Create an instance of the profiler:
-
-```python
-import pveagle
-
-# AccessKey obtained from Picovoice Console (https://console.picovoice.ai/)
-access_key = "${ACCESS_KEY}"
-eagle_profiler = pveagle.create_profiler(access_key)
-```
-
-`EagleProfiler` is responsible for processing and enrolling PCM audio data, with the valid audio sample rate determined
-by `eagle_profiler.sample_rate`. The audio data must be 16-bit linearly-encoded and single-channel.
-
-When passing samples to `eagle_profiler.enroll`, the number of samples must be at
-least `eagle_profiler.min_enroll_samples` to ensure sufficient data for enrollment. The percentage value
-obtained from this process indicates the progress of enrollment, while the feedback value can be utilized to determine
-the status of the enrollment process.
-
-```python
-def get_next_enroll_audio_data(num_samples):
-    pass
-
-
-percentage = 0.0
-while percentage < 100.0:
-    percentage, feedback = eagle_profiler.enroll(get_next_enroll_audio_data(eagle_profiler.min_enroll_samples))
-    print(feedback.name)
-```
-
-After the percentage reaches 100%, the enrollment process is considered complete. While it is possible to continue
-providing additional audio data to the profiler to improve the accuracy of the voiceprint, it is not necessary to do so.
-Moreover, if the audio data submitted is unsuitable for enrollment, the feedback value will indicate the reason, and the
-enrollment progress will remain unchanged.
-
-```python
-speaker_profile = eagle_profiler.export()
-```
-
-The `eagle_profiler.export()` function produces an `EagleProfile` object, which can be converted into a binary form
-using the `EagleProfile.to_bytes()` method. This binary representation can be saved and subsequently retrieved using
-the `EagleProfile.from_bytes()` method.
-
-To reset the profiler and enroll a new speaker, the `eagle_profiler.reset()` method can be used. This method clears all
-previously stored data, making it possible to start a new enrollment session with a different speaker.
-
-Finally, when done be sure to explicitly release the resources:
-
-```python
-eagle_profiler.delete()
-```
-
-### Speaker Recognition
-
-Create an instance of the engine with one or more speaker profiles from the `EagleProfiler`:
-
-```python
-eagle = pveagle.create_recognizer(access_key, speaker_profile)
-```
-
-When initialized, `eagle.sample_rate` specifies the valid sample rate for Eagle. The expected length of a frame, or the
-number of audio samples in an input array, is defined by `eagle.frame_length`.
-
-Like the profiler, Eagle is designed to work with single-channel audio that is encoded using 16-bit linear PCM.
-
-```python
-def get_next_audio_frame():
-    pass
-
-
-while True:
-    scores = eagle.process(get_next_audio_frame())
-```
-
-The `scores` array contains floating-point numbers that indicate the similarity between the input audio frame and the
-enrolled speakers. Each value in the array corresponds to a specific enrolled speaker, maintaining the same order as the
-speaker profiles provided during initialization. The values in the array range from 0.0 to 1.0, where higher values
-indicate a stronger degree of similarity.
-
-Finally, when done be sure to explicitly release the resources:
-
-```python
-eagle.delete()
-```
-
-## Demos
-<!-- markdown-link-check-disable -->
-[pveagledemo](https://pypi.org/project/pveagledemo/) provides command-line utilities for processing real-time
-audio (i.e. microphone) and files using Eagle.
-<!-- markdown-link-check-enable -->