semvec/pypi-packages huggingface dataset:
manim-web-physics 0.1.0
A fork of Manim Physics for Manim Web
Requires Python: <3.14,>=3.10

# Manim Web Physics: A fork of Manim Physics for Manim Web

## Introduction
Manim Physics is a plugin for Manim that provides support for many physics simulations, including rigid mechanics, optics, and more. This fork, `manim-web-physics`, is specifically designed to work with Manim Web, making it easier to create physics-based animations in a web environment. It's **the same code**, but `manim` dependency is replaced with `manim-web` and some minor changes to the code to ensure compatibility with Manim Web.

**Official Documentation:** https://manim-physics.readthedocs.io/en/latest/

**Note:** If something is not working, maybe you must make some minor changes to your scene's code, as Manim Web has some differences compared to Manim. Check this at [Manim Web's repository](https://github.com/MathItYT/manim).

## Installation
Just install `manim-web-physics` with Pyodide's `micropip`:

```python
import micropip

await micropip.install("manim-web-physics")
```

**So important:** You will need to download the `pymunk` wheel file from [here](https://github.com/viblo/pymunk/releases/download/7.0.1/pymunk-7.0.1-cp312-cp312-pyodide_2024_0_wasm32.whl), as it's not available in PyPI. After downloading, you can install it with:

```python
import micropip

await micropip.install("path/to/pymunk-7.0.1-cp312-cp312-pyodide_2024_0_wasm32.whl")
```
argshell 1.6.6
Integrates the argparse and cmd modules.
Requires Python: >=3.10
Keywords: argparse, cmd, commandline, shell, terminal

# argshell

Integrates the argparse and cmd modules to create custom shells with argparse functionality. 

## Installation

Install with:

<pre>
pip install argshell
</pre>



## Usage

Custom shells are created by subclassing the ArgShell class and adding functions of the form `do_*()`, just like the cmd.Cmd class.  
The `ArgShell` class contains a `rich.console.Console` object that can be used to print renderables.  
![](assets/myshell.svg)

In terminal:
![](assets/echo.svg)

---

Rather than being limited to input strings, you can use `argparse` style parsers for shell commands.  
Create a function that instantiates an `ArgShellParser` instance, adds arguments, and then returns the `ArgShellParser` object.  
Then you can can decorate `do_*` functions using `with_parser()` to pass a `Namespace` object instead of a string.
![](assets/myshell_with_parser.svg)

In terminal:
![](assets/add_help.svg)
![](assets/add.svg)

---

The `with_parser` function also accepts an optional list of functions that accept and return an `argshell.Namespace` object.  
These functions will be executed in order after the parser function parses the arguments.
![](assets/post_parser.svg)

In terminal:
![](assets/invert_add.svg)
![](assets/invert_double_add.svg)

--- 

When using your shell, entering `help command` will, in addition to the command's doc string,
print the help message of the parser that decorates it, if it is decorated.  
![](assets/help_list.svg)
![](assets/help.svg)

---

The `capture` command can be used to save an svg of another command's output by prepending to a command.  
(NOTE: This only works for output printed with `ArgShell`'s `console` member mentioned earlier.)  
The font size is proportional to your terminal width when using the command and any text your terminal wraps will be truncated in the svg.  
The following would create a file called `add.svg` in your current directory:
![](assets/capture.svg)
The saved svg:
![](assets/add.svg)

---

There's also a "hidden" command for generating documentation called `shell_docs`.
![](assets/help_shell_docs.svg)

Executing that command for `MyShell`:
![](assets/shell_docs.svg)
speedbeaver 0.2.1
Setting up logging for FastAPI should not take up the bulk of your time.
Requires Python: >=3.10

# SpeedBeaver - Structlog Integration for FastAPI

When asked what their favourite part of a new project is, I can guarantee you very few developers will say this: **setting up logging.**

Thing is, logs are crucial for both security and development, giving you detailed insights as to what's going on at any given point with an application. They just . . . really suck to set up.

SpeedBeaver was built to have a simple, approachable, set-it-and-forget-it way of setting up logging middleware in FastAPI using `structlog`. It's designed as an alternative to the existing [`fastapi-structlog`](https://github.com/redb0/fastapi-logger).

## Current Status

The integration is currently in a pre-alpha state. API is subject to change, as is the name of the library itself, even.

## Features

- 3-4 lines of config for the basics
- Optional BYOP (Bring Your Own Processors)
- Environment variable configuration via Pydantic Settings
- File logging

### Planned Features and Items

- OpenTelemetry integrations
- Database integrations
- Documentation

## Installation

> [!CAUTION]
> SpeedBeaver is NOT yet on PyPI! The below command(s) will not work until this README is updated and the project is fully released.

```bash
pip install speedbeaver
```

## Configuration

To drop SpeedBeaver into any FastAPI app, see the following Python snippet:

```python
from fastapi import FastAPI

import speedbeaver

app = FastAPI()
speedbeaver.quick_configure(app)

# Try using the line below instead to see the difference!
# speedbeaver.quick_configure(app, log_level="DEBUG")

logger = speedbeaver.get_logger()


@app.get("/")
async def index():
    await logger.debug("I'm a debug message!")
    await logger.info("Hello, world!")
    return {"message": "Hello, world!"}
```
segment-animals 1.0.0
Segment (Extract) Animals from Images - Removing Background
Requires Python: >=3.10

# Segment Animals

Segment Animals is a Python package for segmenting (extracting) animals from images using deep learning models. It provides a pipeline that combines object detection and segmentation to identify and extract animals from images, making it useful for wildlife research, conservation efforts, and any application where you wish to remove the background from images containing animals.

Segment Animals builds upon the [Segment Anything](https://github.com/facebookresearch/segment-anything) and [MegaDetector](https://github.com/agentmorris/MegaDetector/blob/main/getting-started.md) models.

# Installation

You can install Segment Animals using pip:

```bash
pip install segment-animals
```

## Usage

Here's a quick example of how to use Segment Animals, for a more detailed guide refer to the [notebook](./notebook.ipynb).

### Importing the library and processing an image

```python
from segment_animals import AutoAnimalSegmenter
from segment_animals.util import load_image

model = AutoAnimalSegmenter()

image = load_image("path/to/your/image.jpg")

detections, masks = model.process_image(image)
print(f"Found {len(detections)} animals.")
```

### Visualizing detections and masks

```python
from segment_animals.viz import plot_detections_and_masks

plot_detections_and_masks(image, detections, masks)
```

You should then see a visualisation along the lines of this ([original image from Wikipedia](https://commons.wikimedia.org/wiki/File:Camouflaged_Predator.jpg))...

![Example Segmentation](./example_viz.png)

### Extracting and saving masks

```python
from segment_animals.viz import extract_masks

# Setting whole_image to False will return individual masks cropped to the extent
# of the predicted masks.
for i, mask_extract in enumerate(extract_masks(image, masks, whole_image=False)):
    # mask_extract is a PIL Image object so you can save it or manipulate it further
    mask_extract.save(f"animal_mask_{i}.png")
```

Resulting in something like this:

![Example Mask](./example_extract.png)

# Working with Segment Animals?

It'd be great to hear how you're using Segment Animals! Drop me a line at Benjamin.Evans at ioz.ac.uk or open an issue on the [GitHub repository](https://github.com/bencevans/segment-animals/issues).
packagelister 2.2.0
Determine what 3rd-party packages a project imports.
Requires Python: >=3.10
Keywords: import, module, package

# packagelister

Determine what packages and versions a project imports.  

Install with:

```console
pip install packagelister
```

## Usage

---

Can be used either programmatically or with the included cli.  

### Programmatic  

![programmatic example](assets/programmatic_eg.svg)

### CLI

There are three cli tools included in this package: `packagelister`, `whouses`, and `localimps`.  

#### packagelister

For the current directory, can be used to print the packages used by the current directory,
generate a `requirements.txt` file, and view which files import a package.

![packagelister help](assets/packagelister_help.svg)

![packagelister example](assets/packagelister_cli_eg.svg)

#### whouses

Given a package name, scan the current directory for which sub-directories use that package.  
Useful for knowing which projects you'll need to update when upgrading an installed package.  

![whouses help](assets/whouses_help.svg)

![whouses example](assets/whouses_eg.svg)

#### localimps

For displaying information about local modules and import structure.

![localimps help](assets/localimps_help.svg)

![localimps example](assets/localimps_eg.svg)
opsduty-client 0.0.7
A client library for accessing opsduty
Requires Python: <4.0,>=3.9

# opsduty-client
A client library for accessing opsduty

## Usage
First, create a client:

```python
from opsduty_client import Client

client = Client(base_url="https://opsduty.io")
```

If the endpoints you're going to hit require authentication, use `AuthenticatedClient` instead:

```python
from opsduty_client import AuthenticatedClient

client = AuthenticatedClient(base_url="https://opsduty.io", token="oAuth2 access token")
```

Now call your endpoint and use your models:

```python
from opsduty_client.models import MyDataModel
from opsduty_client.api.my_tag import get_my_data_model
from opsduty_client.types import Response

with client as client:
    my_data: MyDataModel = get_my_data_model.sync(client=client)
    # or if you need more info (e.g. status_code)
    response: Response[MyDataModel] = get_my_data_model.sync_detailed(client=client)
```

Or do the same thing with an async version:

```python
from opsduty_client.models import MyDataModel
from opsduty_client.api.my_tag import get_my_data_model
from opsduty_client.types import Response

async with client as client:
    my_data: MyDataModel = await get_my_data_model.asyncio(client=client)
    response: Response[MyDataModel] = await get_my_data_model.asyncio_detailed(client=client)
```

## Advanced customizations

There are more settings on the generated `Client` class which let you control more runtime behavior, check out the docstring on that class for more info. You can also customize the underlying `httpx.Client` or `httpx.AsyncClient` (depending on your use-case):

```python
from opsduty_client import Client

def log_request(request):
    print(f"Request event hook: {request.method} {request.url} - Waiting for response")

def log_response(response):
    request = response.request
    print(f"Response event hook: {request.method} {request.url} - Status {response.status_code}")

client = Client(
    base_url="https://opsduty.io",
    httpx_args={"event_hooks": {"request": [log_request], "response": [log_response]}},
)

# Or get the underlying httpx client to modify directly with client.get_httpx_client() or client.get_async_httpx_client()
```

You can even set the httpx client directly, but beware that this will override any existing settings (e.g., base_url):

```python
import httpx
from opsduty_client import Client

client = Client(
    base_url="https://opsduty.io",
)
# Note that base_url needs to be re-set, as would any shared cookies, headers, etc.
client.set_httpx_client(httpx.Client(base_url="https://opsduty.io", proxies="http://localhost:8030"))
```
meshctl 0.1.7
A CLI tool for meshtastic operations
Requires Python: >=3.8

# meshctl

A CLI tool for mesh operations.

## Installation

### Using uv (recommended)

Run directly without installation:
```bash
uvx meshctl
```

### Using pip in a virtual environment

```bash
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate
pip install meshctl
```

## Usage

```bash
meshctl --help
```

## Development

### Setup

Install development dependencies:

```bash
make sync
```

Or manually with uv:

```bash
uv sync --dev
```

### Development Commands

Run tests:

```bash
make test
```

Format code:

```bash
make format
```

Lint code:

```bash
make lint
```

Build package:

```bash
make build
```

Run all checks:

```bash
make check
```

Clean build artifacts:

```bash
make clean
```

Install in development mode:

```bash
make install
```

See all available commands:

```bash
make help
```