Saravanan666/pypi-org huggingface dataset:
Package: marshmallow_api_utils
Marshmallow API UtilitiesA collection of tools for REST API development with Marshmallow.PackageMetaBasic usagefromdatetimeimportdatefromflaskimportFlaskfromflask_smorestimportApifrommarshmallow_dataclassimportdataclassasma_dataclassfromsqlalchemyimportColumn,Select,selectfromsqlalchemy.ormimportDeclarativeBasefrommarshmallow_api_utils.fieldsimportdump_only_field,optional_field,required_fieldfrommarshmallow_api_utils.ma_dataclassimportMaDataclassfrommarshmallow_api_utils.models.sortableimportSortableclassBase(DeclarativeBase):passclassPet(Base):__tablename__='pets'id=Column(st.Integer,primary_key=True)name=Column(st.String)birthdate=Column(st.Date)@ma_dataclassclassPetDTO(MaDataclass):id:int=dump_only_field()name:str=required_field(help='This will show up in the OpenAPI docs.')birthdate:dt.date=optional_field()age:int=dump_only_field(sortable=False)@ma.pre_dumpdefadd_age(self,data,many,**kwargs):data['age']=int((date.today()-data.birthdate)/365.25)returndata@ma_dataclassclassPetQueryParams(Sortable,MaDataclass):classMeta:dto_schema=PetDTO.Schema()flask=Flask(__name__)app.config["API_TITLE"]="My API"app.config["API_VERSION"]="v1"app.config["OPENAPI_VERSION"]="3.0.2"api=Api(app)blp=Blueprint("pets","pets",url_prefix="/pets",description="Operations on pets")@blp.route("/")classPets(MethodView):@blp.arguments(PetQueryParams.Schema,location="query")@blp.response(200,Pet.Schema(many=True))defget(self,query_params:PetQueryParams):"""List pets"""stmt=select(Pet)stmt=query_params.apply_sort(stmt)returnstmt.all()LicenseMarshmallow API Utilities is distributed under the terms of theMITlicense.
Package: marshmallow-attrs
Marshmallow schemas for attrs classesFree software: MIT licenseInstallationpip install marshmallow-attrsDocumentationhttps://marshmallow-attrs.readthedocs.io/DevelopmentTo run the all tests run:toxNote, to combine the coverage data from all the tox environments run:Windowsset PYTEST_ADDOPTS=--cov-append
toxOtherPYTEST_ADDOPTS=--cov-append toxChangelog0.1.0 (2019-06-22)ChangesFirst release on PyPI.—
Package: marshmallow-br
This library providesMarshmallowfields and validators for Brazilian documents:Brazilian phone numberBrazilian birth, marriage and death certificatesCNH (Carteira Nacional de Habilitação)CNPJ (Cadastro Nacional da Pessoa Jurídica)CPF (Cadastro de Pessoas Físicas)Installing$pipinstallmarshmallow-brUsagefrompprintimportpprintfrommarshmallowimportSchemafrommarshmallow_brimportfieldsclassDocuments(Schema):certificate=fields.Certificate(mask=True)cnh=fields.CNH(mask=True)cnpj=fields.CNPJ(mask=True)cpf=fields.CPF(mask=True)phones=fields.List(fields.Phone(mask=True,require_ddi=False,require_ddd=True))raw_data={"certificate":"12173901552014167634174940702955","cnh":"64076917022","cnpj":"52203670000109","cpf":"98008862068","phones":["5511999999999","11 999999999","+55(11)99999-9999","11 9999-9999"],}data=Documents().load(raw_data)pprint(data)# {'certificate': '121739.01.55.2014.1.67634.174.9407029-55',# 'cnh': '64076917022',# 'cnpj': '52.203.670/0001-09',# 'cpf': '980.088.620-68',# 'phones': ['+55 (11) 99999-9999',#             '(11) 99999-9999',#             '+55 (11) 99999-9999',#             '(11) 9999-9999']}
Package: marshmallow-cbor
This module allows serializing and deserializingmarshmallowschemas asCBORdata.CBORis a compact binary data format similar to JSON in it’s data model,
but supporting many more datatypes and an extensible tag system.marshmallowout of the box only supports serialization to JSON.Installpip install marshmallow-cborExamplesPlease see theexamples/folder in this repository.Plain string keys & values, regular marshmallow validationCBOR Tagged item schemasCWT (RFC 8392) token validationTODOAdd marshmallow DateTime fields back in as string only fieldsTag single items in addition to schemas and nested schemas ✅Field support for all cbor2 supported datatypes ✅(partial)Add it to PyPI ✅
Package: marshmallow-configparser
# OverviewEver wanted to load plain `.ini` config files and then validate loaded config?Ever wanted to load config from multiple locations (`/etc/appconfig.conf`, `~/.appconfig.conf`) into single object and then validate that?Worry no more!Python's [ConfigParser] met [marshmallow] and now they get along just fine - without any JSON in sight to spoil the fun.## Installation~~~shpip install marshmallow_configparser~~~## ExampleHaving config file `/tmp/example_config.conf` looking like this:~~~ini[Section1]option1 = mandatory stringoption2 = optional stringoption3 = 42option4 = 24[Section2]option1 = mandatory stringoption2 = optional stringoption3 = 42option4 = 24~~~And wanting to load it into our config object:~~~pythonclass ConfigObject(object):MANDATORY_STRING1 = NoneOPTIONAL_STRING1 = NoneMANDATORY_INTEGER1 = NoneOPTIONAL_INTEGER1 = NoneMANDATORY_STRING2 = NoneOPTIONAL_STRING2 = NoneMANDATORY_INTEGER2 = NoneOPTIONAL_INTEGER2 = None~~~We can define [marshmallow] schema:~~~pythonfrom marshmallow.validate import Rangefrom marshmallow_configparser import (ConfigBoolean, ConfigInteger,ConfigParserSchema, ConfigString,IsNotBlank)class ConfigSchema(ConfigParserSchema):class Meta:model = ConfigObjectMANDATORY_STRING1 = ConfigString(section='Section1', load_from='option1', dump_to='option1',validate=[IsNotBlank()])OPTIONAL_STRING1 = ConfigString(section='Section1', load_from='option2', dump_to='option2',)MANDATORY_INTEGER1 = ConfigInteger(section='Section1', load_from='option3', dump_to='option3',validate=[Range(min=24, max=42)])OPTIONAL_INTEGER1 = ConfigInteger(section='Section1', load_from='option4', dump_to='option4',)MANDATORY_STRING2 = ConfigString(section='Section2', load_from='option1', dump_to='option1',validate=[IsNotBlank()])OPTIONAL_STRING2 = ConfigString(section='Section2', load_from='option2', dump_to='option2',)MANDATORY_INTEGER2 = ConfigInteger(section='Section2', load_from='option3', dump_to='option3',validate=[Range(min=24, max=42)])OPTIONAL_INTEGER2 = ConfigInteger(section='Section2', load_from='option4', dump_to='option4',)~~~Which can then load and validate our config:~~~pythonschema = ConfigSchema()obj, errors = schema.load(['/tmp/example_config.conf'])~~~In the end we have:~~~pythonobj.__dict_{'MANDATORY_INTEGER1': 42,'MANDATORY_INTEGER2': 42,'MANDATORY_STRING1': 'mandatory string','MANDATORY_STRING2': 'mandatory string','OPTIONAL_INTEGER1': 24,'OPTIONAL_INTEGER2': 24,'OPTIONAL_STRING1': 'optional string','OPTIONAL_STRING2': 'optional string'}~~~Instead of using convenience classes like `ConfigString`, there are also classes in `marshmallow_configparser.fields` module that expose full [marshmallow] API. Check the docs for details.## Documentationhttp://marshmallow-configparser.readthedocs.io/en/latest/index.html[marshmallow]: https://github.com/marshmallow-code/marshmallow[ConfigParser]: https://docs.python.org/3/library/configparser.html#configparser.ConfigParser
Package: marshmallow-dataclass-djangofield
Usemarshmallow-dataclasses asDjangoFields.Usagefrommarshmallow_dataclass_djangofieldimportMarshmallowFieldfrommarshmallow_dataclass_djangofieldimportmarshmallow_dataclass_djangofieldclassMyModel(Model):@marshmallow_dataclass_djangofield(model_name='MyModel')@marshmallow_dataclass.dataclassclassMyDataClass:foo:strbar:intfoobars=MarshmallowField(many=True,schema=MyDataClass)
Package: marshmallow-dataframe
marshmallow-dataframemarshmallow-dataframeis a library that helps you generatemarshmallowSchemas for Pandas
DataFrames.UsageLet's start by creating an example dataframe for which we want to create aSchema. This dataframe has four columns: two of them are of string type, one
is a float, and the last one is an integer.importpandasaspdimportnumpyasnpfrommarshmallow_dataframeimportSplitDataFrameSchemaanimal_df=pd.DataFrame([("falcon","bird",389.0,2),("parrot","bird",24.0,2),("lion","mammal",80.5,4),("monkey","mammal",np.nan,4),],columns=["name","class","max_speed","num_legs"],)You can then create a marshmallow schema that will validate and load dataframes
that follow the same structure as the one above and that have been serialized
withDataFrame.to_jsonwith theorient=splitformat.
Thedtypesattribute of theMetaclass is required, and othermarshmallowSchema
optionscan also be passed as attributes ofMeta:classAnimalSchema(SplitDataFrameSchema):"""Automatically generated schema for animal dataframe"""classMeta:dtypes=animal_df.dtypesWhen passing a valid payload for a new animal, this schema will validate it and
build a dataframe:animal_schema=AnimalSchema()new_animal={"data":[("leopard","mammal",58.0,4),("ant","insect",0.288,6)],"columns":["name","class","max_speed","num_legs"],"index":[0,1],}new_animal_df=animal_schema.load(new_animal)print(type(new_animal_df))# <class 'pandas.core.frame.DataFrame'>print(new_animal_df)#       name   class  max_speed  num_legs# 0  leopard  mammal     58.000         4# 1      ant  insect      0.288         6However, if we pass a payload that doesn't conform to the schema, it will raise
a marshmallowValidationErrorexception with informative message about errors:invalid_animal={"data":[("leopard","mammal",58.0,"four")],# num_legs is not an int"columns":["name","class","num_legs"],# missing  max_speed column"index":[0],}animal_schema.load(invalid_animal)# Raises:# marshmallow.exceptions.ValidationError: {#     'columns': ["Must be equal to ['name', 'class', 'max_speed', 'num_legs']."],#     'data': {0: {3: ['Not a valid integer.']}}# }marshmallow_dataframecan also generate Schemas for theorient=recordsformat by following the above steps but usingmarshmallow_dataframe.RecordsDataFrameSchemaas the superclass forAnimalSchema.Installationmarshmallow-dataframe requires Python >= 3.6 and marshmallow >= 3.0. You can
install it with pip:pip install marshmallow-dataframeContributingContributions are welcome!You can report a problem or feature request in theissue
tracker. If you feel
that you can fix it or implement it, please submit a pull request referencing
the issues it solves.Unit tests written using thepytestframework are in thetestsdirectory, and are run usingtoxon Python 3.6 and 3.7. You can run
the tests by installing tox:pip install toxand running the linters and tests for all Python versions by runningtox, or
for a specific Python version by running:tox -e py36We format the code withblack, and you can
format your checkout of the code before commiting it by running:tox -e black -- .
Package: marshmallow-dumped-order
marshmallow-dumped-orderDecorator formarshmallow.Schemato sort fields
in needed order while dumping (python36+).frommarshmallowimportSchema,fieldsfrommarshmallow_dumped_orderimportdumped_order@dumped_order("name","age")classUser(Schema):age=fields.Int()name=fields.String()dumped=User().dumps({"age":356,"name":"Jarvis"})assertdumped.data=='{"name": "Jarvis", "age": 356}'
Package: marshmallow-dynamodb
DynamoDBFields:Example usage:fromdatetimeimportdatetimefrommarshmallowimportSchemafrommarshmallow_dynamodb.fieldsimportDynamoDBDateTimeclassSchemaFixture(Schema):some_field=DynamoDBDateTime()data,errors=SchemaFixture().load({'some_field':datetime.now().timestamp()})# UnmarshalResult(data={'some_field': datetime.datetime(2018, 11, 22, 17, 37, 55)}, errors={})SchemaFixture().dump(data)# MarshalResult(data={'some_field': 1542915517.0}, errors={})
Package: marshmallow-enum
marshmallow-enumEnum field for use with Marshmallow.Installationpipinstall--usermarshmallow_enumIf you're on a version before 3.4, you'll also need to installenum34.Using The FieldTo make use of the field, you must have an existing Enum:fromenumimportEnumclassStopLight(Enum):green=1yellow=2red=3Then, declare it as a field in a schema:frommarshmallowimportSchemafrommarshmallow_enumimportEnumFieldclassTrafficStop(Schema):light_color=EnumField(StopLight)By default, the field will load and dump based on thenamegiven to an enum value.schema=TrafficStop()schema.dump({'light_color':EnumField.red}).data# {'light_color': 'red'}schema.load({'light_color':'red'}).data# {'light_color': StopLight.red}Customizing loading and dumping behaviorTo customize how an enum is serialized or deserialized, there are three options:Settingby_value=True. This will cause both dumping and loading to use the value of the enum.Settingload_by=EnumField.VALUE. This will cause loading to use the value of the enum.Settingdump_by=EnumField.VALUE. This will cause dumping to use the value of the enum.If eitherload_byordump_byare unset, they will follow fromby_value.Additionally, there isEnumField.NAMEto be explicit about the load and dump behavior, this
is the same as leaving bothby_valueand eitherload_byand/ordump_byunset.Custom Error MessageA custom error message can be provided via theerrorkeyword argument. It can accept three
format values:{input}: The value provided to the schema field{names}: The names of the individual enum members{values}: The values of the individual enum membersPreviously, the following inputs were also available but are deprecated and will be removed in 1.6:{name}{value}{choices}Version 1.5Allow unicode enum values (sergeyzsg)
Add support for Marshmallow 3 (svidela)Version 1.4Deprecate the{choices},{name}and{value}format keys for custom error messagesAllow configure loading and dumping independently
Package: marshmallow-extended
Marshmallow advanced Python libraryExtra fieldsActive fieldConvertsactivefield tostateand back.>>>frommarshmallow_extendedimportSchema>>>frommarshmallow_extended.fieldsimportActive>>>classSimpleSchema(Schema):active=Active()>>>SimpleSchema().dump({'state':'active'}){'active':True})>>>SimpleSchema().dump({'state':'inactive'}){'active':False}>>>SimpleSchema().load({'active':True}){'state':'active'}>>>SimpleSchema().load({'active':False}){'state':'inactive'}Filter by query parameter:>>>classSimpleFilterSchema(Schema):active=Active(as_filter=True)>>>SimpleFilterSchema().load({'active':'true'}){'state':'active'}>>>SimpleFilterSchema().load({'active':'false'}){'state':'inactive'}>>>SimpleFilterSchema().load({}){'state__ne':'deleted'}For experienced usage trypositives,negatives,positive_filter,negative_filter,missing_filterparameters. You can see behaviour for this parameters in tests.Email fieldExtendedmarshmallow.field.Emailfield: lowering case.>>>frommarshmallow_extendedimportSchema>>>frommarshmallow_extended.fieldsimportEmail>>>classSimpleSchema(Schema):email=Email()SimpleSchema().load({'email':'Test@email.com'}){'email':'test@email.com'}Changelog1.3.1 (2021-06-10)AddedEnumandIContainsfields.Addedget_paramsandapply_endpoint_paramsdecorators.1.3.0 (2021-06-10)AddedEmailfield.
Package: marshmallow-factory
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 definingdeeply nested Schemas.```from marshmallow_factory import schemaOuterSchema = 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 optionsmy_schema = schema({'Meta': Meta,'str': String()})```Alternative Syntax------------------Schema factory arguments can also be supplied as keywordarguments rather than a dictionary.```my_schema = schema(Meta=Meta, str=String())```For nested Schemas, plain dictionary literals can be providedinstead of Nested(schema({...}).```from marshmallow_factory import schemaOuterSchema = schema({'outer_str': String(),'outer_nested': {'middle_int': Integer(),'middle_nested': {'inner_bool': Boolean()}}})schema_instance = OuterSchema()schema_instance.validate(input_)```
Package: marshmallow-generic
marshmallow-genericGeneric schema with full typing support and minimal boilerplateDocumentation:daniil-berg.github.io/marshmallow-genericSource Code:github.com/daniil-berg/marshmallow-genericExtension formarshmallowto makedeserialization to objectseasier and improve type safety.The mainGenericSchemaclass extendsmarshmallow.Schemamaking itgenericin terms of the class that data should be deserialized to, when callingload/loads.WithGenericSchemathere is no need to explicitly writepost_loadhooks to initialize the object anymore. 🎉If the "model" class is (for example)User, it just needs to be passed as the type argument, when subclassingGenericSchema. The output of theload/loadsmethod will then be automatically inferred as eitherUserorlist[User](depending on whethermanyisTrueor not) by any competent type checker. ✨Usage Examplefrommarshmallow_genericimportGenericSchema,fieldsclassUser:def__init__(self,name:str,email:str)->None:self.name=nameself.email=emaildef__repr__(self)->str:return"<User(name={self.name!r})>".format(self=self)...classUserSchema(GenericSchema[User]):name=fields.Str()email=fields.Email()user_data={"name":"Monty","email":"monty@python.org"}schema=UserSchema()single_user=schema.load(user_data)print(single_user)# <User(name='Monty')>json_data='''[{"name": "Monty", "email": "monty@python.org"},{"name": "Ronnie", "email": "ronnie@stones.com"}]'''multiple_users=schema.loads(json_data,many=True)print(multiple_users)# [<User(name='Monty')>, <User(name='Ronnie')>]Addingreveal_type(single_user)andreveal_type(multiple_users)at the bottom and running that code throughmypywould yield the following output:# note: Revealed type is "User"
# note: Revealed type is "builtins.list[User]"With the regularmarshmallow.Schema, the output ofmypywould instead be this:# note: Revealed type is "Any"
# note: Revealed type is "Any"This also means your IDE will be able to infer the types and thus provide useful auto-suggestions for the loaded objects. 👨‍💻Here is PyCharm with the example from above:Installationpip install marshmallow-genericDependenciesPython Version3.9+andmarshmallow(duh)
Package: marshmallow-jam
Some extra sweets for marshmallow.ExamplesUse annotations for schema description.fromjamimportSchemaclassBar(Schema):baz:strclassFoo(Schema):bar:Barfoo:Foo=Foo().load({"bar":{"baz":"quux"}})assertfoo.bar.baz=="quux"When annotations not enoughclassFoo(Schema):bar:str=fields.Email()Mapping rulesBasic Typesannotationmarshmallow fieldstrfields.Stringfloatfields.Floatboolfields.Booleanintfields.Integeruuid.UUIDfields.UUIDdecimal.Decimalfields.Decimaldt.datetimefields.DateTimedt.timefields.Timedt.datefields.Datedt.timedeltafields.TimeDeltaAll fields will berequiredfor make it optional usetyping.Optional[X]Manyannotationmarshmallow fieldlistfields.Raw(many=True)typing.List[float]fields.List(fields.Float())Nestedannotationmarshmallow fieldNestedSchemafields.Nested(NestedSchema, required=True)typing.Optional[NestedSchema]fields.Nested(NestedSchema, required=True)typing.List[NestedSchema]fields.Nested(NestedSchema, required=True, many=True)
Package: marshmallowjson
Marshmallow JSONTurns a JSON type definition into a marshmallow validation and serialization toolkit.Free software: MIT licenseDocumentation:https://marshmallowjson.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2018-01-27)First release on PyPI.
Package: marshmallow-jsonapi
Homepage:http://marshmallow-jsonapi.readthedocs.io/JSON API 1.0 (https://jsonapi.org) formatting withmarshmallow.marshmallow-jsonapi provides a simple way to produce JSON API-compliant data in any Python web framework.frommarshmallow_jsonapiimportSchema,fieldsclassPostSchema(Schema):id=fields.Str(dump_only=True)title=fields.Str()author=fields.Relationship("/authors/{author_id}",related_url_kwargs={"author_id":"<author.id>"})comments=fields.Relationship("/posts/{post_id}/comments",related_url_kwargs={"post_id":"<id>"},# Include resource linkagemany=True,include_resource_linkage=True,type_="comments",)classMeta:type_="posts"post_schema=PostSchema()post_schema.dump(post)# {#     "data": {#         "id": "1",#         "type": "posts"#         "attributes": {#             "title": "JSON API paints my bikeshed!"#         },#         "relationships": {#             "author": {#                 "links": {#                     "related": "/authors/9"#                 }#             },#             "comments": {#                 "links": {#                     "related": "/posts/1/comments/"#                 }#                 "data": [#                     {"id": 5, "type": "comments"},#                     {"id": 12, "type": "comments"}#                 ],#             }#         },#     }# }Installationpip install marshmallow-jsonapiDocumentationFull documentation is available athttps://marshmallow-jsonapi.readthedocs.io/.RequirementsPython >= 3.6Project LinksDocs:http://marshmallow-jsonapi.readthedocs.io/Changelog:http://marshmallow-jsonapi.readthedocs.io/en/latest/changelog.htmlContributing Guidelines:https://marshmallow-jsonapi.readthedocs.io/en/latest/contributing.htmlPyPI:https://pypi.python.org/pypi/marshmallow-jsonapiIssues:https://github.com/marshmallow-code/marshmallow-jsonapi/issuesLicenseMIT licensed. See the bundledLICENSEfile for more details.
Package: marshmallow-jsonschema-3
marshmallow-jsonschema-3Transform marshmallow schemas into correct OpenAPI3.0.x-3.1 definitions.
Fork ofmarshmallow-jsonschemaby
Stephen J. Fuhry.Why fork?Add support for marshmallow fields.Constant (missing in marshmallow-jsonschema 0.13.0)Add enum handling for the future? At least not as useless as current
approach. Flagsuse_repr_enums=to convert enums into list of1=a, 2=boruse_new_enums=to create3.1 suggested enums.Put schema references into#/components/schemas/<name>instead of#/definitions/<name>sourceAdd oldnullable: trueattribute usinguse_nullable=flag.Installationpip install marshmallow-jsonschema-3in >=Python3.8UsagefrommarshmallowimportSchema,fieldsfrommarshmallow_jsonschema_3importJSONSchemaclassUserSchema(Schema):username=fields.String()age=fields.Integer()birthday=fields.Date()user_schema=UserSchema()json_schema=JSONSchema(use_repr_enums=True,use_nullable=True)json_schema.dump(user_schema)DeploymentMake your changesCreate~/.pypircfile for twine[distutils]
index-servers =
    pypi
    testpypi

[pypi]
username = pypiusername
password = pypipsw

[testpypi]
username = pypiusername
password = pypipswmake pypitestto deploy tohttps://test.pypi.orgUsepip install --index-url https://test.pypi.org/simple/ --extra-index-url https://pypi. org/simple marshmallow-jsonschema-3to install test package in your projects using
real pypi dependencies. The default pip install provided by test.pypi will only look for dependencies
in test.pypi, and will fail to find actual versions of dependencies...Usemake pypifor real pypi and usepip install marshmallow-jsonschema-3to install
published package.
Package: marshmallow-meta
marshmallow-metadecorator syntax for marshmallow meta attributes (with inheritance)Decorators communicate that the behavior of a class is being modified and are more concise when only a few meta attributes are needed. Making inheritance the default further reduces the boilerplate needed to make minor changes to a subclass.Installpipinstallmarshmallow-metafrommarshmallow_metaimportmetaAPI@meta(*kwargs)Build a meta class that inherits attributes from the base schema's meta class.@meta(unknown=INCLUDE)classTest(Schema):foo=fields.String()@meta.new(*kwargs)Build a new meta class without inherited attributes.@meta.new(fields=('bar','baz'))classFresh(Test):pass@meta.use(*classes, **kwargs)Build a meta class that inherits attributes from certain meta classes.@meta.use(Test.Meta)classCopyCat(Schema):buzz=fields.String()