mm-std 0.4.18__py3-none-any.whl → 0.5.1__py3-none-any.whl

mm_std/concurrency/async_task_runner.py

@@ -1,126 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import logging
-from collections.abc import Awaitable
-from dataclasses import dataclass
-from typing import Any
-
-logger = logging.getLogger(__name__)
-
-
-class AsyncTaskRunner:
-    """
-    AsyncTaskRunner executes a batch of asynchronous tasks with controlled concurrency.
-    Note: This runner is designed for one-time use. Create a new instance for each batch of tasks.
-    """
-
-    @dataclass
-    class Result:
-        results: dict[str, Any]  # Maps task_id to result
-        exceptions: dict[str, Any]  # Maps task_id to exception (if any)
-        is_ok: bool  # True if no exception and no timeout occurred
-        is_timeout: bool  # True if at least one task was cancelled due to timeout
-
-    @dataclass
-    class Task:
-        """Individual task representation"""
-
-        task_id: str
-        awaitable: Awaitable[Any]
-
-    def __init__(
-        self, max_concurrent_tasks: int, timeout: float | None = None, name: str | None = None, no_logging: bool = False
-    ) -> None:
-        """
-        :param max_concurrent_tasks: Maximum number of tasks that can run concurrently.
-        :param timeout: Optional overall timeout in seconds for running all tasks.
-        :param name: Optional name for the runner.
-        :param no_logging: If True, suppresses logging for task exception.
-        """
-        if timeout is not None and timeout <= 0:
-            raise ValueError("Timeout must be positive if specified.")
-        self.max_concurrent_tasks: int = max_concurrent_tasks
-        self.timeout: float | None = timeout
-        self.name = name
-        self.no_logging = no_logging
-        self.semaphore: asyncio.Semaphore = asyncio.Semaphore(max_concurrent_tasks)
-        self._tasks: list[AsyncTaskRunner.Task] = []
-        self._was_run: bool = False
-        self._task_ids: set[str] = set()
-
-    def add_task(
-        self,
-        task_id: str,
-        awaitable: Awaitable[Any],
-    ) -> None:
-        """
-        Adds a task to the runner that will be executed when run() is called.
-
-        :param task_id: Unique identifier for the task.
-        :param awaitable: The awaitable (coroutine) to execute.
-        :raises RuntimeError: If the runner has already been used.
-        :raises ValueError: If task_id is empty or already exists.
-        """
-        if self._was_run:
-            raise RuntimeError("This AsyncTaskRunner has already been used. Create a new instance for new tasks.")
-
-        if not task_id:
-            raise ValueError("Task ID cannot be empty")
-
-        if task_id in self._task_ids:
-            raise ValueError(f"Task ID '{task_id}' already exists. All task IDs must be unique.")
-
-        self._task_ids.add(task_id)
-        self._tasks.append(AsyncTaskRunner.Task(task_id, awaitable))
-
-    def _task_name(self, task_id: str) -> str:
-        return f"{self.name}-{task_id}" if self.name else task_id
-
-    async def run(self) -> AsyncTaskRunner.Result:
-        """
-        Executes all added tasks with concurrency limited by the semaphore.
-        If a timeout is specified, non-finished tasks are cancelled.
-
-        :return: AsyncTaskRunner.Result containing task results, exceptions, and flags indicating overall status.
-        :raises RuntimeError: If the runner has already been used.
-        """
-        if self._was_run:
-            raise RuntimeError("This AsyncTaskRunner instance can only be run once. Create a new instance for new tasks.")
-
-        self._was_run = True
-        results: dict[str, Any] = {}
-        exceptions: dict[str, Any] = {}
-        is_timeout: bool = False
-
-        async def run_task(task: AsyncTaskRunner.Task) -> None:
-            async with self.semaphore:
-                try:
-                    res: Any = await task.awaitable
-                    results[task.task_id] = res
-                except Exception as e:
-                    if not self.no_logging:
-                        logger.exception("Task raised an exception", extra={"task_id": task.task_id})
-                    exceptions[task.task_id] = e
-
-        # Create asyncio tasks for all runner tasks
-        tasks = [asyncio.create_task(run_task(task), name=self._task_name(task.task_id)) for task in self._tasks]
-
-        try:
-            if self.timeout is not None:
-                # Run with timeout
-                await asyncio.wait_for(asyncio.gather(*tasks), timeout=self.timeout)
-            else:
-                # Run without timeout
-                await asyncio.gather(*tasks)
-        except TimeoutError:
-            # Cancel all running tasks on timeout
-            for task in tasks:
-                if not task.done():
-                    task.cancel()
-            # Wait for tasks to complete cancellation
-            await asyncio.gather(*tasks, return_exceptions=True)
-            is_timeout = True
-
-        is_ok: bool = (not exceptions) and (not is_timeout)
-        return AsyncTaskRunner.Result(results=results, exceptions=exceptions, is_ok=is_ok, is_timeout=is_timeout)

mm_std/concurrency/sync_decorators.py

@@ -1,35 +0,0 @@
-import functools
-from collections import defaultdict
-from collections.abc import Callable
-from threading import Lock
-
-
-def synchronized_parameter[T, **P](arg_index: int = 0, skip_if_locked: bool = False) -> Callable[..., Callable[P, T | None]]:
-    locks: dict[object, Lock] = defaultdict(Lock)
-
-    def outer(func: Callable[P, T]) -> Callable[P, T | None]:
-        @functools.wraps(func)
-        def wrapper(*args: P.args, **kwargs: P.kwargs) -> T | None:
-            if skip_if_locked and locks[args[arg_index]].locked():
-                return None
-            try:
-                with locks[args[arg_index]]:
-                    return func(*args, **kwargs)
-            finally:
-                locks.pop(args[arg_index], None)
-
-        wrapper.locks = locks  # type: ignore[attr-defined]
-        return wrapper
-
-    return outer
-
-
-def synchronized[T, **P](fn: Callable[P, T]) -> Callable[P, T]:
-    lock = Lock()
-
-    @functools.wraps(fn)
-    def wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
-        with lock:
-            return fn(*args, **kwargs)
-
-    return wrapper

mm_std/concurrency/sync_scheduler.py

@@ -1,73 +0,0 @@
-import time
-from dataclasses import dataclass, field
-from datetime import datetime
-from logging import Logger
-from threading import Thread
-
-from mm_std.date import is_too_old, utc_now
-from mm_std.types_ import Func
-
-
-class Scheduler:
-    def __init__(self, log: Logger, loop_delay: float = 0.5, debug: bool = False) -> None:
-        self.log = log
-        self.debug = debug
-        self.loop_delay = loop_delay
-        self.stopped = False
-        self.jobs: list[Scheduler.Job] = []
-        self.run_immediately_jobs: list[Scheduler.Job] = []
-        self._debug("init")
-
-    @dataclass
-    class Job:
-        func: Func
-        args: tuple[object, ...]
-        interval: int
-        is_running: bool = False
-        last_at: datetime = field(default_factory=utc_now)
-
-        def __str__(self) -> str:
-            return str(self.func)
-
-    def add_job(self, func: Func, interval: int, args: tuple[object, ...] = (), run_immediately: bool = False) -> None:
-        job = Scheduler.Job(func, args, interval)
-        self.jobs.append(job)
-        if run_immediately:
-            self.run_immediately_jobs.append(job)
-
-    def _run_job(self, job: Job) -> None:
-        self._debug(f"_run_job: {job}")
-        if self.stopped:
-            return
-        try:
-            job.func(*job.args)
-            self._debug(f"_run_job: {job} done")
-        except Exception:
-            self.log.exception("scheduler error")
-            self._debug(f"_run_job: {job} error")
-        finally:
-            job.is_running = False
-
-    def _start(self) -> None:
-        self._debug(f"_start: jobs={len(self.jobs)}, run_immediately_jobs={len(self.run_immediately_jobs)}")
-        for j in self.run_immediately_jobs:
-            j.is_running = True
-            j.last_at = utc_now()
-            Thread(target=self._run_job, args=(j,)).start()
-        while not self.stopped:
-            for j in self.jobs:
-                if not j.is_running and is_too_old(j.last_at, j.interval):
-                    j.is_running = True
-                    j.last_at = utc_now()
-                    Thread(target=self._run_job, args=(j,)).start()
-            time.sleep(self.loop_delay)
-
-    def _debug(self, message: str) -> None:
-        if self.debug:
-            self.log.debug("Scheduler: %s", message)
-
-    def start(self) -> None:
-        Thread(target=self._start).start()
-
-    def stop(self) -> None:
-        self.stopped = True

mm_std/concurrency/sync_task_runner.py

@@ -1,45 +0,0 @@
-import concurrent
-from concurrent.futures import ThreadPoolExecutor
-from dataclasses import dataclass
-
-from mm_std.types_ import Args, Func, Kwargs
-
-
-class ConcurrentTasks:
-    def __init__(self, max_workers: int = 5, timeout: int | None = None, thread_name_prefix: str = "concurrent_tasks") -> None:
-        self.max_workers = max_workers
-        self.timeout = timeout
-        self.thread_name_prefix = thread_name_prefix
-        self.tasks: list[ConcurrentTasks.Task] = []
-        self.exceptions: dict[str, Exception] = {}
-        self.error = False
-        self.timeout_error = False
-        self.result: dict[str, object] = {}
-
-    @dataclass
-    class Task:
-        key: str
-        func: Func
-        args: Args
-        kwargs: Kwargs
-
-    def add_task(self, key: str, func: Func, args: Args = (), kwargs: Kwargs | None = None) -> None:
-        if kwargs is None:
-            kwargs = {}
-        self.tasks.append(ConcurrentTasks.Task(key, func, args, kwargs))
-
-    def execute(self) -> None:
-        with ThreadPoolExecutor(self.max_workers, thread_name_prefix=self.thread_name_prefix) as executor:
-            future_to_key = {executor.submit(task.func, *task.args, **task.kwargs): task.key for task in self.tasks}
-            try:
-                result_map = concurrent.futures.as_completed(future_to_key, timeout=self.timeout)
-                for future in result_map:
-                    key = future_to_key[future]
-                    try:
-                        self.result[key] = future.result()
-                    except Exception as err:
-                        self.error = True
-                        self.exceptions[key] = err
-            except concurrent.futures.TimeoutError:
-                self.error = True
-                self.timeout_error = True

mm_std/config.py

@@ -1,81 +0,0 @@
-import sys
-import tomllib
-from pathlib import Path
-from typing import Any, NoReturn, Self, TypeVar
-
-from pydantic import BaseModel, ConfigDict, ValidationError
-
-from .print_ import print_json, print_plain
-from .result import Result
-from .zip import read_text_from_zip_archive
-
-T = TypeVar("T", bound="BaseConfig")
-
-
-class BaseConfig(BaseModel):
-    model_config = ConfigDict(extra="forbid")
-
-    def print_and_exit(self, exclude: set[str] | None = None, count: set[str] | None = None) -> NoReturn:
-        data = self.model_dump(exclude=exclude)
-        if count:
-            for k in count:
-                data[k] = len(data[k])
-        print_json(data)
-        sys.exit(0)
-
-    @classmethod
-    def read_toml_config_or_exit(cls, config_path: Path, zip_password: str = "") -> Self:  # nosec
-        res: Result[Self] = cls.read_toml_config(config_path, zip_password)
-        if res.is_ok():
-            return res.unwrap()
-        cls._print_error_and_exit(res)
-
-    @classmethod
-    async def read_toml_config_or_exit_async(cls, config_path: Path, zip_password: str = "") -> Self:  # nosec
-        res: Result[Self] = await cls.read_toml_config_async(config_path, zip_password)
-        if res.is_ok():
-            return res.unwrap()
-        cls._print_error_and_exit(res)
-
-    @classmethod
-    def read_toml_config(cls, config_path: Path, zip_password: str = "") -> Result[Self]:  # nosec
-        try:
-            config_path = config_path.expanduser()
-            if config_path.name.endswith(".zip"):
-                data = tomllib.loads(read_text_from_zip_archive(config_path, password=zip_password))
-            else:
-                with config_path.open("rb") as f:
-                    data = tomllib.load(f)
-            return Result.ok(cls(**data))
-        except ValidationError as e:
-            return Result.err(("validator_error", e), extra={"errors": e.errors()})
-        except Exception as e:
-            return Result.err(e)
-
-    @classmethod
-    async def read_toml_config_async(cls, config_path: Path, zip_password: str = "") -> Result[Self]:  # nosec
-        try:
-            config_path = config_path.expanduser()
-            if config_path.name.endswith(".zip"):
-                data = tomllib.loads(read_text_from_zip_archive(config_path, password=zip_password))
-            else:
-                with config_path.open("rb") as f:
-                    data = tomllib.load(f)
-            model = await cls.model_validate(data)  # type:ignore[misc]
-            return Result.ok(model)
-        except ValidationError as e:
-            return Result.err(("validator_error", e), extra={"errors": e.errors()})
-        except Exception as e:
-            return Result.err(e)
-
-    @classmethod
-    def _print_error_and_exit(cls, res: Result[Any]) -> NoReturn:
-        if res.error == "validator_error" and res.extra:
-            print_plain("config validation errors")
-            for e in res.extra["errors"]:
-                loc = e["loc"]
-                field = ".".join(str(lo) for lo in loc) if len(loc) > 0 else ""
-                print_plain(f"{field} {e['msg']}")
-        else:
-            print_plain(f"can't parse config file: {res.error} {res.exception}")
-        sys.exit(1)

mm_std/crypto/fernet.py

@@ -1,13 +0,0 @@
-from cryptography.fernet import Fernet
-
-
-def fernet_generate_key() -> str:
-    return Fernet.generate_key().decode()
-
-
-def fernet_encrypt(*, data: str, key: str) -> str:
-    return Fernet(key).encrypt(data.encode()).decode()
-
-
-def fernet_decrypt(*, encoded_data: str, key: str) -> str:
-    return Fernet(key).decrypt(encoded_data).decode()

mm_std/crypto/openssl.py

@@ -1,109 +0,0 @@
-import base64
-import secrets
-from hashlib import pbkdf2_hmac
-
-from cryptography.hazmat.primitives import padding
-from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
-
-
-class OpensslAes256Cbc:
-    """
-    AES-256-CBC encryption/decryption compatible with OpenSSL's `enc -aes-256-cbc -pbkdf2 -iter 1000000`.
-
-    Provides both raw-byte and Base64-encoded interfaces:
-      • encrypt_bytes / decrypt_bytes: work with bytes
-      • encrypt_base64 / decrypt_base64: work with Base64 strings
-
-    Usage:
-        >>> cipher = OpensslAes256Cbc(password="mypassword")
-        >>> # raw bytes
-        >>> ciphertext = cipher.encrypt_bytes(b"secret")
-        >>> plaintext = cipher.decrypt_bytes(ciphertext)
-        >>> # Base64 convenience
-        >>> token = cipher.encrypt_base64("secret message")
-        >>> result = cipher.decrypt_base64(token)
-        >>> print(result)
-        secret message
-
-    OpenSSL compatibility:
-        echo "secret message" |
-          openssl enc -aes-256-cbc -pbkdf2 -iter 1000000 -salt -base64 -pass pass:mypassword
-
-        echo "U2FsdGVkX1/dGGdg6SExWgtKxvuLroWqhezy54aTt1g=" |
-          openssl enc -d -aes-256-cbc -pbkdf2 -iter 1000000 -base64 -pass pass:mypassword
-    """
-
-    MAGIC_HEADER = b"Salted__"
-    SALT_SIZE = 8
-    KEY_SIZE = 32  # AES-256
-    IV_SIZE = 16  # AES block size
-    ITERATIONS = 1_000_000
-    HEADER_LEN = len(MAGIC_HEADER)
-
-    def __init__(self, password: str) -> None:
-        """
-        Initialize the cipher with password. Uses a fixed iteration count of 1,000,000.
-
-        Args:
-            password: Password for encryption/decryption
-        """
-        self._password = password.encode("utf-8")
-
-    def _derive_key_iv(self, salt: bytes) -> tuple[bytes, bytes]:
-        key_iv = pbkdf2_hmac(
-            hash_name="sha256", password=self._password, salt=salt, iterations=self.ITERATIONS, dklen=self.KEY_SIZE + self.IV_SIZE
-        )
-        return key_iv[: self.KEY_SIZE], key_iv[self.KEY_SIZE :]
-
-    def encrypt_bytes(self, plaintext: bytes) -> bytes:
-        """Encrypt raw bytes and return encrypted bytes (OpenSSL compatible)."""
-        salt = secrets.token_bytes(self.SALT_SIZE)
-        key, iv = self._derive_key_iv(salt)
-
-        padder = padding.PKCS7(algorithms.AES.block_size).padder()
-        padded = padder.update(plaintext) + padder.finalize()
-
-        cipher = Cipher(algorithms.AES(key), modes.CBC(iv))
-        encryptor = cipher.encryptor()
-        ciphertext = encryptor.update(padded) + encryptor.finalize()
-
-        return self.MAGIC_HEADER + salt + ciphertext
-
-    def decrypt_bytes(self, encrypted: bytes) -> bytes:
-        """Decrypt raw encrypted bytes (as produced by encrypt_bytes)."""
-        if not encrypted.startswith(self.MAGIC_HEADER):
-            raise ValueError("Invalid format: missing OpenSSL salt header")
-
-        salt = encrypted[self.HEADER_LEN : self.HEADER_LEN + self.SALT_SIZE]
-        ciphertext = encrypted[self.HEADER_LEN + self.SALT_SIZE :]
-
-        key, iv = self._derive_key_iv(salt)
-        cipher = Cipher(algorithms.AES(key), modes.CBC(iv))
-        decryptor = cipher.decryptor()
-
-        try:
-            padded = decryptor.update(ciphertext) + decryptor.finalize()
-        except ValueError as exc:
-            raise ValueError("Decryption failed: wrong password or corrupted data") from exc
-
-        unpadder = padding.PKCS7(algorithms.AES.block_size).unpadder()
-        try:
-            data = unpadder.update(padded) + unpadder.finalize()
-        except ValueError as exc:
-            raise ValueError("Decryption failed: wrong password or corrupted data") from exc
-
-        return data
-
-    def encrypt_base64(self, plaintext: str) -> str:
-        """Encrypt a UTF-8 string and return Base64-encoded encrypted data."""
-        raw = self.encrypt_bytes(plaintext.encode("utf-8"))
-        return base64.b64encode(raw).decode("ascii")
-
-    def decrypt_base64(self, b64_encoded: str) -> str:
-        """Decode Base64, decrypt bytes, and return UTF-8 string."""
-        try:
-            raw = base64.b64decode(b64_encoded.strip())
-        except Exception as exc:
-            raise ValueError("Invalid base64 format") from exc
-        plaintext_bytes = self.decrypt_bytes(raw)
-        return plaintext_bytes.decode("utf-8")

mm_std/dict.py

@@ -1,49 +0,0 @@
-from collections import defaultdict
-from collections.abc import Mapping, MutableMapping
-from typing import TypeVar, cast
-
-K = TypeVar("K")
-V = TypeVar("V")
-DictType = TypeVar("DictType", bound=MutableMapping[K, V])  # type: ignore[valid-type]
-
-
-def replace_empty_dict_entries(
-    data: DictType,
-    defaults: Mapping[K, V] | None = None,
-    zero_is_empty: bool = False,
-    false_is_empty: bool = False,
-    empty_string_is_empty: bool = True,
-) -> DictType:
-    """
-    Replace empty entries in a dictionary with provided default values,
-    or remove them if no default is available. Returns the same type as the input dictionary.
-    """
-    if defaults is None:
-        defaults = {}
-
-    try:
-        if isinstance(data, defaultdict):
-            result: MutableMapping[K, V] = defaultdict(data.default_factory)
-        else:
-            result = data.__class__()
-    except Exception:
-        result = {}
-
-    for key, value in data.items():
-        should_replace = (
-            value is None
-            or (empty_string_is_empty and value == "")
-            or (zero_is_empty and value == 0)
-            or (false_is_empty and value is False)
-        )
-
-        if should_replace:
-            if key in defaults:
-                new_value = defaults[key]
-            else:
-                continue  # Skip the key if no default is available
-        else:
-            new_value = value
-
-        result[key] = new_value
-    return cast(DictType, result)

mm_std/env.py

@@ -1,9 +0,0 @@
-import os
-
-from dotenv import load_dotenv
-
-load_dotenv()
-
-
-def get_dotenv(key: str) -> str | None:
-    return os.getenv(key)

mm_std/fs.py

@@ -1,13 +0,0 @@
-from pathlib import Path
-
-
-def read_text(path: str | Path) -> str:
-    if isinstance(path, str):
-        path = Path(path)
-    return path.read_text()
-
-
-def get_filename_without_extension(path: str | Path) -> str:
-    if isinstance(path, str):
-        path = Path(path)
-    return path.stem

mm_std/http/http_request.py

@@ -1,126 +0,0 @@
-import aiohttp
-from aiohttp import ClientHttpProxyError, InvalidUrlClientError
-from aiohttp.typedefs import LooseCookies, Query
-from aiohttp_socks import ProxyConnectionError, ProxyConnector
-from multidict import CIMultiDictProxy
-
-from mm_std.http.http_response import HttpError, HttpResponse
-
-
-async def http_request(
-    url: str,
-    *,
-    method: str = "GET",
-    params: Query | None = None,
-    data: dict[str, object] | None = None,
-    json: dict[str, object] | None = None,
-    headers: dict[str, str] | None = None,
-    cookies: LooseCookies | None = None,
-    user_agent: str | None = None,
-    proxy: str | None = None,
-    timeout: float | None = 10.0,
-) -> HttpResponse:
-    """
-    Send an HTTP request and return the response.
-    """
-    timeout_ = aiohttp.ClientTimeout(total=timeout) if timeout else None
-    if user_agent:
-        if not headers:
-            headers = {}
-        headers["user-agent"] = user_agent
-
-    try:
-        if proxy and proxy.startswith("socks"):
-            return await _request_with_socks_proxy(
-                url,
-                method=method,
-                params=params,
-                data=data,
-                json=json,
-                headers=headers,
-                cookies=cookies,
-                proxy=proxy,
-                timeout=timeout_,
-            )
-        return await _request_with_http_or_none_proxy(
-            url,
-            method=method,
-            params=params,
-            data=data,
-            json=json,
-            headers=headers,
-            cookies=cookies,
-            proxy=proxy,
-            timeout=timeout_,
-        )
-    except TimeoutError as err:
-        return HttpResponse(error=HttpError.TIMEOUT, error_message=str(err))
-    except (aiohttp.ClientProxyConnectionError, ProxyConnectionError, ClientHttpProxyError) as err:
-        return HttpResponse(error=HttpError.PROXY, error_message=str(err))
-    except InvalidUrlClientError as e:
-        return HttpResponse(error=HttpError.INVALID_URL, error_message=str(e))
-    except Exception as err:
-        return HttpResponse(error=HttpError.ERROR, error_message=str(err))
-
-
-async def _request_with_http_or_none_proxy(
-    url: str,
-    *,
-    method: str = "GET",
-    params: Query | None = None,
-    data: dict[str, object] | None = None,
-    json: dict[str, object] | None = None,
-    headers: dict[str, str] | None = None,
-    cookies: LooseCookies | None = None,
-    proxy: str | None = None,
-    timeout: aiohttp.ClientTimeout | None,
-) -> HttpResponse:
-    async with aiohttp.request(
-        method, url, params=params, data=data, json=json, headers=headers, cookies=cookies, proxy=proxy, timeout=timeout
-    ) as res:
-        return HttpResponse(
-            status_code=res.status,
-            error=None,
-            error_message=None,
-            body=(await res.read()).decode(),
-            headers=headers_dict(res.headers),
-        )
-
-
-async def _request_with_socks_proxy(
-    url: str,
-    *,
-    method: str = "GET",
-    proxy: str,
-    params: Query | None = None,
-    data: dict[str, object] | None = None,
-    json: dict[str, object] | None = None,
-    headers: dict[str, str] | None = None,
-    cookies: LooseCookies | None = None,
-    timeout: aiohttp.ClientTimeout | None,
-) -> HttpResponse:
-    connector = ProxyConnector.from_url(proxy)
-    async with (
-        aiohttp.ClientSession(connector=connector) as session,
-        session.request(
-            method, url, params=params, data=data, json=json, headers=headers, cookies=cookies, timeout=timeout
-        ) as res,
-    ):
-        return HttpResponse(
-            status_code=res.status,
-            error=None,
-            error_message=None,
-            body=(await res.read()).decode(),
-            headers=headers_dict(res.headers),
-        )
-
-
-def headers_dict(headers: CIMultiDictProxy[str]) -> dict[str, str]:
-    result: dict[str, str] = {}
-    for key in headers:
-        values = headers.getall(key)
-        if len(values) == 1:
-            result[key] = values[0]
-        else:
-            result[key] = ", ".join(values)
-    return result