semvec/pypi-packages huggingface dataset:
traceAI-groq 0.1.8
OpenTelemetry instrumentation for Groq
Requires Python: <3.13,>=3.10

# Groq OpenTelemetry Integration

## Overview
This integration provides support for using OpenTelemetry with the Groq framework. It enables tracing and monitoring of applications built with Groq.

## Installation

1. **Install traceAI Groq**

```bash
pip install traceAI-groq
```


### Set Environment Variables
Set up your environment variables to authenticate with FutureAGI.

```python
import os

os.environ["FI_API_KEY"] = FI_API_KEY
os.environ["FI_SECRET_KEY"] = FI_SECRET_KEY
os.environ["GROQ_API_KEY"] = GROQ_API_KEY
```

## Quickstart

### Register Tracer Provider
Set up the trace provider to establish the observability pipeline. The trace provider:

```python
from fi_instrumentation import register
from fi_instrumentation.fi_types import ProjectType

trace_provider = register(
    project_type=ProjectType.OBSERVE,
    project_name="groq_app"
)
```

### Configure Groq Instrumentation
Instrument the Groq client to enable telemetry collection. This step ensures that all interactions with the Groq SDK are tracked and monitored.

```python
from groq import Groq

def test():
    client = Groq(
        api_key=os.environ.get("GROQ_API_KEY"),
    )

    weather_function = {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "finds the weather for a given city",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "The city to find the weather for, e.g. 'London'",
                    }
                },
                "required": ["city"],
            },
        },
    }

    sys_prompt = "Respond to the user's query using the correct tool."
    user_msg = "What's the weather like in San Francisco?"

    messages = [
        {"role": "system", "content": sys_prompt},
        {"role": "user", "content": user_msg},
    ]
    response = client.chat.completions.create(
        model="mixtral-8x7b-32768",
        messages=messages,
        temperature=0.0,
        tools=[weather_function],
        tool_choice="required",
    )

    message = response.choices[0].message
    assert (tool_calls := message.tool_calls)
    tool_call_id = tool_calls[0].id
    messages.append(message)
    messages.append(
        ChatCompletionToolMessageParam(
            content="sunny", role="tool", tool_call_id=tool_call_id
        ),
    )
    final_response = client.chat.completions.create(
        model="mixtral-8x7b-32768",
        messages=messages,
    )
    return final_response

if __name__ == "__main__":
    response = test()
    print("Response\n")
    print(response)
```
traceAI-DSPy 0.1.7
OpenTelemetry instrumentation for DSPy
Requires Python: <3.13,>=3.10

# DSPy OpenTelemetry Integration

## Overview
This integration provides support for using OpenTelemetry with the DSPy framework. It enables tracing and monitoring of applications built with DSPy.

## Installation

1. **Install traceAI DSPy**

```bash
pip install traceAI-DSPy
```

2. **Install DSPy**
```bash
pip install dspy
```


### Set Environment Variables
Set up your environment variables to authenticate with FutureAGI

```python
import os

os.environ["FI_API_KEY"] = FI_API_KEY
os.environ["FI_SECRET_KEY"] = FI_SECRET_KEY
```

## Quickstart

### Register Tracer Provider
Set up the trace provider to establish the observability pipeline. The trace provider:

```python
from fi_instrumentation import register
from fi_instrumentation.fi_types import ProjectType

trace_provider = register(
    project_type=ProjectType.OBSERVE,
    project_name="dspy_app"
)
```

### Configure DSPy Instrumentation
Instrument the DSPy client to enable telemetry collection. This step ensures that all interactions with the DSPy SDK are tracked and monitored.

```python
from traceai_dspy import DSPyInstrumentor

DSPyInstrumentor().instrument(tracer_provider=trace_provider)
```

### Create DSPy Components
Set up your DSPy client with built-in observability.

```python
import dspy

class BasicQA(dspy.Signature):
    """Answer questions with short factoid answers."""

    question = dspy.InputField()
    answer = dspy.OutputField(desc="often between 1 and 5 words")

if __name__ == "__main__":
    turbo = dspy.LM(model="openai/gpt-4")

    dspy.settings.configure(lm=turbo)

    # Define the predictor.
    generate_answer = dspy.Predict(BasicQA)

    # Call the predictor on a particular input.
    pred = generate_answer(question="What is the capital of the united states?")
    print(f"Predicted Answer: {pred.answer}")
```
traceAI-crewai 0.1.7
OpenTelemetry instrumentation for Crewai
Requires Python: <3.13,>=3.10

# Crewai OpenTelemetry Integration

## Overview
This integration provides support for using OpenTelemetry with the Crewai framework. It enables tracing and monitoring of applications built with Crewai.

## Installation

1. **Install traceAI Crewai**

```bash
pip install traceAI-crewai
```

2. **Install Crewai and Crewai_tools**

```bash
pip install crewai crewai_tools
```


### Set Environment Variables
Set up your environment variables to authenticate with FutureAGI

```python
import os

os.environ["FI_API_KEY"] = FI_API_KEY
os.environ["FI_SECRET_KEY"] = FI_SECRET_KEY
```

## Quickstart

### Register Tracer Provider
Set up the trace provider to establish the observability pipeline. The trace provider:

```python
from fi_instrumentation import register
from fi_instrumentation.fi_types import ProjectType

trace_provider = register(
    project_type=ProjectType.OBSERVE,
    project_name="crewai_app"
)
```

### Configure Crewai Instrumentation
Instrument the Crewai client to enable telemetry collection. This step ensures that all interactions with the Crewai SDK are tracked and monitored.

```python
from traceai_crewai import CrewAIInstrumentor

CrewAIInstrumentor().instrument(tracer_provider=trace_provider)
```

### Create Crewai Components
Set up your Crewai client with built-in observability.

```python
from crewai import LLM, Agent, Crew, Process, Task
from crewai_tools import SerperDevTool

def story_example():
    llm = LLM(
        model="gpt-4",
        temperature=0.8,
        max_tokens=150,
        top_p=0.9,
        frequency_penalty=0.1,
        presence_penalty=0.1,
        stop=["END"],
        seed=42,
    )

    writer = Agent(
        role="Writer",
        goal="Write creative stories",
        backstory="You are a creative writer with a passion for storytelling",
        allow_delegation=False,
        llm=llm,
    )

    writing_task = Task(
        description="Write a short story about a magical forest",
        agent=writer,
        expected_output="A short story about a magical forest",
    )

    crew = Crew(agents=[writer], tasks=[writing_task])

    # Execute the crew
    result = crew.kickoff()
    print(result)

if __name__ == "__main__":
    story_example()
```
traceAI-bedrock 0.1.9
OpenTelemetry instrumentation for Bedrock
Requires Python: <3.14,>3.10

# Bedrock OpenTelemetry Integration

## Overview
This integration provides support for using OpenTelemetry with the Bedrock framework. It enables tracing and monitoring of applications built with Bedrock.

## Installation

1. **Install traceAI Bedrock**

```bash
pip install traceAI-bedrock
```
2. **Install boto3**

```bash
pip install boto3
```


### Set Environment Variables
Set up your environment variables to authenticate with FutureAGI.

```python
import os

os.environ["AWS_ACCESS_KEY_ID"] = AWS_ACCESS_KEY_ID
os.environ["AWS_SECRET_ACCESS_KEY"] = AWS_SECRET_ACCESS_KEY
os.environ["FI_API_KEY"] = FI_API_KEY
os.environ["FI_SECRET_KEY"] = FI_SECRET_KEY
```

## Quickstart

### Register Tracer Provider
Set up the trace provider to establish the observability pipeline. The trace provider:

```python
from fi_instrumentation import register
from fi_instrumentation.fi_types import ProjectType

trace_provider = register(
    project_type=ProjectType.OBSERVE,
    project_name="bedrock_app"
)
```

### Configure Bedrock Instrumentation
Instrument the Bedrock client to enable telemetry collection. This step ensures that all interactions with the Bedrock SDK are tracked and monitored.

```python
from traceai_bedrock import BedrockInstrumentor

BedrockInstrumentor().instrument(tracer_provider=trace_provider)
```

### Create Bedrock Components
Set up your Bedrock client with built-in observability.

```python
def converse_with_claude():
    system_prompt = [{"text": "You are an expert at creating music playlists"}]
    messages = [
        {
            "role": "user",
            "content": [{"text": "Hello, how are you?"}, {"text": "What's your name?"}],
        }
    ]
    inference_config = {"maxTokens": 1024, "temperature": 0.0}

    try:
        response = client.converse(
            modelId="model_id",
            system=system_prompt,
            messages=messages,
            inferenceConfig=inference_config,
        )
        out = response["output"]["message"]
        messages.append(out)
        print(out)
    except Exception as e:
        print(f"Error: {str(e)}")

if __name__ == "__main__":
    converse_with_claude()
```
traceAI-anthropic 0.1.9
OpenTelemetry instrumentation for Anthropic
Requires Python: <3.14,>3.9

# Anthropic OpenTelemetry Integration

## Overview
This integration provides support for using OpenTelemetry with the Anthropic framework. It enables tracing and monitoring of applications built with Anthropic.

## Installation

1. **Install traceAI Anthropic**

```bash
pip install traceAI-anthropic
```


### Set Environment Variables
Set up your environment variables to authenticate with FutureAGI

```python
import os

os.environ["FI_API_KEY"] = FI_API_KEY
os.environ["FI_SECRET_KEY"] = FI_SECRET_KEY
os.environ["ANTHROPIC_API_KEY"] = ANTHROPIC_API_KEY
```

## Quickstart

### Register Tracer Provider
Set up the trace provider to establish the observability pipeline. The trace provider:

```python
from fi_instrumentation import register
from fi_instrumentation.fi_types import ProjectType

trace_provider = register(
    project_type=ProjectType.OBSERVE,
    project_name="anthropic_app"
)
```

### Configure Anthropic Instrumentation
Instrument the Anthropic client to enable telemetry collection. This step ensures that all interactions with the Anthropic SDK are tracked and monitored.

```python
from traceai_anthropic import AnthropicInstrumentor

AnthropicInstrumentor().instrument(tracer_provider=trace_provider)
```

### Create Anthropic Components
Set up your Anthropic client with built-in observability.

```python
client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-3-5-sonnet-20240620",
    max_tokens=1024,
    tools=[
        {
            "name": "get_weather",
            "description": "Get the current weather in a given location",
            "input_schema": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "The city and state, e.g. San Francisco, CA",
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                        "description": "The unit of temperature, either 'celsius' or 'fahrenheit'",
                    },
                },
                "required": ["location"],
            },
        },
        {
            "name": "get_time",
            "description": "Get the current time in a given time zone",
            "input_schema": {
                "type": "object",
                "properties": {
                    "timezone": {
                        "type": "string",
                        "description": "The IANA time zone name, e.g. America/Los_Angeles",
                    }
                },
                "required": ["timezone"],
            },
        },
    ],
    messages=[
        {
            "role": "user",
            "content": "What is the weather like right now in New York?"
            " Also what time is it there? Use necessary tools simultaneously.",
        }
    ],
)
print(response)
```
monkie 2025.8.6.2
monkie is a Marimo NotebooK Image Explorer
Requires Python: >=3.10

[![GPLv3 License](https://img.shields.io/badge/License-GPL%20v3-yellow.svg)](https://opensource.org/licenses/GPL-3.0)

# [MoNkIE](https://bitbucket.org/raymond_hawkins_utor/monkie/src/main/) (a Marimo NotebooK Image Explorer) 

MoNkIE is a multi-dimensional image explorer built for Marimo notebooks!
MoNkIE is based off of [JuNkIE]((https://bitbucket.org/rfg_lab/junkie/src/master/), the Jupyter Notebook Image Explorer.

## Installing [MoNkIE](https://bitbucket.org/raymond_hawkins_utor/monkie/src/main/)

To install [MoNkIE](https://bitbucket.org/raymond_hawkins_utor/monkie/src/main/), type:

    $ python3 -m pip install --no-chache-dir -U monkie

## Using [MoNkIE](https://bitbucket.org/raymond_hawkins_utor/monkie/src/main/)

[MoNkIE](https://bitbucket.org/raymond_hawkins_utor/monkie/src/main/) requires that you call two simple functions in
separate cells to load the image and show the UI, respectively:

```python
# Put this in your setup cell
from monkie import monkie
```

```python
# First cell
monkie.load(image)
```

```python
# Second cell
monkie.show()
```

There are a few ways to open an image with [MoNkIE](https://bitbucket.org/raymond_hawkins_utor/monkie/src/main/):

- You can open an image with some other package (e.g. scikit-image, opencv, PIL, etc.) and pass a 
[numpy ndarray](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html) to 
[MoNkIE](https://bitbucket.org/raymond_hawkins_utor/monkie/src/main/) as the parameter

- You can specify the path to the image that you want to open

- Or you can indicate a folder that contains an image sequence.

  - If there are image channels split into different files, you can also specify a tuple of strings to distinguish which files in the folder belong to which channel.

*setup_ui* (bool) specifies whether you want to create the UI elements (True) or just load the image (False). (Defaults to True)
riv-hex-table 0.2.2
A Python package to generate Hex styled HTML tables from Pandas DataFrames.
Requires Python: >=3.7

# My Table Package

A Python package to generate and display Hex styled HTML tables from Pandas DataFrames directly in Jupyter notebooks or other IPython environments.

## Installation

You can install this package via pip:

```bash
pip install riv_hex_table # (Once published to PyPI)
2024-can-data-explorer 0.3.0
Library and GUI for viewing CAN bus data from HSM research machines.

# README - CAN Data Explorer

![iFOS logo](/assets/iFOS_Logo_klein_transparent.png)
![Project logo](/assets/co2forit.png)

___

### Data download and installation

1. Download the CAN data from the [CO2ForIT SharePoint][1].

2. Unzip the CAN data at
`2024Q2_Testdaten_Blankenhain/*/can_ifos_logs/CAN_logs.7z`.

3. If you're viewing this online, download the `CAN_Data_Explorer` directory.

4. Install the conda or [mamba][2]
Environment Manager if you don't have it yet
(You can check if you have it by typing `conda --version` on the command line).
If you only have conda, replace `mamba` with `conda` in the commands below.

5. Navigate to the CAN_Data_Explorer folder in the console. E.g.:

        cd /home/user/Downloads/CAN_Data_Explorer

6. Create a new environment from *environment.yml* file using:

        mamba env create -f environment.yml

### How to run the script

7. Run *CAN_Data_Explorer.py* in that environment. E.g.:

        mamba activate co2forit
        python -m CAN_Data_Explorer

8. Now the GUI should open.
    * Use the *Input Parameters* box to enter the locations of the CAN
    measurement files, the DBC file and the time period.
    * Use the *Fuel Calculator* tab to compute the fuel consumed in that time
    period.
    * Use the *Diagrams* tab to plot diagrams of selected CAN signals.
    The signal selection patterns are applied from top to bottom (like this: ↯);
    every signal is only plotted once.
    The <kbd>?</kbd> button brings up a PDF that explains the available signals.
    Create the diagram by clicking on *Draw the figure.*
    The time needed to create the diagram is proportional to the duration of the
    selected time period.
    You can pan and zoom these diagrams and save them to disk.

9. You can also integrate the functions from this library in your own Python
scripts. See:

        python
        >>> import CAN_Data_Explorer as cde
        >>> help(cde)

[1]: https://rifevdortmund.sharepoint.com/:f:/r/sites/CO2For-IT/Freigegebene%20Dokumente/Daten/2024Q2_Testdaten_Blankenhain?csf=1&web=1&e=rBQQkY.
[2]: https://mamba.readthedocs.io/en/latest/