class TaskComment(Schema):
from .users import UserShortProfile
author = fields.Nested(UserShortProfile, required=True)
content = fields.Str(required=True)
creation = fields.Date(required=True)
class EventsCreateSchema(BaseEventsSchema):
start_date = fields.Date(required=True)
end_date = fields.Date(required=True)
topics_ids = fields.List(fields.Integer)
def test_invalid_date_field_deserialization(self, in_value):
field = fields.Date()
with pytest.raises(ValidationError) as excinfo:
field.deserialize(in_value)
msg = 'Not a valid date.'
assert excinfo.value.args[0] == msg
class DepositDumpSchema(IdSchema):
price = fields.Int()
name = fields.Str()
date = fields.Date()
lectures = fields.List(fields.Str())
class TransactionSchema(Schema): id = fields.Int() description = fields.Str() amount = fields.Number() created_at = fields.Date() type = fields.Str()
class TaskUpdateSchema(TaskCreateSchema):
description = fields.Str(required=True)
priority = fields.Int(required=True)
due_date = fields.Date(required=True, allow_none=True)
is_completed = fields.Boolean(required=True)
class RestaurantsSchema(pl.BaseSchema):
id = fields.String()
#storeid = fields.String(load_from='StoreID', dump_to='store_id')
facility_name = fields.String()
num = fields.String(
allow_none=True) # Non-integer values include "8011-B".
street = fields.String()
city = fields.String()
state = fields.String()
zip = fields.String()
municipal = fields.String()
category_cd = fields.String()
description = fields.String()
p_code = fields.String()
fdo = fields.Date()
bus_st_date = fields.Date(allow_none=True)
noseat = fields.Integer(dump_to="seat_count")
noroom = fields.Integer(allow_none=True)
sqfeet = fields.Integer(dump_to="sq_feet")
status = fields.String()
placard_st = fields.String()
x = fields.Float(allow_none=True)
y = fields.Float(allow_none=True)
address = fields.String()
class Meta:
ordered = True
# @pre_load
# def geocode(self,data):
# if 'num' in data and 'street' in data and 'city' in data:
# num = data['num']
# street = data['street']
# city = data['city']
# state = None
# zip_code = None
# directional = None
# if 'state' in data:
# state = data['state']
# if 'zip' in data:
# zip_code = data['zip']
# longitude, latitude = geocode_address_by_parts(num, directional, street, city, state, zip_code)
#
# if longitude is None:
# streets = correct_address(street)
# if len(streets) > 0:
# longitude, latitude = geocode_address_by_parts(num, directional, street, city, state, zip_code)
# data['x'] = longitude
# data['y'] = latitude
@pre_load
def geocode(self, data):
if 'address' in data and not OVERRIDE_GEOCODING:
address_string = data['address']
longitude, latitude = geocode_address_string(address_string)
if longitude is None:
corrected_addresses = correct_address(address_string)
if len(corrected_addresses) > 0:
# For now just try the first of the proposed corrections:
longitude, latitude = geocode_address_string(
corrected_addresses[0])
data['x'] = longitude
data['y'] = latitude
@pre_load
def convert_dates(self, data):
date_fields = ['fdo', 'bus_st_date']
for field in date_fields:
if data[field] is not None:
data[field] = parser.parse(data[field]).date().isoformat()
class AvailableCleanersSchema(Schema):
date = fields.Date(required=True)
city = fields.Int(required=True)
class ParamsGraphScham(Schema):
dataInicial = fields.Date(required=True)
dataFinal = fields.Date(required=True)
rankingClientesPor = fields.Int(required=True)
tiposServicosPor = fields.Int(required=True)
class UserReporterSchema(CommonUserFields):
first_name = fields.Str()
last_name = fields.Str()
id = fields.Int()
created_at = fields.Date()
updated_at = fields.Date()
class UrlQuerySchema(Schema):
start_date = fields.Date('%Y-%m-%d')
end_date = fields.Date('%Y-%m-%d')
class ReporterQuery(Schema):
added_from = fields.Date(required=True)
added_to = fields.Date(required=True)
class GetNBUCurrencyScheme(AbstractScheme):
r030 = fields.Int()
txt = fields.Str()
rate = fields.Float()
cc = fields.Str()
exchangedate = fields.Date()
class ViolationsSchema(pl.BaseSchema):
encounter = fields.String(allow_none=True)
id = fields.String(allow_none=True)
placard_st = fields.String(allow_none=True)
# placard_desc = fields.String(allow_none=True)
facility_name = fields.String(allow_none=True)
bus_st_date = fields.Date(allow_none=True)
# category_cd = fields.String(allow_none=True)
description = fields.String(allow_none=True)
description_new = fields.String(allow_none=True)
num = fields.String(allow_none=True)
street = fields.String(allow_none=True)
city = fields.String(allow_none=True)
state = fields.String(allow_none=True)
zip = fields.String(allow_none=True) # This was (for no obvious
# reason) a Float in the predecessor of this ETL job.
inspect_dt = fields.Date(allow_none=True)
start_time = fields.Time(allow_none=True)
end_time = fields.Time(allow_none=True)
municipal = fields.String(allow_none=True)
rating = fields.String(allow_none=True)
low = fields.String(allow_none=True)
medium = fields.String(allow_none=True)
high = fields.String(allow_none=True)
url = fields.String(allow_none=True)
class Meta():
ordered = True
@pre_load
def strip_strings(self, data):
fields_to_recode = ['facility_name', 'description']
for field in fields_to_recode:
data[field] = fix_encoding_errors(data[field].strip())
fields_to_strip = ['num']
for field in fields_to_strip:
if type(data[field]) == str:
data[field] = fix_encoding_errors(data[field].strip())
def fix_dates_times(self, data):
if data['bus_st_date']:
#data['bus_st_date'] = datetime.strptime(data['bus_st_date'], "%m/%d/%Y %H:%M").date().isoformat()
data['bus_st_date'] = parser.parse(
data['bus_st_date']).date().isoformat()
if data['inspect_dt']:
#data['inspect_dt'] = datetime.strptime(data['inspect_dt'], "%m/%d/%Y %H:%M").date().isoformat()
data['inspect_dt'] = parser.parse(
data['inspect_dt']).date().isoformat()
if data['start_time']:
data['start_time'] = datetime.strptime(
data['start_time'], "%I:%M %p").time().isoformat()
if data['end_time']:
data['end_time'] = datetime.strptime(
data['end_time'], "%I:%M %p").time().isoformat()
to_string = ['encounter', 'id']
for field in to_string:
if type(data[field]) != str:
data[field] = str(int(data[field]))
class PaymentDueSchema(CoreSchema):
due_date = fields.Date(required=True)
amount = fields.Float(required=True)
linked_lease = fields.UUID(required=True)
class BillingSchema(Schema):
borrow_id = fields.Integer(required=True)
return_date = fields.Date(required=True)
bill_amount = fields.String(required=True)
else:
total, data = search_users(name, email, 10)
return {
'total':
total,
'users': [
sign_user(u, fields={'email', 'name', 'uid'})
for u in UserSearchResultSchema(many=True).dump(data)
],
}
@api.route('/users/busy')
@use_kwargs({
'date':
fields.Date(format=DATE_FORMAT, required=True),
'tz':
fields.String(required=True, validate=OneOf(common_timezones_set)),
'uid':
fields.String(required=True),
})
def get_busy_times(date, tz, uid):
return _get_busy_times(date, tz, uid)
@api.route('/newdle/<code>/participants/<participant_code>/busy')
@api.route('/newdle/<code>/participants/me/busy')
@allow_anonymous
@use_kwargs({
'date':
fields.Date(format=DATE_FORMAT, required=True),
class AlbumSchema(Schema):
title = fields.Str()
release_date = fields.Date()
class MessageSchema(Schema):
title = fields.Str()
body = fields.Str()
created_at = fields.Date()
type = fields.Str()
def test_date_field(self):
field = fields.Date()
assert_equal(
field.output('birthdate', self.user),
self.user.birthdate.isoformat(),
)
class Default(Schema):
string = fields.String(missing=lambda: 'default')
integer = fields.Integer(missing=lambda: 10)
boolean = fields.Boolean(missing=lambda: True)
date = fields.Date(missing=lambda: datetime.date(2000, 1, 1))
datetime = fields.DateTime(missing=lambda: datetime.datetime(2000, 1, 1, 1, 1, 1))
class CreateSalesInvoiceSchema(RejectUnknownFieldsSchema):
sales_invoice_number = fields.Integer(attibute='number')
sales_invoice_date = fields.Date(attribute='date')
sales_invoice_delivery_date = fields.Date(attribute='delivery_date')
sales_invoice_reference_number = fields.String(
attribute='reference_number')
sales_invoice_amount = Decimal(attribute='amount')
seller_identifier = fields.String()
seller_name = fields.String()
invoice_type = fields.String()
sales_invoice_status = fields.String(attribute='status')
sales_invoice_free_text_before_lines = fields.String(
attribute='free_text_before_lines')
sales_invoice_free_text_after_lines = fields.String(
attribute='free_text_after_lines')
sales_invoice_our_reference = fields.String(attribute='our_reference')
sales_invoice_your_reference = fields.String(attribute='your_reference')
sales_invoice_private_comment = fields.String(attribute='private_comment')
invoicing_customer_identifier = fields.String()
invoicing_customer_name = fields.String()
invoicing_customer_name_extension = fields.String()
invoicing_customer_address_line = fields.String()
invoicing_customer_additional_address_line = fields.String()
invoicing_customer_post_number = fields.String()
invoicing_customer_town = fields.String()
invoicing_customer_country_code = fields.String()
delivery_address_name = fields.String()
delivery_address_name_extension = fields.String()
delivery_address_line = fields.String()
delivery_address_post_number = fields.String()
delivery_address_town = fields.String()
delivery_address_country_code = fields.String()
delivery_method = fields.String()
delivery_term = fields.String()
payment_term_net_days = fields.Integer()
payment_term_cash_discount_days = fields.Integer()
payment_term_cash_discount = Decimal()
invoice_lines = List(fields.Nested(SalesInvoiceProductLineSchema),
default=list)
class Meta:
ordered = True
@post_dump
def post_dump(self, data):
if 'seller_identifier' in data:
data['seller_identifier'] = {
'#text': data['seller_identifier'],
'@type': 'netvisor'
}
if 'sales_invoice_status' in data:
data['sales_invoice_status'] = {
'#text': data['sales_invoice_status'],
'@type': 'netvisor'
}
if 'invoicing_customer_identifier' in data:
data['invoicing_customer_identifier'] = {
'#text': data['invoicing_customer_identifier'],
'@type': 'netvisor'
}
if 'payment_term_cash_discount' in data:
data['payment_term_cash_discount'] = {
'#text': data['payment_term_cash_discount'],
'@type': 'percentage'
}
data['invoice_lines'] = {
'invoice_line': [{
'sales_invoice_product_line': line
} for line in data['invoice_lines']]
}
return data
class OrderDumpSchema(IdSchema):
name = fields.Str()
documents = fields.List(fields.Nested(DocumentDumpSchema))
creation_time = fields.Date()
from pyspark.sql import Row
from marshmallow_pyspark.constants import *
from marshmallow_pyspark.schema import Schema, _RowValidator
def test_create():
schema = Schema()
assert schema.error_column_name == DEFAULT_ERRORS_COLUMN
assert schema.split_errors == DEFAULT_SPLIT_ERRORS
@pytest.mark.parametrize(
"ma_field, spark_field",
[(fields.String(), StringType()), (fields.DateTime(), TimestampType()),
(fields.Date(), DateType()), (fields.Boolean(), BooleanType()),
(fields.Integer(), IntegerType()), (fields.Number(), DoubleType()),
(fields.List(fields.String()), ArrayType(StringType())),
(fields.Nested(Schema.from_dict({"name": fields.String()})),
StructType([StructField("name", StringType())]))])
def test_spark_schema(ma_field, spark_field):
class TestSchema(Schema):
test_column = ma_field
spark_schema = StructType([
StructField("test_column", spark_field, nullable=True),
StructField(DEFAULT_ERRORS_COLUMN, StringType(), nullable=True)
])
schema = TestSchema()
assert schema.spark_schema == spark_schema
class EventsResponseSchema(BaseEventsSchema):
id = fields.Integer(required=True)
start_date = fields.Date()
end_date = fields.Date()
topics = fields.List(fields.Nested(BaseTopicsSchema))
class TestSchema(Schema):
title = fields.Str()
release_date = fields.Date()
timestamp = fields.Raw(spark_type=DateType())
class EventsRequestSchema(BaseEventsSchema):
from_date = fields.Date()
to_date = fields.Date()
topics_ids = fields.List(fields.Nested(BaseTopicsSchema))
class TestSchema(Schema):
UNIQUE = ["title"]
title = fields.Str()
release_date = fields.Date()
def test_date_field(self, user):
field = fields.Date()
assert field.serialize('birthdate', user) == user.birthdate.isoformat()
user.birthdate = None
assert field.serialize('birthdate', user) is None
class PlayerSchema(BaseSchema):
firstName = fields.String(attribute="first_name")
lastName = fields.String(attribute="last_name")
dateOfBirth = fields.Date(attribute="dob")
