semvec/pypi-packages huggingface dataset:
syftbox 0.4.0
Add your description here
Requires Python: >=3.9

```
 ____         __ _   ____
/ ___| _   _ / _| |_| __ )  _____  __
\___ \| | | | |_| __|  _ \ / _ \ \/ /
 ___) | |_| |  _| |_| |_) | (_) >  <
|____/ \__, |_|  \__|____/ \___/_/\_\
       |___/
```

# Quickstart User Installation

## SyftBox 1 liner

curl -LsSf https://syftbox.openmined.org/install.sh | sh -s -- run

## Manual install

### install uv

curl -LsSf https://astral.sh/uv/install.sh | sh

### create a virtualenv somewhere

uv venv .venv

### Install Syftbox

uv pip install -U syftbox

### run the client

uv run syftbox client

# Quickstart Client Developer Installation

### Step 0: Open your terminal to the root of this Github repository

Begin by opening your terminal and navigating to the root directory of this github repository (so when you run 'ls' it should show folders like "syftbox", "server", "tests", etc.). Then run the commands in steps 1-4:

### Step 1: Install Homebrew

```
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
```

### Step 2: Install uv (using homebrew — which is better for this than pip)

```
brew install uv
```

### Step 3: Install a virtual environment using uv

```
uv venv
```

### Step 4: Install a relative version of uv.

```
uv pip install -e .
```

### Step 5: Run the client

```
uv run syftbox/client/client.py
```

# Alternative Options

### Run Client

```
syftbox client --config_path=./config.json --sync_folder=~/Desktop/SyftBox --email=your@email.org --port=8082  --server=https://syftbox.openmined.org
```

### Staging Server

If you have issues or want to use a bleeding edge server try --server=https://syftboxstage.openmined.org

### Deploy

This builds the latest source to a wheel and deploys and restarts the server:
https://syftbox.openmined.org

```
./scripts/deploy.sh
```

### Dev Mode

Run the server and clients locally in editable mode with:
Server:

```
./scripts/server.sh
```

Client1:

```
./scripts/madhava.sh
```

Client2:

```
./scripts/andrew.sh
```
lpsolvers 2.1.0
Linear programming solvers in Python with a unified API.
Requires Python: >=3.8
Keywords: linear programming, solver, numerical optimization

# LP Solvers for Python

[![CI](https://img.shields.io/github/actions/workflow/status/stephane-caron/lpsolvers/test.yml?branch=main)](https://github.com/stephane-caron/lpsolvers/actions)
[![Documentation](https://img.shields.io/github/actions/workflow/status/stephane-caron/lpsolvers/docs.yml?branch=main&label=docs)](https://stephane-caron.github.io/lpsolvers/)
[![Coverage](https://coveralls.io/repos/github/stephane-caron/lpsolvers/badge.svg?branch=main)](https://coveralls.io/github/stephane-caron/lpsolvers?branch=main)
[![Conda version](https://img.shields.io/conda/vn/conda-forge/lpsolvers.svg)](https://anaconda.org/conda-forge/lpsolvers)
[![PyPI version](https://img.shields.io/pypi/v/lpsolvers)](https://pypi.org/project/lpsolvers/)

Wrapper around Linear Programming (LP) solvers in Python, with a unified interface.

## Installation

### From conda-forge

```console
conda install -c conda-forge lpsolvers
```

### From PyPI

To install the library and all available LP solvers at the same time:

```console
pip install lpsolvers[open_source_solvers]
```

To install the library only, assuming LP solvers are installed separately: ``pip install lpsolvers``.

## Usage

The function [`solve_lp`](https://stephane-caron.github.io/lpsolvers//linear-programming.html#lpsolvers.solve_lp) is called with the ``solver`` keyword argument to select the backend solver. The linear program it solves is, in standard form:

$$
\begin{split}
\begin{array}{ll}
    \mbox{minimize} &
        c^T x \\
    \mbox{subject to}
        & G x \leq h \\
        & A x = b
\end{array}
\end{split}
$$

Vector inequalities are taken coordinate by coordinate.

## Example

To solve a linear program, build the matrices that define it and call the ``solve_lp`` function:

```python
from numpy import array
from lpsolvers import solve_lp

c = array([1., 2., 3.])
G = array([[1., 2., -1.], [2., 0., 1.], [1., 2., 1.], [-1., -1., -1.]])
h = array([4., 1., 3., 2.])

x = solve_lp(c, G, h, solver="cvxopt")  # select solver here
print(f"LP solution: {x=}")
```

This example outputs the solution ``[2.2, -0.8, -3.4]``.

## Solvers

The list of supported solvers currently includes:

- [cdd](https://github.com/mcmtroffaes/pycddlib)
- [CVXOPT](http://cvxopt.org/)
- [CVXPY](https://www.cvxpy.org/) (interface)
- [PDLP](https://developers.google.com/optimization/lp/pdlp_math)
- [ProxQP](https://github.com/Simple-Robotics/proxsuite#proxqp)