semvec/pypi-packages huggingface dataset:
Broadway 0.0.2
A set of extensions for Flask that take the boilerplate out of your project.
License: MIT

Broadway
========

Broadway is a set of extensions for Flask_ that take the boilerplate out of 
your project. It provides a powerful application factory that handles loading
and configuring extensions / blueprints. So you can get on with the code that
matters.

For more information check the Documentation_.

Example
-------

.. code:: python

    import broadway

    factory = broadway.factory()

    factory.add_extensions(
        'broadway_sqlalchemy'
    )

    factory.add_blueprints(
        'myapp.views.main:blueprint',
        'myapp.views.admin:blueprint'
    )

    application = factory()

    if __name__ == '__main__':
        application.run()

Install
-------

To install broadway via pip:

::

    pip install broadway

Source
------

To install from source:

::

    git clone git://github.com/artisanofcode/python-broadway.git
    cd python-broadway
    python setup.py develop


History
-------

See `CHANGES <CHANGES>`_

Licence
-------

This project is licensed under the `MIT licence`_.

Meta
----

This project uses `Semantic Versioning`_.

.. _Flask: http://flask.pocoo.org/
.. _Documentation: http://broadway.craftedbyartisans.com/
.. _Semantic Versioning: http://semver.org/
.. _MIT Licence: http://dan.mit-license.org/
schematics-factory 0.1.0
Convenient anonymous and nested models using dict literal syntax for Schematics.
License: MIT
Keywords: schematics,validation,schema,model,models,modelling,object,objects

Schematics Factory
==================


Inspired by [Voluptuous](https://github.com/alecthomas/voluptuous).

It's sometimes inconvenient to define
named [Schematics](https://github.com/schematics/schematics)
Models, especially when those models are deeply nested.

Example:

```
class InnerModel(Model):
    inner_bool = BooleanType()


class MiddleModel(Model):
    middle_int = IntType()
    middle_nested = ModelType(InnerModel)


class OuterModel(Model):
    outer_str = StringType()
    outer_nested = ModelType(MiddleModel)


model_instance = OuterModel(input_)
model_instance.validate()
```

So, this library provides a convenient syntax for defining
deeply nested Models.

```
from schematics_factory import model

OuterModel = model({
    'outer_str': StringType(),
    'outer_nested': ModelType(model({
        'middle_int': IntType(),
        'middle_nested': ModelType(model({
            'inner_bool': BooleanType()
        }))
    }))
})

model_instance = OuterModel(input_)
model_instance.validate()
```

The model() function can also be imported as _model_factory_.

Alternative Syntax
------------------

Schema factory arguments can also be supplied as keyword
arguments rather than a dictionary.

```
Person = model(name=StringType(), age=IntType())

person = Person(dict(name='Test', age=27))

person.validate()
```

For nested Models, a concise __nested()__ convenience function
is provided to replace ModelType(model(...)) with nested(...).
The nested() function can also be imported as _nested_model_.

```
from schematics_factory import model, nested

Person = model(name=StringType(), pet=nested(name=StringType()))

person = Person(dict(name='Test', pet=dict(name='Rover')))

person.validate()
```

Nested models can also be provided as plain dictionary literals.

```
Person = model(name=StringType(), pet=dict(name=StringType()))

person = Person(dict(name='Test', pet=dict(name='Rover')))

person.validate()
```

Or equivalently...

```
Person = model({
    'name': StringType(),
    'pet': {
        'name': StringType()
    }
})

person = Person({
    'name': 'Test',
    'pet': {
        'name': 'Rover'
    }
})

person.validate()
```
marshmallow-factory 0.1.0
Convenient anonymous and nested schemas using dict literal syntax for Marshmallow.
License: MIT
Keywords: serialization,rest,json,api,marshal,marshalling,deserialization,validation,schema,model,models,modelling,object,objects

Marshmallow Factory
===================


Inspired by [Voluptuous](https://github.com/alecthomas/voluptuous).

It's sometimes inconvenient to define named 
[Marshmallow](https://github.com/marshmallow-code/marshmallow)
Schemas, especially when those schemas are deeply nested.

Example:

```
class InnerSchema(Schema):
    inner_bool = Boolean()


class MiddleSchema(Schema):
    middle_int = Integer()
    middle_nested = Nested(InnerSchema)


class OuterSchema(Schema):
    outer_str = String()
    outer_nested = Nested(MiddleSchema)


schema_instance = OuterSchema()
schema_instance.validate(input_)
```

So, this library provides a convenient syntax for defining
deeply nested Schemas.

```
from marshmallow_factory import schema

OuterSchema = schema({
    'outer_str': String(),
    'outer_nested': Nested(schema({
        'middle_int': Integer(),
        'middle_nested': Nested(schema({
            'inner_bool': Boolean()
        }))
    }))
})

schema_instance = OuterSchema()
schema_instance.validate(input_)
```


Support For Meta Options
------------------------

Meta options are supported using the following syntax:

```
class Meta:
    strict = True  # or your other options

my_schema = schema({
    'Meta': Meta,
    'str': String()
})
```


Alternative Syntax
------------------

Schema factory arguments can also be supplied as keyword
arguments rather than a dictionary.

```
my_schema = schema(Meta=Meta, str=String())
```

For nested Schemas, plain dictionary literals can be provided
instead of Nested(schema({...}).

```
from marshmallow_factory import schema

OuterSchema = schema({
    'outer_str': String(),
    'outer_nested': {
        'middle_int': Integer(),
        'middle_nested': {
            'inner_bool': Boolean()
        }
    }
})

schema_instance = OuterSchema()
schema_instance.validate(input_)
```