semvec/pypi-packages huggingface dataset:
tisp 0.1.1
Solve TSP instances to optimality.
Requires Python: >=3.9,<3.12

Download the TSP instances.

Extract them and put them in a folder called `tsp`. 

When installed into your environment (for example using Poetry), you can do:

```
tisp <path to tsp .dat>
```

Alternatively, when using it as a library, you can do:

```python
from tisp import cli

cli()
```

Then run the script. By default it looks for the `gr48` instance.

To run a specific instance, do (the path is interpreted relatively):


```python
from tisp import solve_from_path

solve_from_path("gr96.dat")
```

Or, when you have an instance already loaded, with the costs a simple cost matrix of type `list[list[float]]`:

```python
from tisp import do_branch_and_bound

# inst = ... load instance here

do_branch_and_bound(inst)
```

It only works for fully connected instances. An example is:

```
3
0 20 5
20 0 3
5 3 0
```

"3" is the size of the instance, the rest indicates the cost of edge (i, j), where i is the row and j the column.

Supports Python up to 3.11. Uses mip as the underlying LP solving library. By default it uses included CBC binaries.

### Performance

The main peformance bottleneck is the computation of the min cut to find the constraint to be added to the LP, although for larger instances solving the LP's also takes significant time.

On my 5-year old laptop, `gr48` takes under 10 seconds. Computing it directly as an LP with a solver can take 30-50 seconds. For larger instances, this solver performs even better.
Eliza-GPT 0.1.0
Eliza, the chatbot from the 1960s, running on OpenAI's Chat Completions API
Requires Python: >=3.8

# Eliza-GPT

[Eliza](https://en.wikipedia.org/wiki/ELIZA), the classic chatbot from the 1960s, running on OpenAI's [Chat Completions API](https://platform.openai.com/docs/api-reference/chat).

## Why?

The main reason is that this seemed like a fun project to help me acquire a greater understanding of the Chat Completions API from OpenAI, which has become a sort of standard for turn-based conversation between a human and a machine.

But also, it is great to have a fast and free service with negligible resource consumption that can be used as a stand-in for a real LLM when the quality of the responses do not matter, such as while doing development or testing.

## How To Use

Eliza-GPT is written in Python and can be installed with `pip`:

    $ pip install eliza-gpt

Once installed, run it to start it as a local service on your computer:


    $ eliza-gpt
    Eliza-GPT is running!
    Set base_url="http://127.0.0.1:5005/v1" in your OpenAI client to connect.

Run with `--help` to learn about configuration options, which include:

- Setting the listening IP address and port
- Adding an API key for authentication
- Changing the (simulated) response times, or removing all artificial delays.

If you are using the official Python client from OpenAI, add the `base_url` option to it as follows:

    openai_client = OpenAI(base_url='http://localhost:5005/v1')

If you use Langchain, then use the following to connect to Eliza-GPT:

    chat = ChatOpenAI(base_url='http://localhost:5005/v1')

Eliza-GPT supports both the direct and streaming interfaces.

## Examples

The [examples](https://github.com/miguelgrinberg/Eliza-GPT/tree/main/examples) directory includes demonstration applications implemented with the OpenAI client and Langchain.

## Implementation Details

Eliza-GPT implements a portion of the OpenAI Chat Completions API, ignoring anything that isn't useful.

The following aspects of the API are currently supported:

- The chat history given in the `messages` argument. Only messages with role `user` are used to "prime" Eliza so that it provides a reasonable response.
- The `stream` argument, which determines if the response should be given in a single JSON object or as a stream of Server-Sent Events.
- The `seed` option, which makes it possible to have deterministic responses.

These are not used or implemented:

- Any messages in the chat history that have a role different than `user`.
- Model names. Eliza-GPT returns the requested model name in the response.
- The `n` argument, which controls how many responses are returned. Eliza-GPT always returns a single response.
- The `max_tokens` argument.
- Temperature and other LLM-specific tuning parameters.
- The `stop` argument.
- Anything related to tools or functions that the model may call.
- Anything related to log probabilities.
Destipy 0.81
Asynchronous Python Wrapper for the Bungie API
Requires Python: >=3.7
Keywords: bungie,destiny,async,wrapper,api

# Destipy

This is a asynchronous Python Wrapper around the Bungie API. It allows one to send requests to all given endpoints of the Bungie API seen in their [Bungie.Net API Documentation](https://bungie-net.github.io/multi/index.html).

NOTE:

* The endpoints are parsed from the API documentation and are therefore not tested, some of them might not work or are missing parameters due to inconsistencies in the documentation.
* Some of the code is inspired or taken from [pydest](https://github.com/jgayfer/pydest/tree/master/pydest) and [aiobungie](https://github.com/nxtlo/aiobungie) so check them out!

## Features

* Every endpoint in the documentation is implemented, POST and GET.
* Download and Extraction of the manifest to a .content file.
* Download and Extraction of the manifest to a MongoDB database (COMING SOON).
* Logging with own logger or with the default logger by adding a file "logs/Destipy.log" ('logs' being a folder) in the root folder.

## Examples

Here are a few examples:

* [COMING SOON](https://www.youtube.com/watch?v=dQw4w9WgXcQ&ab_channel=RickAstley)
* [COMING SOON](https://www.youtube.com/watch?v=dQw4w9WgXcQ&ab_channel=RickAstley)
* [COMING SOON](https://www.youtube.com/watch?v=dQw4w9WgXcQ&ab_channel=RickAstley)

### Requirements

* aiohttp

Install `Destipy`:

```
pip install Destipy
```

In you project you can use it as a simple client without authentication by initialize a client with your Api Key like this:

```
from destipy.destiny_client import DestinyClient

client = DestinyClient(<API_KEY>)
user = await client.user.GetBungieNetUserById(<MEMBERSHIP_ID>)
```

If you plan on using a specific category of endpoints multiple times you can also use the endpoint category itself as a class:

```
from destipy.destiny_client import DestinyClient

client = DestinyClient(<API_KEY>)
user_endpoints = client.user
user = await user_endpoints.GetBungieNetUserById(<MEMBERSHIP_ID>)
```

## Contact

Discord: `sedam79`
imgsegmentationmq 1.3.0
Image segmentation package
Requires Python: >=3

# Description
Repository for the image segmentation package.

# Installing the package

To install the package in Unix/macOS, execute the following command:

python3 -m pip install imgsegmentationmq


To install the package in Windows, execute the following command:

py -m pip install imgsegmentationmq

# Importing and uding the package

To import the package to your python script run the following line:

import imgsegmentationmq

To import all the algorithms to your script run the following line:

from imgsegmentationmq import *

Once you have run the previous line, you can start using the algorithms by using the respective calls:  

    For the k-means algorithm:

        imgsegmentationmq.means.kmeans(k,image, max_it, init_centroids)

    For the c-means algorithm:

        imgsegmentationmq.means.kmeans(k,image,m,max_it,init_centroids)

    For the k-quantile algorithm:

        imgsegmentationmq.means.kmeans(k,image,k1,k2,max_it,init_centroids)

    For the c-quantile algorithm:
    
        imgsegmentationmq.means.kmeans(k,image,m,k1,k2, max_it, init_centroids)

Please make sure you have the arguments in the appropiate form. Specifically note that to use these algorithms
the image to which you will apply it needs to be a numpy array with shape (image length, image width, image colorscale),
this means that for a 60x40 image in gray colorscale, the shape should be (60,40,1) while for the a 60x40 image with RGB
colorscale, the shape of the numpy array should be (60,40,3).
ctool 0.0.1
A CMake wrapper and toolset
Requires Python: >=3.6
Keywords: cmake

# CTool

A CMake wrapper and toolset.

## Planned tools

- `ctool-autoinstall` - detect missing dependencies and install them using distribution package managers
- `ctool-changed-tests` - use cmake-file-api and CTest json to determine what files might change the output of which tests
fb-streamlit-auth 0.0.2
Streamlit component that allows you to implement Firebase login
Requires Python: >=3.7

fb-streamlit-auth

Simple component that implements Firebase authentication.

Example usage:

```python
import streamlit as st
from fb_streamlit_auth import fb_streamlit_auth

st.write('''## Hello
- world
''')

user = fb_streamlit_auth(
    "<apiKey>",
    "<authDomain>",
    "<databaseURL>",
    "<projectId>",
    "<storageBucket>",
    "messagingSenderId",
    "appId",
    "measurementId"
)

st.write(user)
```

The implementation, right now, is really crude. The API is subject to change. The ```user``` object returned by fb_streamlit_auth is None if the user is not logged in.
When the user is logged in the object also contains the custom claims associated to the user. In this way the app can check for claims to block or allow access.

## Inspiration
My main source of inspiration was the [msal_streamlit_authentication library](https://github.com/mstaal/msal_streamlit_authentication)
ht2 0.2.5
Just a bag of quality of life tools for Machine Learning Engineers
Requires Python: >=3.7

# htlib
Just a bag of quality of life tools for Machine Learning Engineers

## install
`pip install ht2 ` or
`pip install ht2 --index-url https://pypi.org/simple`

## post upgrades
`python3 -m build`
`python3 -m twine upload --repository pypi dist/*`

## TODO
* sphinx documentation