semvec/pypi-packages huggingface dataset:
llama-index-llms-openrouter 0.4.4
llama-index llms openrouter integration
Requires Python: <4.0,>=3.9

# LlamaIndex Llms Integration: Openrouter

## Installation

To install the required packages, run:

```bash
%pip install llama-index-llms-openrouter
!pip install llama-index
```

## Setup

### Initialize OpenRouter

You need to set either the environment variable `OPENROUTER_API_KEY` or pass your API key directly in the class constructor. Replace `<your-api-key>` with your actual API key:

```python
from llama_index.llms.openrouter import OpenRouter
from llama_index.core.llms import ChatMessage

llm = OpenRouter(
    api_key="<your-api-key>",
    max_tokens=256,
    context_window=4096,
    model="gryphe/mythomax-l2-13b",
)
```

## Generate Chat Responses

You can generate a chat response by sending a list of `ChatMessage` instances:

```python
message = ChatMessage(role="user", content="Tell me a joke")
resp = llm.chat([message])
print(resp)
```

### Streaming Responses

To stream responses, use the `stream_chat` method:

```python
message = ChatMessage(role="user", content="Tell me a story in 250 words")
resp = llm.stream_chat([message])
for r in resp:
    print(r.delta, end="")
```

### Complete with Prompt

You can also generate completions with a prompt using the `complete` method:

```python
resp = llm.complete("Tell me a joke")
print(resp)
```

### Streaming Completion

To stream completions, use the `stream_complete` method:

```python
resp = llm.stream_complete("Tell me a story in 250 words")
for r in resp:
    print(r.delta, end="")
```

## Model Configuration

To use a specific model, you can specify it during initialization. For example, to use Mistral's Mixtral model, you can set it like this:

```python
llm = OpenRouter(model="mistralai/mixtral-8x7b-instruct")
resp = llm.complete("Write a story about a dragon who can code in Rust")
print(resp)
```

## Provider Routing (OpenRouter)

OpenRouter supports selecting which upstream providers to prioritize. You can pass these via `OpenRouter(..., order=[...], allow_fallbacks=...)`.

```python
from llama_index.llms.openrouter import OpenRouter

llm = OpenRouter(
    api_key="<your-api-key>",
    model="mistralai/mixtral-8x7b-instruct",
    order=["openai", "together"],
    allow_fallbacks=False,
)

resp = llm.complete("Hello")
print(resp)
```

### LLM Implementation example

https://docs.llamaindex.ai/en/stable/examples/llm/openrouter/
llama-index-llms-openai-like 0.6.0
llama-index llms openai like integration
Requires Python: <4.0,>=3.9

# LlamaIndex Llms Integration: Openai Like

`pip install llama-index-llms-openai-like`

This package is a thin wrapper around the OpenAI API. It is designed to be used with the OpenAI API, but can be used with any OpenAI-compatible API.

## Usage

```python
from llama_index.llms.openai_like import OpenAILike

llm = OpenAILike(
    model="model-name",
    api_base="http://localhost:1234/v1",
    api_key="fake",
    # Explicitly set the context window to match the model's context window
    context_window=128000,
    # Controls whether the model uses chat or completion endpoint
    is_chat_model=True,
    # Controls whether the model supports function calling
    is_function_calling_model=False,
)
```
distributed 2026.1.2
Distributed scheduler for Dask
Requires Python: >=3.10

Distributed
===========

|Test Status| |Longitudinal Report (full)| |Longitudinal Report (short)| |Coverage| |Doc Status| |Discourse| |Version Status| |NumFOCUS|

A library for distributed computation.  See documentation_ for more details.

.. _documentation: https://distributed.dask.org
.. |Test Status| image:: https://github.com/dask/distributed/actions/workflows/tests.yaml/badge.svg?branch=main
   :target: https://github.com/dask/distributed/actions?query=workflow%3ATests+branch%3Amain
.. |Longitudinal Report (full)| image:: https://github.com/dask/distributed/actions/workflows/test-report.yaml/badge.svg?branch=main
   :target: https://dask.github.io/distributed/test_report.html
   :alt: Longitudinal test report (full version)
.. |Longitudinal Report (short)| image:: https://github.com/dask/distributed/actions/workflows/test-report.yaml/badge.svg?branch=main
   :target: https://dask.github.io/distributed/test_short_report.html
   :alt: Longitudinal test report (short version)
.. |Coverage| image:: https://codecov.io/gh/dask/distributed/branch/main/graph/badge.svg
   :target: https://codecov.io/gh/dask/distributed/branch/main
   :alt: Coverage status
.. |Doc Status| image:: https://readthedocs.org/projects/distributed/badge/?version=latest
   :target: https://distributed.dask.org
   :alt: Documentation Status
.. |Discourse| image:: https://img.shields.io/discourse/users?logo=discourse&server=https%3A%2F%2Fdask.discourse.group
   :alt: Discuss Dask-related things and ask for help
   :target: https://dask.discourse.group
.. |Version Status| image:: https://img.shields.io/pypi/v/distributed.svg
   :target: https://pypi.python.org/pypi/distributed/
.. |NumFOCUS| image:: https://img.shields.io/badge/powered%20by-NumFOCUS-orange.svg?style=flat&colorA=E1523D&colorB=007D8A
   :target: https://www.numfocus.org/
dask 2026.1.2
Parallel PyData with Task Scheduling
Requires Python: >=3.10
Keywords: task-scheduling parallel numpy pandas pydata

Dask
====

|Build Status| |Coverage| |Doc Status| |Discourse| |Version Status| |NumFOCUS|

Dask is a flexible parallel computing library for analytics.  See
documentation_ for more information.


LICENSE
-------

New BSD. See `License File <https://github.com/dask/dask/blob/main/LICENSE.txt>`__.

.. _documentation: https://dask.org
.. |Build Status| image:: https://github.com/dask/dask/actions/workflows/tests.yml/badge.svg
   :target: https://github.com/dask/dask/actions/workflows/tests.yml
.. |Coverage| image:: https://codecov.io/gh/dask/dask/branch/main/graph/badge.svg
   :target: https://codecov.io/gh/dask/dask/branch/main
   :alt: Coverage status
.. |Doc Status| image:: https://readthedocs.org/projects/dask/badge/?version=latest
   :target: https://dask.org
   :alt: Documentation Status
.. |Discourse| image:: https://img.shields.io/discourse/users?logo=discourse&server=https%3A%2F%2Fdask.discourse.group
   :alt: Discuss Dask-related things and ask for help
   :target: https://dask.discourse.group
.. |Version Status| image:: https://img.shields.io/pypi/v/dask.svg
   :target: https://pypi.python.org/pypi/dask/
.. |NumFOCUS| image:: https://img.shields.io/badge/powered%20by-NumFOCUS-orange.svg?style=flat&colorA=E1523D&colorB=007D8A
   :target: https://www.numfocus.org/
llama-index-postprocessor-tei-rerank 0.4.2
llama-index postprocessor text embedding inference rerank integration
Requires Python: <4.0,>=3.9

# LlamaIndex Postprocessor Integration: TEI Rerank

Re-Rankers hosted on Text Embedding Inference Serve by Huggingface.

Install TEI Rerank package with:
`pip install llama-index-postprocessor-tei-rerank`

_text-embeddings-inference_ v0.4.0 added support for CamemBERT, RoBERTa and XLM-RoBERTa Sequence Classification models. Please refer to their repo for any further clarrification :
https://github.com/huggingface/text-embeddings-inference

## Docker start-up for TEI:

```shell
model=BAAI/bge-reranker-large
volume=$PWD/data # share a volume with the Docker container to avoid downloading weights every run

docker run --gpus all -p 8080:80 -v $volume:/data --pull always ghcr.io/huggingface/text-embeddings-inference:1.5 --model-id $model --auto-truncate
```

Post successful startup of the docker image, the re-ranker can be initialised as follows:

```python
from llama_index.postprocessor.tei_rerank import TextEmbeddingInference as TEIR

query_bundle = QueryBundle(prompt)
retrieved_nodes = retriever.retrieve(query_bundle)

postprocessor = TEIR(
    "BAAI/bge-reranker-large", "http://0.0.0.0/8080"
)  # Name of the model used in the docker server and base url (ip:port)

reranked_nodes = postprocessor.postprocess_nodes(
    nodes=retrieved_nodes, query_bundle=query_bundle
)
```
django-jstocks 0.5.4
Collection of small utilities for Django and Django REST framework projects.
Requires Python: >=3.8

Library for Managing Shares Issuance
====================================

Features
--------
* Share registry, ownership information and parties
* Share authorization and allocation to subscribers
* Share transfers
  * Share ownership tracking by sequences
  * Sequence has constant space requirement independent of sequence length
* Double entry accounting system


Install
-------

* pip install django-jshares


About Terminology
-----------------

Issued shares = number of shares of a corporation which have been allocated (allotted) and are subsequently held by shareholders

Issuance = The act of creating new issued shares is called issuance, allocation or allotment. Allotment is simply the creation of shares and their transfer to a subscriber. After allotment, a subscriber becomes a shareholder, though usually that also requires formal entry in the share registry.

Total authorized shares = The number of shares that can be issued. Issued shares are those shares which the board of directors and/or shareholders have agreed to allocate. 

Issued shares are the sum of outstanding shares held by shareholders; and treasury shares are shares which had been issued but have been repurchased by the corporation, and which generally have no voting rights or rights to dividends.

Shares are most commonly issued fully paid, in which case the liability of the shareholders is limited to the amount paid on the shares; but they may also be issued partly paid, with unlimited liability, subject to guarantee, or some other form.

So, as summary, the basic formula:

* Shares authorized = Shares issued + Shares unissued
* Shares issued = Shares outstanding + Treasury shares

(source: https://en.wikipedia.org/wiki/Issued_shares)
llama-index-tools-wolfram-alpha 0.5.0
llama-index tools wolfram_alpha integration
Requires Python: <4.0,>=3.9
Keywords: math

# Wolfram Alpha Tool

This tool connects to Wolfram|Alpha's LLM API, which returns responses optimized
for language model consumption.

You will need to provide an API key: https://products.wolframalpha.com/api

## Usage

This tool has more extensive example usage documented in a Jupyter notebook [here](https://github.com/run-llama/llama_index/blob/main/llama-index-integrations/tools/llama-index-tools-wolfram-alpha/examples/wolfram_alpha.ipynb)

Here's an example usage of the WolframAlphaToolSpec.

```python
from llama_index.tools.wolfram_alpha import WolframAlphaToolSpec
from llama_index.agent.core.agent import FunctionAgent
from llama_index.llms.openai import OpenAI


wolfram_spec = WolframAlphaToolSpec(app_id="API-key")

agent = FunctionAgent(
    tools=wolfram_spec.to_tool_list(),
    llm=OpenAI(model="gpt-4.1"),
)

print(await agent.run("how many calories are in 100g of milk chocolate"))
print(await agent.run("what is the mass of the helium in the sun"))
```

### API Parameters

You can pass additional parameters to the Wolfram|Alpha LLM API:

```python
wolfram_spec = WolframAlphaToolSpec(
    app_id="API-key",
    api_params={
        "maxchars": 2048,  # Maximum characters in response
        "units": "metric",  # Unit system preference
    },
)
```

See the [Wolfram|Alpha LLM API documentation](https://products.wolframalpha.com/llm-api/documentation)
for available parameters.

`wolfram_alpha_query`: Get the result of a query from Wolfram Alpha

This loader is designed to be used as a way to load data as a Tool in a Agent.
sqlmodel-activerecord-mixin 0.1.0
Active Record-style convenience methods (Model.query, save, delete) for SQLModel with Flask-SQLAlchemy.
Requires Python: >=3.9
Keywords: sqlmodel, sqlalchemy, flask, activerecord, orm

# sqlmodel-activerecord-mixin

Active Record–style convenience methods for [SQLModel](https://sqlmodel.tiangolo.com/) when using [Flask-SQLAlchemy](https://flask-sqlalchemy.palletsprojects.com/): `Model.query`, `.save()`, and `.delete()`.

## Install

```bash
pip install sqlmodel-activerecord-mixin
```

## Usage

1. Create a Flask app and init Flask-SQLAlchemy with SQLModel metadata (this package exposes the same `db` instance):

```python
from flask import Flask
from sqlmodel_activerecord import db

app = Flask(__name__)
app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///app.db"
db.init_app(app)
```

2. Define models by inheriting from SQLModel, this mixin, and set `table=True`:

```python
from typing import Optional
from sqlmodel import SQLModel, Field
from sqlmodel_activerecord import ActiveRecordMixin

class Hero(SQLModel, ActiveRecordMixin, table=True):
    id: Optional[int] = Field(default=None, primary_key=True)
    name: str
    secret_name: str
```

3. Use Active Record–style APIs (inside a Flask request or `app.app_context()`):

```python
# Create and save
hero = Hero(name="Iron Man", secret_name="Tony Stark")
hero.save()

# Query
Hero.query.all()
Hero.query.get(1)
Hero.query.filter_by(name="Iron Man").first()
Hero.query.count()

# Update (mutate then save)
hero.age = 50
hero.save()

# Delete
hero.delete()
```

## Requirements

- Python >= 3.9
- Flask, Flask-SQLAlchemy, SQLModel

## Development

```bash
pip install -e .
python usage_test.py   # run module tests
```

## License

MIT