MeUtils 2025.3.14.8.43.3__py3-none-any.whl → 2025.3.19.19.13.35__py3-none-any.whl

meutils/llm/completions/qwen_demo.py

@@ -1,26 +0,0 @@
-
-from openai import OpenAI
-cookies={'ssxmod_itna': 'euitD57IejxAo=DhODcmmv30j=DKDODl4BtGRDeq7tDRDFqAPiDHA17P5DU2OY2MGXxGDaieAqzRxGXxaexiNDAxq0iDCbeQ5ou2ivv3e3nemU4qRhnub1G7NQgR3+H3utAR5RMFgYDHxi8DBF4wCGYDenaDCeDQxirDD4DADibq4D1IDDkD0+m7UovW4GWDmbADYHGf78fDGpobRAfbDDCbPYDwEbpzDDzzQj5PmAqPm3DePAfIjkIoAQxb4G1fD0HaG65bzk9kMxA3d=xvUewDlFSDCKvu+gUuWEA1zSrtjeYtY+sYFrT+0x3GqliqB5Y7Di7i4nhhlwNf0xWA5DTttRPa4DG35zY=eBY3E5QiefL1XdWqbz+DreA=dh=2WeKR58GYxEwgG5/DYMADaA5+A4PADN0=a7eziDD',
- 'ssxmod_itna2': 'euitD57IejxAo=DhODcmmv30j=DKDODl4BtGRDeq7tDRDFqAPiDHA17P5DU2OY2MGXxGDaieAqzexD3raKY3rh4DFxnDKW1Bh0xDlxkDasWVgcuBepTBPecj=tk1QFgt3HxjB3pxx9=sdl5aSW9DG1yipgx+wgIO0mcDAoYQfrF4/xT++xEk02A7+4mHPbOA+oTOQBaahcHEWZfG3bok7rP8PcI8uRYYIUAHo0yE6aPp54bX0EQ8rUIHKYdC/1pjy6d0WqM90CG0PoMmhv3xrXwjP37hf4EgwgGqSxAhSaPAVxzGQUop4MXgBE+OX0DUmE5/no9eKynE/hjA6ECEP=oKnQo1DIjDq/YN00voKx0nLPbb3SG4DI4ZA/25ynwKc2a6rOEIQrN3+u0AiDbI5O2MCTK+LFfvq40LOQOALmFP0=bdo3w8onWpA+dhzA0C51ahgZjkR3y7olY=k8XW1ugrtAOIxC57jtViIOUdBtt7=D/0NE1oTf0k/d5aircE6f056c4rUy=c4wrh9XnhL1bIL9XZxdAcj8/YK4cRQN7Cc=XH6BTNFiFbTaOLxhrim5Q8p40K5fPAD4Ke+CYKKim2WDyieFrU3AqcDjfiGyUvmkP10CsY=3ZeLCx6YpkcELdkcAwlitYm6sFGq1tRkPRQewwrUYKiBh42Dzlpu=EuoV4aD2w24mPiDu1DZ51o3DA9ZW3h5leHGnB5Crc1KTbP03C2qlGQBezsq0xiHBeHDxncUxHTANQktHZ1KkxS6Hy4qQklKcxsKrxAqr2rmq32tnqViiY1spUPPi2mAw5hDD'}
-cookie = '; '.join([f'{i}={j}' for i,j in cookies.items()])
-
-headers = {
-    # 'authorization':'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6IjIxZDJiMjhmLWZmMTctNGQ2MS1hYmI0LWM2NzJhZWNjMTQ5ZCIsImV4cCI6MTc0MzkzNTk1OX0.y3oSO7aOwmzuE3GI3_aSxd9c5iXz9Krw0zJDG1FCLBQ',
-             'user-agent':'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36',
-             'cookie':cookie
-         }
-client=OpenAI(base_url='https://chat.qwen.ai/api',
-         api_key='eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6IjIxZDJiMjhmLWZmMTctNGQ2MS1hYmI0LWM2NzJhZWNjMTQ5ZCIsImV4cCI6MTc0MzkzNTk1OX0.y3oSO7aOwmzuE3GI3_aSxd9c5iXz9Krw0zJDG1FCLBQ',
-         # default_headers=headers
-             )
-
-comp=client.chat.completions.create(
-    model="qwen-max-latest", 
-    messages=[{"role": "user", "content": "你好"}],
-    max_tokens=2,
-    # extra_headers=headers, # 放在这里也可以
-    extra_body={'chat_type':'t2t'},
-    stream=False
-)
-print(comp.choices[0].message.content)
-# comp

meutils/other/aiomultiprocess/__init__.py

@@ -1,14 +0,0 @@
-# Copyright 2018 John Reese
-# Licensed under the MIT license
-
-"""
-AsyncIO version of the standard multiprocessing module
-"""
-
-__author__ = "John Reese"  # https://github.com/omnilib/aiomultiprocess
-
-from .__version__ import __version__
-from .core import Process, Worker, set_context, set_start_method
-from .pool import Pool, PoolResult
-from .scheduler import RoundRobin, Scheduler
-from .types import QueueID, TaskID

meutils/other/aiomultiprocess/__version__.py

@@ -1 +0,0 @@
-__version__ = "0.9.0"

meutils/other/aiomultiprocess/core.py

@@ -1,241 +0,0 @@
-# Copyright 2018 John Reese
-# Licensed under the MIT license
-
-import asyncio
-import logging
-import multiprocessing
-import multiprocessing.managers
-import os
-import sys
-from typing import Any, Callable, Dict, Optional, Sequence
-
-from .types import Context, R, Unit
-
-DEFAULT_START_METHOD = "spawn"
-
-# shared context for all multiprocessing primitives, for platform compatibility
-# "spawn" is default/required on windows and mac, but can't execute non-global functions
-# see https://docs.python.org/3/library/multiprocessing.html#contexts-and-start-methods
-context = multiprocessing.get_context(DEFAULT_START_METHOD)
-_manager = None
-
-log = logging.getLogger(__name__)
-
-
-def get_manager() -> multiprocessing.managers.SyncManager:
-    """Return a singleton shared manager."""
-    global _manager
-    if _manager is None:
-        _manager = context.Manager()
-
-    return _manager
-
-
-def set_start_method(method: Optional[str] = DEFAULT_START_METHOD) -> None:
-    """
-    Set the start method and context used for future processes/pools.
-
-    When given no parameters (`set_context()`), will default to using the "spawn" method
-    as this provides a predictable set of features and compatibility across all major
-    platforms, and trades a small cost on process startup for potentially large savings
-    on memory usage of child processes.
-
-    Passing an explicit string (eg, "fork") will force aiomultiprocess to use the given
-    start method instead of "spawn".
-
-    Passing an explicit `None` value will force aiomultiprocess to use CPython's default
-    start method for the current platform rather than defaulting to "spawn".
-
-    See the official multiprocessing documentation for details on start methods:
-    https://docs.python.org/3/library/multiprocessing.html#contexts-and-start-methods
-    """
-    global context
-    context = multiprocessing.get_context(method)
-
-
-def get_context() -> Context:
-    """Get the current active global context."""
-    global context
-    return context
-
-
-def set_context(method: Optional[str] = None) -> None:
-    """
-    Set the start method and context used for future processes/pools. [DEPRECATED]
-
-    Retained for backwards compatibility, and to retain prior behavior of "no parameter"
-    resulting in selection of the platform's default start method.
-    """
-    return set_start_method(method)
-
-
-async def not_implemented(*args: Any, **kwargs: Any) -> None:
-    """Default function to call when none given."""
-    raise NotImplementedError()
-
-
-class Process:
-    """Execute a coroutine on a separate process."""
-
-    def __init__(
-        self,
-        group: None = None,
-        target: Callable = None,
-        name: str = None,
-        args: Sequence[Any] = None,
-        kwargs: Dict[str, Any] = None,
-        *,
-        daemon: bool = None,
-        initializer: Optional[Callable] = None,
-        initargs: Sequence[Any] = (),
-        loop_initializer: Optional[Callable] = None,
-        process_target: Optional[Callable] = None,
-    ) -> None:
-        if target is not None and not asyncio.iscoroutinefunction(target):
-            raise ValueError("target must be coroutine function")
-
-        if initializer is not None and asyncio.iscoroutinefunction(initializer):
-            raise ValueError("initializer must be synchronous function")
-
-        if loop_initializer is not None and asyncio.iscoroutinefunction(
-            loop_initializer
-        ):
-            raise ValueError("loop_initializer must be synchronous function")
-
-        self.unit = Unit(
-            target=target or not_implemented,
-            args=args or (),
-            kwargs=kwargs or {},
-            namespace=get_manager().Namespace(),
-            initializer=initializer,
-            initargs=initargs,
-            loop_initializer=loop_initializer,
-        )
-        self.aio_process = context.Process(
-            group=group,
-            target=process_target or Process.run_async,
-            args=(self.unit,),
-            name=name,
-            daemon=daemon,
-        )
-
-    def __await__(self) -> Any:
-        """Enable awaiting of the process result by chaining to `start()` & `join()`."""
-        if not self.is_alive() and self.exitcode is None:
-            self.start()
-
-        return self.join().__await__()
-
-    @staticmethod
-    def run_async(unit: Unit) -> R:
-        """Initialize the child process and event loop, then execute the coroutine."""
-        try:
-            if unit.loop_initializer is None:
-                loop = asyncio.new_event_loop()
-            else:
-                loop = unit.loop_initializer()
-
-            asyncio.set_event_loop(loop)
-
-            if unit.initializer:
-                unit.initializer(*unit.initargs)
-
-            result: R = loop.run_until_complete(unit.target(*unit.args, **unit.kwargs))
-
-            return result
-
-        except BaseException:
-            log.exception(f"aio process {os.getpid()} failed")
-            raise
-
-    def start(self) -> None:
-        """Start the child process."""
-        return self.aio_process.start()
-
-    async def join(self, timeout: int = None) -> None:
-        """Wait for the process to finish execution without blocking the main thread."""
-        if not self.is_alive() and self.exitcode is None:
-            raise ValueError("must start process before joining it")
-
-        if timeout is not None:
-            return await asyncio.wait_for(self.join(), timeout)
-
-        while self.exitcode is None:
-            await asyncio.sleep(0.005)
-
-    @property
-    def name(self) -> str:
-        """Child process name."""
-        return self.aio_process.name
-
-    def is_alive(self) -> bool:
-        """Is child process running."""
-        return self.aio_process.is_alive()
-
-    @property
-    def daemon(self) -> bool:
-        """Should child process be daemon."""
-        return self.aio_process.daemon
-
-    @daemon.setter
-    def daemon(self, value: bool) -> None:
-        """Should child process be daemon."""
-        self.aio_process.daemon = value
-
-    @property
-    def pid(self) -> Optional[int]:
-        """Process ID of child, or None if not started."""
-        return self.aio_process.pid
-
-    @property
-    def exitcode(self) -> Optional[int]:
-        """Exit code from child process, or None if still running."""
-        return self.aio_process.exitcode
-
-    def terminate(self) -> None:
-        """Send SIGTERM to child process."""
-        return self.aio_process.terminate()
-
-    # multiprocessing.Process methods added in 3.7
-    if sys.version_info >= (3, 7):
-
-        def kill(self) -> None:
-            """Send SIGKILL to child process."""
-            return self.aio_process.kill()
-
-        def close(self) -> None:
-            """Clean up child process once finished."""
-            return self.aio_process.close()
-
-
-class Worker(Process):
-    """Execute a coroutine on a separate process and return the result."""
-
-    def __init__(self, *args, **kwargs) -> None:
-        super().__init__(*args, process_target=Worker.run_async, **kwargs)
-        self.unit.namespace.result = None
-
-    @staticmethod
-    def run_async(unit: Unit) -> R:
-        """Initialize the child process and event loop, then execute the coroutine."""
-        try:
-            result: R = Process.run_async(unit)
-            unit.namespace.result = result
-            return result
-
-        except BaseException as e:
-            unit.namespace.result = e
-            raise
-
-    async def join(self, timeout: int = None) -> Any:
-        """Wait for the worker to finish, and return the final result."""
-        await super().join(timeout)
-        return self.result
-
-    @property
-    def result(self) -> R:
-        """Easy access to the resulting value from the coroutine."""
-        if self.exitcode is None:
-            raise ValueError("coroutine not completed")
-
-        return self.unit.namespace.result

meutils/other/aiomultiprocess/pool.py

@@ -1,379 +0,0 @@
-# Copyright 2019 John Reese
-# Licensed under the MIT license
-
-import asyncio
-import logging
-import os
-import queue
-import traceback
-from typing import (
-    Any,
-    AsyncIterable,
-    AsyncIterator,
-    Awaitable,
-    Callable,
-    Dict,
-    Generator,
-    Optional,
-    Sequence,
-    Tuple,
-    TypeVar,
-)
-
-from .core import Process, get_context
-from .scheduler import RoundRobin, Scheduler
-from .types import (
-    LoopInitializer,
-    PoolTask,
-    ProxyException,
-    Queue,
-    QueueID,
-    R,
-    T,
-    TaskID,
-    TracebackStr,
-)
-
-MAX_TASKS_PER_CHILD = 0  # number of tasks to execute before recycling a child process
-CHILD_CONCURRENCY = 16  # number of tasks to execute simultaneously per child process
-_T = TypeVar("_T")
-
-log = logging.getLogger(__name__)
-
-
-class PoolWorker(Process):
-    """Individual worker process for the async pool."""
-
-    def __init__(
-        self,
-        tx: Queue,
-        rx: Queue,
-        ttl: int = MAX_TASKS_PER_CHILD,
-        concurrency: int = CHILD_CONCURRENCY,
-        *,
-        initializer: Optional[Callable] = None,
-        initargs: Sequence[Any] = (),
-        loop_initializer: Optional[LoopInitializer] = None,
-        exception_handler: Optional[Callable[[BaseException], None]] = None,
-    ) -> None:
-        super().__init__(
-            target=self.run,
-            initializer=initializer,
-            initargs=initargs,
-            loop_initializer=loop_initializer,
-        )
-        self.concurrency = max(1, concurrency)
-        self.exception_handler = exception_handler
-        self.ttl = max(0, ttl)
-        self.tx = tx
-        self.rx = rx
-
-    async def run(self) -> None:
-        """Pick up work, execute work, return results, rinse, repeat."""
-        pending: Dict[asyncio.Future, TaskID] = {}
-        completed = 0
-        running = True
-        while running or pending:
-            # TTL, Tasks To Live, determines how many tasks to execute before dying
-            if self.ttl and completed >= self.ttl:
-                running = False
-
-            # pick up new work as long as we're "running" and we have open slots
-            while running and len(pending) < self.concurrency:
-                try:
-                    task: PoolTask = self.tx.get_nowait()
-                except queue.Empty:
-                    break
-
-                if task is None:
-                    running = False
-                    break
-
-                tid, func, args, kwargs = task
-                future = asyncio.ensure_future(func(*args, **kwargs))
-                pending[future] = tid
-
-            if not pending:
-                await asyncio.sleep(0.005)
-                continue
-
-            # return results and/or exceptions when completed
-            done, _ = await asyncio.wait(
-                pending.keys(), timeout=0.05, return_when=asyncio.FIRST_COMPLETED
-            )
-            for future in done:
-                tid = pending.pop(future)
-
-                result = None
-                tb = None
-                try:
-                    result = future.result()
-                except BaseException as e:
-                    if self.exception_handler is not None:
-                        self.exception_handler(e)
-
-                    tb = traceback.format_exc()
-
-                self.rx.put_nowait((tid, result, tb))
-                completed += 1
-
-
-class PoolResult(Awaitable[Sequence[_T]], AsyncIterable[_T]):
-    """
-    Asynchronous proxy for map/starmap results. Can be awaited or used with `async for`.
-    """
-
-    def __init__(self, pool: "Pool", task_ids: Sequence[TaskID]):
-        self.pool = pool
-        self.task_ids = task_ids
-
-    def __await__(self) -> Generator[Any, None, Sequence[_T]]:
-        """Wait for all results and return them as a sequence"""
-        return self.results().__await__()
-
-    async def results(self) -> Sequence[_T]:
-        """Wait for all results and return them as a sequence"""
-        return await self.pool.results(self.task_ids)
-
-    def __aiter__(self) -> AsyncIterator[_T]:
-        """Return results one-by-one as they are ready"""
-        return self.results_generator()
-
-    async def results_generator(self) -> AsyncIterator[_T]:
-        """Return results one-by-one as they are ready"""
-        for task_id in self.task_ids:
-            yield (await self.pool.results([task_id]))[0]
-
-
-class Pool:
-    """Execute coroutines on a pool of child processes."""
-
-    def __init__(
-        self,
-        processes: int = None,
-        initializer: Callable[..., None] = None,
-        initargs: Sequence[Any] = (),
-        maxtasksperchild: int = MAX_TASKS_PER_CHILD,
-        childconcurrency: int = CHILD_CONCURRENCY,
-        queuecount: Optional[int] = None,
-        scheduler: Scheduler = None,
-        loop_initializer: Optional[LoopInitializer] = None,
-        exception_handler: Optional[Callable[[BaseException], None]] = None,
-    ) -> None:
-        self.context = get_context()
-
-        self.scheduler = scheduler or RoundRobin()
-        self.process_count = max(1, processes or os.cpu_count() or 2)
-        self.queue_count = max(1, queuecount or 1)
-
-        if self.queue_count > self.process_count:
-            raise ValueError("queue count must be <= process count")
-
-        self.initializer = initializer
-        self.initargs = initargs
-        self.loop_initializer = loop_initializer
-        self.maxtasksperchild = max(0, maxtasksperchild)
-        self.childconcurrency = max(1, childconcurrency)
-        self.exception_handler = exception_handler
-
-        self.processes: Dict[Process, QueueID] = {}
-        self.queues: Dict[QueueID, Tuple[Queue, Queue]] = {}
-
-        self.running = True
-        self.last_id = 0
-        self._results: Dict[TaskID, Tuple[Any, Optional[TracebackStr]]] = {}
-
-        self.init()
-        self._loop = asyncio.ensure_future(self.loop())
-
-    async def __aenter__(self) -> "Pool":
-        """Enable `async with Pool() as pool` usage."""
-        return self
-
-    async def __aexit__(self, *args) -> None:
-        """Automatically terminate the pool when falling out of scope."""
-        self.terminate()
-        await self.join()
-
-    def init(self) -> None:
-        """
-        Create the initial mapping of processes and queues.
-
-        :meta private:
-        """
-        for _ in range(self.queue_count):
-            tx = self.context.Queue()
-            rx = self.context.Queue()
-            qid = self.scheduler.register_queue(tx)
-
-            self.queues[qid] = (tx, rx)
-
-        qids = list(self.queues.keys())
-        for i in range(self.process_count):
-            qid = qids[i % self.queue_count]
-            self.processes[self.create_worker(qid)] = qid
-            self.scheduler.register_process(qid)
-
-    async def loop(self) -> None:
-        """
-        Maintain the pool of workers while open.
-
-        :meta private:
-        """
-        while self.processes or self.running:
-            # clean up workers that reached TTL
-            for process in list(self.processes):
-                if not process.is_alive():
-                    qid = self.processes.pop(process)
-                    if self.running:
-                        self.processes[self.create_worker(qid)] = qid
-
-            # pull results into a shared dictionary for later retrieval
-            for _, rx in self.queues.values():
-                while True:
-                    try:
-                        task_id, value, tb = rx.get_nowait()
-                        self.finish_work(task_id, value, tb)
-
-                    except queue.Empty:
-                        break
-
-            # let someone else do some work for once
-            await asyncio.sleep(0.005)
-
-    def create_worker(self, qid: QueueID) -> Process:
-        """
-        Create a worker process attached to the given transmit and receive queues.
-
-        :meta private:
-        """
-        tx, rx = self.queues[qid]
-        process = PoolWorker(
-            tx,
-            rx,
-            self.maxtasksperchild,
-            self.childconcurrency,
-            initializer=self.initializer,
-            initargs=self.initargs,
-            loop_initializer=self.loop_initializer,
-            exception_handler=self.exception_handler,
-        )
-        process.start()
-        return process
-
-    def queue_work(
-        self,
-        func: Callable[..., Awaitable[R]],
-        args: Sequence[Any],
-        kwargs: Dict[str, Any],
-    ) -> TaskID:
-        """
-        Add a new work item to the outgoing queue.
-
-        :meta private:
-        """
-        self.last_id += 1
-        task_id = TaskID(self.last_id)
-
-        qid = self.scheduler.schedule_task(task_id, func, args, kwargs)
-        tx, _ = self.queues[qid]
-        tx.put_nowait((task_id, func, args, kwargs))
-        return task_id
-
-    def finish_work(
-        self, task_id: TaskID, value: Any, tb: Optional[TracebackStr]
-    ) -> None:
-        """
-        Mark work items as completed.
-
-        :meta private:
-        """
-        self._results[task_id] = value, tb
-        self.scheduler.complete_task(task_id)
-
-    async def results(self, tids: Sequence[TaskID]) -> Sequence[R]:
-        """
-        Wait for all tasks to complete, and return results, preserving order.
-
-        :meta private:
-        """
-        pending = set(tids)
-        ready: Dict[TaskID, R] = {}
-
-        while pending:
-            for tid in pending.copy():
-                if tid in self._results:
-                    result, tb = self._results.pop(tid)
-                    if tb is not None:
-                        raise ProxyException(tb)
-                    ready[tid] = result
-                    pending.remove(tid)
-
-            await asyncio.sleep(0.005)
-
-        return [ready[tid] for tid in tids]
-
-    async def apply(
-        self,
-        func: Callable[..., Awaitable[R]],
-        args: Sequence[Any] = None,
-        kwds: Dict[str, Any] = None,
-    ) -> R:
-        """Run a single coroutine on the pool."""
-        if not self.running:
-            raise RuntimeError("pool is closed")
-
-        args = args or ()
-        kwds = kwds or {}
-
-        tid = self.queue_work(func, args, kwds)
-        results: Sequence[R] = await self.results([tid])
-        return results[0]
-
-    def map(
-        self,
-        func: Callable[[T], Awaitable[R]],
-        iterable: Sequence[T],
-        # chunksize: int = None,  # todo: implement chunking maybe
-    ) -> PoolResult[R]:
-        """Run a coroutine once for each item in the iterable."""
-        if not self.running:
-            raise RuntimeError("pool is closed")
-
-        tids = [self.queue_work(func, (item,), {}) for item in iterable]
-        return PoolResult(self, tids)
-
-    def starmap(
-        self,
-        func: Callable[..., Awaitable[R]],
-        iterable: Sequence[Sequence[T]],
-        # chunksize: int = None,  # todo: implement chunking maybe
-    ) -> PoolResult[R]:
-        """Run a coroutine once for each sequence of items in the iterable."""
-        if not self.running:
-            raise RuntimeError("pool is closed")
-
-        tids = [self.queue_work(func, args, {}) for args in iterable]
-        return PoolResult(self, tids)
-
-    def close(self) -> None:
-        """Close the pool to new visitors."""
-        self.running = False
-        for qid in self.processes.values():
-            tx, _ = self.queues[qid]
-            tx.put_nowait(None)
-
-    def terminate(self) -> None:
-        """No running by the pool!"""
-        if self.running:
-            self.close()
-
-        for process in self.processes:
-            process.terminate()
-
-    async def join(self) -> None:
-        """Wait for the pool to finish gracefully."""
-        if self.running:
-            raise RuntimeError("pool is still open")
-
-        await self._loop