viam-sdk 0.41.1__py3-none-linux_armv6l.whl → 0.66.0__py3-none-linux_armv6l.whl

{viam_sdk-0.41.1.dist-info → viam_sdk-0.66.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any

viam/components/audio_input/__init__.py

@@ -1,18 +0,0 @@
-from viam.resource.registry import Registry, ResourceRegistration
-
-from .audio_input import AudioInput
-from .client import AudioInputClient
-from .service import AudioInputRPCService
-
-__all__ = [
-    "AudioInput",
-]
-
-
-Registry.register_api(
-    ResourceRegistration(
-        AudioInput,
-        AudioInputRPCService,
-        lambda name, channel: AudioInputClient(name, channel),
-    )
-)

viam/components/audio_input/audio_input.py

@@ -1,81 +0,0 @@
-import abc
-from dataclasses import dataclass
-from datetime import timedelta
-from typing import Final, Optional
-
-from google.protobuf.duration_pb2 import Duration
-from typing_extensions import Self
-
-from viam.media.audio import Audio, AudioStream
-from viam.proto.component.audioinput import PropertiesResponse
-from viam.resource.types import API, RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT
-from viam.streams import StreamSource
-
-from ..component_base import ComponentBase
-
-
-class AudioInput(ComponentBase, StreamSource[Audio]):
-    """AudioInput represents a component that can capture audio.
-
-    This acts as an abstract base class for any drivers representing specific
-    audio input implementations. This cannot be used on its own. If the ``__init__()`` function is
-    overridden, it must call the ``super().__init__()`` function.
-    """
-
-    API: Final = API(  # pyright: ignore [reportIncompatibleVariableOverride]
-        RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT, "audio_input"
-    )
-
-    @dataclass
-    class Properties:
-        channel_count: int
-        latency: timedelta
-        sample_rate: int
-        sample_size: int
-        is_big_endian: bool
-        is_float: bool
-        is_interleaved: bool
-
-        @property
-        def proto(self) -> PropertiesResponse:
-            latency = Duration()
-            latency.FromTimedelta(self.latency)
-            return PropertiesResponse(
-                channel_count=self.channel_count,
-                latency=latency,
-                sample_rate=self.sample_rate,
-                sample_size=self.sample_size,
-                is_big_endian=self.is_big_endian,
-                is_float=self.is_float,
-                is_interleaved=self.is_interleaved,
-            )
-
-        @classmethod
-        def from_proto(cls, proto: PropertiesResponse) -> Self:
-            return cls(
-                channel_count=proto.channel_count,
-                latency=proto.latency.ToTimedelta(),
-                sample_rate=proto.sample_rate,
-                sample_size=proto.sample_size,
-                is_big_endian=proto.is_big_endian,
-                is_float=proto.is_float,
-                is_interleaved=proto.is_interleaved,
-            )
-
-    @abc.abstractmethod
-    async def stream(self, *, timeout: Optional[float] = None, **kwargs) -> AudioStream:
-        """Stream audio samples from the audio input of the underlying robot
-
-        Returns:
-            Stream[Audio]: The stream of audio chunks
-        """
-        ...
-
-    @abc.abstractmethod
-    async def get_properties(self, *, timeout: Optional[float] = None, **kwargs) -> Properties:
-        """Get the properties of the audio input of the underlying robot
-
-        Returns:
-            Properties: The audio input properties
-        """
-        ...

viam/components/audio_input/client.py

@@ -1,70 +0,0 @@
-from typing import Any, AsyncIterator, Dict, List, Mapping, Optional, Union
-
-from grpclib.client import Channel
-
-from viam.media.audio import Audio
-from viam.proto.common import DoCommandRequest, DoCommandResponse, Geometry
-from viam.proto.component.audioinput import (
-    AudioInputServiceStub,
-    ChunksRequest,
-    ChunksResponse,
-    PropertiesRequest,
-    PropertiesResponse,
-    SampleFormat,
-)
-from viam.resource.rpc_client_base import ReconfigurableResourceRPCClientBase
-from viam.streams import Stream, StreamWithIterator
-from viam.utils import ValueTypes, dict_to_struct, get_geometries, struct_to_dict
-
-from .audio_input import AudioInput
-
-
-class AudioInputClient(AudioInput, ReconfigurableResourceRPCClientBase):
-    """
-    gRPC client for the AudioInput component.
-    """
-
-    def __init__(self, name: str, channel: Channel):
-        self.channel = channel
-        self.client = AudioInputServiceStub(channel)
-        super().__init__(name)
-
-    async def stream(self, *, timeout: Optional[float] = None, **kwargs) -> Stream[Audio]:
-        async def read() -> AsyncIterator[Audio]:
-            md = kwargs.get("metadata", self.Metadata()).proto
-            async with self.client.Chunks.open(timeout=timeout, metadata=md) as chunks_stream:
-                await chunks_stream.send_message(
-                    ChunksRequest(name=self.name, sample_format=SampleFormat.SAMPLE_FORMAT_FLOAT32_INTERLEAVED), end=True
-                )
-                response: Union[ChunksResponse, None] = await chunks_stream.recv_message()
-                if not response:
-                    await chunks_stream.recv_trailing_metadata()  # causes us to throw appropriate gRPC error.
-                    raise TypeError("Response cannot be empty")  # we should never get here, but for typechecking
-                assert response.HasField("info")
-                info = response.info
-
-                while True:
-                    response = await chunks_stream.recv_message()
-                    if response is None:
-                        break
-                    assert response.HasField("chunk")
-                    audio = Audio(info=info, chunk=response.chunk)
-                    yield audio
-
-        return StreamWithIterator(read())
-
-    async def get_properties(self, *, timeout: Optional[float] = None, **kwargs) -> AudioInput.Properties:
-        md = kwargs.get("metadata", self.Metadata()).proto
-        request = PropertiesRequest(name=self.name)
-        response: PropertiesResponse = await self.client.Properties(request, timeout=timeout, metadata=md)
-        return AudioInput.Properties.from_proto(response)
-
-    async def do_command(self, command: Mapping[str, ValueTypes], *, timeout: Optional[float] = None, **kwargs) -> Mapping[str, ValueTypes]:
-        md = kwargs.get("metadata", self.Metadata()).proto
-        request = DoCommandRequest(name=self.name, command=dict_to_struct(command))
-        response: DoCommandResponse = await self.client.DoCommand(request, timeout=timeout, metadata=md)
-        return struct_to_dict(response.result)
-
-    async def get_geometries(self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **kwargs) -> List[Geometry]:
-        md = kwargs.get("metadata", self.Metadata())
-        return await get_geometries(self.client, self.name, extra, timeout, md)

viam/components/audio_input/service.py

@@ -1,114 +0,0 @@
-import wave
-from datetime import timedelta
-from io import BytesIO
-
-from google.api.httpbody_pb2 import HttpBody  # type: ignore
-from grpclib import GRPCError, Status
-from grpclib.server import Stream
-
-from viam.errors import NotSupportedError
-from viam.proto.common import DoCommandRequest, DoCommandResponse, GetGeometriesRequest, GetGeometriesResponse
-from viam.proto.component.audioinput import (
-    AudioInputServiceBase,
-    ChunksRequest,
-    ChunksResponse,
-    PropertiesRequest,
-    PropertiesResponse,
-    RecordRequest,
-    SampleFormat,
-)
-from viam.resource.rpc_service_base import ResourceRPCServiceBase
-from viam.utils import dict_to_struct, struct_to_dict
-
-from .audio_input import AudioInput
-
-
-class AudioInputRPCService(AudioInputServiceBase, ResourceRPCServiceBase[AudioInput]):
-    """
-    gRPC Service for a generic AudioInput
-    """
-
-    RESOURCE_TYPE = AudioInput
-
-    async def Chunks(self, stream: Stream[ChunksRequest, ChunksResponse]) -> None:
-        request = await stream.recv_message()
-        assert request is not None
-        audio_input = self.get_resource(request.name)
-        timeout = stream.deadline.time_remaining() if stream.deadline else None
-        audio_stream = await audio_input.stream(timeout=timeout, metadata=stream.metadata)
-        first_chunk = await audio_stream.__anext__()
-        await stream.send_message(ChunksResponse(info=first_chunk.info))
-        await stream.send_message(ChunksResponse(chunk=first_chunk.chunk))
-
-        async for audio in audio_stream:
-            await stream.send_message(ChunksResponse(chunk=audio.chunk))
-
-    async def Properties(self, stream: Stream[PropertiesRequest, PropertiesResponse]) -> None:
-        request = await stream.recv_message()
-        assert request is not None
-        audio_input = self.get_resource(request.name)
-        timeout = stream.deadline.time_remaining() if stream.deadline else None
-        response = (await audio_input.get_properties(timeout=timeout, metadata=stream.metadata)).proto
-        await stream.send_message(response)
-
-    async def Record(self, stream: Stream[RecordRequest, HttpBody]) -> None:  # pyright: ignore [reportInvalidTypeForm]
-        raise NotSupportedError("Recording audio input is not supported").grpc_error
-
-        # TODO: Eventually implement recording
-        request = await stream.recv_message()
-        assert request is not None
-        duration = request.duration.ToTimedelta()
-        if duration.total_seconds() == 0:
-            duration = timedelta(seconds=1)
-        if duration.total_seconds() > 5:
-            raise GRPCError(Status.INVALID_ARGUMENT, "Can only record up to 5 seconds")
-
-        audio_input = self.get_resource(request.name)
-        audio_stream = await audio_input.stream()
-        first_chunk = await audio_stream.__anext__()
-        num_chunks = int(duration.total_seconds() * float(first_chunk.info.sampling_rate / first_chunk.chunk.length))
-
-        sample_width: int
-        if first_chunk.info.sample_format == SampleFormat.SAMPLE_FORMAT_INT16_INTERLEAVED:
-            sample_width = 2
-        elif first_chunk.info.sample_format == SampleFormat.SAMPLE_FORMAT_FLOAT32_INTERLEAVED:
-            sample_width = 4
-        else:
-            raise GRPCError(Status.INVALID_ARGUMENT, "Unspecified type of audio buffer")
-
-        output = BytesIO()
-        wav_file = wave.open(output, "w")
-        wav_file.setnchannels(first_chunk.info.channels)
-        wav_file.setframerate(first_chunk.info.sampling_rate)
-        wav_file.setsampwidth(sample_width)
-        try:
-            wav_file.writeframes(first_chunk.chunk.data)
-            for _ in range(num_chunks - 1):
-                chunk = await audio_stream.__anext__()
-                wav_file.writeframes(chunk.chunk.data)
-        finally:
-            wav_file.close()
-            output.close()
-
-        output.seek(0)
-        response = HttpBody(data=output.read(), content_type="audio/wav")
-
-        await stream.send_message(response)
-
-    async def DoCommand(self, stream: Stream[DoCommandRequest, DoCommandResponse]) -> None:
-        request = await stream.recv_message()
-        assert request is not None
-        audio_input = self.get_resource(request.name)
-        timeout = stream.deadline.time_remaining() if stream.deadline else None
-        result = await audio_input.do_command(command=struct_to_dict(request.command), timeout=timeout, metadata=stream.metadata)
-        response = DoCommandResponse(result=dict_to_struct(result))
-        await stream.send_message(response)
-
-    async def GetGeometries(self, stream: Stream[GetGeometriesRequest, GetGeometriesResponse]) -> None:
-        request = await stream.recv_message()
-        assert request is not None
-        audio_input = self.get_resource(request.name)
-        timeout = stream.deadline.time_remaining() if stream.deadline else None
-        geometries = await audio_input.get_geometries(extra=struct_to_dict(request.extra), timeout=timeout)
-        response = GetGeometriesResponse(geometries=geometries)
-        await stream.send_message(response)