promptlayer 1.0.60__py3-none-any.whl → 1.0.62__py3-none-any.whl

promptlayer/utils.py

@@ -9,7 +9,7 @@ import sys
 import types
 from copy import deepcopy
 from enum import Enum
-from typing import Any, AsyncGenerator, AsyncIterable, Callable, Dict, Generator, List, Optional, Union
+from typing import Any, Dict, List, Optional, Union
 from uuid import uuid4
 
 import httpx
@@ -59,6 +59,10 @@ def _make_httpx_client():
     return httpx.AsyncClient(timeout=_get_http_timeout())
 
 
+def _make_simple_httpx_client():
+    return httpx.Client(timeout=_get_http_timeout())
+
+
 def _get_workflow_workflow_id_or_name(workflow_id_or_name, workflow_name):
     # This is backward compatibility code
     if (workflow_id_or_name := workflow_name if workflow_id_or_name is None else workflow_id_or_name) is None:
@@ -1231,364 +1235,6 @@ async def aget_all_prompt_templates(
         raise Exception(f"PromptLayer had the following error while getting all your prompt templates: {str(e)}") from e
 
 
-def openai_stream_chat(results: list):
-    from openai.types.chat import (
-        ChatCompletion,
-        ChatCompletionChunk,
-        ChatCompletionMessage,
-        ChatCompletionMessageToolCall,
-    )
-    from openai.types.chat.chat_completion import Choice
-    from openai.types.chat.chat_completion_message_tool_call import Function
-
-    chat_completion_chunks: List[ChatCompletionChunk] = results
-    response: ChatCompletion = ChatCompletion(
-        id="",
-        object="chat.completion",
-        choices=[
-            Choice(
-                finish_reason="stop",
-                index=0,
-                message=ChatCompletionMessage(role="assistant"),
-            )
-        ],
-        created=0,
-        model="",
-    )
-    last_result = chat_completion_chunks[-1]
-    response.id = last_result.id
-    response.created = last_result.created
-    response.model = last_result.model
-    response.system_fingerprint = last_result.system_fingerprint
-    response.usage = last_result.usage
-    content = ""
-    tool_calls: Union[List[ChatCompletionMessageToolCall], None] = None
-    for result in chat_completion_chunks:
-        choices = result.choices
-        if len(choices) == 0:
-            continue
-        if choices[0].delta.content:
-            content = f"{content}{result.choices[0].delta.content}"
-
-        delta = choices[0].delta
-        if delta.tool_calls:
-            tool_calls = tool_calls or []
-            last_tool_call = None
-            if len(tool_calls) > 0:
-                last_tool_call = tool_calls[-1]
-            tool_call = delta.tool_calls[0]
-            if not tool_call.function:
-                continue
-            if not last_tool_call or tool_call.id:
-                tool_calls.append(
-                    ChatCompletionMessageToolCall(
-                        id=tool_call.id or "",
-                        function=Function(
-                            name=tool_call.function.name or "",
-                            arguments=tool_call.function.arguments or "",
-                        ),
-                        type=tool_call.type or "function",
-                    )
-                )
-                continue
-            last_tool_call.function.name = f"{last_tool_call.function.name}{tool_call.function.name or ''}"
-            last_tool_call.function.arguments = (
-                f"{last_tool_call.function.arguments}{tool_call.function.arguments or ''}"
-            )
-
-    response.choices[0].message.content = content
-    response.choices[0].message.tool_calls = tool_calls
-    return response
-
-
-async def aopenai_stream_chat(generator: AsyncIterable[Any]) -> Any:
-    from openai.types.chat import (
-        ChatCompletion,
-        ChatCompletionChunk,
-        ChatCompletionMessage,
-        ChatCompletionMessageToolCall,
-    )
-    from openai.types.chat.chat_completion import Choice
-    from openai.types.chat.chat_completion_message_tool_call import Function
-
-    chat_completion_chunks: List[ChatCompletionChunk] = []
-    response: ChatCompletion = ChatCompletion(
-        id="",
-        object="chat.completion",
-        choices=[
-            Choice(
-                finish_reason="stop",
-                index=0,
-                message=ChatCompletionMessage(role="assistant"),
-            )
-        ],
-        created=0,
-        model="",
-    )
-    content = ""
-    tool_calls: Union[List[ChatCompletionMessageToolCall], None] = None
-
-    async for result in generator:
-        chat_completion_chunks.append(result)
-        choices = result.choices
-        if len(choices) == 0:
-            continue
-        if choices[0].delta.content:
-            content = f"{content}{choices[0].delta.content}"
-
-        delta = choices[0].delta
-        if delta.tool_calls:
-            tool_calls = tool_calls or []
-            last_tool_call = None
-            if len(tool_calls) > 0:
-                last_tool_call = tool_calls[-1]
-            tool_call = delta.tool_calls[0]
-            if not tool_call.function:
-                continue
-            if not last_tool_call or tool_call.id:
-                tool_calls.append(
-                    ChatCompletionMessageToolCall(
-                        id=tool_call.id or "",
-                        function=Function(
-                            name=tool_call.function.name or "",
-                            arguments=tool_call.function.arguments or "",
-                        ),
-                        type=tool_call.type or "function",
-                    )
-                )
-                continue
-            last_tool_call.function.name = f"{last_tool_call.function.name}{tool_call.function.name or ''}"
-            last_tool_call.function.arguments = (
-                f"{last_tool_call.function.arguments}{tool_call.function.arguments or ''}"
-            )
-
-    # After collecting all chunks, set the response attributes
-    if chat_completion_chunks:
-        last_result = chat_completion_chunks[-1]
-        response.id = last_result.id
-        response.created = last_result.created
-        response.model = last_result.model
-        response.system_fingerprint = getattr(last_result, "system_fingerprint", None)
-        response.usage = last_result.usage
-
-    response.choices[0].message.content = content
-    response.choices[0].message.tool_calls = tool_calls
-    return response
-
-
-def openai_stream_completion(results: list):
-    from openai.types.completion import Completion, CompletionChoice
-
-    completions: List[Completion] = results
-    last_chunk = completions[-1]
-    response = Completion(
-        id=last_chunk.id,
-        created=last_chunk.created,
-        model=last_chunk.model,
-        object="text_completion",
-        choices=[CompletionChoice(finish_reason="stop", index=0, text="")],
-    )
-    text = ""
-    for completion in completions:
-        usage = completion.usage
-        system_fingerprint = completion.system_fingerprint
-        if len(completion.choices) > 0 and completion.choices[0].text:
-            text = f"{text}{completion.choices[0].text}"
-        if usage:
-            response.usage = usage
-        if system_fingerprint:
-            response.system_fingerprint = system_fingerprint
-    response.choices[0].text = text
-    return response
-
-
-async def aopenai_stream_completion(generator: AsyncIterable[Any]) -> Any:
-    from openai.types.completion import Completion, CompletionChoice
-
-    completions: List[Completion] = []
-    text = ""
-    response = Completion(
-        id="",
-        created=0,
-        model="",
-        object="text_completion",
-        choices=[CompletionChoice(finish_reason="stop", index=0, text="")],
-    )
-
-    async for completion in generator:
-        completions.append(completion)
-        usage = completion.usage
-        system_fingerprint = getattr(completion, "system_fingerprint", None)
-        if len(completion.choices) > 0 and completion.choices[0].text:
-            text = f"{text}{completion.choices[0].text}"
-        if usage:
-            response.usage = usage
-        if system_fingerprint:
-            response.system_fingerprint = system_fingerprint
-
-    # After collecting all completions, set the response attributes
-    if completions:
-        last_chunk = completions[-1]
-        response.id = last_chunk.id
-        response.created = last_chunk.created
-        response.model = last_chunk.model
-
-    response.choices[0].text = text
-    return response
-
-
-def anthropic_stream_message(results: list):
-    from anthropic.types import Message, MessageStreamEvent, Usage
-
-    message_stream_events: List[MessageStreamEvent] = results
-    response: Message = Message(
-        id="",
-        model="",
-        content=[],
-        role="assistant",
-        type="message",
-        stop_reason="stop_sequence",
-        stop_sequence=None,
-        usage=Usage(input_tokens=0, output_tokens=0),
-    )
-
-    for event in message_stream_events:
-        if event.type == "message_start":
-            response = event.message
-            break
-
-    content_blocks, usage, stop_reason = build_anthropic_content_blocks(message_stream_events)
-    response.content = content_blocks
-    if usage:
-        response.usage.output_tokens = usage.output_tokens
-    if stop_reason:
-        response.stop_reason = stop_reason
-
-    return response
-
-
-async def aanthropic_stream_message(generator: AsyncIterable[Any]) -> Any:
-    from anthropic.types import Message, MessageStreamEvent, Usage
-
-    message_stream_events: List[MessageStreamEvent] = []
-    response: Message = Message(
-        id="",
-        model="",
-        content=[],
-        role="assistant",
-        type="message",
-        stop_reason="stop_sequence",
-        stop_sequence=None,
-        usage=Usage(input_tokens=0, output_tokens=0),
-    )
-
-    async for event in generator:
-        if event.type == "message_start":
-            response = event.message
-        message_stream_events.append(event)
-
-    content_blocks, usage, stop_reason = build_anthropic_content_blocks(message_stream_events)
-    response.content = content_blocks
-    if usage:
-        response.usage.output_tokens = usage.output_tokens
-    if stop_reason:
-        response.stop_reason = stop_reason
-
-    return response
-
-
-def anthropic_stream_completion(results: list):
-    from anthropic.types import Completion
-
-    completions: List[Completion] = results
-    last_chunk = completions[-1]
-    response = Completion(
-        id=last_chunk.id,
-        completion="",
-        model=last_chunk.model,
-        stop_reason="stop",
-        type="completion",
-    )
-
-    text = ""
-    for completion in completions:
-        text = f"{text}{completion.completion}"
-    response.completion = text
-    return response
-
-
-async def aanthropic_stream_completion(generator: AsyncIterable[Any]) -> Any:
-    from anthropic.types import Completion
-
-    completions: List[Completion] = []
-    text = ""
-    response = Completion(
-        id="",
-        completion="",
-        model="",
-        stop_reason="stop",
-        type="completion",
-    )
-
-    async for completion in generator:
-        completions.append(completion)
-        text = f"{text}{completion.completion}"
-
-    # After collecting all completions, set the response attributes
-    if completions:
-        last_chunk = completions[-1]
-        response.id = last_chunk.id
-        response.model = last_chunk.model
-
-    response.completion = text
-    return response
-
-
-def stream_response(*, generator: Generator, after_stream: Callable, map_results: Callable):
-    data = {
-        "request_id": None,
-        "raw_response": None,
-        "prompt_blueprint": None,
-    }
-    results = []
-    for result in generator:
-        results.append(result)
-        data["raw_response"] = result
-        yield data
-    request_response = map_results(results)
-    response = after_stream(request_response=request_response.model_dump())
-    data["request_id"] = response.get("request_id")
-    data["prompt_blueprint"] = response.get("prompt_blueprint")
-    yield data
-
-
-async def astream_response(
-    generator: AsyncIterable[Any],
-    after_stream: Callable[..., Any],
-    map_results: Callable[[Any], Any],
-) -> AsyncGenerator[Dict[str, Any], None]:
-    data = {
-        "request_id": None,
-        "raw_response": None,
-        "prompt_blueprint": None,
-    }
-    results = []
-    async for result in generator:
-        results.append(result)
-        data["raw_response"] = result
-        yield data
-
-    async def async_generator_from_list(lst):
-        for item in lst:
-            yield item
-
-    request_response = await map_results(async_generator_from_list(results))
-    after_stream_response = await after_stream(request_response=request_response.model_dump())
-    data["request_id"] = after_stream_response.get("request_id")
-    data["prompt_blueprint"] = after_stream_response.get("prompt_blueprint")
-    yield data
-
-
 def openai_chat_request(client, **kwargs):
     return client.chat.completions.create(**kwargs)
 
@@ -1754,7 +1400,7 @@ async def autil_log_request(api_key: str, **kwargs) -> Union[RequestLog, None]:
 def mistral_request(prompt_blueprint: GetPromptTemplateResponse, client_kwargs: dict, function_kwargs: dict):
     from mistralai import Mistral
 
-    client = Mistral(api_key=os.environ.get("MISTRAL_API_KEY"))
+    client = Mistral(api_key=os.environ.get("MISTRAL_API_KEY"), client=_make_simple_httpx_client())
     if "stream" in function_kwargs and function_kwargs["stream"]:
         function_kwargs.pop("stream")
         return client.chat.stream(**function_kwargs)
@@ -1770,139 +1416,12 @@ async def amistral_request(
 ):
     from mistralai import Mistral
 
-    client = Mistral(api_key=os.environ.get("MISTRAL_API_KEY"))
+    client = Mistral(api_key=os.environ.get("MISTRAL_API_KEY"), async_client=_make_httpx_client())
     if "stream" in function_kwargs and function_kwargs["stream"]:
         return await client.chat.stream_async(**function_kwargs)
     return await client.chat.complete_async(**function_kwargs)
 
 
-def mistral_stream_chat(results: list):
-    from openai.types.chat import ChatCompletion, ChatCompletionMessage, ChatCompletionMessageToolCall
-    from openai.types.chat.chat_completion import Choice
-    from openai.types.chat.chat_completion_message_tool_call import Function
-
-    last_result = results[-1]
-    response = ChatCompletion(
-        id=last_result.data.id,
-        object="chat.completion",
-        choices=[
-            Choice(
-                finish_reason=last_result.data.choices[0].finish_reason or "stop",
-                index=0,
-                message=ChatCompletionMessage(role="assistant"),
-            )
-        ],
-        created=last_result.data.created,
-        model=last_result.data.model,
-    )
-
-    content = ""
-    tool_calls = None
-
-    for result in results:
-        choices = result.data.choices
-        if len(choices) == 0:
-            continue
-
-        delta = choices[0].delta
-        if delta.content is not None:
-            content = f"{content}{delta.content}"
-
-        if delta.tool_calls:
-            tool_calls = tool_calls or []
-            for tool_call in delta.tool_calls:
-                if len(tool_calls) == 0 or tool_call.id:
-                    tool_calls.append(
-                        ChatCompletionMessageToolCall(
-                            id=tool_call.id or "",
-                            function=Function(
-                                name=tool_call.function.name,
-                                arguments=tool_call.function.arguments,
-                            ),
-                            type="function",
-                        )
-                    )
-                else:
-                    last_tool_call = tool_calls[-1]
-                    if tool_call.function.name:
-                        last_tool_call.function.name = f"{last_tool_call.function.name}{tool_call.function.name}"
-                    if tool_call.function.arguments:
-                        last_tool_call.function.arguments = (
-                            f"{last_tool_call.function.arguments}{tool_call.function.arguments}"
-                        )
-
-    response.choices[0].message.content = content
-    response.choices[0].message.tool_calls = tool_calls
-    response.usage = last_result.data.usage
-    return response
-
-
-async def amistral_stream_chat(generator: AsyncIterable[Any]) -> Any:
-    from openai.types.chat import ChatCompletion, ChatCompletionMessage, ChatCompletionMessageToolCall
-    from openai.types.chat.chat_completion import Choice
-    from openai.types.chat.chat_completion_message_tool_call import Function
-
-    completion_chunks = []
-    response = ChatCompletion(
-        id="",
-        object="chat.completion",
-        choices=[
-            Choice(
-                finish_reason="stop",
-                index=0,
-                message=ChatCompletionMessage(role="assistant"),
-            )
-        ],
-        created=0,
-        model="",
-    )
-    content = ""
-    tool_calls = None
-
-    async for result in generator:
-        completion_chunks.append(result)
-        choices = result.data.choices
-        if len(choices) == 0:
-            continue
-        delta = choices[0].delta
-        if delta.content is not None:
-            content = f"{content}{delta.content}"
-
-        if delta.tool_calls:
-            tool_calls = tool_calls or []
-            for tool_call in delta.tool_calls:
-                if len(tool_calls) == 0 or tool_call.id:
-                    tool_calls.append(
-                        ChatCompletionMessageToolCall(
-                            id=tool_call.id or "",
-                            function=Function(
-                                name=tool_call.function.name,
-                                arguments=tool_call.function.arguments,
-                            ),
-                            type="function",
-                        )
-                    )
-                else:
-                    last_tool_call = tool_calls[-1]
-                    if tool_call.function.name:
-                        last_tool_call.function.name = f"{last_tool_call.function.name}{tool_call.function.name}"
-                    if tool_call.function.arguments:
-                        last_tool_call.function.arguments = (
-                            f"{last_tool_call.function.arguments}{tool_call.function.arguments}"
-                        )
-
-    if completion_chunks:
-        last_result = completion_chunks[-1]
-        response.id = last_result.data.id
-        response.created = last_result.data.created
-        response.model = last_result.data.model
-        response.usage = last_result.data.usage
-
-    response.choices[0].message.content = content
-    response.choices[0].message.tool_calls = tool_calls
-    return response
-
-
 def google_chat_request(client, **kwargs):
     from google.genai.chats import Content
 
@@ -1927,65 +1446,6 @@ def google_completions_request(client, **kwargs):
     return client.models.generate_content(model=model, contents=contents, config=config)
 
 
-def _build_google_response_from_parts(thought_content: str, regular_content: str, function_calls: list, last_result):
-    """Helper function to build Google response with thought, regular, and function call parts."""
-    from google.genai.chats import Part
-
-    response = last_result.model_copy()
-    final_parts = []
-
-    if thought_content:
-        thought_part = Part(text=thought_content, thought=True)
-        final_parts.append(thought_part)
-
-    if regular_content:
-        text_part = Part(text=regular_content, thought=None)
-        final_parts.append(text_part)
-
-    for function_call in function_calls:
-        function_part = Part(function_call=function_call, thought=None)
-        final_parts.append(function_part)
-
-    if final_parts:
-        response.candidates[0].content.parts = final_parts
-
-    return response
-
-
-def map_google_stream_response(results: list):
-    from google.genai.chats import GenerateContentResponse
-
-    response = GenerateContentResponse()
-    if not results:
-        return response
-    results: List[GenerateContentResponse] = results
-
-    thought_content = ""
-    regular_content = ""
-    function_calls = []
-
-    for result in results:
-        if result.candidates and result.candidates[0].content.parts:
-            for part in result.candidates[0].content.parts:
-                if hasattr(part, "text") and part.text:
-                    if hasattr(part, "thought") and part.thought:
-                        thought_content = f"{thought_content}{part.text}"
-                    else:
-                        regular_content = f"{regular_content}{part.text}"
-                elif hasattr(part, "function_call") and part.function_call:
-                    function_calls.append(part.function_call)
-
-    return _build_google_response_from_parts(thought_content, regular_content, function_calls, results[-1])
-
-
-def google_stream_chat(results: list):
-    return map_google_stream_response(results)
-
-
-def google_stream_completion(results: list):
-    return map_google_stream_response(results)
-
-
 MAP_TYPE_TO_GOOGLE_FUNCTION = {
     "chat": google_chat_request,
     "completion": google_completions_request,
@@ -2038,42 +1498,6 @@ async def agoogle_request(prompt_blueprint: GetPromptTemplateResponse, client_kw
     return await request_to_make(client, **function_kwargs)
 
 
-async def amap_google_stream_response(generator: AsyncIterable[Any]):
-    from google.genai.chats import GenerateContentResponse
-
-    response = GenerateContentResponse()
-
-    thought_content = ""
-    regular_content = ""
-    function_calls = []
-    last_result = None
-
-    async for result in generator:
-        last_result = result
-        if result.candidates and result.candidates[0].content.parts:
-            for part in result.candidates[0].content.parts:
-                if hasattr(part, "text") and part.text:
-                    if hasattr(part, "thought") and part.thought:
-                        thought_content = f"{thought_content}{part.text}"
-                    else:
-                        regular_content = f"{regular_content}{part.text}"
-                elif hasattr(part, "function_call") and part.function_call:
-                    function_calls.append(part.function_call)
-
-    if not last_result:
-        return response
-
-    return _build_google_response_from_parts(thought_content, regular_content, function_calls, last_result)
-
-
-async def agoogle_stream_chat(generator: AsyncIterable[Any]):
-    return await amap_google_stream_response(generator)
-
-
-async def agoogle_stream_completion(generator: AsyncIterable[Any]):
-    return await amap_google_stream_response(generator)
-
-
 def vertexai_request(prompt_blueprint: GetPromptTemplateResponse, client_kwargs: dict, function_kwargs: dict):
     if "gemini" in prompt_blueprint["metadata"]["model"]["name"]:
         return google_request(

{promptlayer-1.0.60.dist-info → promptlayer-1.0.62.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: promptlayer
-Version: 1.0.60
+Version: 1.0.62
 Summary: PromptLayer is a platform for prompt engineering and tracks your LLM requests.
 License: Apache-2.0
 Author: Magniv

promptlayer-1.0.62.dist-info/RECORD

@@ -0,0 +1,22 @@
+promptlayer/__init__.py,sha256=GjRpGyl6bTJY05ZQlkVZOr8_ahNCmuYI3BPS3vyKvsk,140
+promptlayer/groups/__init__.py,sha256=xhOAolLUBkr76ZHvJr29OwjCIk1V9qKQXjZCuyTJUIY,429
+promptlayer/groups/groups.py,sha256=YPROicy-TzpkrpA8vOpZS2lwvJ6VRtlbQ1S2oT1N0vM,338
+promptlayer/promptlayer.py,sha256=qaxxSvimmXgN45q-IvWsAtyzIJ-w397F97ofsH_7w00,22516
+promptlayer/promptlayer_base.py,sha256=jOgXzNZlV1LKOOsXSSAOgn8o4hXn_EV0oY9Nf3Bsu_s,6872
+promptlayer/promptlayer_mixins.py,sha256=x-HOqd7SaKnVHoGeySYKzwlPVnqpFH5oCohJQIEjLQY,12172
+promptlayer/span_exporter.py,sha256=Pc1-zWAcjVCSykh-4rYPqiEZvzkG9xaYLVoHFY_TWaQ,2410
+promptlayer/streaming/__init__.py,sha256=yNO77fyOi_scNPbE-eIEDGwSOyp8WYyPZ7ZrHaoipmM,1523
+promptlayer/streaming/blueprint_builder.py,sha256=NLmqwspHoAsecrY7varbF4EQaUg5yBKfBxS4y7UycuU,5925
+promptlayer/streaming/response_handlers.py,sha256=vNvpP-RLVl2uHkKLc8Ci9bmNldCezRey40tgtBEd4bo,19005
+promptlayer/streaming/stream_processor.py,sha256=NQIumPzDwceFyqxLOHDe3tpAr2v39luICJlByVgB9mA,2813
+promptlayer/templates.py,sha256=7ObDPMzHXjttDdJdCXA_pDL9XAnmcujIWucmgZJcOC8,1179
+promptlayer/track/__init__.py,sha256=tyweLTAY7UpYpBHWwY-T3pOPDIlGjcgccYXqU_r0694,1710
+promptlayer/track/track.py,sha256=A-awcYwsSwxktrlCMchy8NITIquwxU1UXbgLZMwqrA0,3164
+promptlayer/types/__init__.py,sha256=xJcvQuOk91ZBBePb40-1FDNDKYrZoH5lPE2q6_UhprM,111
+promptlayer/types/prompt_template.py,sha256=blkVBhh4u5pMhgX_Dsn78sN7Rv2Vy_zhd1-NERLXTpM,5075
+promptlayer/types/request_log.py,sha256=xU6bcxQar6GaBOJlgZTavXUV3FjE8sF_nSjPu4Ya_00,174
+promptlayer/utils.py,sha256=ds8F-pF-1xcrJrurg4Uamg7GcMx8VHc-0vaD0zEtZnw,56018
+promptlayer-1.0.62.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+promptlayer-1.0.62.dist-info/METADATA,sha256=xNrV0NJFpwRnLmWm7yStyQqdh1YCq3vCoU7LbMhHj3o,4819
+promptlayer-1.0.62.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+promptlayer-1.0.62.dist-info/RECORD,,

promptlayer-1.0.60.dist-info/RECORD

@@ -1,18 +0,0 @@
-promptlayer/__init__.py,sha256=7i62BmXAXcIvBDJ1JoA82MY44zPz-tzFZyvflNG979k,140
-promptlayer/groups/__init__.py,sha256=xhOAolLUBkr76ZHvJr29OwjCIk1V9qKQXjZCuyTJUIY,429
-promptlayer/groups/groups.py,sha256=YPROicy-TzpkrpA8vOpZS2lwvJ6VRtlbQ1S2oT1N0vM,338
-promptlayer/promptlayer.py,sha256=llLxfEBX5-j8NSaOTQqSPSsmnqy-E-msi4LM4xV9OAU,22366
-promptlayer/promptlayer_base.py,sha256=jOgXzNZlV1LKOOsXSSAOgn8o4hXn_EV0oY9Nf3Bsu_s,6872
-promptlayer/promptlayer_mixins.py,sha256=1DfNk9woiB-EWtbydFRPp55f3Y88gt6be0m1OdVcDxs,12134
-promptlayer/span_exporter.py,sha256=Pc1-zWAcjVCSykh-4rYPqiEZvzkG9xaYLVoHFY_TWaQ,2410
-promptlayer/templates.py,sha256=7ObDPMzHXjttDdJdCXA_pDL9XAnmcujIWucmgZJcOC8,1179
-promptlayer/track/__init__.py,sha256=tyweLTAY7UpYpBHWwY-T3pOPDIlGjcgccYXqU_r0694,1710
-promptlayer/track/track.py,sha256=A-awcYwsSwxktrlCMchy8NITIquwxU1UXbgLZMwqrA0,3164
-promptlayer/types/__init__.py,sha256=xJcvQuOk91ZBBePb40-1FDNDKYrZoH5lPE2q6_UhprM,111
-promptlayer/types/prompt_template.py,sha256=blkVBhh4u5pMhgX_Dsn78sN7Rv2Vy_zhd1-NERLXTpM,5075
-promptlayer/types/request_log.py,sha256=xU6bcxQar6GaBOJlgZTavXUV3FjE8sF_nSjPu4Ya_00,174
-promptlayer/utils.py,sha256=lJoEMhXteIdkztX67rRoel8EcIMEcxH7JwQXXmg_yLo,75790
-promptlayer-1.0.60.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-promptlayer-1.0.60.dist-info/METADATA,sha256=_Xo7wCnK6PjRLC4nUEXjhVA-O_Es7sdU6xriDD4uSHk,4819
-promptlayer-1.0.60.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-promptlayer-1.0.60.dist-info/RECORD,,