@camera.ui/server 0.0.49 → 0.0.50-internal.0

package/dist/server/src/_camera_ui_tools/camera_ui_common/common_utils/thread.py

@@ -0,0 +1,10 @@
+import asyncio
+from concurrent.futures import ThreadPoolExecutor
+from typing import Any
+
+toThreadExecutor: ThreadPoolExecutor = ThreadPoolExecutor(max_workers=2, thread_name_prefix="worker")
+
+
+async def to_thread(f: Any) -> Any:
+    loop = asyncio.get_running_loop()
+    return await loop.run_in_executor(toThreadExecutor, f)

package/dist/server/src/_camera_ui_tools/camera_ui_common/common_utils/utils.py

@@ -0,0 +1,91 @@
+import asyncio
+import copy
+from collections.abc import Coroutine
+from typing import Any, Callable, Optional, ParamSpec, TypeVar, Union, cast
+
+TSource = TypeVar("TSource", bound=Union[dict[Any, Any], list[Any], Any])
+TTarget = TypeVar("TTarget", bound=Union[dict[Any, Any], list[Any], Any])
+TKey = Union[str, int, None]
+Customizer = Callable[[Any, Any, TKey, TSource, TTarget, list[dict[Any, Any]]], Any]
+
+R = TypeVar("R")
+P = ParamSpec("P")
+
+
+def make_sync(async_func: Callable[P, Coroutine[Any, Any, R]]) -> Callable[P, R]:
+    def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+        try:
+            loop = asyncio.get_running_loop()
+            return asyncio.run_coroutine_threadsafe(async_func(*args, **kwargs), loop).result()
+        except RuntimeError:
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            return loop.run_until_complete(async_func(*args, **kwargs))
+
+    return wrapper
+
+
+def merge_with(
+    source_object: TSource,
+    target_object: Optional[TTarget],
+    customizer: Optional[Customizer[Any, Any]] = None,
+    stack: Optional[list[dict[Any, Any]]] = None,
+) -> Union[TSource, TTarget]:
+    if stack is None:
+        stack = []
+
+    if isinstance(source_object, list) and isinstance(target_object, list):
+        customized_value = (
+            customizer(source_object, target_object, None, source_object, target_object, stack)
+            if customizer
+            else None
+        )
+        if customized_value is not None:
+            return cast(Union[TSource, TTarget], customized_value)
+        else:
+            return cast(Union[TSource, TTarget], source_object + target_object)
+
+    if isinstance(source_object, dict) and isinstance(target_object, dict):
+        for key in target_object:
+            obj_value = source_object.get(key)
+            src_value = target_object[key]
+
+            stack.append({"key": key, "source_object": source_object, "target_object": target_object})
+
+            customized_value = (
+                customizer(obj_value, src_value, key, source_object, target_object, stack)
+                if customizer
+                else None
+            )
+
+            if customized_value is not None:
+                source_object[key] = customized_value
+            elif isinstance(obj_value, (dict, list)) and isinstance(src_value, (dict, list)):
+                source_object[key] = merge_with(
+                    copy.deepcopy(cast(Any, obj_value)),
+                    cast(Any, src_value),
+                    customizer,
+                    stack,
+                )
+            else:
+                source_object[key] = src_value
+
+            stack.pop()
+    else:
+        if not isinstance(target_object, (dict, list)):
+            return source_object
+
+    return source_object
+
+
+def merge(
+    source: Any,
+    target: Any,
+    key: TKey,
+    source_object: Union[dict[Any, Any], list[Any], Any],  # TSource
+    target_object: Union[dict[Any, Any], list[Any], Any],  # TTarget
+    stack: list[Any],
+) -> Any:
+    if isinstance(source, list):
+        return target
+    return None

package/dist/server/src/_camera_ui_tools/camera_ui_common/logger_service/ansicolor.py

@@ -0,0 +1,62 @@
+class AnsicolorMethods:
+    start_code: str
+    end_code: str
+
+    def __init__(self, start_code: str, end_code: str = "39") -> None:
+        self.start_code = start_code
+        self.end_code = end_code
+
+    def __call__(self, text: str) -> str:
+        return f"\033[{self.start_code}m{text}\033[{self.end_code}m"
+
+
+class Ansicolor:
+    # Foreground colors
+    default: AnsicolorMethods = AnsicolorMethods("39")
+    white: AnsicolorMethods = AnsicolorMethods("97")
+    black: AnsicolorMethods = AnsicolorMethods("30")
+    red: AnsicolorMethods = AnsicolorMethods("31")
+    green: AnsicolorMethods = AnsicolorMethods("32")
+    yellow: AnsicolorMethods = AnsicolorMethods("33")
+    blue: AnsicolorMethods = AnsicolorMethods("34")
+    magenta: AnsicolorMethods = AnsicolorMethods("35")
+    cyan: AnsicolorMethods = AnsicolorMethods("36")
+
+    darkGray: AnsicolorMethods = AnsicolorMethods("90")
+    lightGray: AnsicolorMethods = AnsicolorMethods("37")
+    lightRed: AnsicolorMethods = AnsicolorMethods("91")
+    lightGreen: AnsicolorMethods = AnsicolorMethods("92")
+    lightYellow: AnsicolorMethods = AnsicolorMethods("93")
+    lightBlue: AnsicolorMethods = AnsicolorMethods("94")
+    lightMagenta: AnsicolorMethods = AnsicolorMethods("95")
+    lightCyan: AnsicolorMethods = AnsicolorMethods("96")
+
+    # Text styles
+    bright: AnsicolorMethods = AnsicolorMethods("1", "22")
+    dim: AnsicolorMethods = AnsicolorMethods("2", "22")
+    italic: AnsicolorMethods = AnsicolorMethods("3", "23")
+    underline: AnsicolorMethods = AnsicolorMethods("4", "24")
+    inverse: AnsicolorMethods = AnsicolorMethods("7", "27")
+
+    # Background colors
+    bgDefault: AnsicolorMethods = AnsicolorMethods("49", "49")
+    bgWhite: AnsicolorMethods = AnsicolorMethods("107", "49")
+    bgBlack: AnsicolorMethods = AnsicolorMethods("40", "49")
+    bgRed: AnsicolorMethods = AnsicolorMethods("41", "49")
+    bgGreen: AnsicolorMethods = AnsicolorMethods("42", "49")
+    bgYellow: AnsicolorMethods = AnsicolorMethods("43", "49")
+    bgBlue: AnsicolorMethods = AnsicolorMethods("44", "49")
+    bgMagenta: AnsicolorMethods = AnsicolorMethods("45", "49")
+    bgCyan: AnsicolorMethods = AnsicolorMethods("46", "49")
+
+    bgDarkGray: AnsicolorMethods = AnsicolorMethods("100", "49")
+    bgLightGray: AnsicolorMethods = AnsicolorMethods("47", "49")
+    bgLightRed: AnsicolorMethods = AnsicolorMethods("101", "49")
+    bgLightGreen: AnsicolorMethods = AnsicolorMethods("102", "49")
+    bgLightYellow: AnsicolorMethods = AnsicolorMethods("103", "49")
+    bgLightBlue: AnsicolorMethods = AnsicolorMethods("104", "49")
+    bgLightMagenta: AnsicolorMethods = AnsicolorMethods("105", "49")
+    bgLightCyan: AnsicolorMethods = AnsicolorMethods("106", "49")
+
+
+ansicolor: Ansicolor = Ansicolor()

package/dist/server/src/_camera_ui_tools/camera_ui_common/logger_service/logger.py

@@ -0,0 +1,178 @@
+import json
+import traceback
+from datetime import datetime
+from typing import Any, Callable, Optional, TypedDict, cast
+
+from .ansicolor import ansicolor
+
+
+class LoggerOptions(TypedDict, total=False):
+    prefix: Optional[str]
+    suffix: Optional[str]
+    disable_timestamps: Optional[bool]
+    debug_enabled: Optional[bool]
+    trace_enabled: Optional[bool]
+    logger_id: Optional[str]
+    disable_prefix: Optional[bool]
+
+
+class LoggerService:
+    __LOGGER_ID_PREFIX = "##LOG_ID::"
+    __LOGGER_ID_SUFFIX = "::LOG_ID_END##"
+    __LOGGER_END = "##LOG_END##"
+
+    prefix: str
+    suffix: Optional[str]
+    logger_id: Optional[str]
+    disable_prefix: Optional[bool]
+
+    disable_timestamps: bool
+    debug_enabled: bool
+    trace_enabled: bool
+
+    def __init__(self, options: Optional[LoggerOptions] = None) -> None:
+        self.prefix = cast(str, options.get("prefix", "camera.ui") if options else "camera.ui")
+        self.suffix = options.get("suffix") if options else None
+        self.logger_id = options.get("logger_id") if options else None
+        self.disable_prefix = options.get("disable_prefix", False) if options else False
+
+        self.disable_timestamps = cast(bool, options.get("disable_timestamps", False) if options else False)
+        self.debug_enabled = cast(bool, options.get("debug_enabled", False) if options else False)
+        self.trace_enabled = cast(bool, options.get("trace_enabled", False) if options else False)
+
+    def create_logger(self, options: Optional[LoggerOptions] = None) -> "LoggerService":
+        logger_options: LoggerOptions = {
+            "prefix": options.get("prefix", self.prefix) if options else self.prefix,
+            "suffix": options.get("suffix", self.suffix) if options else self.suffix,
+            "disable_timestamps": options.get("disable_timestamps", self.disable_timestamps)
+            if options
+            else self.disable_timestamps,
+            "debug_enabled": options.get("debug_enabled", self.debug_enabled)
+            if options
+            else self.debug_enabled,
+            "trace_enabled": options.get("trace_enabled", self.trace_enabled)
+            if options
+            else self.trace_enabled,
+            "logger_id": options.get("logger_id", self.logger_id) if options else self.logger_id,
+            "disable_prefix": options.get("disable_prefix", False) if options else False,
+        }
+        return LoggerService(logger_options)
+
+    @property
+    def logger_prefix(self) -> list[str]:
+        logger_id = (
+            f"{self.__LOGGER_ID_PREFIX}{self.logger_id}{self.__LOGGER_ID_SUFFIX}" if self.logger_id else ""
+        )
+
+        timestamp = "" if self.disable_timestamps else f"[{self.__format_date_time()}]"
+        prefix = ansicolor.blue(f"[{self.prefix}]") if not self.disable_prefix else ""
+        suffix = ansicolor.cyan(f"[{self.suffix}]") if self.suffix else ""
+        prefixes = [logger_id + timestamp, prefix, suffix]
+
+        return [x for x in prefixes if x != ""]
+
+    def log(self, *args: Any) -> None:
+        message = self.__format_message("log", *args)
+        print(*message)
+
+    def error(self, *args: Any) -> None:
+        message = self.__format_message("error", *args)
+        print(*message)
+
+    def warn(self, *args: Any) -> None:
+        message = self.__format_message("warn", *args)
+        print(*message)
+
+    def success(self, *args: Any) -> None:
+        message = self.__format_message("success", *args)
+        print(*message)
+
+    def attention(self, *args: Any) -> None:
+        message = self.__format_message("attention", *args)
+        print(*message)
+
+    def debug(self, *args: Any) -> None:
+        if not self.debug_enabled:
+            return
+        message = self.__format_message("debug", *args)
+        print(*message)
+
+    def trace(self, *args: Any) -> None:
+        if not self.trace_enabled:
+            return
+        message = self.__format_message("trace", *args)
+        print(*message)
+
+    def __format_message(self, level: str, *args: Any) -> list[str]:
+        formatted_args = self.__formatted_args(*args)
+        message = []
+
+        if level == "debug":
+            message = [*self.logger_prefix] + [
+                self.__format_multiline(arg, ansicolor.darkGray) for arg in formatted_args
+            ]
+        elif level == "warn":
+            message = [
+                *self.logger_prefix,
+                ansicolor.bgYellow(" WARN "),
+                *[self.__format_multiline(arg, ansicolor.yellow) for arg in formatted_args],
+            ]
+        elif level == "error":
+            message = [
+                *self.logger_prefix,
+                ansicolor.bgRed(" ERROR "),
+                *[self.__format_multiline(arg, ansicolor.red) for arg in formatted_args],
+            ]
+        elif level == "success":
+            message = [
+                *self.logger_prefix,
+                ansicolor.bgGreen(" SUCCESS "),
+                *[self.__format_multiline(arg, ansicolor.green) for arg in formatted_args],
+            ]
+        elif level == "trace":
+            message = [
+                *self.logger_prefix,
+                ansicolor.bgDarkGray(" TRACE "),
+                *[self.__format_multiline(arg, ansicolor.darkGray) for arg in formatted_args],
+            ]
+        elif level == "attention":
+            message = [
+                *self.logger_prefix,
+                ansicolor.bgMagenta(" ATTENTION "),
+                *[self.__format_multiline(arg, ansicolor.magenta) for arg in formatted_args],
+            ]
+        else:
+            message = [*self.logger_prefix] + [self.__format_multiline(arg) for arg in formatted_args]
+
+        if self.logger_id:
+            message.append(self.__LOGGER_END)
+
+        return message
+
+    def __format_multiline(self, arg: str, color_func: Optional[Callable[..., Any]] = None) -> str:
+        if not color_func:
+            return arg
+
+        lines = arg.split("\n")
+        colored_lines = [color_func(line) for line in lines]
+        return "\n".join(colored_lines)
+
+    def __formatted_args(self, *args: Any) -> list[str]:
+        formatted_args: list[str] = []
+        for arg in args:
+            if isinstance(arg, BaseException):
+                message = str(arg).split("\n")[0].strip() if str(arg) else "Unknown error"
+                error_traceback = traceback.format_exc().rstrip()
+                formatted_args.append(message)
+                formatted_args.append(f"\n{error_traceback}")
+            elif isinstance(arg, (dict, list)):
+                formatted_args.append(json.dumps(arg, indent=2))
+            else:
+                formatted_args.append(str(arg))
+        return formatted_args
+
+    def __format_date_time(self) -> str:
+        try:
+            return datetime.now().strftime("%d.%m.%Y, %H:%M:%S")
+        except:  # noqa
+            return "Unknown"

package/dist/server/src/_camera_ui_tools/camera_ui_common/logger_service/test.py

@@ -0,0 +1,116 @@
+import asyncio
+from typing import Any
+
+from logger import LoggerService
+
+
+async def test_logger():
+    # Logger mit verschiedenen Optionen
+    logger = LoggerService(
+        {"prefix": "TestLogger", "suffix": "DEV", "debug_enabled": True, "trace_enabled": True}
+    )
+
+    print("\n=== Basis Tests ===\n")
+
+    # Einfache Werte
+    logger.log("Einfacher String")
+    logger.log(123)
+    logger.log(True)
+    logger.log(None)
+    logger.log(None)  # undefined gibt es in Python nicht, nutzen wir None
+
+    print("\n=== Array Tests ===\n")
+
+    # Arrays (Listen in Python)
+    logger.log([1, 2, 3])
+    logger.log(["a", "b", {"test": "nested"}])
+
+    # Verschachteltes Array
+    nested_array = [1, [2, [3, [4]]]]
+    logger.log(nested_array)
+
+    print("\n=== Objekt Tests ===\n")
+
+    # Einfaches Objekt (Dict in Python)
+    logger.log({"name": "Test", "value": 42})
+
+    # Komplexes Objekt
+    complex_obj = {
+        "string": "text",
+        "number": 42,
+        "boolean": True,
+        "null": None,
+        "undefined": None,
+        "array": [1, 2, 3],
+        "nested": {"a": 1, "b": 2, "c": {"d": 3}},
+    }
+    logger.log(complex_obj)
+
+    print("\n=== Zirkuläre Referenz Tests ===\n")
+
+    # Zirkuläre Referenz in Objekt
+    circular: dict[str, Any] = {"a": 1, "b": 2}
+    circular["self"] = circular
+    logger.log(circular)
+
+    # Zirkuläre Referenz in Array
+    circular_array: list[Any] = [1, 2, 3]
+    circular_array.append(circular_array)
+    logger.log(circular_array)
+
+    # Mehrfache zirkuläre Referenzen
+    obj1: dict[str, Any] = {"name": "obj1"}
+    obj2: dict[str, Any] = {"name": "obj2"}
+    obj1["ref"] = obj2
+    obj2["ref"] = obj1
+    logger.log(obj1)
+
+    print("\n=== Error Tests ===\n")
+
+    # Standard Error
+    try:
+        raise Exception("Test Error")
+    except Exception as original_error:
+        logger.error(original_error)
+
+    print("\n=== Spezielle Objekt Tests ===\n")
+
+    # Dict (statt Map)
+    map_dict = {"key1": "value1", "key2": {"nested": "value2"}}
+    logger.log(map_dict)
+
+    # Set
+    test_set = {1, 2, "test"}  # Note: In Python können Sets keine Dicts enthalten
+    logger.log(test_set)
+
+    # Future (statt Promise)
+    loop = asyncio.get_event_loop()
+    future = loop.create_future()
+    future.set_result("test")
+    logger.log(future)
+
+    print("\n=== Log Level Tests ===\n")
+
+    # Verschiedene Log-Level
+    logger.log("Standard Log")
+    logger.error("Error Message")
+    logger.warn("Warning Message")
+    logger.debug("Debug Message")
+    logger.trace("Trace Message")
+    logger.attention("Attention Message")
+    logger.success("Success Message")
+
+    print("\n=== Kombinations Tests ===\n")
+
+    # Mehrere Argumente
+    logger.log("String", 123, {"test": "object"}, ["array"])
+
+    # Alles zusammen
+    logger.log(
+        "Mixed Content", 123, {"obj": "test"}, ["array"], Exception("Test Error"), circular, map_dict, future
+    )
+
+
+# Test ausführen
+if __name__ == "__main__":
+    asyncio.run(test_logger())