semvec/pypi-packages huggingface dataset:
in-container 0.7
Check if running inside a Docker container
Requires Python: >=3.6

# in-container [![PyPI version](https://badge.fury.io/py/in-container.svg)](https://badge.fury.io/py/in-container)[![Build Status](https://travis-ci.com/ZiggerZZ/in_container.svg?branch=master)](https://travis-ci.com/ZiggerZZ/in_container)[![codecov](https://codecov.io/gh/ZiggerZZ/in_container/branch/master/graph/badge.svg)](https://codecov.io/gh/ZiggerZZ/in_container)

> Allows you to check if your program is running inside a Docker container

## Install

```
$ pip install in-container
```

## Usage

```python
from in_container import in_container
print(in_container()) # True or False
```

## License

[MIT](https://github.com/ZiggerZZ/in_container/blob/master/LICENSE)
oswhich 0.1.0
{description}
Requires Python: <4,>=3.7

# oswhich
This package allows for cross-platform implementations on-the-go with a very sugary decorator syntax. It works also for classes, its methods and properties. Although, development is still incipient so feel free to open an issue on the bug tracker.

## Examples
```python
from oswhich import linux, macosx, windows, solaris

@linux
def f(x):
    return 2 * x

@macosx
def f(x):
    return x ** 2

@windows
def f(x):
    return x + 2

>>> f(3) # in Linux
6
>>> f(3) # in MacOSx
9
>>> f(3) # in Windows
5
>>> f(3) # in Solaris
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
RuntimeError: Sorry, function `f` was not implemented for your platform. 
```

## Advanced usage
You may define your own definition selector. Internally, ``OsWhich`` relies on ``platform.system()`` to select current platform. If ``OsWhich.__init__`` takes a string as parameter, it just compares it with ``platform.system()``'s output. If you pass a ``callable`` to the constructor, you are allowed to do whatever you want, as long as this function follows the signature ``foo(system: str) -> bool``.

```python
from oswhich import OsWhich

mysystem = OsWhich(foo)

@mysystem
def f(x):
    return -x
```
ingot-rabbitmq 0.1.0
Provides functionality for working with the RabbitMQ tool

# Ingot Rabbitmq Ingot package.

Provides functionality for working with the RabbitMQ tool

## For consumers

For using the Ingot package just execute the following command:
```bash
pip install ingot_rabbitmq
```
Of course, need to activate a destination virtual environment before:
```bash
source .venv/bin/activate
```
... or to create one, if it hasn't prepared yet:
```bash
python3 -m venv .venv
```

### Bootstrap entrypoint

The Ingot package provides the Bootstrap CLI tool.
It allows to begin working with the Ingot package quickly.
It generates the following skeletons:
TODO. Add builders here after generating their by the `ingots package_bootstrap` tool.

For using the CLI tool just call the following command:
```bash
ingot-rabbitmq-cli <command> --name=<entity_name> --description="The <entity> brief description."
```
Getting help:
```bash
ingot-rabbitmq-cli --help
ingot-rabbitmq-cli <command> --help
```

## For developers

### Prepare the project for working

Clone a repository:
```bash
mkdir ingots-libs
cd ingots-libs
git clone https://github.com/ABKorotky/ingot-rabbitmq.git
cd ingot-rabbitmq
```

Prepare a virtual environment:
```bash
python -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
```

Prepare repository hooks
```bash
pip install pre_commit
pre-commit install
```

Configure code-quality tools:
```bash
pip install black flake8 mypy coverage
```

Configure the Sphinx tool

Please, use the following page for configuring the Sphinx documentation generator: [Sphinx](https://www.sphinx-doc.org/en/master/usage/installation.html)
```bash
pip install sphinx
sphinx-build -b html docs docs/build -v
```

### Using the tox tool

The Ingot package allows automation via the `tox` tool.
```bash
pip install tox
```

Use configured tox tool for several activities.

`tox -e reformat` - auto reformat code by the black tool, makes ordering import too.

`tox -e cs` - checks code style by PEP8.

`tox -e ann` - checks annotations of types by the mypy tool.

`tox -e utc` - runs unittests with the coverage tool.

`tox -e report` - builds coverage report for the project.

`tox -e doc` - builds a package documentation.

`tox -e build` - builds a package form current branch / tag / commit. Set the `INGOT_RABBITMQ_VERSION_SUFFIX` virtual variable for specify package suffix.

`tox -e upload` - uploads package to the PyPI index. Set the `PYPI_REPOSITORY_ALIAS` virtual variable for specify PyPI destination.

Calling tox without parameters will execute the following steps: **cs**, **ann**, **utc** and **report**.

### Using package bootstrap locally
Obviously, it's impossible to call the package bootstrap tool via package entry-point.

Use the following command instead:
```bash
python -m ingot_rabbitmq.scripts.ingot_rabbitmq ...
```