semvec/pypi-packages huggingface dataset:
stubdocs 0.0.0
Adds docstrings to your type stubs.
License: MIT
Requires Python: >=3.7

# stubdocs

Adds docstrings to your type stubs.

## Installation

```bash
pip install stubdocs
```

## Usage

```console
$ stubdocs . --stub-dir stubs
rewrote stub stubs/mypackage/foo.pyi using docstrings in mypackage/foo.py
rewrote stub stubs/mypackage/bar/baz.pyi using docstrings in mypackage/bar/baz.py
```

## Local Development / Testing

- Create and activate a virtual environment
- Run `pip install -r requirements-dev.txt` to do an editable install
- Run `pytest` to run tests

## Type Checking

Run `mypy .`

## Create and upload a package to PyPI

Make sure to bump the version in `setup.cfg`.

Then run the following commands:

```bash
rm -rf build dist
python setup.py sdist bdist_wheel
```

Then upload it to PyPI using [twine](https://twine.readthedocs.io/en/latest/#installation):

```bash
twine upload dist/*
```
letrista 0.1.0
Python3 package for lyrics writing and formating.
License: MIT
Requires Python: >=3.7

====================================================
Letrista |pipy-version| |build-status| |docs-status|
====================================================


Letrista is a markup syntax and parser system for lyrics writing, written in `Python 3 <https://www.python.org/>`_. It allows the use of comments and useful notes for lyrics drafts, such as rhyme scheme and syllable count.

The output of this parser is in `marke37 <https://github.com/ramoscarlos/marke37>`_ format, which is a modified version of the Markdown syntax. This output can be processed further if needed into a more common and visual format (mainly HTML).

The primary goal of this package is to aid the lyricists/songwriters (mainly myself) to concentrate on the actual content that will remain on the lyrics, while also leaving the options available within the same file (for if those are needed to compare or restore).

The ideal usage of this package is with a real-time editing tool, like within the Sublime Text editor, with the `Letrista Sublime <https://github.com/ramoscarlos/letrista_sublime>`_ plugin, but the module is provided for inclusion in other projects.

A demo editor is provided at `quick-draft.letrista.app <https://quick-draft.letrista.app/>`_, with an already populated `example in English <https://quick-draft.letrista.app/example>`_ and `one in Spanish <https://quick-draft.letrista.app/ejemplo>`_.

The module is released under the MIT license, so you can pretty much what you want with it. For the full documentation, visit `Read The Docs <https://letrista.readthedocs.io>`_.


.. ###
.. Substitutions
.. ################

.. |pipy-version| image:: https://img.shields.io/pypi/v/letrista.svg
   :target: https://pypi.python.org/pypi/letrista
   :alt: PiPy Version

.. |build-status| image:: https://img.shields.io/travis/ramoscarlos/letrista.svg
   :target: https://travis-ci.com/ramoscarlos/letrista
   :alt: Build Status

.. |docs-status| image:: https://readthedocs.org/projects/letrista/badge/?version=latest
   :target: https://letrista.readthedocs.io/en/latest/?version=latest
   :alt: Documentation Status
flaregun 0.0.2
Tiny PyTorch helper package to get stats on GPU usage, model params, etc.
License: MIT
Requires Python: >=3.9

# flaregun

A simple helper package for PyTorch to get better visibility on real-time GPU usage, model params, etc.

## Installation

```bash
$ pip install flaregun
```

## Usage

Get real-time Nvidia GPU memory usage in Python:

```python
from flaregun import GPUStats

# Pretty print statistics for GPU #0
GPUStats(device=0).print()
> "GPU memory usage: 3061 / 32510 MB"
```

Get parameter count in any PyTorch compatible model (e.g. HuggingFace, etc.):

```python
from flaregun import ModelStats

# Get HuggingFace model
model = AutoModelForMaskedLM.from_pretrained("/path/to/Longformer-Model")

# Pretty print Model parameter count
ModelStats(model).print()
> "148711257 params (148711257 trainable | 0 non-trainable)"
```

## API

All features of the library are listed below.

### GPU memory utilization

```python
from flaregun import GPUStats

device = ...integer of GPU device...

# Free GPU memory (in MB)
free_mem = GPUStats(device).free()

# Total GPU memory (in MB)
total_mem = GPUStats(device).total()

# Used GPU memory (in MB)
used_mem = GPUStats(device).used()
```

### Model parameter count

```python
from flaregun import ModelStats

model = ...PyTorch-compatible model...

# Total params
total = ModelStats(model).total()

# Trainable params
trainable = ModelStats(model).trainable()

# Frozen (non-trainable) params
frozen = ModelStats(model).frozen()
```
## Contributing

Interested in contributing? Check out the contributing guidelines. Please note that this project is released with a Code of Conduct. By contributing to this project, you agree to abide by its terms.

### Running Tests

```bash
poetry run pytest tests/
```

### Test PyPI

Create release:
```
git tag vXX.XX.XXX
git push --tags
# Then go to Github and link this tag to a Release
```

Publish:

```bash
poetry build
poetry publish -r test-pypi --username XXX --password XXXX
```

Install:
```bash
pip3 install --index-url https://test.pypi.org/simple/ --extra-index-url https://pypi.org/simple flaregun
```

### PyPI

Publish:
```
poetry publish
```

### Building Docs

```bash
cd docs
poetry run make clean html && poetry run make html
```
## License

`flaregun` was created by Michael Wornow. It is licensed under the terms of the MIT license.

## Credits

`flaregun` was created with [`cookiecutter`](https://cookiecutter.readthedocs.io/en/latest/) and the `py-pkgs-cookiecutter` [template](https://github.com/py-pkgs/py-pkgs-cookiecutter).
announce-server 0.0.3rc0
Announces a server to a host
License: MIT
Requires Python: >=3.7

# Announce Server

A Python library that announces a server to a host.

## Installation

```bash
pip install announce-server
```

## Development

To install the developer dependencies required for testing and publishing:
```bash
pip install -e .[dev,pub]
```

## Build
To build the package, run:

```bash
rm -rf dist/ build/ .eggs/ .pytest_cache/ src/announce_server.egg-info/
python -m build --sdist --wheel
```

To publish:

```bash
twine upload dist/*
```

## Test

To run the tests, call:

```bash
pytest
```

## Usage

```python
from announce_server import register_service

@register_service(name="server_name", ip="server_ip", port=8000, host_ip="host_server_ip", host_port=5000, retry_interval=5)
def your_function():
    pass

```

## Registry

The `announce_server` CLI provides a simple way to start a registry server. The registry server keeps track of available services and periodically sends heartbeat messages to ensure that registered services are still active.

### Command

```bash
announce_server start_registry [--address ADDRESS] [--port PORT] [--heartbeat_interval INTERVAL] [--heartbeat_timeout TIMEOUT]
```

### Arguments

- `--address ADDRESS`: The IP address of the server. Default: `0.0.0.0`.
- `--port PORT`: The port number of the server. Default: `4999`.
- `--heartbeat_interval INTERVAL`: The interval between heartbeat messages in seconds. Default: `5`.
- `--heartbeat_timeout TIMEOUT`: The timeout for waiting for a response in seconds. Default: `3`.

### Example

To start the registry server with the default configuration, run:

```bash
announce_server start_registry
```

The full syntax is equivalent to:

```bash
announce_server start_registry --address 0.0.0.0 --port 4999 --heartbeat_interval 5 --heartbeat_timeout 3
```

To test connections, run:

```bash
announce_server start_client --host-ip 0.0.0.0 --host-port 4999
```