semvec/pypi-packages huggingface dataset:
structconf 0.3.0
struct config using yaml
License: MIT
Requires Python: >=3.7,<4.0

# StructConf

[![PyPI](https://img.shields.io/pypi/v/structconf?color=blue)](https://pypi.org/project/structconf/)
[![Codecov](https://img.shields.io/codecov/c/gh/Green-Wood/structconf)](https://app.codecov.io/gh/Green-Wood/structconf)

Config your project with yaml and validation.

Enjoy wirting your code with IDEs python **type hint**

## Simple Usage

1. Define your configuration class, with attribute type and default value

```python
from structconf import StructConf

class SimpleConf(StructConf):
    a: int = 1
    b: str = "b"
```

2. write your yaml config file (e.g simple.yaml)

```yaml
a: 2
b: "123"
```

3. load yaml config file to your struct class

```python
conf = SimpleConf.load("simple.yaml")
assert conf.a == 2
assert conf.b == "123"
```



## Advanced Usage

StructConf use [pydantic](https://github.com/samuelcolvin/pydantic) to validate your yaml and python class. So we can use recursive modelto build complex configuration.

```python
from structconf import StructConf

class AConf(StructConf):
    a: int = 1


class BConf(StructConf):
    b: int = 2


class ComplexConf(StructConf):
    aconf: AConf = AConf()
    bconf: BConf = BConf()
```
django-flipt 0.2.4
Flipt Integration for Django and Django REST Framework
License: MIT
Requires Python: >=3.6,<4.0
Keywords: flipt,django,django-rest-framework,feature-flag,feature-toggle

# django-flipt

<p>
<img src="https://img.shields.io/pypi/v/django-flipt">
<img src="https://img.shields.io/pypi/l/django-flipt">
<img src="https://img.shields.io/pypi/pyversions/django-flipt">
<img src="https://img.shields.io/pypi/dm/django-flipt">
<img src="https://img.shields.io/github/workflow/status/earthpyy/django-flipt/CI/main">
<img src="https://img.shields.io/github/workflow/status/earthpyy/django-flipt/CodeQL/main?label=CodeQL">
</p>

<p>Flipt Integration for Django and Django REST Framework</p>

## Installation

```shell
pip install django-flipt
```

## Usage

1. Add `flipt` into `INSTALLED_APPS`

```python
INSTALLED_APPS = [
    ...
    'flipt',
]
```

2. Define Flipt gRPC endpoint in `settings.py`

```python
FLIPT_GRPC_HOST = 'flipt:9000'
```

3. Ready to go!

### Overriding Flags

You can override any flag by defining your flag key and overriding value

```python
FLIPT_FLAG_OVERRIDDEN = {
    'some-flag-key': True
}
```

### Available Classes/Functions

- `flag_enabled`
- `flag_disabled`
- `FlaggedRouter`
- `@flag_check`
- `@override_flags`
- `{% featureflag %} ... {% endfeatureflag %}`
- `FeatureFlagListView`
- `flagged_path`
- `flagged_re_path`

## Development

### Requirements

- Docker

### Run Project

```shell
$ make
```

### Linting/Test Project

```shell
$ make lint
$ make test
```

## Credits

- [Flipt](https://flipt.io)
- Inspired by [django-flags](https://github.com/cfpb/django-flags)
flasksaml 0.2.0
A Flask wrapper that implements SAML Service Provider functionalities
License: MIT
Requires Python: >=3.6
Keywords: saml saml2 flask python3

# Flask SAML

A Flask wrapper that implements SAML Service Provider (SP) functionalities. A marriage between
[Flask](https://github.com/pallets/flask) and [python3-saml](https://github.com/onelogin/python3-saml).

## Installation

```
pip install flasksaml
```

## Usage

### Set SAML parameters

For SAML SSO to work, you need to set certain parameters, particularly regarding the SAML SP & IdP. These
definitions are set in `settings.json` and `advanced_settings.json`. For more information, please consult
the documentation of [python3-saml](https://github.com/onelogin/python3-saml).

After you configured `settings.json` & `advanced_settings.json`, set the location of the directory
containing those 2 files in the `FLASK_SAML_SETTINGS_PATH` environment variable.

### Create Flask App

Create your Flask application using the FlaskSAML class as such:

```python
from flasksaml import FlaskSAML

app = FlaskSAML(__name__)

# Set a cryptographically secure secret key. This secret key is used to sign session cookies. Failure to
# to do so might enable tampering of session cookies
# https://flask.palletsprojects.com/en/1.1.x/config/?highlight=secret_key#SECRET_KEY
app.config["SECRET_KEY"] = "so-so-secret"
```


## Environment Variables

```python

# Comma-separated string of URL paths that should not require authentication
# Default: "status,healthcheck,health"
FLASK_SAML_WHITELISTED_ENDPOINTS: "status,healthcheck,health"

# The location of directory containing settings.json & advanced_settings.json
# Defaults to current working directory
FLASK_SAML_SETTINGS_PATH: ""
```
fast_layers 0.1.2
Fast-Layers is a python library for Keras and Tensorflow users: The fastest way to build complex deep neural network architectures with sequential models
License: MIT
Keywords: keras

# Fast-Layers
Fast-Layers is a python library for Keras and Tensorflow users: The fastest way to build complex deep neural network architectures with sequential models

## Introduction
Tensorflow's sequential model is a very intuitive way to start learning about Deep Neural Networks.
However it is quite hard to dive into more complex networks without learning more about Keras.

Well it won't be hard anymore with Fast-layers! Define your Connectors and Pipes to start building complex layers in a sequential fashion.

I create fast-layers for beginners who wants to build more advanced networks and for experimented users who wants to quickly build and test complex module architectures.

# Documentation

    Please note that eager execution is not supported for the moment

#### class Sequence:
    Arguments:
        name: str, positional arg
        inputs: str: name of input pipe/connector | list: names of input pipes/connectors, positional arg
        sequence=None: list of keras.layers objects,
        is_output_layer=False,
        trainable=True,

    Attributes:
        inputs: str or list of input names.
        sequence: list of keras.layers objects,
        is_output_layer: True if this is the output Sequence of a Layer object.
        
    Methods:
        call(x, training=False): by calling the sequence through __call__(), computes x.
        self_build(): build the layers of the sequence into this Sequence object.


#### class Layer:
    Arguments:
        sequences: list of sequences,
        trainable=True,
        n_iteration_error=50: max number of iteration permitted in the computation loop before break

    Attributes:
        names: list of sequences names
        trainable: True if the weights of this layer are trainable.
        sequences: list of sequences
        first_call=True: False means the Layer object has been called and
        n_iteration_error: max number of iteration permitted in the computation loop before break

    Methods:
        init_layer(sequences): Takes a list of sequences and initialize the layer. Is called on __init__() if the layer object has been instantiate with the argument sequences=*List of sequences*
        call(x, training=False): by calling the layer through __call__(), computes x.



## Fast Layer MNIST tutorial but using Inception modules

TRY IT YOURSELF: https://www.kaggle.com/alexandremahdhaoui/fast-layers-tutorial

original MNIST tutorial: https://www.tensorflow.org/datasets/keras_example
Szegedy et al. 2014, Going deeper with convolutions: https://arxiv.org/pdf/1409.4842.pdf