flet-audio-recorder 0.1.0__tar.gz

flet_audio_recorder-0.1.0/PKG-INFO

@@ -0,0 +1,93 @@
+Metadata-Version: 2.2
+Name: flet-audio-recorder
+Version: 0.1.0
+Summary: AudioRecorder control for Flet
+Author-email: Flet contributors <hello@flet.dev>
+Project-URL: Homepage, https://flet.dev
+Project-URL: Documentation, https://flet.dev/docs/controls/audiorecorder
+Project-URL: Repository, https://github.com/flet-dev/flet-audio-recorder
+Project-URL: Issues, https://github.com/flet-dev/flet-audio-recorder/issues
+Classifier: License :: OSI Approved :: Apache Software License
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: flet>=0.25.2
+
+# AudioRecorder control for Flet
+
+`AudioRecorder` control for Flet.
+
+## Usage
+
+Add `flet-audio-recorder` as dependency (`pyproject.toml` or `requirements.txt`) to your Flet project.
+
+## Example
+
+```py
+
+import flet as ft
+
+import flet_audio_recorder as far
+
+async def main(page: ft.Page):
+    page.horizontal_alignment = ft.CrossAxisAlignment.CENTER
+    page.appbar = ft.AppBar(title=ft.Text("Audio Recorder"), center_title=True)
+
+    path = "test-audio-file.wav"
+
+    async def handle_start_recording(e):
+        print(f"StartRecording: {path}")
+        await audio_rec.start_recording_async(path)
+
+    async def handle_stop_recording(e):
+        output_path = await audio_rec.stop_recording_async()
+        print(f"StopRecording: {output_path}")
+        if page.web and output_path is not None:
+            await page.launch_url_async(output_path)
+
+    async def handle_list_devices(e):
+        devices = await audio_rec.get_input_devices_async()
+        print(devices)
+
+    async def handle_has_permission(e):
+        try:
+            print(f"HasPermission: {await audio_rec.has_permission_async()}")
+        except Exception as e:
+            print(e)
+
+    async def handle_pause(e):
+        print(f"isRecording: {await audio_rec.is_recording_async()}")
+        if await audio_rec.is_recording_async():
+            await audio_rec.pause_recording_async()
+
+    async def handle_resume(e):
+        print(f"isPaused: {await audio_rec.is_paused_async()}")
+        if await audio_rec.is_paused_async():
+            await audio_rec.resume_recording_async()
+
+    async def handle_audio_encoding_test(e):
+        for i in list(far.AudioEncoder):
+            print(f"{i}: {await audio_rec.is_supported_encoder_async(i)}")
+
+    async def handle_state_change(e):
+        print(f"State Changed: {e.data}")
+
+    audio_rec = far.AudioRecorder(
+        audio_encoder=far.AudioEncoder.WAV,
+        on_state_changed=handle_state_change,
+    )
+    page.overlay.append(audio_rec)
+    await page.update_async()
+
+    await page.add_async(
+        ft.ElevatedButton("Start Audio Recorder", on_click=handle_start_recording),
+        ft.ElevatedButton("Stop Audio Recorder", on_click=handle_stop_recording),
+        ft.ElevatedButton("List Devices", on_click=handle_list_devices),
+        ft.ElevatedButton("Pause Recording", on_click=handle_pause),
+        ft.ElevatedButton("Resume Recording", on_click=handle_resume),
+        ft.ElevatedButton("Test AudioEncodings", on_click=handle_audio_encoding_test),
+        ft.ElevatedButton("Has Permission", on_click=handle_has_permission),
+    )
+
+
+ft.app(main)
+```

flet_audio_recorder-0.1.0/README.md

@@ -0,0 +1,79 @@
+# AudioRecorder control for Flet
+
+`AudioRecorder` control for Flet.
+
+## Usage
+
+Add `flet-audio-recorder` as dependency (`pyproject.toml` or `requirements.txt`) to your Flet project.
+
+## Example
+
+```py
+
+import flet as ft
+
+import flet_audio_recorder as far
+
+async def main(page: ft.Page):
+    page.horizontal_alignment = ft.CrossAxisAlignment.CENTER
+    page.appbar = ft.AppBar(title=ft.Text("Audio Recorder"), center_title=True)
+
+    path = "test-audio-file.wav"
+
+    async def handle_start_recording(e):
+        print(f"StartRecording: {path}")
+        await audio_rec.start_recording_async(path)
+
+    async def handle_stop_recording(e):
+        output_path = await audio_rec.stop_recording_async()
+        print(f"StopRecording: {output_path}")
+        if page.web and output_path is not None:
+            await page.launch_url_async(output_path)
+
+    async def handle_list_devices(e):
+        devices = await audio_rec.get_input_devices_async()
+        print(devices)
+
+    async def handle_has_permission(e):
+        try:
+            print(f"HasPermission: {await audio_rec.has_permission_async()}")
+        except Exception as e:
+            print(e)
+
+    async def handle_pause(e):
+        print(f"isRecording: {await audio_rec.is_recording_async()}")
+        if await audio_rec.is_recording_async():
+            await audio_rec.pause_recording_async()
+
+    async def handle_resume(e):
+        print(f"isPaused: {await audio_rec.is_paused_async()}")
+        if await audio_rec.is_paused_async():
+            await audio_rec.resume_recording_async()
+
+    async def handle_audio_encoding_test(e):
+        for i in list(far.AudioEncoder):
+            print(f"{i}: {await audio_rec.is_supported_encoder_async(i)}")
+
+    async def handle_state_change(e):
+        print(f"State Changed: {e.data}")
+
+    audio_rec = far.AudioRecorder(
+        audio_encoder=far.AudioEncoder.WAV,
+        on_state_changed=handle_state_change,
+    )
+    page.overlay.append(audio_rec)
+    await page.update_async()
+
+    await page.add_async(
+        ft.ElevatedButton("Start Audio Recorder", on_click=handle_start_recording),
+        ft.ElevatedButton("Stop Audio Recorder", on_click=handle_stop_recording),
+        ft.ElevatedButton("List Devices", on_click=handle_list_devices),
+        ft.ElevatedButton("Pause Recording", on_click=handle_pause),
+        ft.ElevatedButton("Resume Recording", on_click=handle_resume),
+        ft.ElevatedButton("Test AudioEncodings", on_click=handle_audio_encoding_test),
+        ft.ElevatedButton("Has Permission", on_click=handle_has_permission),
+    )
+
+
+ft.app(main)
+```

flet_audio_recorder-0.1.0/pyproject.toml

@@ -0,0 +1,36 @@
+[project]
+name = "flet-audio-recorder"
+version = "0.1.0"
+description = "AudioRecorder control for Flet"
+readme = "README.md"
+authors = [
+    { name = "Flet contributors", email = "hello@flet.dev" }
+]
+classifiers = [
+  "License :: OSI Approved :: Apache Software License",
+]
+requires-python = ">=3.8"
+dependencies = [
+    "flet>=0.25.2",
+]
+
+[project.urls]
+Homepage = "https://flet.dev"
+Documentation = "https://flet.dev/docs/controls/audiorecorder"
+Repository = "https://github.com/flet-dev/flet-audio-recorder"
+Issues = "https://github.com/flet-dev/flet-audio-recorder/issues"
+
+[tool.setuptools.package-data]
+"flutter.flet_audio_recorder" = ["**/*"]
+
+[tool.uv]
+dev-dependencies = [
+    "flet[all]>=0.25.2",
+]
+
+[tool.setuptools]
+license-files = []
+
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"

flet_audio_recorder-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

flet_audio_recorder-0.1.0/src/flet_audio_recorder/__init__.py

@@ -0,0 +1,6 @@
+from flet_audio_recorder.audio_recorder import (
+    AudioEncoder,
+    AudioRecorder,
+    AudioRecorderState,
+    AudioRecorderStateChangeEvent,
+)

flet_audio_recorder-0.1.0/src/flet_audio_recorder/audio_recorder.py

@@ -0,0 +1,294 @@
+import json
+from enum import Enum
+from typing import Any, Optional
+
+from flet.core.control import Control, OptionalNumber
+from flet.core.control_event import ControlEvent
+from flet.core.event_handler import EventHandler
+from flet.core.ref import Ref
+from flet.core.types import OptionalEventCallable
+from flet.utils import deprecated
+
+
+class AudioRecorderState(Enum):
+    STOPPED = "stopped"
+    RECORDING = "recording"
+    PAUSED = "paused"
+
+
+class AudioRecorderStateChangeEvent(ControlEvent):
+    def __init__(self, e: ControlEvent):
+        super().__init__(e.target, e.name, e.data, e.control, e.page)
+        self.state: AudioRecorderState = AudioRecorderState(e.data)
+
+
+class AudioEncoder(Enum):
+    AACLC = "aacLc"
+    AACELD = "aacEld"
+    AACHE = "aacHe"
+    AMRNB = "amrNb"
+    AMRWB = "amrWb"
+    OPUS = "opus"
+    FLAC = "flac"
+    WAV = "wav"
+    PCM16BITS = "pcm16bits"
+
+
+class AudioRecorder(Control):
+    """
+    A control that allows you to record audio from your device.
+
+    -----
+
+    Online docs: https://flet.dev/docs/controls/audiorecorder
+    """
+
+    def __init__(
+        self,
+        audio_encoder: Optional[AudioEncoder] = None,
+        suppress_noise: Optional[bool] = None,
+        cancel_echo: Optional[bool] = None,
+        auto_gain: Optional[bool] = None,
+        channels_num: OptionalNumber = None,
+        sample_rate: OptionalNumber = None,
+        bit_rate: OptionalNumber = None,
+        on_state_changed: OptionalEventCallable[AudioRecorderStateChangeEvent] = None,
+        #
+        # Control
+        #
+        ref: Optional[Ref] = None,
+        data: Any = None,
+    ):
+        Control.__init__(
+            self,
+            ref=ref,
+            data=data,
+        )
+        self.__on_state_changed = EventHandler(
+            lambda e: AudioRecorderStateChangeEvent(e)
+        )
+        self._add_event_handler("state_changed", self.__on_state_changed.get_handler())
+
+        self.audio_encoder = audio_encoder
+        self.suppress_noise = suppress_noise
+        self.cancel_echo = cancel_echo
+        self.auto_gain = auto_gain
+        self.channels_num = channels_num
+        self.sample_rate = sample_rate
+        self.bit_rate = bit_rate
+        self.on_state_changed = on_state_changed
+
+    def _get_control_name(self):
+        return "audiorecorder"
+
+    def start_recording(
+        self, output_path: str = None, wait_timeout: Optional[float] = 10
+    ) -> bool:
+        assert (
+            self.page.web or output_path
+        ), "output_path must be provided when not on web"
+        started = self.invoke_method(
+            "start_recording",
+            {"outputPath": output_path},
+            wait_for_result=True,
+            wait_timeout=wait_timeout,
+        )
+        return started == "true"
+
+    def is_recording(self, wait_timeout: Optional[float] = 5) -> bool:
+        recording = self.invoke_method(
+            "is_recording",
+            wait_for_result=True,
+            wait_timeout=wait_timeout,
+        )
+        return recording == "true"
+
+    async def is_recording_async(self, wait_timeout: Optional[float] = 5) -> bool:
+        recording = await self.invoke_method_async(
+            "is_recording",
+            wait_for_result=True,
+            wait_timeout=wait_timeout,
+        )
+        return recording == "true"
+
+    def stop_recording(self, wait_timeout: Optional[float] = 5) -> Optional[str]:
+        return self.invoke_method(
+            "stop_recording",
+            wait_for_result=True,
+            wait_timeout=wait_timeout,
+        )
+
+    async def stop_recording_async(
+        self, wait_timeout: Optional[float] = 10
+    ) -> Optional[str]:
+        return await self.invoke_method_async(
+            "stop_recording",
+            wait_for_result=True,
+            wait_timeout=wait_timeout,
+        )
+
+    def cancel_recording(self, wait_timeout: Optional[float] = 5) -> None:
+        self.invoke_method(
+            "cancel_recording",
+            wait_for_result=True,
+            wait_timeout=wait_timeout,
+        )
+
+    def resume_recording(self):
+        self.invoke_method("resume_recording")
+
+    def pause_recording(self):
+        self.invoke_method("pause_recording")
+
+    def is_paused(self, wait_timeout: Optional[float] = 5) -> bool:
+        paused = self.invoke_method(
+            "is_paused",
+            wait_for_result=True,
+            wait_timeout=wait_timeout,
+        )
+        return paused == "true"
+
+    async def is_paused_async(self, wait_timeout: Optional[float] = 5) -> bool:
+        supported = await self.invoke_method_async(
+            "is_paused",
+            wait_for_result=True,
+            wait_timeout=wait_timeout,
+        )
+        return supported == "true"
+
+    def is_supported_encoder(
+        self, encoder: AudioEncoder, wait_timeout: Optional[float] = 5
+    ) -> bool:
+        supported = self.invoke_method(
+            "is_supported_encoder",
+            {
+                "encoder": (
+                    encoder.value if isinstance(encoder, AudioEncoder) else encoder
+                )
+            },
+            wait_for_result=True,
+            wait_timeout=wait_timeout,
+        )
+        return supported == "true"
+
+    async def is_supported_encoder_async(
+        self, encoder: AudioEncoder, wait_timeout: Optional[float] = 5
+    ) -> bool:
+        supported = await self.invoke_method_async(
+            "is_supported_encoder",
+            {
+                "encoder": (
+                    encoder.value if isinstance(encoder, AudioEncoder) else encoder
+                )
+            },
+            wait_for_result=True,
+            wait_timeout=wait_timeout,
+        )
+        return supported == "true"
+
+    def get_input_devices(self, wait_timeout: Optional[float] = 5) -> dict:
+        devices = self.invoke_method(
+            "get_input_devices",
+            wait_for_result=True,
+            wait_timeout=wait_timeout,
+        )
+        return json.loads(devices)
+
+    async def get_input_devices_async(self, wait_timeout: Optional[float] = 5) -> dict:
+        devices = await self.invoke_method_async(
+            "get_input_devices",
+            wait_for_result=True,
+            wait_timeout=wait_timeout,
+        )
+        return json.loads(devices)
+
+    def has_permission(self, wait_timeout: Optional[float] = 10) -> bool:
+        p = self.invoke_method(
+            "has_permission",
+            wait_for_result=True,
+            wait_timeout=wait_timeout,
+        )
+        return p == "true"
+
+    async def has_permission_async(self, wait_timeout: Optional[float] = 10) -> bool:
+        p = await self.invoke_method_async(
+            "has_permission",
+            wait_for_result=True,
+            wait_timeout=wait_timeout,
+        )
+        return p == "true"
+
+    # audio_encoder
+    @property
+    def audio_encoder(self):
+        return self._get_attr("audioEncoder")
+
+    @audio_encoder.setter
+    def audio_encoder(self, value: Optional[AudioEncoder]):
+        self._set_enum_attr("audioEncoder", value, AudioEncoder)
+
+    # suppress_noise
+    @property
+    def suppress_noise(self) -> bool:
+        return self._get_attr("suppressNoise", data_type="bool", def_value=False)
+
+    @suppress_noise.setter
+    def suppress_noise(self, value: Optional[bool]):
+        self._set_attr("suppressNoise", value)
+
+    # cancel_echo
+    @property
+    def cancel_echo(self) -> bool:
+        return self._get_attr("cancelEcho", data_type="bool", def_value=False)
+
+    @cancel_echo.setter
+    def cancel_echo(self, value: Optional[bool]):
+        self._set_attr("cancelEcho", value)
+
+    # auto_gain
+    @property
+    def auto_gain(self) -> bool:
+        return self._get_attr("autoGain", data_type="bool", def_value=False)
+
+    @auto_gain.setter
+    def auto_gain(self, value: Optional[bool]):
+        self._set_attr("autoGain", value)
+
+    # bit_rate
+    @property
+    def bit_rate(self) -> OptionalNumber:
+        return self._get_attr("bitRate")
+
+    @bit_rate.setter
+    def bit_rate(self, value: OptionalNumber):
+        self._set_attr("bitRate", value)
+
+    # sample_rate
+    @property
+    def sample_rate(self) -> OptionalNumber:
+        return self._get_attr("sampleRate")
+
+    @sample_rate.setter
+    def sample_rate(self, value: OptionalNumber):
+        self._set_attr("sampleRate", value)
+
+    # channels_num
+    @property
+    def channels_num(self) -> OptionalNumber:
+        return self._get_attr("channels")
+
+    @channels_num.setter
+    def channels_num(self, value: OptionalNumber):
+        if value is None or value in (1, 2):
+            self._set_attr("channels", value)
+
+    # on_state_changed
+    @property
+    def on_state_changed(self):
+        return self.__on_state_changed.handler
+
+    @on_state_changed.setter
+    def on_state_changed(
+        self, handler: OptionalEventCallable[AudioRecorderStateChangeEvent]
+    ):
+        self.__on_state_changed.handler = handler

flet_audio_recorder-0.1.0/src/flet_audio_recorder.egg-info/PKG-INFO

@@ -0,0 +1,93 @@
+Metadata-Version: 2.2
+Name: flet-audio-recorder
+Version: 0.1.0
+Summary: AudioRecorder control for Flet
+Author-email: Flet contributors <hello@flet.dev>
+Project-URL: Homepage, https://flet.dev
+Project-URL: Documentation, https://flet.dev/docs/controls/audiorecorder
+Project-URL: Repository, https://github.com/flet-dev/flet-audio-recorder
+Project-URL: Issues, https://github.com/flet-dev/flet-audio-recorder/issues
+Classifier: License :: OSI Approved :: Apache Software License
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: flet>=0.25.2
+
+# AudioRecorder control for Flet
+
+`AudioRecorder` control for Flet.
+
+## Usage
+
+Add `flet-audio-recorder` as dependency (`pyproject.toml` or `requirements.txt`) to your Flet project.
+
+## Example
+
+```py
+
+import flet as ft
+
+import flet_audio_recorder as far
+
+async def main(page: ft.Page):
+    page.horizontal_alignment = ft.CrossAxisAlignment.CENTER
+    page.appbar = ft.AppBar(title=ft.Text("Audio Recorder"), center_title=True)
+
+    path = "test-audio-file.wav"
+
+    async def handle_start_recording(e):
+        print(f"StartRecording: {path}")
+        await audio_rec.start_recording_async(path)
+
+    async def handle_stop_recording(e):
+        output_path = await audio_rec.stop_recording_async()
+        print(f"StopRecording: {output_path}")
+        if page.web and output_path is not None:
+            await page.launch_url_async(output_path)
+
+    async def handle_list_devices(e):
+        devices = await audio_rec.get_input_devices_async()
+        print(devices)
+
+    async def handle_has_permission(e):
+        try:
+            print(f"HasPermission: {await audio_rec.has_permission_async()}")
+        except Exception as e:
+            print(e)
+
+    async def handle_pause(e):
+        print(f"isRecording: {await audio_rec.is_recording_async()}")
+        if await audio_rec.is_recording_async():
+            await audio_rec.pause_recording_async()
+
+    async def handle_resume(e):
+        print(f"isPaused: {await audio_rec.is_paused_async()}")
+        if await audio_rec.is_paused_async():
+            await audio_rec.resume_recording_async()
+
+    async def handle_audio_encoding_test(e):
+        for i in list(far.AudioEncoder):
+            print(f"{i}: {await audio_rec.is_supported_encoder_async(i)}")
+
+    async def handle_state_change(e):
+        print(f"State Changed: {e.data}")
+
+    audio_rec = far.AudioRecorder(
+        audio_encoder=far.AudioEncoder.WAV,
+        on_state_changed=handle_state_change,
+    )
+    page.overlay.append(audio_rec)
+    await page.update_async()
+
+    await page.add_async(
+        ft.ElevatedButton("Start Audio Recorder", on_click=handle_start_recording),
+        ft.ElevatedButton("Stop Audio Recorder", on_click=handle_stop_recording),
+        ft.ElevatedButton("List Devices", on_click=handle_list_devices),
+        ft.ElevatedButton("Pause Recording", on_click=handle_pause),
+        ft.ElevatedButton("Resume Recording", on_click=handle_resume),
+        ft.ElevatedButton("Test AudioEncodings", on_click=handle_audio_encoding_test),
+        ft.ElevatedButton("Has Permission", on_click=handle_has_permission),
+    )
+
+
+ft.app(main)
+```

flet_audio_recorder-0.1.0/src/flet_audio_recorder.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+README.md
+pyproject.toml
+src/flet_audio_recorder/__init__.py
+src/flet_audio_recorder/audio_recorder.py
+src/flet_audio_recorder.egg-info/PKG-INFO
+src/flet_audio_recorder.egg-info/SOURCES.txt
+src/flet_audio_recorder.egg-info/dependency_links.txt
+src/flet_audio_recorder.egg-info/requires.txt
+src/flet_audio_recorder.egg-info/top_level.txt
+src/flutter/flet_audio_recorder/CHANGELOG.md
+src/flutter/flet_audio_recorder/LICENSE
+src/flutter/flet_audio_recorder/README.md
+src/flutter/flet_audio_recorder/analysis_options.yaml
+src/flutter/flet_audio_recorder/pubspec.lock
+src/flutter/flet_audio_recorder/pubspec.yaml
+src/flutter/flet_audio_recorder/lib/flet_audio_recorder.dart
+src/flutter/flet_audio_recorder/lib/src/audio_recorder.dart
+src/flutter/flet_audio_recorder/lib/src/create_control.dart
+src/flutter/flet_audio_recorder/lib/src/utils/audio_recorder.dart

flet_audio_recorder-0.1.0/src/flet_audio_recorder.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

flet_audio_recorder-0.1.0/src/flet_audio_recorder.egg-info/requires.txt

@@ -0,0 +1 @@
+flet>=0.25.2

flet_audio_recorder-0.1.0/src/flet_audio_recorder.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+flet_audio_recorder
+flutter

flet_audio_recorder-0.1.0/src/flutter/flet_audio_recorder/CHANGELOG.md

@@ -0,0 +1,3 @@
+# 0.1.0
+
+Initial release of the package.