semvec/pypi-packages huggingface dataset:
karma_sphinx_theme 0.0.8
A sphinx theme built with KarmaCSS

# Karma Sphinx Theme

A simple responsive theme for sphinx. This theme is in it's early stage of development so only 
contains limited options.

## Installing

```
pip install karma_sphinx_theme
```

## Configuration

The theme's project-wide options are defined in the `karma_sphinx_theme/theme.conf`
file, and can be defined in your project's `conf.py` via
`html_theme_options`. For example:

```
html_theme_options = {
    'navigation_depth': 2,
    'includehidden': True,
    'titles_only': False
}
```

## Options

* `navigation_depth` Int. Indicate the max depth of the tree, by default, 2 levels are included.
* `includehidden` Bool. Specifies if the sidebar includes toctrees marked with the `:hidden:` option
* `titles_only` Bool. If True, removes headers within a page from the sidebar.
strictclasses 0.1.4
A strict companion to dataclasses

# strictclasses

**Disclaimer: this is beta software, API is not stable.**

This is a validation companion to `dataclasses`. 

It adds the `strict` method to the dataclass to validate the types are correct.
Usage:

```python
from dataclasses import dataclass
from strictclasses import strict

@strict
@dataclass
class Foo:
    bar: int


f = Foo('3')
f.strict() # -> AssertionError: bar is not an instance of <class 'int'>
```
frond 0.0.4
Asynchronous Fan Out/In for Pyramid.

Run an asyncio loop in it's own thread for scheduling awaitables from
within Pyramid views.

This adds request property `loop` and request methods `wait_for`,
`wait_results`, and `await`.

The `loop` property returns the loop running
in it's own thread. Use this loop with `asyncio.run_coroutine_threadsafe`
to run awaitables. For example:

```python
    import asyncio
    from concurrent import futures

    def my_view(request):
        running = asyncio.run_coroutine_threadsafe(my_coroutine(), request.loop)
        done, not_done = futures.wait([running, ...], timeout=3)
        results = [ftr.result() for ftr in done]
        return {'done': results}
```

The `wait_for` method reduces the above boiler plate by waiting for the
futures. Example usage
```python
    def my_view(request):
        done, not_done = request.wait_for([my_coroutine(), ...])
        results = [ftr.result() for ftr in done]
        return {'done': results}
```

The `wait_results` method reduces the boiler plate further by returning
the results after waiting. This is useful if you don't care about
unfinished tasks. Example usage:

```python
    def my_view(request):
        results = request.wait_results([my_coroutine(), ...])
        return {'done': results}
```

The `await` method runs a single awaitable and
blocks until it's results are complete or timeout passes.
Example usage:

```python
    from frond import AwaitableTimeout

    def my_view(request):
        try:
            result = request.await(my_coroutine(), timeout=3)
        except AwaitableTimeout:
            result = 'not completed'
        return {'result': result}
```

Use as any other Pyramid plugin:

```python
    config.include('frond')
```

Currently this package only supports Python 3 (and only tested on Python >=3.6).
flask-cfg 0.0.6
A little package for loading Flask configurations from YAML files.

===========
flask-cfg
===========

A little package for loading Flask configurations from YAML files. Comes 
with an abstract class with base functionality for loading YAML base 
configurations. You can extend the base functionality to dynamically load
additional configurations (e.g. from a database). Typical usage looks like
this::

    from flask import Flask
    from flask_cfg import SimpleConfig

    app = Flask() 
    config = SimpleConfig(default_conf_paths='default.yaml', 
        override_conf_paths='some/path/staging.yaml',
        secret_conf_paths='instance/local.yaml')
    app.config.from_object(config)