semvec/pypi-packages huggingface dataset:
voxelfarm 0.0.240
Voxel Farm Python Lambdas
Requires Python: >=3.7

# Voxel Farm Client Package

This is a simple example package. You can use
[Voxelfarm PythonCookbook](https://www.voxelfarm.com/help/PythonCookbook.html)

to write your content.


## Initialize API
This example shows how to create a new instance of the Voxel Farm client Python API.


``` python

# Import the Voxel Farm Client Library
from voxelfarm import voxelfarmclient

# The URL for the Voxel Farm API
vf_api_url = os.getenv('YOUR_VOXELFARM_API_URL')

# Create instance of the Voxel Farm REST API
vf = voxelfarmclient.rest(vf_api_url)

```

## Provide Credentials
This example shows how to provide credentials for API authentication.

``` python

# Set credentials
aad_app_secrets = os.getenv('AAD_APP_SECRETS')

if (aad_app_secrets!=None):
    vf.set_file_credentials(aad_app_secrets)

```

## Specify an HTTP proxy
This example shows how to specify an HTTP proxy to be used in all HTTP calls made by the API.

```
# Use a proxy to debug HTTP requests using Fiddler or similar
proxies = {
  "http": os.getenv('YOUR_PROXY_URL'),
}

# Set the proxy to debug HTTP calls
vf.set_proxy(proxies)

```

## Get CRS from project
This example shows how to retrieve the project's CRS (Coordinate Reference System).

``` python
# Get the coordinate system given project ID
result = vf.get_project_crs(project)

if not result.success:
    print(result.error_info)
    exit()
crs = result.crs

```
Forking 0.2
A context manager to fork.
Requires Python: >=3.9

# Forking

`Forking` is a Python context manager that run the code in a different
process.

That means funny business:

```pycon
>>> import os
>>> from forking import Forking
>>>
>>>
>>> with Forking():
...     os._exit(0)
>>> print("I will survive!")
I will survive!
>>>
```

Obviously side effects are only executed in the child process so not
visible to the parent:

```pycon
>>> i = 1
>>> with Forking():
...     i += 1
>>> print(i)
1
>>>
```

## Capturing `stdout` and `stderr`

You can capture `stdout` and `stderr` though:

```python
child = Forking()
with child:
    print("Youpi")
print(child.stdout)
```

Note that we can't do `with Forking() as child` because the `as child`
part is not executed (as considered inside the with body).


## Getting exit status informations

You can also get info about the exit status of your process though
`child.exit` which contains `code`, `signal` and `has_core_dump`:

```pycon
>>> child = Forking()
>>> with child:
...     os._exit(12)
>>> print(child.exit.code)
12
>>>
```

## Reusing a context manager


A `Forking` context can be reused (but its process will not):

```pycon
>>> child = Forking()
>>> with child:
...     os._exit(21)
>>> print(child.exit.code)
21
>>> with child:
...     os._exit(22)
>>> print(child.exit.code)
22
>>>
```

## Timeout


You can specify a `timeout` for your child, the following snipet runs
in 0.2s, not 10s:

```pycon
>>> import time
>>>
>>> child = Forking()
>>> child.timeout = 0.2
>>> with child:
...    time.sleep(10)
...
>>>
```

When a child is killed after exceeding its deadline, you'll have a
`SIGKILL` in `child.exit.signal`:

```
>>> child.exit.signal
9
>>>
```


## Custom child exception hooks

You can give a custom exception hook, either by subclassing:

```python
class FriendlyForking(Forking):
    """A Forking class that use Friendly Traceback"""

    def exception_hook(self, exc_type, exc_value, tb):
        friendly_traceback.session.exception_hook(exc_type, exc_value, tb)
```

or if you're lazy:

```python
forking = Forking()
forking.exception_hook = friendly_traceback.session.exception_hook
```
mlcpl 0.1.7
Add your description here
Requires Python: >=3.8

# mlcpl: A Python Package for Deep Multi-label Image Classification with Partial-labels on PyTorch

(This is the Introduction part of the package. It will be filled after the paper is published.

---

## Requirements

This mlcpl package requires Python having a minimum version of 3.8.20. Additionally, it also requires the following packages:
- `"Cython==0.29.33"`,
- `"lvis==0.5.3"`,
- `"pandas==1.5.2"`,
- `"protobuf==3.20.1"`,
- `"pycocotools>=2.0.7"`,
- `"tensorboard>=2.14.0"`,
- `"torch>=1.13.1"`,
- `"torchmetrics>=1.5.2"`,
- `"torchvision>=0.14.1"`,
- `"xmltodict==0.13.0"`

These requirements should be automatically installed when installing the mlcpl package.

## Installation

The mlcpl package can be easily installed via the Python package index (PyPI). For example:

```
# with pip
pip install mlcpl

# or with uv
uv add mlcpl
```

Once the package is installed, it should be able to be used by calling:

```
import mlcpl
```
simple-tsp 0.2.1
Solving the Traveling Salesman Problem
Requires Python: >=3.12

# Solving the Traveling Salesman Problem

This package uses PyVRP to solve the traveling salesman problem.
It can handle distance data in the following three ways.

* A dictionary whose keys are tuples of two cities and whose values are integer distances
  * A dictionary whose city type is an integer (pattern 1)
  * A dictionary whose key is a tuple of cities and whose value is a string (Pattern 2)
* Nested lists whose values are distances (pattern 3)

## Functions

* `tsp(distances, depot, max_iterations)`: Solve a traveling salesman problem and return a list of cities
  * `distances`: Dictionary or list of distances
  * `depot`: First city
  * `max_iterations`: Number of iterations to use in PyVRP

```python
tsp(distances: dict[tuple[int, int], int], depot: int = 0, max_iterations: int = 100) -> list[int]
tsp(distances: dict[tuple[str, str], int], depot: str, max_iterations: int = 100) -> list[str]
tsp(distances: list[list[int]], depot: int = 0, max_iterations: int = 100) -> list[str]
```

* `distance(lat1: float, lon1: float, lat2: float, lon2: float) -> float`: Return the great circle distance (km) between two points
  * `lat1`: Latitude of location 1
  * `lon1`: Longitude of location 1
  * `lat2`: Latitude of location 2
  * `lon2`: Longitude of location 2

## Usage

```python
from simple_tsp import tsp

# Pattern 1
distances1 = {(0, 2): 1, (2, 3): 1, (3, 1): 1, (1, 0): 1}
print(tsp(distances1, 0))  # [0, 2, 3, 1]

# Pattern 2
distances2 = {("a", "c"): 1, ("c", "d"): 1, ("d", "b"): 1, ("b", "a"): 1}
print(tsp(distances2, "a"))  # ['a', 'c', 'd', 'b']

# Pattern 3
distances3 = [[0, 9, 1, 9], [1, 0, 9, 9], [9, 9, 0, 1], [9, 1, 9, 0]]
print(tsp(distances3))  # [0, 2, 3, 1]
```
simgrid 4.1
Toolkit for scalable simulation of distributed applications

SimGrid is a scientific instrument to study the behavior of large-scale distributed systems such as Grids, Clouds, HPC or P2P systems. It can be used to evaluate heuristics, prototype applications or even assess legacy MPI applications.

This package contains a native library. Please install cmake, boost, pybind11 and a C++ compiler before using pip3. On Debian/Ubuntu, this is as easy as
sudo apt install cmake libboost-dev pybind11-dev g++ gcc