semvec/pypi-packages huggingface dataset:
cogrow-protean-streamlit 0.0.1
The official Protean Streamlit library
Requires Python: >=3.11

# Protean SDK Streamlit
The CoGrow Protean Streamlit library provides functionality that simplifies integration of Streamlit applications with Protean platform.

## Installation
```sh
# install from PyPI
pip install cogrow-protean-streamlit
```

## Protean Authenticator
`ProteanAuthenticator` allows Streamlit applications to leverage Protean platform authentication using [OAuth2 Resource Server](https://www.oauth.com/oauth2-servers/the-resource-server/) pattern.

### Usage
Using `ProteanAuthenticator` is as simple as importing the module, initializing an instance with the OAuth2 issuer URI and calling `authenticate` to verify logged-in user's credentials:
```python
import streamlit as st

from protean_streamlit import ProteanAuthenticator

protean_authenticator = ProteanAuthenticator("https://keycloak.cogrow.tech/realms/cogrow")
protean_authenticator.authenticate()
if protean_authenticator.is_logged_in:
    st.title("Protean Streamlit App")
```
You could use Protean bearer token to authenticate and access all Protean platform APIs:
```python
import streamlit as st
from openai import OpenAI

from protean import Protean
from protean_streamlit import ProteanAuthenticator

protean_authenticator = ProteanAuthenticator("https://keycloak.cogrow.tech/realms/cogrow")
protean_authenticator.authenticate()

if protean_authenticator.is_logged_in:
    st.title("💬 Chatbot")

    # Use Protean APIs to fetch the user profile details
    protean_client = Protean(base_url=st.context.headers.get('Origin'), api_key=protean_authenticator.bearer_token)
    user_profile = protean_client.user.get_user_profile()
    with st.sidebar:
        st.markdown(f"### 👤 Logged in as: [{user_profile.fullname}](mailto:{user_profile.email})")

    if "messages" not in st.session_state:
        st.session_state["messages"] = [{"role": "assistant", "content": "How can I help you?"}]

    for msg in st.session_state.messages:
        st.chat_message(msg["role"]).write(msg["content"])

    if prompt := st.chat_input():
        client = OpenAI(api_key=protean_authenticator.bearer_token, base_url=f"{st.context.headers.get('Origin')}/api/inference/text")
        st.session_state.messages.append({"role": "user", "content": prompt})
        st.chat_message("user").write(prompt)
        response = client.chat.completions.create(model="llama-3.2-1b-instruct", messages=st.session_state.messages)
        msg = response.choices[0].message.content
        st.session_state.messages.append({"role": "assistant", "content": msg})
        st.chat_message("assistant").write(msg)
```
vonage-utils 1.1.4.dev2
Utils package containing objects for use with Vonage APIs
Requires Python: >=3.9

# Vonage Utils Package

This package contains utility code that is used by the Vonage Python SDK and other related packages.

The utils module provides two utility functions: `format_phone_number` and `remove_none_values`. It also exposes the `VonageError` type that other exceptions related to Vonage SDK inherit from. This can also be accessed via the main SDK module with `vonage.VonageError`.

## Usage

```python
from utils import format_phone_number, remove_none_values

# Use format_phone_number
try:
    formatted_number = format_phone_number('123-456-7890')
    print(formatted_number)
except (InvalidPhoneNumberError, InvalidPhoneNumberTypeError) as e:
    print(e)

# Use remove_none_values to remove null values from a Vonage API response when converting to a dictionary with the `asdict` method
from dataclasses import asdict

vonage_api_response = vonage.api.method()
cleaned_dict = asdict(my_dataclass, dict_factory=remove_none_values)
print(cleaned_dict)
```
mlx-lm-omni 0.1.3
Add your description here
Requires Python: >=3.11

# Inference for Speech Models in MLX

This repo implements some speech models in MLX for better performance on Mac devices.

Currently, it supports the following models:

- [x] Qwen2.5-Omni (both original version and mlx-quant version), currently supported only speech model
- [x] Ultravox-0.5

# Performance

Tested on MacBook M4-Pro (48GB RAM):
| Model                                                                            | Prompt TPS | Generation TPS |
| -------------------------------------------------------------------------------- | ---------- | -------------- |
| Qwen/Qwen2.5-Omni-7B                                                             | 259.5      | 17.8           |
| Qwen/Qwen2.5-Omni-3B                                                             | 468.4      | 38.8           |
| giangndm/qwen2.5-omni-7b-mlx-8bit                                                | 253.4      | 31.7           |
| giangndm/qwen2.5-omni-7b-mlx-4bit                                                | 259.2      | 57.6           |
| giangndm/qwen2.5-omni-3b-mlx-8bit                                                | 456.2      | 67.0           |
| fixie-ai/ultravox-v0_5-llama-3_1-8b and mlx-community/Llama-3.1-8B-Instruct-4bit | 188.5      | 40.4           |

# How to use

```bash
uv add mlx-lm-omni 
# or
uv add https://github.com/giangndm/mlx-lm-omni.git
```

```python
from mlx_lm_omni import load, generate
import librosa
from io import BytesIO
from urllib.request import urlopen

# model, tokenizer = load("giangndm/qwen2.5-omni-7b-mlx-4bit")
model, tokenizer = load("fixie-ai/ultravox-v0_5-llama-3_1-8b", model_config={"text_model_id": "mlx-community/Llama-3.1-8B-Instruct-4bit"})

audio_path = "https://qianwen-res.oss-cn-beijing.aliyuncs.com/Qwen2-Audio/audio/1272-128104-0000.flac"
audio = librosa.load(BytesIO(urlopen(audio_path).read()), sr=16000)[0]

messages = [
    {"role": "system", "content": "You are a speech recognition model."},
    {"role": "user", "content": "Transcribe the English audio into text without any punctuation marks.", "audio": audio},
]
prompt = tokenizer.apply_chat_template(
    messages, add_generation_prompt=True
)

text = generate(model, tokenizer, prompt=prompt, verbose=True)
```
jaraco.itertools 6.4.3
jaraco.itertools
Requires Python: >=3.9

.. image:: https://img.shields.io/pypi/v/jaraco.itertools.svg
   :target: https://pypi.org/project/jaraco.itertools

.. image:: https://img.shields.io/pypi/pyversions/jaraco.itertools.svg

.. image:: https://github.com/jaraco/jaraco.itertools/actions/workflows/main.yml/badge.svg
   :target: https://github.com/jaraco/jaraco.itertools/actions?query=workflow%3A%22tests%22
   :alt: tests

.. image:: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json
    :target: https://github.com/astral-sh/ruff
    :alt: Ruff

.. image:: https://readthedocs.org/projects/jaracoitertools/badge/?version=latest
   :target: https://jaracoitertools.readthedocs.io/en/latest/?badge=latest

.. image:: https://img.shields.io/badge/skeleton-2025-informational
   :target: https://blog.jaraco.com/skeleton
yid-langchain-extensions 0.7.5
Useful classes extending langchain library
Requires Python: <4.0,>=3.9

# Langchain Extensions

A collection of useful extensions for the LangChain library.

## Installation

```bash
pip install yid-langchain-extensions
```

Using uv (recommended):

```bash
uv pip install yid-langchain-extensions
```

For development:

```bash
pip install -e ".[dev]"
```

Or with uv:

```bash
uv pip install -e ".[dev]"
```

## Development

### Running Tests

If you need to run tests sequentially, you can use the standard unittest module:

```bash
python -m unittest discover
```
homegrown 0.0.2
The LLM-Native Agent Framework
Requires Python: >=3.8


# Native 
Agentic workflows uses 2 steps

1. Agent loops: which handles core operation of taking an input and giving an output in micro level. 

2. Agentic Core Components:  peripherals for agentic workflows which enhances agentic workflow into a system level. and give them actual useful problem solving capabilities 


Agent loop consists of core internal flow :

intent  →  plan  →  act  →  interpret  → loop reflection - >  memory ↺

And Agentic Core Components are abstarct features such like:  Multilayer Context
Reflection
Extensive Planning       
Tool Orchestration
Self-Modeling 
Dynamic Memory
Integrated Awareness
Holistic Memory
Autonomous Productive Capacity


there are different approaches to achive/reach these Core Components. And all frameworks treats LLM operations as not enough and support and fill between the operations with lots of python code. 

This has 2 harmful outcomes.  First is scalability problems. To scale your agent you should enhance both agent loop codes and your code resposible of creating abstarct features. Which is not maintainable on the long run. 

Second harmful outcome is about chaining and self calling and recursive looping.  Such manual code based scaffolding makes chaining and self calling non-native and tool calling like.  

So with Native what we do is like every organ in the body is composed of cells and cells are made from atoms, we maintain similar structure in the overall agent by composing each piece from LLMs.  
Agent loop components (intent,  plan ,  act ,  interpret , loop reflection ) are all composed of LLM calls. We dont use python scaffold around everything and this is amazing. 



our framework has 2 slogans

- minimal glue code, maximal LLM calls
- When GLue is absolutely needed, we also use an LLM for glueing