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

viam/logging.py

@@ -1,14 +1,120 @@
+import asyncio
 import logging
 import sys
 from copy import copy
+from datetime import datetime
 from logging import DEBUG, ERROR, FATAL, INFO, WARN, WARNING  # noqa: F401
-from typing import Dict
+from threading import Event, Lock, Thread
+from typing import TYPE_CHECKING, Dict, Iterable, List, Optional, Union
 
-LOG_LEVEL = INFO
-LOGGERS: Dict[str, logging.Logger] = {}
+from grpclib.exceptions import StreamTerminatedError
+
+import viam
 
+if TYPE_CHECKING:
+    from .robot.client import RobotClient
 
-class ColorFormatter(logging.Formatter):
+
+LOG_LEVEL = INFO
+LOGGERS: Dict[str, logging.Logger] = {}
+_MODULE_PARENT: Optional["RobotClient"] = None
+
+
+class _SingletonEventLoopThread:
+    _instance = None
+    _lock = Lock()
+    # We use a threading.Event instead of an asyncio.Event because the latter are not thread safe,
+    # and this is set in a separate thread than it is waited on.
+    _ready_event = Event()
+    _loop: asyncio.AbstractEventLoop
+    _thread: Thread
+
+    def __new__(cls):
+        # Ensure singleton precondition
+        if cls._instance is None:
+            with cls._lock:
+                if cls._instance is None:
+                    cls._instance = super(_SingletonEventLoopThread, cls).__new__(cls)
+                    cls._instance._loop = asyncio.new_event_loop()
+                    cls._instance._thread = Thread(target=cls._instance._run)
+                    cls._instance._thread.start()
+        return cls._instance
+
+    def _run(self):
+        asyncio.set_event_loop(self._loop)
+        self._ready_event.set()
+        self._loop.run_forever()
+
+    def stop(self):
+        if self._loop is not None:
+            self._loop.call_soon_threadsafe(self._loop.stop)
+        self._thread.join()
+
+    def get_loop(self):
+        if self._loop is None:
+            raise RuntimeError("Event loop is None. Did you call .start() and .wait_until_ready()?")
+        return self._loop
+
+    def wait_until_ready(self):
+        self._ready_event.wait()
+
+
+class _ModuleHandler(logging.Handler):
+    _parent: "RobotClient"
+    _logger: logging.Logger
+    _worker: _SingletonEventLoopThread
+
+    def __init__(self, parent: "RobotClient"):
+        super().__init__()
+        self._parent = parent
+        self._logger = logging.getLogger("ModuleLogger")
+        addHandlers(self._logger, True)
+        self._logger.setLevel(self.level)
+        self._worker = _SingletonEventLoopThread()
+
+    def setLevel(self, level: Union[int, str]) -> None:
+        self._logger.setLevel(level)
+        return super().setLevel(level)
+
+    async def handle_task_result(self, task: asyncio.Task):
+        try:
+            _ = task.result()
+        except (asyncio.CancelledError, asyncio.InvalidStateError, StreamTerminatedError):
+            pass
+
+    def emit(self, record: logging.LogRecord):
+        assert isinstance(record, logging.LogRecord)
+        # Fully qualified name of form "{API triplet}/{name}", e.g. "rdk:component:arm/myarm"
+        name = record.name.replace(".", "/")
+        message = f"{record.filename}:{record.lineno}\t{record.getMessage()}"
+        stack = f"exc_info: {record.exc_info}, exc_text: {record.exc_text}, stack_info: {record.stack_info}"
+        time = datetime.fromtimestamp(record.created)
+
+        try:
+            loop = self._worker.get_loop()
+            asyncio.run_coroutine_threadsafe(
+                self._asynchronously_emit(record, name, message, stack, time),
+                loop,
+            )
+        except Exception as err:
+            # If the module log fails, log using stdout/stderr handlers
+            self._logger.error(f"ModuleLogger failed for {record.name} - {err}")
+            self._logger.log(record.levelno, message)
+
+    async def _asynchronously_emit(self, record: logging.LogRecord, name: str, message: str, stack: str, time: datetime):
+        self._worker.wait_until_ready()
+        task = self._worker.get_loop().create_task(
+            self._parent.log(name, record.levelname, time, message, stack),
+            name=f"{viam._TASK_PREFIX}-LOG-{record.created}",
+        )
+        task.add_done_callback(lambda t: asyncio.run_coroutine_threadsafe(self.handle_task_result(t), self._worker.get_loop()))
+
+    def close(self):
+        self._worker.stop()
+        super().close()
+
+
+class _ColorFormatter(logging.Formatter):
     MAPPING = {
         "DEBUG": 37,  # white
         "INFO": 36,  # cyan
@@ -17,8 +123,8 @@ class ColorFormatter(logging.Formatter):
         "CRITICAL": 41,  # white on red bg
     }
 
-    def __init__(self, patern):
-        logging.Formatter.__init__(self, patern)
+    def __init__(self, pattern):
+        logging.Formatter.__init__(self, pattern)
 
     def format(self, record):
         colored_record = copy(record)
@@ -43,21 +149,56 @@ def getLogger(name: str) -> logging.Logger:
     return logger
 
 
-def addHandlers(logger: logging.Logger):
-    format = ColorFormatter("%(asctime)s\t\t" + "%(levelname)s\t" + "%(name)s (%(filename)s:%(lineno)d)\t" + "%(message)s\t")
+def addHandlers(logger: logging.Logger, use_default_handlers=False):
+    _addHandlers([logger], use_default_handlers)
+
+
+def update_log_level(logger: logging.Logger, level: Union[int, str]):
+    if level == "":
+        level = LOG_LEVEL
+    logger.setLevel(level)
+    for handler in logger.handlers:
+        handler.setLevel(level)
+
 
-    handler = logging.StreamHandler(stream=sys.stdout)
-    handler.setFormatter(format)
+def _addHandlers(loggers: Iterable[logging.Logger], use_default_handlers=False):
+    format = _ColorFormatter("%(asctime)s\t\t" + "%(levelname)s\t" + "%(name)s (%(filename)s:%(lineno)d)\t" + "%(message)s\t")
+
+    handlers: List[logging.Handler] = []
+
+    std_handler = logging.StreamHandler(stream=sys.stdout)
+    std_handler.setFormatter(format)
     # filter out logs at error level or above
-    handler.setLevel(LOG_LEVEL)
-    handler.addFilter(filter=lambda record: (record.levelno < ERROR))
-    logger.addHandler(handler)
+    std_handler.setLevel(LOG_LEVEL)
+    std_handler.addFilter(filter=lambda record: (record.levelno < ERROR))
 
     err_handler = logging.StreamHandler(stream=sys.stderr)
     err_handler.setFormatter(format)
     # filter out logs below error level
     err_handler.setLevel(max(ERROR, LOG_LEVEL))
-    logger.addHandler(err_handler)
+
+    if _MODULE_PARENT is not None and not use_default_handlers:
+        mod_handler = _ModuleHandler(_MODULE_PARENT)
+        mod_handler.setFormatter(format)
+        mod_handler.setLevel(LOG_LEVEL)
+        handlers = [mod_handler]
+    else:
+        handlers = [std_handler, err_handler]
+
+    for logger in loggers:
+        logger.handlers.clear()
+        if "viam.sessions_client" in LOGGERS and LOGGERS["viam.sessions_client"] == logger:
+            logger.addHandler(std_handler)
+            logger.addHandler(err_handler)
+        else:
+            for h in handlers:
+                logger.addHandler(h)
+
+
+def setParent(parent: "RobotClient"):
+    global _MODULE_PARENT
+    _MODULE_PARENT = parent
+    _addHandlers(LOGGERS.values())
 
 
 def setLevel(level: int):
@@ -65,10 +206,12 @@ def setLevel(level: int):
     LOG_LEVEL = level
     for logger in LOGGERS.values():
         logger.setLevel(LOG_LEVEL)
-        for handler in logger.handlers:
-            logger.removeHandler(handler)
-        addHandlers(logger)
+    _addHandlers(LOGGERS.values())
 
 
 def silence():
     setLevel(FATAL + 1)
+
+
+def shutdown():
+    logging.shutdown()

viam/media/__init__.py

@@ -1,9 +0,0 @@
-from .media import MediaReader, MediaSource, MediaStream, MediaStreamWithIterator, MediaType
-
-__all__ = [
-    "MediaReader",
-    "MediaSource",
-    "MediaStream",
-    "MediaStreamWithIterator",
-    "MediaType",
-]

viam/media/audio.py

@@ -1,16 +1,28 @@
-from dataclasses import dataclass
+from enum import Enum
 
-from viam.media.media import MediaReader, MediaStream
-from viam.proto.component.audioinput import AudioChunk, AudioChunkInfo
 
+class AudioCodec(str, Enum):
+    """Common audio codec identifiers.
 
-@dataclass
-class Audio:
-    """A block of audio data containing information about the block and the audio data"""
+    These constants represent commonly supported audio codecs
+    for audioin and audioout components.
 
-    info: AudioChunkInfo
-    chunk: AudioChunk
+    Example::
 
+        from viam.components.codecs import AudioCodec
+        from viam.proto.common import AudioInfo
 
-AudioReader = MediaReader[Audio]
-AudioStream = MediaStream[Audio]
+        audio_info = AudioInfo(
+            codec=AudioCodec.PCM16,
+            sample_rate_hz=44100,
+            num_channels=2
+        )
+    """
+
+    PCM16 = "pcm16"
+    PCM32 = "pcm32"
+    PCM32_FLOAT = "pcm32_float"
+    MP3 = "mp3"
+    AAC = "aac"
+    OPUS = "opus"
+    FLAC = "flac"

viam/media/utils/pil/__init__.py

@@ -0,0 +1,55 @@
+from io import BytesIO
+
+from PIL import Image
+
+from ....media.video import CameraMimeType, ViamImage
+from .viam_rgba_plugin import RGBA_FORMAT_LABEL
+
+# Formats that are supported by PIL
+LIBRARY_SUPPORTED_FORMATS = ["JPEG", "PNG", RGBA_FORMAT_LABEL]
+
+
+def viam_to_pil_image(image: ViamImage) -> Image.Image:
+    """
+    Convert a ViamImage to a PIL.Image.
+
+    In order to use this function, Pillow must be installed.
+    https://pillow.readthedocs.io/
+
+    Args:
+        image (ViamImage): The image to convert.
+
+    Returns:
+        Image.Image: The resulting PIL.Image
+    """
+    return Image.open(BytesIO(image.data), formats=LIBRARY_SUPPORTED_FORMATS)
+
+
+def pil_to_viam_image(image: Image.Image, mime_type: CameraMimeType) -> ViamImage:
+    """
+    Convert a PIL.Image to a ViamImage.
+
+    In order to use this function, Pillow must be installed.
+    https://pillow.readthedocs.io/
+
+    Args:
+        image (Image.Image): The image to convert.
+        mime_type (CameraMimeType): The mime type to convert the image to.
+
+    Returns:
+        ViamImage: The resulting ViamImage
+    """
+    # Make sure at runtime the mime_type string is actually a CameraMimeType
+    if not isinstance(mime_type, CameraMimeType):
+        raise ValueError(f"Cannot encode to unsupported mimetype: {mime_type}")
+
+    if mime_type.name in LIBRARY_SUPPORTED_FORMATS:
+        buf = BytesIO()
+        if image.mode == "RGBA" and mime_type == CameraMimeType.JPEG:
+            image = image.convert("RGB")
+        image.save(buf, format=mime_type.name)
+        data = buf.getvalue()
+    else:
+        raise ValueError(f"Cannot encode to unsupported mimetype: {mime_type}")
+
+    return ViamImage(data, mime_type)

viam/media/{viam_rgba_plugin.py → utils/pil/viam_rgba_plugin.py}

@@ -1,19 +1,10 @@
-from typing import Tuple
+from typing import ClassVar, Tuple
 
 from PIL import Image
-from PIL.ImageFile import ImageFile, PyDecoder, PyEncoder, _safe_read
-from PIL.ImageFile import _save as image_save
+from PIL.ImageFile import ImageFile, PyDecoder, PyEncoder, _safe_read  # type: ignore -- (njooma) this exists, manually checked
+from PIL.ImageFile import _save as image_save  # type: ignore -- (njooma) this exists, manually checked
 
-# Viam uses a special header prepended to raw RGBA data. The header is composed of a
-# 4-byte magic number followed by a 4-byte line of the width as a uint32 number
-# and another for the height. Credit to Ben Zotto for inventing this formulation
-# https://bzotto.medium.com/introducing-the-rgba-bitmap-file-format-4a8a94329e2c
-
-RGBA_MAGIC_NUMBER = bytes("RGBA", "utf-8")
-
-RGBA_FORMAT_LABEL = "VIAM_RGBA"
-
-RGBA_HEADER_LENGTH = 12
+from ...viam_rgba import RGBA_FORMAT_LABEL, RGBA_HEADER_LENGTH, RGBA_MAGIC_NUMBER
 
 
 def _accept(prefix: str):
@@ -25,7 +16,7 @@ class RGBAEncoder(PyEncoder):
 
     _pushes_fd = True
 
-    def encode(self, bufsize):
+    def encode(self, bufsize):  # pyright: ignore [reportIncompatibleMethodOverride]
         data_arr = bytearray()
         width, height = self.im.size
         for y in range(height):
@@ -46,7 +37,7 @@ def _save_rgba(img, fp, filename):
 
 
 class RGBAImage(ImageFile):
-    format: str = RGBA_FORMAT_LABEL
+    format: ClassVar[str] = RGBA_FORMAT_LABEL  # pyright: ignore [reportIncompatibleVariableOverride]
     format_description = "Viam's Raw RGBA Format"
 
     def _open(self):
@@ -55,7 +46,10 @@ class RGBAImage(ImageFile):
         width = int.from_bytes(header[4:8], "big")
         height = int.from_bytes(header[8:12], "big")
         self._size = width, height
-        self.mode = "RGBA"
+        if hasattr(self, "_mode"):
+            self._mode = "RGBA"
+        else:
+            self.mode = "RGBA"  # type: ignore -- (njooma) newer versions of PIL hide this behind _mode, which is why we check
 
         # data descriptor
         self.tile = [(RGBAEncoder.ENCODER_NAME, (0, 0, width, height), RGBA_HEADER_LENGTH, (self.mode, 0, 1))]

viam/media/viam_rgba.py

@@ -0,0 +1,10 @@
+# Viam uses a special header prepended to raw RGBA data. The header is composed of a
+# 4-byte magic number followed by a 4-byte line of the width as a uint32 number
+# and another for the height. Credit to Ben Zotto for inventing this formulation
+# https://bzotto.medium.com/introducing-the-rgba-bitmap-file-format-4a8a94329e2c
+
+RGBA_MAGIC_NUMBER = bytes("RGBA", "utf-8")
+
+RGBA_FORMAT_LABEL = "VIAM_RGBA"
+
+RGBA_HEADER_LENGTH = 12