sycommon-python-lib 0.1.55b1__tar.gz → 0.1.56b2__tar.gz

{sycommon_python_lib-0.1.55b1 → sycommon_python_lib-0.1.56b2}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.1.55b1
+Version: 0.1.56b2
 Summary: Add your description here
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 Requires-Dist: aio-pika>=9.5.8
 Requires-Dist: aiohttp>=3.13.2
@@ -10,6 +10,10 @@ Requires-Dist: aiomysql>=0.3.2
 Requires-Dist: decorator>=5.2.1
 Requires-Dist: fastapi>=0.127.0
 Requires-Dist: kafka-python>=2.3.0
+Requires-Dist: langchain>=1.2.0
+Requires-Dist: langchain-core>=1.2.6
+Requires-Dist: langchain-openai>=1.1.6
+Requires-Dist: langgraph>=1.0.5
 Requires-Dist: loguru>=0.7.3
 Requires-Dist: mysql-connector-python>=9.5.0
 Requires-Dist: nacos-sdk-python<3.0,>=2.0.9

{sycommon_python_lib-0.1.55b1 → sycommon_python_lib-0.1.56b2}/pyproject.toml

@@ -1,9 +1,9 @@
 [project]
 name = "sycommon-python-lib"
-version = "0.1.55-beta1"
+version = "0.1.56-beta2"
 description = "Add your description here"
 readme = "README.md"
-requires-python = ">=3.10"
+requires-python = ">=3.11"
 dependencies = [
     "aio-pika>=9.5.8",
     "aiohttp>=3.13.2",
@@ -11,6 +11,10 @@ dependencies = [
     "decorator>=5.2.1",
     "fastapi>=0.127.0",
     "kafka-python>=2.3.0",
+    "langchain>=1.2.0",
+    "langchain-core>=1.2.6",
+    "langchain-openai>=1.1.6",
+    "langgraph>=1.0.5",
     "loguru>=0.7.3",
     "mysql-connector-python>=9.5.0",
     "nacos-sdk-python>=2.0.9,<3.0",

{sycommon_python_lib-0.1.55b1 → sycommon_python_lib-0.1.56b2}/src/sycommon/config/Config.py

@@ -16,10 +16,9 @@ class Config(metaclass=SingletonMeta):
             self.config = yaml.safe_load(f)
         self.MaxBytes = self.config.get('MaxBytes', 209715200)
         self.Timeout = self.config.get('Timeout', 300000)
+        self.MaxRetries = self.config.get('MaxRetries', 3)
         self.OCR = self.config.get('OCR', None)
         self.INVOICE_OCR = self.config.get('INVOICE_OCR', None)
-        self.UnstructuredAPI = self.config.get('UnstructuredAPI', None)
-        self.MaxRetries = self.config.get('MaxRetries', 3)
         self.llm_configs = []
         self.embedding_configs = []
         self.reranker_configs = []
@@ -71,3 +70,8 @@ class Config(metaclass=SingletonMeta):
                 self.reranker_configs.append(validated_config.model_dump())
             except ValueError as e:
                 print(f"Invalid LLM configuration: {e}")
+
+    def set_attr(self, share_configs: dict):
+        self.config = {**self.config, **
+                       share_configs.get('llm', {}), **share_configs}
+        self._process_config()

{sycommon_python_lib-0.1.55b1 → sycommon_python_lib-0.1.56b2}/src/sycommon/config/RerankerConfig.py

@@ -5,6 +5,7 @@ class RerankerConfig(BaseModel):
     model: str
     provider: str
     baseUrl: str
+    maxTokens: int
 
     @classmethod
     def from_config(cls, model_name: str):

sycommon_python_lib-0.1.56b2/src/sycommon/llm/embedding.py

@@ -0,0 +1,149 @@
+import asyncio
+import json
+import aiohttp
+from typing import Union, List, Optional
+
+from sycommon.config.Config import SingletonMeta
+from sycommon.config.EmbeddingConfig import EmbeddingConfig
+from sycommon.config.RerankerConfig import RerankerConfig
+from sycommon.logging.kafka_log import SYLogger
+
+
+class Embedding(metaclass=SingletonMeta):
+    def __init__(self):
+        # 1. 并发限制
+        self.max_concurrency = 20
+        # 保留默认模型名称
+        self.default_embedding_model = "bge-large-zh-v1.5"
+        self.default_reranker_model = "bge-reranker-large"
+
+        # 初始化默认模型的基础URL
+        self.embeddings_base_url = EmbeddingConfig.from_config(
+            self.default_embedding_model).baseUrl
+        self.reranker_base_url = RerankerConfig.from_config(
+            self.default_reranker_model).baseUrl
+
+        # 并发信号量
+        self.semaphore = asyncio.Semaphore(self.max_concurrency)
+
+    async def _get_embeddings_http_async(
+        self,
+        input: Union[str, List[str]],
+        encoding_format: str = None,
+        model: str = None,
+        **kwargs
+    ):
+        async with self.semaphore:
+            # 优先使用传入的模型名，无则用默认值
+            target_model = model or self.default_embedding_model
+            target_base_url = EmbeddingConfig.from_config(target_model).baseUrl
+            url = f"{target_base_url}/v1/embeddings"
+
+            request_body = {
+                "model": target_model,
+                "input": input,
+                "encoding_format": encoding_format or "float"
+            }
+            request_body.update(kwargs)
+
+            async with aiohttp.ClientSession() as session:
+                async with session.post(url, json=request_body) as response:
+                    if response.status != 200:
+                        error_detail = await response.text()
+                        SYLogger.error(
+                            f"Embedding request failed (model: {target_model}): {error_detail}")
+                        return None
+                    return await response.json()
+
+    async def _get_reranker_http_async(
+        self,
+        documents: List[str],
+        query: str,
+        top_n: Optional[int] = None,
+        model: str = None,
+        max_chunks_per_doc: Optional[int] = None,
+        return_documents: Optional[bool] = True,
+        return_len: Optional[bool] = True,
+        **kwargs
+    ):
+        async with self.semaphore:
+            # 优先使用传入的模型名，无则用默认值
+            target_model = model or self.default_reranker_model
+            target_base_url = RerankerConfig.from_config(target_model).baseUrl
+            url = f"{target_base_url}/v1/rerank"
+
+            request_body = {
+                "model": target_model,
+                "documents": documents,
+                "query": query,
+                "top_n": top_n or len(documents),
+                "max_chunks_per_doc": max_chunks_per_doc,
+                "return_documents": return_documents,
+                "return_len": return_len,
+                "kwargs": json.dumps(kwargs),
+            }
+            request_body.update(kwargs)
+
+            async with aiohttp.ClientSession() as session:
+                async with session.post(url, json=request_body) as response:
+                    if response.status != 200:
+                        error_detail = await response.text()
+                        SYLogger.error(
+                            f"Rerank request failed (model: {target_model}): {error_detail}")
+                        return None
+                    return await response.json()
+
+    async def get_embeddings(
+        self,
+        corpus: List[str],
+        model: str = None
+    ):
+        """
+        获取语料库的嵌入向量，结果顺序与输入语料库顺序一致
+
+        Args:
+            corpus: 待生成嵌入向量的文本列表
+            model: 可选，指定使用的embedding模型名称，默认使用bge-large-zh-v1.5
+        """
+        SYLogger.info(
+            f"Requesting embeddings for corpus: {corpus} (model: {model or self.default_embedding_model}, max_concurrency: {self.max_concurrency})")
+        # 给每个异步任务传入模型名称
+        tasks = [self._get_embeddings_http_async(
+            text, model=model) for text in corpus]
+        results = await asyncio.gather(*tasks)
+
+        vectors = []
+        for result in results:
+            if result is None:
+                zero_vector = [0.0] * 1024
+                vectors.append(zero_vector)
+                SYLogger.warning(
+                    f"Embedding request failed, append zero vector (1024D)")
+                continue
+            for item in result["data"]:
+                vectors.append(item["embedding"])
+
+        SYLogger.info(
+            f"Embeddings for corpus: {corpus} created (model: {model or self.default_embedding_model})")
+        return vectors
+
+    async def get_reranker(
+        self,
+        top_results: List[str],
+        query: str,
+        model: str = None
+    ):
+        """
+        对搜索结果进行重排序
+
+        Args:
+            top_results: 待重排序的文本列表
+            query: 排序参考的查询语句
+            model: 可选，指定使用的reranker模型名称，默认使用bge-reranker-large
+        """
+        SYLogger.info(
+            f"Requesting reranker for top_results: {top_results} (model: {model or self.default_reranker_model}, max_concurrency: {self.max_concurrency})")
+        data = await self._get_reranker_http_async(top_results, query, model=model)
+        SYLogger.info(
+            f"Reranker for top_results: {top_results} completed (model: {model or self.default_reranker_model})")
+        return data

sycommon_python_lib-0.1.56b2/src/sycommon/llm/get_llm.py

@@ -0,0 +1,177 @@
+from typing import Dict, Type, List, Union, Optional, Callable
+
+from sycommon.llm.llm_logger import LLMLogger
+from langchain_core.language_models import BaseChatModel
+from langchain_core.runnables import Runnable, RunnableLambda
+from langchain_core.output_parsers import PydanticOutputParser
+from langchain_core.messages import BaseMessage, SystemMessage, HumanMessage
+from langchain.chat_models import init_chat_model
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+from pydantic import BaseModel, ValidationError
+from sycommon.config.LLMConfig import LLMConfig
+
+
+def get_llm(model: str = None, streaming: bool = False) -> BaseChatModel:
+    if not model:
+        model = "Qwen2.5-72B"
+        # model = "SyMid"
+    llmConfig = LLMConfig.from_config(model)
+    llm = None
+    if llmConfig:
+        llm = init_chat_model(
+            model_provider=llmConfig.provider,
+            model=llmConfig.model,
+            base_url=llmConfig.baseUrl,
+            api_key="-",
+            temperature=0.1,
+            streaming=streaming,
+        )
+    else:
+        raise Exception("Invalid model")
+
+    # 为LLM动态添加with_structured_output方法，官方的with_structured_output方法有概率在qwen2.5中导致模型卡死不返回数据，2.5对functioncall支持不好
+    def with_structured_output(
+        self: BaseChatModel,
+        output_model: Type[BaseModel],
+        max_retries: int = 3,
+        is_extract: bool = False,
+        override_prompt: ChatPromptTemplate = None,
+        # 自定义处理函数列表（每个函数接收str，返回str）
+        custom_processors: Optional[List[Callable[[str], str]]] = None,
+        # 自定义解析函数（接收str，返回BaseModel）
+        custom_parser: Optional[Callable[[str], BaseModel]] = None
+    ) -> Runnable[List[BaseMessage], BaseModel]:
+        parser = PydanticOutputParser(pydantic_object=output_model)
+
+        accuracy_instructions = """
+        字段值的抽取准确率（0~1之间），评分规则：
+        1.0（完全准确）：直接从原文提取，无需任何加工，且格式与原文完全一致
+        0.9（轻微处理）：数据来源明确，但需进行格式标准化或冗余信息剔除（不改变原始数值）
+        0.8（有限推断）：数据需通过上下文关联或简单计算得出，仍有明确依据
+        0.8以下（不可靠）：数据需大量推测、存在歧义或来源不明，处理方式：直接忽略该数据，设置为None
+        """
+
+        if is_extract:
+            # 抽取模式下使用固定的抽取专用prompt
+            prompt = ChatPromptTemplate.from_messages([
+                MessagesPlaceholder(variable_name="messages"),
+                HumanMessage(content=f"""
+                请提取信息并遵循以下规则：
+                1. 准确率要求：{accuracy_instructions.strip()}
+                2. 输出格式：{parser.get_format_instructions()}
+                """)
+            ])
+        else:
+            if override_prompt:
+                prompt = override_prompt
+            else:
+                prompt = ChatPromptTemplate.from_messages([
+                    MessagesPlaceholder(variable_name="messages"),
+                    HumanMessage(content=f"""
+                    输出格式：{parser.get_format_instructions()}
+                    """)
+                ])
+
+        # ========== 基础处理函数 ==========
+        def extract_response_content(response: BaseMessage) -> str:
+            """提取响应中的文本内容"""
+            try:
+                return response.content
+            except Exception as e:
+                raise ValueError(f"提取响应内容失败：{str(e)}") from e
+
+        def strip_code_block_markers(content: str) -> str:
+            """移除JSON代码块标记（```json/```）"""
+            try:
+                return content.strip("```json").strip("```").strip()
+            except Exception as e:
+                raise ValueError(
+                    f"移除代码块标记失败（内容：{str(content)[:100]}）：{str(e)}") from e
+
+        def normalize_in_json(content: str) -> str:
+            """将None替换为null，确保JSON格式合法"""
+            try:
+                cleaned = content.replace("None", "null")
+                cleaned = cleaned.replace("none", "null")
+                cleaned = cleaned.replace("NONE", "null")
+                cleaned = cleaned.replace("''", '""')
+                return cleaned
+            except Exception as e:
+                raise ValueError(
+                    f"替换None为null失败（内容：{str(content)[:100]}）：{str(e)}") from e
+
+        def default_parse_to_pydantic(content: str) -> BaseModel:
+            """默认解析函数：将处理后的文本解析为Pydantic模型"""
+            try:
+                return parser.parse(content)
+            except (ValidationError, ValueError) as e:
+                raise type(e)(f"解析失败（原始内容：{content[:200]}）：{str(e)}") from e
+
+        # ========== 构建处理链条 ==========
+        # 基础链 prompt → LLM → 提取响应内容
+        base_chain = (
+            prompt
+            | self
+            | RunnableLambda(extract_response_content)
+        )
+
+        # 处理函数链 优先使用自定义，否则用默认
+        if custom_processors:
+            # 自定义处理函数 → 转为RunnableLambda列表
+            process_runnables = [RunnableLambda(
+                func) for func in custom_processors]
+        else:
+            # 默认处理函数：移除代码块标记 → 标准化JSON空值
+            process_runnables = [
+                RunnableLambda(strip_code_block_markers),
+                RunnableLambda(normalize_in_json)
+            ]
+
+        # 拼接处理链
+        process_chain = base_chain
+        for runnable in process_runnables:
+            process_chain = process_chain | runnable
+
+        # 解析函数 优先使用自定义，否则用默认
+        parse_func = custom_parser if custom_parser else default_parse_to_pydantic
+        parse_chain = process_chain | RunnableLambda(parse_func)
+
+        retry_chain = parse_chain.with_retry(
+            retry_if_exception_type=(ValidationError, ValueError),
+            stop_after_attempt=max_retries,
+            wait_exponential_jitter=True,
+            exponential_jitter_params={
+                "initial": 0.1,  # 初始等待时间（秒）
+                "max": 3.0,      # 最大等待时间（秒）
+                "exp_base": 2.0,  # 指数基数（默认2）
+                "jitter": 1.0    # 随机抖动值（默认1）
+            }
+        )
+
+        class StructuredRunnable(Runnable[Union[List[BaseMessage], BaseMessage, str, Dict[str, str]], BaseModel]):
+            def _adapt_input(self, input: Union[List[BaseMessage], BaseMessage, str, Dict[str, str]]) -> List[BaseMessage]:
+                """将多种输入格式统一转换为 List[BaseMessage]"""
+                if isinstance(input, list) and all(isinstance(x, BaseMessage) for x in input):
+                    return input
+                elif isinstance(input, BaseMessage):
+                    return [input]
+                elif isinstance(input, str):
+                    return [HumanMessage(content=input)]
+                elif isinstance(input, dict) and "input" in input:
+                    return [HumanMessage(content=str(input["input"]))]
+                else:
+                    raise ValueError(
+                        "不支持的输入格式，请使用消息列表、单条消息、文本或 {'input': '文本'}")
+
+            def invoke(self, input: Union[List[BaseMessage], BaseMessage, str, Dict[str, str]], config={"callbacks": [LLMLogger()]}):
+                adapted_input = self._adapt_input(input)
+                return retry_chain.invoke({"messages": adapted_input}, config=config)
+
+            async def ainvoke(self, input: Union[List[BaseMessage], BaseMessage, str, Dict[str, str]], config={"callbacks": [LLMLogger()]}):
+                adapted_input = self._adapt_input(input)
+                return await retry_chain.ainvoke({"messages": adapted_input}, config=config)
+
+        return StructuredRunnable()
+
+    llm.__class__.with_structured_output = with_structured_output
+    return llm

sycommon_python_lib-0.1.56b2/src/sycommon/llm/llm_logger.py

@@ -0,0 +1,126 @@
+from langchain_core.callbacks import AsyncCallbackHandler
+from typing import Any, Dict, List
+from langchain_core.outputs import GenerationChunk, ChatGeneration
+from langchain_core.messages import BaseMessage
+
+from sycommon.logging.kafka_log import SYLogger
+
+
+class LLMLogger(AsyncCallbackHandler):
+    """
+    通用LLM日志回调处理器，同时支持：
+    - 同步调用（如 chain.invoke()）
+    - 异步调用（如 chain.astream()）
+    - 聊天模型调用
+    """
+
+    # ------------------------------
+    # 同步回调方法（处理 invoke 等同步调用）
+    # ------------------------------
+    def on_llm_start(self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any) -> None:
+        model_name = serialized.get('name', 'unknown')
+        SYLogger.info(
+            f"[同步] LLM调用开始 | 模型: {model_name} | 提示词数: {len(prompts)}")
+        self._log_prompts(prompts)
+
+    def on_chat_model_start(
+        self,
+        serialized: Dict[str, Any],
+        messages: List[List[BaseMessage]],
+        **kwargs: Any
+    ) -> None:
+        model_name = serialized.get('name', 'unknown')
+        SYLogger.info(
+            f"[同步] 聊天模型调用开始 | 模型: {model_name} | 消息组数: {len(messages)}")
+        self._log_chat_messages(messages)
+
+    def on_llm_end(self, response: Any, **kwargs: Any) -> None:
+        # 处理普通LLM结果
+        if hasattr(response, 'generations') and all(
+            isinstance(gen[0], GenerationChunk) for gen in response.generations
+        ):
+            for i, generation in enumerate(response.generations):
+                result = generation[0].text
+                SYLogger.info(
+                    f"[同步] LLM调用结束 | 结果 #{i+1} 长度: {len(result)}")
+                self._log_result(result, i+1)
+        # 处理聊天模型结果
+        elif hasattr(response, 'generations') and all(
+            isinstance(gen[0], ChatGeneration) for gen in response.generations
+        ):
+            for i, generation in enumerate(response.generations):
+                result = generation[0].message.content
+                SYLogger.info(
+                    f"[同步] 聊天模型调用结束 | 结果 #{i+1} 长度: {len(result)}")
+                self._log_result(result, i+1)
+
+    def on_llm_error(self, error: Exception, **kwargs: Any) -> None:
+        if isinstance(error, GeneratorExit):
+            SYLogger.info("[同步] LLM生成器正常关闭")
+            return
+        SYLogger.error(f"[同步] LLM调用出错: {str(error)}")
+
+    # ------------------------------
+    # 异步回调方法（处理 astream 等异步调用）
+    # ------------------------------
+    async def on_llm_start(self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any) -> None:
+        model_name = serialized.get('name', 'unknown')
+        SYLogger.info(
+            f"[异步] LLM调用开始 | 模型: {model_name} | 提示词数: {len(prompts)}")
+        self._log_prompts(prompts)
+
+    async def on_chat_model_start(
+        self,
+        serialized: Dict[str, Any],
+        messages: List[List[BaseMessage]],
+        **kwargs: Any
+    ) -> None:
+        model_name = serialized.get('name', 'unknown')
+        SYLogger.info(
+            f"[异步] 聊天模型调用开始 | 模型: {model_name} | 消息组数: {len(messages)}")
+        self._log_chat_messages(messages)
+
+    async def on_llm_end(self, response: Any, **kwargs: Any) -> None:
+        # 处理普通LLM结果
+        if hasattr(response, 'generations') and all(
+            isinstance(gen[0], GenerationChunk) for gen in response.generations
+        ):
+            for i, generation in enumerate(response.generations):
+                result = generation[0].text
+                SYLogger.info(
+                    f"[异步] LLM调用结束 | 结果 #{i+1} 长度: {len(result)}")
+                self._log_result(result, i+1)
+        # 处理聊天模型结果
+        elif hasattr(response, 'generations') and all(
+            isinstance(gen[0], ChatGeneration) for gen in response.generations
+        ):
+            for i, generation in enumerate(response.generations):
+                result = generation[0].message.content
+                SYLogger.info(
+                    f"[异步] 聊天模型调用结束 | 结果 #{i+1} 长度: {len(result)}")
+                self._log_result(result, i+1)
+
+    async def on_llm_error(self, error: Exception, **kwargs: Any) -> None:
+        if isinstance(error, GeneratorExit):
+            SYLogger.info("[异步] LLM生成器正常关闭")
+            return
+        SYLogger.error(f"[异步] LLM调用出错: {str(error)}")
+
+    # ------------------------------
+    # 共享工具方法（避免代码重复）
+    # ------------------------------
+    def _log_prompts(self, prompts: List[str]) -> None:
+        """记录提示词"""
+        for i, prompt in enumerate(prompts):
+            SYLogger.info(f"提示词 #{i+1}:\n{prompt}")
+
+    def _log_chat_messages(self, messages: List[List[BaseMessage]]) -> None:
+        """记录聊天模型的消息"""
+        for i, message_group in enumerate(messages):
+            SYLogger.info(f"消息组 #{i+1}:")
+            for msg in message_group:
+                SYLogger.info(f"  {msg.type}: {msg.content}")
+
+    def _log_result(self, result: str, index: int) -> None:
+        """记录结果"""
+        SYLogger.info(f"结果 #{index}:\n{result}")

{sycommon_python_lib-0.1.55b1 → sycommon_python_lib-0.1.56b2}/src/sycommon/logging/kafka_log.py

@@ -15,7 +15,7 @@ from kafka import KafkaProducer
 from loguru import logger
 import loguru
 from sycommon.config.Config import Config, SingletonMeta
-from sycommon.middleware.context import current_trace_id
+from sycommon.middleware.context import current_trace_id, current_headers
 from sycommon.tools.snowflake import Snowflake
 
 # 配置Loguru的颜色方案
@@ -441,6 +441,18 @@ class SYLogger:
         """重置当前的 trace_id"""
         current_trace_id.reset(token)
 
+    @staticmethod
+    def get_headers():
+        return current_headers.get()
+
+    @staticmethod
+    def set_headers(headers: list[tuple[str, str]]):
+        return current_headers.set(headers)
+
+    @staticmethod
+    def reset_headers(token):
+        current_headers.reset(token)
+
     @staticmethod
     def _get_execution_context() -> str:
         """获取当前执行上下文的线程或协程信息，返回格式化字符串"""

sycommon_python_lib-0.1.56b2/src/sycommon/logging/logger_levels.py

@@ -0,0 +1,23 @@
+import logging
+
+
+def setup_logger_levels():
+    """配置各模块的日志级别，抑制无关INFO/DEBUG日志"""
+    # Nacos 客户端：仅输出WARNING及以上（屏蔽INFO级的心跳/注册日志）
+    logging.getLogger("nacos.client").setLevel(logging.WARNING)
+
+    # Kafka Python客户端：屏蔽INFO级的连接/版本检测日志
+    logging.getLogger("kafka.conn").setLevel(logging.WARNING)
+    logging.getLogger("kafka.producer").setLevel(logging.WARNING)
+
+    # Uvicorn/FastAPI：屏蔽启动/应用初始化的INFO日志（保留ERROR/WARNING）
+    # logging.getLogger("uvicorn").setLevel(logging.WARNING)
+    # logging.getLogger("uvicorn.access").setLevel(logging.WARNING)  # 屏蔽访问日志
+    # logging.getLogger("uvicorn.error").setLevel(logging.ERROR)     # 仅保留错误
+
+    # 自定义的root日志（如同步数据库/监听器初始化）：屏蔽INFO
+    logging.getLogger("root").setLevel(logging.WARNING)
+
+    # RabbitMQ相关日志（如果有专属日志器）
+    logging.getLogger("pika").setLevel(logging.WARNING)  # 若使用pika客户端
+    logging.getLogger("rabbitmq").setLevel(logging.WARNING)

{sycommon_python_lib-0.1.55b1 → sycommon_python_lib-0.1.56b2}/src/sycommon/middleware/context.py

@@ -1,3 +1,5 @@
 import contextvars
 
 current_trace_id = contextvars.ContextVar("trace_id", default=None)
+
+current_headers = contextvars.ContextVar("headers", default=None)