semvec/pypi-packages huggingface dataset:
kalabash-admin-limits 1.0.5
Per administrator limits for Kalabash
License: MIT

####################################
`Kalabash <https://monakmail.com/>`_
####################################

********
Kalabash
********


*************
External code
*************

External libraries provided with Kalabash:

* `jQuery version 1.9.1 <http://www.jquery.org/>`_
* `jQuery-UI 1.10+ <http://jqueryui.com/>`_
* `Bootstrap version 3.3.7 <http://getbootstrap.com/>`_
* `Bootstrap datetimepicker <http://eonasdan.github.io/bootstrap-datetimepicker/>`_
mloq 0.0.75
Package for initializing ML projects following ML Ops best practices.
License: MIT
Keywords: Machine learning,artificial intelligence

# ML Ops Quickstart
[![Documentation Status](https://readthedocs.org/projects/mloq/badge/?version=latest)](https://mloq.readthedocs.io/en/latest/?badge=latest)
[![Code coverage](https://codecov.io/github/fragiletech/ml-ops-quickstart/coverage.svg)](https://codecov.io/github/fragiletech/ml-ops-quickstart)
[![PyPI package](https://badgen.net/pypi/v/mloq)](https://pypi.org/project/mloq/)
[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)
[![license: MIT](https://img.shields.io/badge/license-MIT-green.svg)](https://opensource.org/licenses/MIT)

ML Ops Quickstart is a tool for initializing Machine Learning projects following ML Ops best practices.

Setting up new repositories is a time-consuming task that involves creating different files and 
configuring tools such as linters, docker containers and continuous integration pipelines. 
The goal of `mloq` is to simplify that process, so you can start writing code as fast as possible.

`mloq` generates customized templates for Python projects with focus on Maching Learning. An example of 
the generated templates can be found in [mloq-template](https://github.com/FragileTech/mloq-template).

## [1.](#Index) Installation

`mloq` is tested on Ubuntu 18.04+, and supports Python 3.6+.

### Install from pypi
```bash
pip install mloq
```
### Install from source
```bash
git clone https://github.com/FragileTech/ml-ops-quickstart.git
cd ml-ops-quickstart
pip install -e .
```

## [2.](#Index) Usage
### [2.1](#Index) Command line interface

Options:
* `--file` `-f`: Name of the configuration file. If `file` it's a directory it will load the `mloq.yml` file present in it.

* `--overwrite` `-o`: Rewrite files that already exist in the target project.
* `--interactive` `-i`: Missing configuration data can be defined interactively from the CLI.

#### Usage examples
Arguments:
* `OUTPUT_DIRECTORY`: Path to the target project.

To set up a new repository from scratch interactively in the curren working directory:
```bash
mloq setup -i .
```

To load a `mloq.yml` configuration file from the current repository, and initialize the directory `example`, and 
overwrite all existing files with no interactivity:
```bash
mloq setup -f . -o example
```

![ci python](docs/images/mloq_setup.png)

## [5.](#Index) License
ML Ops Quickstart is released under the [MIT](LICENSE) license.

## [6.](#Index) Contributing

Contributions are very welcome! Please check the [contributing guidelines](CONTRIBUTING.md) before opening a pull request.
fnsafe 0.0.1.post1
Not raising functions - like rust.
License: MIT
Keywords: error,exception,function,functional,raise,rust,safe

fnsafe
======

The `fnsafe` library provides a decorator to
make your functions not raising errors. Instead
you are forced to handle the error.

The design is inspired by rust's
[Option](https://doc.rust-lang.org/std/option/enum.Option.html) and
[Result](https://doc.rust-lang.org/std/result/enum.Result.html)
enums.

While the class's name is `Result`, it provides
most of the functionality from rust's `Option` enum
instead of rust's `Result` enum.

```bash
pip install fnsafe
```

```python
import fnsafe

@fnsafe.makesafe
def divide(a, b, /):
    return a / b

result = divide(10, 0)
# Normally, this would raise an error since we're
# dividing through zero. The decorator turns the
# return value into a `Result` object.

print(result.unwrap())
# If the calculation succeded, it will be printed,
# otherwise it will throw an exception. However we
# can provide a default value:

print(result.unwrap_or(42))
import time
print(result.unwrap_or_else(lambda: time.time_ns()))

# Checking if a function succeded can be done by
# calling one of the `is_*` methods:
print(f"{result.is_none() = }")
print(f"{result.is_some() = }")
print(f"{result.is_some_and(lambda x: x % 2 == 0) = }")

# ... and much more feautures ...
```