semvec/pypi-packages huggingface dataset:
fmo-cli 1.2.0
Command Line Interface to access and upload FindMyOyster data
Requires Python: <4,>=3.7
Keywords: FindMyOyster, CLI

# FindMyOyster Command Line Interface

This CLI tool allows you to interact with the [FindMyOyster](https://findmyoyster.com) backend to upload or access data. You can also use it as a library in your own scripts.

## Installation

```
pip install fmo-cli
```

## Authenticate 

Before making any requests to the API you must authenticate. API requests are authenticated using a token.

To get a token to must use the `authenticate` command.

```
fmo authenticate
```
The command will ask for 4 values
- URL: Where is the FMO server? The default value is most likely OK
- Farm: FMO isolates all data per farm. Before doing anything you need to know what farm you are working with. For experiments you can probably use the "demo" farm, which is basically open to anyone.
- Username: The username you would use in the app
- Password: The password you would use in the app

If authentication is successful, then a token will be saved in a `.env` file. FMO will look for the token there for all subsequent request. 

If you already have a token, you are welcome to create the file by hand and skip the authentication step. The file should look like this:
```
FMO_TOKEN=<my-token>
FMO_API_URL=https://api.findmyoyster.com/v1
```


## Example commands

Get a list of oyster beds at the farm
```
fmo beds list
```

Generate a sample path on a given oyster bed. Generated paths are useful for test and demos.
```
fmo simulator spiral-path --bed <bed-id> -o my-path.json --preview
```

Upload a path as a new substrate log
```
fmo logs upload --file my-path.json --type substrate
```

Find a list of logs on a oyster bed
```
fmo logs find --bed <bed-id> --type substrate
```

View and download a specific log
```
fmo logs geometry <log-id> --preview -o output.json
```
drakken 3.1.4
Python web microframework

# Drakken

A minimalist [WSGI] web framework written in [Python]. Uses the [SQLAlchemy] database toolkit and the [Mako] template engine.

## Install

    pip3 install drakken

## Quickstart

1. Create a file **demo.py** and paste the following code into it:

        from drakken.core import Drakken
        app = Drakken()

        @app.route('/')
        def home(request, response):
            response.text = 'Hello from the HOME page'

        if __name__ == "__main__":
            app.runserver()

2. Launch demo.py:

        python3 demo.py

3. Visit the demo app's [home page](http://127.0.0.1:8000). You should see a web page with the message **Hello from the HOME page**.

## Links

- [Project page](https://seagrape.us/drakken/index.html)

## Contact Me

Send bug reports and patches to <craig@seagrape.us>.

[WSGI]: https://seagrape.us/blog/wsgi.html
[SQLAlchemy]: https://www.sqlalchemy.org
[Mako]: https://www.makotemplates.org
[Python]: https://www.python.org
monitool 0.1.1
A little library for writing monitoring plugins for Nagios, Icinga, and probably others that are ABI-compatible.

# monitool

A little library for writing monitoring plugins for Nagios, Icinga, and
probably others that are ABI-compatible.

## Usage

```python
import monitool
from monitool import Info, Perf, Status

# First: define a Plugin class.
class Plugin(monitools.Plugin):
    # Then: set up some defaults
    description = 'My awesome monitoring plugin'

    # single_valued = False
    # If the above is uncommented, doesn't add args.warn (-w) and args.crit
    # (-c) automatically

    def configure_parser(self, parser):
        parser.add_argument('arg', type=float, help='The value to check')
        parser.add_argument('unit', default='', help='The unit this value has')

    # Finally: define some checks
    # The Plugin automatically finds `check`, and any method starting with
    # `check_`, but you can override `all_checks` to change this
    def check(self, args):
        return Info(
            # status=Status.OK,  # Without this, inferred from the Perf data
            head='The arg is {}{}'.format(args.arg, args.unit),
            perf=Perf('arg', args.arg, args.unit, args.warn, args.crit),
        )

if __name__ == '__main__':
    Plugin().main()  # don't forget to run it!
```

The API is experimental and subject to change. Feedback is welcome!

Further examples are in the `examples/` directory; the one above is by no means
a complete demonstration.

## Specification

This package attempts to conform with [the Nagios plugin guidelines][npdg].
Generally speaking, usage of this library (without malice) that results in an
out-of-spec output is a bug. Feel free to report it as such!

[npdg]: https://nagios-plugins.org/doc/guidelines.html

## License

GPLv3 or later at your option. See LICENSE for details.
dss_wdc_client 0.1.0
A small Client for the WDC-Rest-API.
Requires Python: >=3.10

Step 1: After clean rebuild
=== 

	poetry install

Step 2: Typical cases
=== 

* Abhängigkeiten aktualisieren
	 poetry update
	 
* Eine Python-Datei: src/main.py

	poetry run python3 src/main.py
	
* Testfälle siehe: https://pytest-with-eric.com/getting-started/poetry-run-pytest/

	poetry run pytest 
	poetry run pytest -k test_simple
	poetry run pytest -s (mit Output)
	
Publish to PyPI
===
(https://python-poetry.org/docs/repositories/#publishable-repositories)
	
1. Config token (once)
	poetry config pypi-token.pypi <my-token>

2. Publish
	poetry publish --build
yt-music-down 0.0.2
A tool to download music playlists from youtube
Requires Python: >=3.8

# yt music down

[![PyPI - Version](https://img.shields.io/pypi/v/yt-music-down.svg)](https://pypi.org/project/yt-music-down)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/yt-music-down.svg)](https://pypi.org/project/yt-music-down)

-----

## Table of Contents

- [Installation](#installation)
- [License](#license)

## Installation

```console
pip install yt-music-down
```

## License

`yt-music-down` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.
async-interpreters 0.1.4
subinterpreters for asyncio.
Requires Python: >=3.12

# async-interpreters
subinterpreters for asyncio

## Usage

```python
from async_interpreters import WorkersPool

workers = WorkersPool(max_size=10, timeout=5)

def calc_sum(a, b):
    sum = a
    for i in range(b):
        sum += i
    return sum


async def usage():
    await workers.run_sync(calc_sum, 10, 100_000_000)


async def benchmark():
    t = time.perf_counter()
    await asyncio.gather(*(usage() for _ in range(10)))
    print(time.perf_counter() - t)

```
stylotool 0.0.1
A tool for stylistic device detection
Requires Python: >=3.6

# STYLOTOOL - an easy-to-use stylistic device detection tool for stylometry

An easy-to-use package for detecting stylistic devices in text. This package is designed to be used in stylometry, the study of linguistic style.

For those proficient in python, this package provides a collection of approaches to detect stylistic devices in text. For those less proficient in python, this package provides a simple interface to detect stylistic devices in text with simple commands and user-friendly configuration.
For an example on usage, see `example_chiasmus.sh` and the config file `example_config.json`.

# Installation
The package is available on PyPi and can be installed using pip.
TODO: add installation instructions

# Participation
The package is free and open-source software and contributions are very welcome.
It is designed to be a living project that is constantly improved and extended.
If you have implemented your own stylistic device detector, please consider contributing it to the package.
Also, if you have any suggestions for improvements or if you find any bugs, please open an issue on the GitHub page.
torchlet 0.1.0
A small, minimalist variant of PyTorch.
Requires Python: <4.0,>=3.11

# Torchlet

<div align="center">
  <figure>
    <img width="223" alt="torchlet_logo" src="assets/torchlet.png">
  </figure>
</div>


A small, minimalist variant of Pytorch. Built for educational purposes.

## Notes
- This is a work in progress. The goal is to implement a small subset of Pytorch's functionality.
- The code is not optimized for performance.
- Inspired by [karpathy/micrograd](https://github.com/karpathy/micrograd).