MeUtils 2025.3.14.8.41.43__py3-none-any.whl → 2025.3.19.18.18.56__py3-none-any.whl

meutils/apis/search/zhipu.py

@@ -1,80 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-# @Project      : AI.  @by PyCharm
-# @File         : zhipu
-# @Time         : 2025/2/19 20:42
-# @Author       : betterme
-# @WeChat       : meutils
-# @Software     : PyCharm
-# @Description  : 
-
-from meutils.pipe import *
-from meutils.str_utils.json_utils import json_path
-from meutils.llm.clients import AsyncOpenAI, chatfire_client, zhipuai_client, moonshot_client
-from meutils.llm.openai_utils import to_openai_params
-from meutils.schemas.openai_types import chat_completion, chat_completion_chunk, ChatCompletionRequest, CompletionUsage
-
-
-class Completions(object):
-
-    def __init__(self, api_key: Optional[str] = None):
-        self.api_key = api_key
-
-    async def create(self, request: ChatCompletionRequest, search_result2md: bool = False):
-        request.stream = False
-        request.model = "web-search-pro"
-        request.messages = [{
-            "role": "user",
-            "content": request.last_content,
-        }]
-        data = to_openai_params(request)
-
-        search_completion = await zhipuai_client.chat.completions.create(**data)
-        logger.debug(search_completion.model_dump_json(indent=4))
-
-        if results := json_path(search_completion, '$..[keywords,query,search_result]'):
-            data = dict(zip(["keywords", "query", "search_result"], results))
-            if search_result2md:
-                global df
-
-                df = pd.DataFrame(data["search_result"])
-
-                df['title'] = [f"[{k}]({v})" for k, v in zip(df['title'], df['link'])]
-                df['media'] = [f"![{k}]({v})" for k, v in zip(df['media'], df['icon'])]
-
-                df = df[['title', 'media']]
-                df.index += 1
-                # {df_.to_markdown(index=False).replace('|:-', '|-').replace('-:|', '-|')}
-                data["search_result"] = df.to_markdown()
-            return data
-
-    async def query(self, q: str):
-        pass
-
-        # {
-        #     "role": "user",
-        #     "content": search_completion.model_dump_json(indent=4),
-        # }
-
-
-if __name__ == '__main__':
-    model = "web-search-pro"
-    # model = "tencent-search"
-
-    request = ChatCompletionRequest(
-        # model="baichuan4-turbo",
-        # model="xx",
-        # model="deepseek-r1",
-        # model="deepseek-r1:1.5b",
-        model=model,
-
-        # model="moonshot-v1-8k",
-        # model="doubao",
-
-        messages=[
-            {"role": "user", "content": "《哪吒之魔童闹海》现在的票房是多少"}
-        ],
-
-        stream=True
-    )
-    arun(Completions().create(request, search_result2md=True))

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