semvec/pypi-packages huggingface dataset:
modelscout 0.1.1
ModelScout: Find the best LLM for your needs.
Requires Python: >=3.7

# ModelScout

**ModelScout** is a command-line tool designed to help users pick the best LLM for their needs. Modelscout uses a similar recommendation algorithm as to [Macros On Demand](https://github.com/Hadi-M-Ibrahim/Macros-On-Demand) a more in-depth example of my SWE work. While ModelScout is simple it serves as a useful stop-gap in the quickly evolving field of LLMs. As the name suggests ModelScout is simply a scout and should serve as the beginning, not the end of your LLM search.

Subjective metrics such as performance and the degree to which a model is supported are gathered from various sources and forums (ie. Benchmarks, Reddit, Google trends. etc) and are based largely on community sentiment so should be taken with a grain of salt. Further note the cost per million tokens for open source models are very rough estimates with varying accuracy.

---

## Installation

Ensure you have Python installed, then install ModelScout using pip:

```sh
pip install modelscout
```

Alternatively, clone the repository manually:

```sh
git clone https://github.com/Hadi-M-Ibrahim/ModelScout.git
cd ModelScout
```

For installation details, visit the [ModelScout PyPI page](https://pypi.org/project/modelscout/).

---

## Command-Line Arguments

| Argument                         | Description                                                 |
| -------------------------------- | ----------------------------------------------------------- |
| `file` (Default: `./models.csv`) | Path to the CSV file                                        |
| `--scout`                        | Launch interactive mode for selecting filters (Recommended) |
| `--top`                          | Number of recommended models to display (5 by default)      |
| `--license`                      | Ideal license (1 for open source, 0 for no preference)      |
| `--performance`                  | Ideal performance rating (1.0-10.0)                         |
| `--cost`                         | Ideal cost per million tokens                               |
| `--context_length`               | Ideal context length                                        |
| `--Support`                      | Ideal API/tools availability (1.0-10.0)                     |

For implemtion details, visit the [ModelScout Github Repo](https://github.com/Hadi-M-Ibrahim/ModelScout).

---

## CSV format

```
Model Name,Company,Context Length,Cost per Million Tokens,Performance,license,Support
```
GenText 0.1.2
A Python package for advanced text generation
Requires Python: >=3.6

# GenText

=======

# GenText

A Python package for advanced text generation capabilities. GenText provides simple, intuitive access to state-of-the-art language models.

## Installation

```bash
pip install GenText
```

Or install from source:

```bash
git clone hhttps://github.com/Sohail-Shaikh-07/Gentext
cd GenText
pip install -e .
```

## Features

- Simple API for text generation
- Advanced chat capabilities
- Access to top-tier language models
- Streaming responses
- Comprehensive error handling
- No API key required - everything works out of the box!

## Usage Examples

### Generate text with a single line

```python
import GenText

response = GenText.generate_text("Write a short poem about nature.")
print(response['content'])
```

### Chat conversations

```python
response = GenText.generate_chat([
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "Explain quantum computing in simple terms."}
])

print(response['content'])
```

### Advanced options

```python
from GenText import client

response = client.chat.generate(
    messages=[
        {"role": "user", "content": "Write a creative story about space exploration."}
    ],
    temperature=0.6,
    max_tokens=1000
)

print(response['content'])
```

### Access full response data

```python
response = GenText.generate_text("Suggest three book titles.")
print(f"Generated by model: {response['model_used']}")
print(response['content'])

# Access the complete API response if needed
full_data = response['full_response']
```

## Error Handling

The package provides helpful error classes:

- `TextGenError`: Base exception class
- `APIError`: Raised for API response errors with status codes

```python
from GenText.exceptions import TextGenError

try:
    response = GenText.generate_text("Write a story.")
except TextGenError as e:
    print(f"Error: {str(e)}")
```

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

## License

This project is licensed under the MIT License
pygfc 1.1.0
Implementation of a Generalized-Feistel Cipher for generating random permutations.
Requires Python: >=3.6

# ðŸŽ² gfc â€” fast & lazy random permutations

[![Tests Status](https://img.shields.io/github/actions/workflow/status/maxmouchet/gfc/tests.yml?logo=github&label=tests)](https://github.com/maxmouchet/gfc/actions/workflows/tests.yml)
[![PyPI](https://img.shields.io/pypi/v/pygfc?color=blue&logo=pypi&logoColor=white)](https://pypi.org/project/pygfc/)

gfc is a C implementation of a Generalized-Feistel Cipher [[1, alg. 3]](#1) for generating random permutations.  
It uses [Speck](https://en.wikipedia.org/wiki/Speck_%28cipher%29) 64/128 as the random function, and can generate permutations with up to `2^64` elements.  
The permutation is computed, and reversed, _on-the-fly_, without any mutable state and by using very little memory.

## Usage

### C / C++

#### API

```c
#include <gfc/gfc.h>
GFC* gfc_init(uint64_t range, uint64_t rounds, uint64_t seed);
void gfc_destroy(GFC* gfc);
uint64_t gfc_decrypt(const GFC* gfc, uint64_t m);
uint64_t gfc_encrypt(const GFC* gfc, uint64_t m);
```

#### Example

```c
// main.c
// gcc -Iinclude/ src/gfc.c main.c -o main
#include <assert.h>
#include <gfc/gfc.h>

int main() {
  GFC* gfc = gfc_init(65536, 6, 42);
  
  for (uint64_t i = 0; i < 65536; i++) {
    uint64_t enc = gfc_encrypt(gfc, i);
    uint64_t dec = gfc_decrypt(gfc, enc);
    assert(enc != i);
    assert(dec == i);
  }

  gfc_destroy(gfc);
  return 0;
}
```

#### CMake Integration

```cmake
cmake_minimum_required(VERSION 3.12)
project(example)
add_subdirectory(gfc)
add_executable(main main.c)
target_link_libraries(main PRIVATE gfc)
```

```bash
git submodule add https://github.com/maxmouchet/gfc.git
mkdir build && cd build
cmake .. && cmake --build .
./main
```

### Python

```
pip install pygfc
```

```python
from pygfc import Permutation
# Permutation(range, rounds, seed)
perm = Permutation(2 ** 16, 8, 42)
assert set(perm) == set(range(2 ** 16))
assert all(perm.inv(perm[i]) == i for i in range(2 ** 16))
```

## Dependencies

The Speck implementation is from [madmo/speck](https://github.com/madmo/speck) and is licensed under the ISC license (MIT-compatible).  

## References

<a id="1">[1]</a> Black, John, and Phillip Rogaway. "Ciphers with arbitrary finite domains." _Cryptographersâ€™ track at the RSA conference_. Springer, Berlin, Heidelberg, 2002.
https://web.cs.ucdavis.edu/~rogaway/papers/subset.pdf
tkinterdnd2 0.4.3
TkinterDnD2 is a python wrapper for George Petasis'' tkDnD Tk extension version 2
Requires Python: >=3.6

## TkinterDnD2

[Eliav2/tkinterdnd2](https://github.com/Eliav2/tkinterdnd2) is a fork of the (unmaintained) [pmgagne/tkinterdnd2](https://github.com/pmgagne/tkinterdnd2) which is a python wrapper for [tkdnd](https://github.com/petasis/tkdnd) . 

This repo was originally forked and edited for the purpose of publishing to pypi so one could simply install this package with  `pip install tkinterdnd2`.

This repository is being maintained to ensure availability of `tkinterdnd2` into the future.

## Install

`python -m pip install tkinterdnd2`

## Usage

```python
import tkinter as tk

from tkinterdnd2 import DND_FILES, TkinterDnD

root = TkinterDnD.Tk()  # notice - use this instead of tk.Tk()

lb = tk.Listbox(root)
lb.insert(1, "drag files to here")

# register the listbox as a drop target
lb.drop_target_register(DND_FILES)
lb.dnd_bind('<<Drop>>', lambda e: lb.insert(tk.END, e.data))

lb.pack()
root.mainloop()
```
![tkinterdnd2 example usage](https://i.stack.imgur.com/jnOWd.png)


see any of the [demos](./demos) for usage examples.

# tkinterdnd2

Tkinter native drag and drop support for windows, unix and Mac OSX.

## What is TkinterDnD2

[TkinterDnD2](http://tkinterdnd.sourceforge.net) is a python wrapper for George Petasis' tkDnD Tk extension version 2.

It is a domain public project.

## What is TkDnD2

[tkDnD2](https://github.com/petasis/tkdnd) is a tcl/Tk extension adding native drag and drop support.

## What this repository is about

This repo package TkinterDnD2 and tkdnd2 into a standard python module.

When the extension is imported in python its location will be automatically added to the Tk search path.

This repository contains the compiled binaries from https://github.com/petasis/tkdnd/releases/tag/tkdnd-release-test-v2.9.4. In order to provide support on ARM, we include built binaries from the now defunct [tkinterdnd2-universal](https://pypi.org/project/tkinterdnd2-universal/#files) which added ARM support.

## pyinstaller

When using `pyinstaller`, you should use the hook-tkinterdnd2.py file included to collect the TkDnD binaries and build them into the project. To use it, copy it into the base directory of your project, then run pyinstaller as follows:

    pyinstaller -F -w myproject/myproject.py --additional-hooks-dir=.
rayson 0.0.4
Generate scripts for JSON instantly for faster development and testing
Requires Python: >=3.6

# JSONQL: JSON Query and Path Generator

JSONQL is a Python library that helps you quickly query JSON data and generate JSON paths for debugging and development. It provides functions to locate keys by a given value and recursively generate full paths for nested JSON structures.

## Features

- **keys_by_value(data, target_value):**  
  Search your JSON data for a specific target value and return a list of key names where that value appears.

- **generate_path(data, payload_name="payload"):**  
  Recursively generate JSON paths for each key in your JSON data. Useful for understanding the structure of nested JSON objects.

- **recursive_path_finder(current_path, value, result):**  
  A helper function that traverses the JSON structure to build complete key paths.

## Installation

Clone the repository and install the package locally:

```bash
https://github.com/ray837/JSONQL.git
cd JSONQL
pip install .
linear-matrix 1.0
A Python library for linear algebra matrix operations.
Requires Python: >=3.6

# Linear Matrix

Linear Matrix is a Python library for performing linear algebra matrix operations.

## Features
- Matrix Addition
- Matrix Multiplication
- Determinants
- Inverse Matrices
- Transposition
- Eigenvalues & Eigenvectors

## Installation
```sh
pip install linear-matrix
```

## Usage

```python
from linear_matrix.matrix import Matrix

A = Matrix([[1, 2], [3, 4]])
B = Matrix([[5, 6], [7, 8]])

# Matrix addition
C = A + B
print(C)

# Matrix multiplication
D = A * B
print(D)

# Transpose
print(A.transpose())

# Determinant
print(A.determinant())

# Inverse
print(A.inverse())
```

## License
MIT License
catgrad 0.2.2
deep learning with reverse derivatives
Requires Python: >=3.8

<div align="center">
<img src="https://raw.githubusercontent.com/statusfailed/catgrad/master/docs/source/catgrad-logo.svg" height=200 />
<h1>catgrad</h1>
</div>

You like category theory? You like tinygrad? You love catgrad! ❤️

catgrad is a bit different: instead of using autograd to train, you *compile*
your model's reverse pass into static code.
This means your training loop can run without needing a deep learning framework
(not even catgrad!)

Here is a linear model in catgrad:

```python
model = layers.linear(BATCH_TYPE, INPUT_TYPE, OUTPUT_TYPE)
```

catgrad can compile this model...

```python
CompiledModel, _, _ = compile_model(model, layers.sgd(learning_rate), layers.mse)
```

... into static code like this...

```python
class CompiledModel:
    backend: ArrayBackend

    def predict(self, x1, x0):
        x2 = x0 @ x1
        return [x2]

    def step(self, x0, x1, x9):
        x4, x10 = (x0, x0)
        x11, x12 = (x1, x1)
        x16 = self.backend.constant(0.0001, Dtype.float32)
        # ... snip ...
        x18 = x17 * x5
        x2 = x10 - x18
        return [x2]
```

... so you can train your model by just iterating `step`; no autograd needed:

    for i in range(0, NUM_ITER):
        p = step(p, x, y)

Catgrad doesn't just compile to Python: I'm working on support for other targets like C++ (ggml), CUDA, FPGAs, and more!

Catgrad uses [reverse derivatives](https://arxiv.org/abs/1910.07065)
and [open hypergraphs](https://github.com/statusfailed/open-hypergraphs/)
to transform a model into its backwards pass.
For details, see [this paper](https://arxiv.org/abs/2305.01041).

# Install

    pip install catgrad

# Examples

Train simple MLPs for the
[iris dataset](https://archive.ics.uci.edu/dataset/53/iris):

    ./data/get-iris-data.sh
    python3 -m examples.iris (linear|simple|dense|hidden)

# Compilation Targets

Target backends we plan to support soon:

- [x] Python/numpy
- [x] Python/torch
- [ ] Python/[tinygrad](https://github.com/tinygrad/tinygrad/)
- [ ] C++/[GGML](https://github.com/ggerganov/ggml)