semvec/pypi-packages huggingface dataset:
mipsolver-lytreallynb 1.0.1
High-performance Mixed-Integer Programming solver (Professional Edition)
Requires Python: >=3.8
Keywords: optimization mip solver integer programming commercial


# MIPSolver Pro

High-performance C++ Mixed-Integer Programming solver with Python interface.

## Features
- Optimized Branch & Bound algorithm
- Support for MPS standard file format  
- Simple and easy-to-use Python API
- Commercial-grade algorithm protection
- Cross-platform support (Windows/Linux/macOS)

## Quick Start

```python
import mipsolver

# Create optimization problem
problem = mipsolver.Problem("MyProblem", mipsolver.ObjectiveType.MAXIMIZE)

# Add binary variables
x0 = problem.add_variable("x0", mipsolver.VariableType.BINARY)
x1 = problem.add_variable("x1", mipsolver.VariableType.BINARY)

# Set objective function
problem.set_objective_coefficient(x0, 5.0)
problem.set_objective_coefficient(x1, 8.0)

# Add constraints
c0 = problem.add_constraint("c0", mipsolver.ConstraintType.LESS_EQUAL, 10.0)
problem.add_constraint_coefficient(c0, x0, 2.0)
problem.add_constraint_coefficient(c0, x1, 4.0)

# Solve
solver = mipsolver.Solver()
solution = solver.solve(problem)

print(f"Optimal solution: {solution.get_objective_value()}")
print(f"Variable values: {solution.get_values()}")
```

## License
This software is commercial software protected by intellectual property rights. 
Use of this software indicates agreement to the relevant license terms.
paral 0.2.4
An Git User/Credential Switcher
Requires Python: >=3.13

# Parallel (paral)
An Git User/Credential Switcher

## Demo
[![asciicast](https://asciinema.org/a/729390.svg)](https://asciinema.org/a/729390)

## Install
```shell
pipx install paral
```

uv: 
```shell
uv tool install paral
```

## how to use
### Temporarily switch users
```shell
$ paral env
```
### Add User
```shell
$ paral user add
```
### Delete User
```shell
$ paral user delete
```
### Switch User
```shell
$ paral user switch

# or
$ paral switch
```
#### Apply account switching to local only
```shell
$ paral user switch --local
```
### Add Alias
```shell
$ paral alias add
```
### Delete Alias
```shell
$ paral alias delete
```

## Feature
- Terminal-Based UI
- Manage multiple Git users
- Manage Git credential informations and switch between credentials to use
- Aliases

## Requirements
- Python
- Git
- GCM Core

## Todo
- Golang Port
    - Need to write a parser for gitconfig
weatherapi-mcp-server 0.1.0
Add your description here
Requires Python: >=3.13

# Weather MCP Server

[![smithery badge](https://smithery.ai/badge/@devilcoder01/weather-mcp-server)](https://smithery.ai/server/@devilcoder01/weather-mcp-server)

A Model Context Protocol (MCP) server for weather data, built with FastAPI and the MCP framework. This server provides various weather-related tools that can be used by AI assistants to retrieve current weather conditions, forecasts, air quality data, and more.

## Features

- Current weather conditions
- Weather forecasts (1-14 days)
- Historical weather data
- Weather alerts
- Air quality information
- Astronomy data (sunrise, sunset, moon phases)
- Location search
- Timezone information
- Sports events

## Requirements

- Python 3.13+
- [uv](https://github.com/astral-sh/uv) package manager
- [WeatherAPI](https://www.weatherapi.com/) API key

## Installation

### Installing via Smithery

To install Weather Data Server for Claude Desktop automatically via [Smithery](https://smithery.ai/server/@devilcoder01/weather-mcp-server):

```bash
npx -y @smithery/cli install @devilcoder01/weather-mcp-server --client claude
```

### Manual Installation
1. Clone this repository:
   ```
   git clone https://github.com/yourusername/Weather_mcp_server.git
   cd Weather_mcp_server
   ```

2. Install dependencies using uv:
   ```
   uv venv
   uv pip install -e .
   ```

3. Create a `.env` file in the project root with your WeatherAPI key:
   ```
   WEATHER_API_KEY=your_api_key_here
   ```

## Usage

Run the server:

```
python main.py
```

The server will start on http://localhost:8000 by default.

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
limin-talk 0.2.0
A Python library for letting two LLMs talk to each other.
Requires Python: >=3.10

# limin-talk

A Python library for letting two LLMs talk to each other.

## Installation

Install the library using pip:

```bash
python -m pip install limin-talk
```

## Usage

After you've installed the library, you can use it by importing the `limin_talk` module and calling the functions you need.
You will also need to provide an API key for your API either by running `export OPENAI_API_KEY=$YOUR_API_KEY` or by creating an `.env` file in the root directory of your project and adding the following line:

```
OPENAI_API_KEY=$YOUR_API_KEY
```

Here's an example of how to use the library:

```python
from limin import ModelConfiguration
from limin_talk import Character, talk

user_character = Character(
    system_prompt="You are a helpful assistant who only speaks English.",
    model_configuration=ModelConfiguration(model="gpt-4o"),
)

assistant_character = Character(
    system_prompt="You are a helpful assistant who only speaks German.",
    model_configuration=ModelConfiguration(model="gpt-4o"),
)


async def main():
    conversation = await talk(user_character, assistant_character, 3)
    print(conversation.to_pretty_string())


if __name__ == "__main__":
    import asyncio
    import dotenv

    dotenv.load_dotenv()

    asyncio.run(main())
```

Basically, the library contains the following two components:

The `Character` class, which is used to create a character that can be used to talk to another character.
To instantiate a character, you need to provide a system prompt and a model configuration for the character.

The `talk` function, which is used to let two characters talk to each other.
To use the `talk` function, you need to provide two characters and the number of turns you want the conversation to have.

The `talk` function will return a `Conversation` object, which contains the conversation history.

You can find the example in [`examples/demo.py`](examples/demo.py).
django-compteurvues 0.1.0
Package Django pour compter les vues sur n'importe quel objet comme une page, un article de blog, un produit etc.
Requires Python: >=3.6

# django-compteurvues

"djangocompteurvues" est un package Django réutilisable permettant de compter et afficher le nombre de vues sur n’importe quel objet de votre projet Django (articles, pages, produits, etc.).

Il utilise la puissance des relations génériques (`GenericForeignKey`) pour s’adapter à tout modèle, et fournit une interface simple avec une vue et un template minimaliste.


## Fonctionnalités

- Comptabilisation automatique des vues sur n’importe quel modèle Django.
- Généricité totale grâce à `ContentType` et `GenericForeignKey`.
- Interface simple (pas de JavaScript, juste du HTML).
- L'intégration est facile dans n’importe quel projet Django.
- Gestion des compteurs visible et modifiable dans l’admin Django.

## Prérequis
Ce package est une app Django.
Vous devez déjà avoir un projet Django existant (avec un manage.py).

## Installation

1. Installez le package via pip :

    pip install django-compteurvues

2. Ajoutez `compteurvues` à la liste `INSTALLED_APPS` de votre fichier `settings.py` :

    INSTALLED_APPS = [
        ...
        'compteurvues',
    ]

3. Lancez les migrations :

    python manage.py migrate


## Utilisation
1. Ajoutez le compteur dans votre vue :

    from compteurvues.utils import ajouter_vue

    def detail_article(request, pk):
        article = get_object_or_404(Article, pk=pk)
        ajouter_vue(request, article)  # Enregistre une vue
        return render(request, "article_detail.html", {"article": article})

2. Affichez le nombre de vues dans votre template :

    <p>{{ article.vues }} vues</p>

Exemple de modèle personnalisé

    from compteurvues.models import VueCompteurMixin

    class Article(VueCompteurMixin, models.Model):
        titre = models.CharField(max_length=200)
        contenu = models.TextField()

-ADMIN

Le modèle `CompteurVue` est visible dans l’interface d’administration Django.
mappls-map-widget 0.1.1
Mappls Map Widget for Django
Requires Python: >=3.7

# mappls-map-widget

Mappls Map Widget for Django  
Easily embed Mappls maps and PIN location previews in your Django forms.

## Features

- Django form widget for Mappls PIN with map preview
- Customizable zoom and pitch
- Simple integration with your forms

## Installation

```bash
pip install mappls-map-widget
```

## Usage

Add the widget to your Django form:

```python
from django import forms
from mappls_map_widget.widgets import MapplsPinWithMapEmbedWidget

class LocationForm(forms.Form):
    pin = forms.CharField(widget=MapplsPinWithMapEmbedWidget(zoom=10, pitch=2))
```

## Requirements

- Python 3.7+
- Django 3.2+

## Development

Clone the repo and install dependencies:

```bash
git clone https://github.com/soumayg9673/mappls-django.git
cd mappls-django
pip install -e .
```

## Django Setup

Add `mappls_map_widget` to your `INSTALLED_APPS` in `settings.py`:

```python
INSTALLED_APPS = [
    # ... other apps ...
    'mappls_map_widget',
]
```

## License

MIT

## Author

Soumay Gupta  
pmrs9673@gmail.com
satya-1 0.1.3
Satya - Educational Python interpreter for data structures and algorithms in natural language.
Requires Python: >=3.6

# satya-1

Write and learn data structures and algorithms in easy, everyday languageâ€”no complex code, just simple commands.

## Installation

```bash
pip install satya-1
```

## Basic Usage

```python
from satya import SatyaInterpreter

interpreter = SatyaInterpreter()
print(interpreter.run("Create linked list with 3 nodes"))
print(interpreter.run("Add satya, 1, 2, 3"))
print(interpreter.run("Remove 2nd element"))
print(interpreter.run("List show"))
```

## More Use Cases

### Stack Operations
```python
interpreter.run("Create stack")
interpreter.run("Push X")
interpreter.run("Pop")
interpreter.run("Stack show")
```

### Queue Operations
```python
interpreter.run("Create queue")
interpreter.run("Enqueue 5,6,7")
interpreter.run("Dequeue")
interpreter.run("Queue show")
```

### Graph Operations
```python
interpreter.run("Create graph")
interpreter.run("Add edge A B")
interpreter.run("Add edge B C")
interpreter.run("Show graph")
interpreter.run("DFS A")
interpreter.run("BFS A")
```

### Math & Logic
```python
interpreter.run("Is 121 palindrome?")
interpreter.run("Factorial of 5")
interpreter.run("Fibonacci till 10")
interpreter.run("Sort 5 1 3 2")
interpreter.run("Search 3 in 1 2 3 4")
interpreter.run("Is 153 armstrong?")
interpreter.run("Is 29 prime?")
```

## Advantages
- **Natural Language Interface:** Use plain English to interact with data structures and algorithms.
- **Educational:** Great for teaching and learning basic data structures and algorithms.
- **Quick Prototyping:** Instantly test logic and structure operations without boilerplate code.
- **Extensible:** Easily add new commands or extend existing ones for custom educational needs.
- **No Dependencies:** Pure Python, no external requirements.

## License
MIT