def get_makes_for_vehicle_type(self, vehicle_type: str) -> List[Make]:
"""Returns makes that produce a vehicle_type
Args:
vehicle_type: A vPIC vehicle_type. For example, "Passenger Car",
"Truck", or "Multipurpose Passenger Vehicle (MPV)". If you pass
a partial vehicle_type, for example "Passenger", results will
include makes for all matching vehicle types. Matching is not
case sensitive.
Returns:
A list of ``Makes``s that produce the ``vehicle_type``
Raises:
ValueError: if ``vehicle_type`` is missing
Examples:
>>> get_makes_for_vehicle_type('Car')
[
Make(
make_id=440,
make='ASTON MARTIN',
manufacturer_id=None,
manufacturer=None,
vehicle_type_id=2,
vehicle_type='Passenger Car'
)
...
]
"""
makes = self._client.get_makes_for_vehicle_type(vehicle_type)
schema = desert.schema(Make, meta=self._meta)
return [schema.load(snake_case(m)) for m in makes]
def get_vehicle_variable_values_list(self,
variable_name: str) -> List[Value]:
"""Return the values for a vehicle variable
Args:
variable_name: the name of the vehicle variable
Returns:
A list of ``Values``s
Raises:
ValueError: if ``variable_name`` is missing
Examples:
>>> get_vehicle_variable_values_list("Vehicle Type")
[
Value(element_name="Vehicle Type", id=1, name="Motorcycle"),
Value(element_name="Vehicle Type", id=2, name="Passenger Car"),
Value(element_name="Vehicle Type", id=3, name="Truck "),
Value(element_name="Vehicle Type", id=5, name="Bus"),
Value(element_name="Vehicle Type", id=6, name="Trailer"),
Value(element_name="Vehicle Type", id=7, name="Multipurpose P..."),
Value(element_name="Vehicle Type", id=9, name="Low Speed Vehi..."),
Value(element_name="Vehicle Type", id=10, name="Incomplete Ve..."),
Value(element_name="Vehicle Type", id=13, name="Off Road Vehicle")
]
"""
values = self._client.get_vehicle_variable_values_list(variable_name)
schema = desert.schema(Value, meta=self._meta)
return [schema.load(snake_case(v)) for v in values]
def get_all_makes(self) -> List[Make]:
"""Returns all of the makes registered with vPIC.
Returns:
A list of all of the ``Make``s registered with vPIC.
Examples:
>>> get_all_makes()
[
Make(make_id=440, make='ASTON MARTIN'),
Make(make_id=441, make='TESLA'),
Make(make_id=442, make='JAGUAR'),
Make(make_id=443, make='MASERATI'),
Make(make_id=444, make='LAND ROVER'),
Make(make_id=445, make='ROLLS ROYCE'),
Make(make_id=446, make='BUELL (EBR)'),
Make(make_id=447, make='JIALING'),
Make(make_id=448, make='TOYOTA'),
Make(make_id=449, make='MERCEDES-BENZ'),
...
]
"""
makes = self._client.get_all_makes()
schema = desert.schema(Make, meta=self._meta)
return [schema.load(snake_case(make)) for make in makes]
def to_class(cls: Any, data: List[Dict]) -> List[object]:
"""Collects json response into dataclass using desert."""
all_data = []
for d in data:
desert_cls = desert.schema(cls)
all_data.append(desert_cls.load(d, unknown=EXCLUDE))
return all_data
def test_reportF016TH():
test_data = {
"time": "2020-07-09 10:54:16",
"new": 56,
"model": "SwitchDoc Labs F007TH Thermo-Hygrometer",
"device": "233",
"modelnumber": 5,
"channel": 3,
"battery": "OK",
"temperature_F": 72.100,
"humidity": 45,
"mic": "CRC"
}
schema = desert.schema(reportF016TH) #, meta={"unknown": EXCLUDE})
# # data = schema.load(json.loads(sLine))
# # assert data
# dumped = desert.validate_and_dump(schema)
# defs = dumped["definitions"]
# assert "OuterSchema" in defs
try:
data = schema.load(test_data)
print(data)
except ValidationError as err:
print(err.messages)
print(err.valid_data)
assert False
def test_non_string_metadata_key(module):
"""A non-string key in the attrib metadata comes through in the mm field."""
@module.dataclass
class A:
x: int = module.field(metadata={1: 2})
field = desert.schema(A).fields["x"]
assert field.metadata == {1: 2, desert._make._DESERT_SENTINEL: {}}
def get_vehicle_types_for_make(self,
make: Union[str, int]) -> List[VehicleType]:
"""Returns vehicle types produced by a make or make
Args:
make: Pass the MakeId (int) or the complete make name (str) to return
vehicle types for a single manufacturer. Pass a partial make name
to return vehicle types for all makes that match the partial name.
When you pass a make name, results will include the MakeId and
MakeName because you may get vehicle_types for more than one make.
Returns:
A list of ``VehicleType``s produced by the ``make``(s)
Raises:
ValueError: if ``make`` is missing
Examples:
>>> get_vehicle_types_for_make(474)
[
VehicleType(
vehicle_type_id=1,
vehicle_type='Motorcycle',
make_id=None,
make=None
),
VehicleType(
vehicle_type_id=2,
vehicle_type='Passenger Car',
make_id=None,
make=None
),
VehicleType(
vehicle_type_id=3,
vehicle_type='Truck ',
make_id=None,
make=None
),
VehicleType(
vehicle_type_id=7,
vehicle_type='Multipurpose Passenger Vehicle (MPV)',
make_id=None,
make=None
),
VehicleType(
vehicle_type_id=9,
vehicle_type='Low Speed Vehicle (LSV)',
make_id=None,
make=None
)
]
"""
schema = desert.schema(VehicleType, meta=self._meta)
results = self._client.get_vehicle_types_for_make(make)
snake_cased = [snake_case(r) for r in results]
return [schema.load(sc) for sc in snake_cased]
def test_non_optional_means_required(module):
"""Non-optional fields are required."""
@module.dataclass
class A:
x: int = module.field(metadata={1: 2})
schema = desert.schema(A)
with pytest.raises(marshmallow.exceptions.ValidationError):
schema.load({})
def test_methods_not_on_schema(module):
"""Dataclass methods are not copied to the schema."""
@module.dataclass
class A:
def dataclass_method(self) -> None:
"""This method should not exist on the schema."""
schema = desert.schema(A)
sentinel = object()
method = getattr(schema, "dataclass_method", sentinel)
assert method is sentinel
def get_parts(self,
cfr_part: str,
from_date: str,
to_date: str,
page: int = 1) -> List[Document]:
"""Returns a list of vehicle documentation submitted by manufacturers.
Manufacturers provide vehicle information to NHTSA to comply with these
regulations:
* 49 CFR Part 565 (Vehicle Identification Number Guidance)
* 49 CFR Part 566 (Manufacturer Identification – Reporting Requirements)
This provides a list of documents submitted in a date range. Up to 1,000
results will be returned at a time.
Args:
cfr_part: '565' to return 49 CFR Part 565 submissions;
'566' to return 49 CFR Part 566 submissions
from_date: the beginning of the date range to search
to_date: the end of the date range to search
page: results are paginated; this is page number to return
Returns:
A list of ``Document``s registered with vPIC.
Raises:
ValueError: if ``cfr_part`` is missing
Examples:
>>> get_parts('565', '2015-01-01', '2015-05-05', 1)
[
Document(
cover_letter_url='',
letter_date='1/1/2015',
manufacturer_id=959,
manufacturer='MASERATI NORTH AMERICA, INC.',
name='ORG13044',
url='...',
type=None,
model_year_from=20,
model_year_to=None
),
...
]
"""
documents = self._client.get_parts(cfr_part, from_date, to_date, page)
for doc in documents:
# snake_case doesn't handle lowerUPPER
doc["CoverLetterUrl"] = doc["CoverLetterURL"]
del doc["CoverLetterURL"]
schema = desert.schema(Document, meta=self._meta)
return [schema.load(snake_case(doc)) for doc in documents]
def get_validated_configs(
config_text: str, config_path: str,
preset_target_definitions_text: str) -> "PlotmanConfig":
"""Return a validated instance of PlotmanConfig with data from plotman.yaml
:raises ConfigurationException: Raised when plotman.yaml is either missing or malformed
"""
schema = desert.schema(PlotmanConfig)
config_objects = yaml.load(config_text, Loader=yaml.SafeLoader)
version = config_objects.get('version', (0, ))
expected_major_version = 1
if version[0] != expected_major_version:
message = textwrap.dedent(f"""\
Expected major version {expected_major_version}, found version {version}
See https://github.com/ericaltendorf/plotman/wiki/Configuration#versions
""")
raise Exception(message)
loaded: PlotmanConfig
try:
loaded = schema.load(config_objects)
except marshmallow.exceptions.ValidationError as e:
raise ConfigurationException(
f"Config file at: '{config_path}' is malformed") from e
if loaded.archiving is not None:
preset_target_objects = yaml.safe_load(preset_target_definitions_text)
preset_target_schema = desert.schema(PresetTargetDefinitions)
preset_target_definitions = preset_target_schema.load(
preset_target_objects)
loaded.archiving.target_definitions = {
**preset_target_definitions.target_definitions,
**loaded.archiving.target_definitions,
}
return loaded
def test_custom_field(module: DataclassModule) -> None:
@module.dataclass
class A:
x: str = module.field(
metadata=desert.metadata(marshmallow.fields.NaiveDateTime())
)
timestring = "2019-10-21T10:25:00"
dt = datetime.datetime(year=2019, month=10, day=21, hour=10, minute=25, second=00)
schema = desert.schema(A)
assert schema.load({"x": timestring}) == A(x=dt) # type: ignore[call-arg]
def test_concise_attrib() -> None:
"""Concisely create an attr.ib()"""
@attr.dataclass
class A:
x: datetime.datetime = desert.ib(marshmallow.fields.NaiveDateTime())
timestring = "2019-10-21T10:25:00"
dt = datetime.datetime(year=2019, month=10, day=21, hour=10, minute=25, second=00)
schema = desert.schema(A)
assert schema.load({"x": timestring}) == A(x=dt)
def test_takes_self():
"""Attrs default factories are constructed after instance creation."""
@attr.s
class C:
x: int = attr.ib()
y: int = attr.ib()
@y.default
def _(self):
return self.x + 1
schema = desert.schema(C)
assert schema.load({"x": 1}) == C(x=1, y=2)
def test_concise_field_metadata() -> None:
"""Concisely create a dataclasses.Field with metadata."""
@dataclasses.dataclass
class A:
x: datetime.datetime = desert.field(
marshmallow.fields.NaiveDateTime(),
metadata={"foo": 1},
)
timestring = "2019-10-21T10:25:00"
dt = datetime.datetime(year=2019, month=10, day=21, hour=10, minute=25, second=00)
schema = desert.schema(A)
assert schema.load({"x": timestring}) == A(x=dt)
assert dataclasses.fields(A)[0].metadata["foo"] == 1
def test_concise_dataclasses_field():
"""Concisely create a dataclasses.Field."""
@dataclasses.dataclass
class A:
x: str = desert.field(marshmallow.fields.NaiveDateTime())
timestring = "2019-10-21T10:25:00"
dt = datetime.datetime(year=2019,
month=10,
day=21,
hour=10,
minute=25,
second=00)
schema = desert.schema(A)
assert schema.load({"x": timestring}) == A(x=dt)
def get_validated_configs(config_text, config_path):
"""Return a validated instance of PlotmanConfig with data from plotman.yaml
:raises ConfigurationException: Raised when plotman.yaml is either missing or malformed
"""
schema = desert.schema(PlotmanConfig)
config_objects = yaml.load(config_text, Loader=yaml.SafeLoader)
try:
loaded = schema.load(config_objects)
except marshmallow.exceptions.ValidationError as e:
raise ConfigurationException(
f"Config file at: '{config_path}' is malformed"
) from e
return loaded
def get_wmis_for_manufacturer(
self,
manufacturer: Union[str, int],
vehicle_type: Optional[Union[str, int]] = None,
) -> List[WMI]:
"""Returns the WMIs for one or all manufacturers
Args:
manufacturer: Pass the Manufacturer Id (int) or the complete
manufacturer name (str) to return WMIs for a single manufacturer.
Pass a partial name to return WMIs for all manufacturers with
names that include the partial name.
vehicle_type: Pass the vehicle_type Id (int) or complete vehicle_type
name to return WMIs for that vehicle_type. Pass a partial name to
return WMIs for vehicle_types matching that name.
Returns:
A list of ``WorldManufacturerIndex`` with information about the
manufacturers.
Raises:
ValueError: if ``manufacturer`` is missing
Examples:
>>> get_wmis_for_manufacturer('Honda')
[
WorldManufacturerIndex(
created_on='2015-03-26',
date_available_to_public='2015-01-01',
manufacturer='HONDA MOTOR CO., LTD',
updated_on='2015-06-04',
vehicle_type='Passenger Car',
wmi='JHM', common_name='',
country=None,
make='',
manufacturer_id=987,
parent_company_name='',
url=''
),
...
]
"""
wmis = self._client.get_wmis_for_manufacturer(manufacturer,
vehicle_type)
schema = desert.schema(WMI, meta=self._meta)
return [schema.load(snake_case(wmi)) for wmi in wmis]
def get_equipment_plant_codes(self,
year: int,
equipment_type: int,
report_type: str = "All") -> List[PlantCode]:
"""Returns a list of plants that manufacture certain vehicle equipment.
Plants have a unique three-character U.S. Department of Transportation
(DOT) code. vPIC API documentation says this API only accepts 2016 and
later.
Args:
year: must be 2016 or later
equipment_type: return plants that manufacture one of these equipment
types: 1 = Tires; 3 = Brake Hoses; 13 = Glazing; 16 = Retread
report_type: must be one of
New = plants whose code was assigned during the selected year
Updated = plants whose data was modified during the selected year
Closed = plants that are no longer active
All = all active and closed plants, regardless of year
Returns:
A list of ``PlantCode``s that manufacture the equipment_type
Raises:
ValueError: if ``year`` is earlier than 2016
Example:
>>> get_equipment_plant_codes(2016, 1)
[
PlantCode(address='2950 INTERNATIONAL BLVD.', city='CLARKSVILLE', ...),
PlantCode(address='1850 BARTON FERRY ROAD', city='WEST POINT', cou...),
PlantCode(address='No. 52 Street 536, Bau Tran Hamlet, Nhuan Duc C...),
PlantCode(address='NO. 23, HAILAR EAST ROAD', city='HUHHOT', count...),
PlantCode(address='NO. 9 EAST BEISAN ROAD', city='SHENYANG', count...),
PlantCode(address='HONGSHANZUI ECONOMIC DEV. ZONE', city='PINGQUAN...),
PlantCode(address='QIANLIU VILLAGE XIADIAN TOWN', city='CHANGYI CI...),
PlantCode(address='DOWANG TOWN', city='GUANGRAO COUNTY', country='...),
PlantCode(address='NO.1 HUIXIN ROAD', city='GAOTANG', country='CHI...),
PlantCode(address='NO.668 LAMEI ROAD,JIESHI TOWN,BANAN DISTRICT', ...),
]
"""
plant_codes = self._client.get_equipment_plant_codes(
year, equipment_type, report_type)
schema = desert.schema(PlantCode, meta=self._meta)
return [schema.load(snake_case(pc)) for pc in plant_codes]
def test_concise_attrib_metadata():
"""Concisely create an attr.ib() with metadata."""
@attr.dataclass
class A:
x: str = desert.ib(marshmallow.fields.NaiveDateTime(),
metadata={"foo": 1})
timestring = "2019-10-21T10:25:00"
dt = datetime.datetime(year=2019,
month=10,
day=21,
hour=10,
minute=25,
second=00)
schema = desert.schema(A)
assert schema.load({"x": timestring}) == A(x=dt)
assert attr.fields(A).x.metadata["foo"] == 1
def get_validated_configs():
"""Return a validated instance of the PlotmanConfig dataclass with data from plotman.yaml
:raises ConfigurationException: Raised when plotman.yaml is either missing or malformed
"""
schema = desert.schema(PlotmanConfig)
config_file_path = get_path()
try:
with open(config_file_path, "r") as file:
config_file = yaml.load(file, Loader=yaml.SafeLoader)
return schema.load(config_file)
except FileNotFoundError as e:
raise ConfigurationException(
f"No 'plotman.yaml' file exists at expected location: '{config_file_path}'. To generate "
f"default config file, run: 'plotman config generate'") from e
except marshmallow.exceptions.ValidationError as e:
raise ConfigurationException(
f"Config file at: '{config_file_path}' is malformed") from e
def get_makes_for_manufacturer(
self,
manufacturer: Union[str, int],
model_year: Optional[int] = None) -> List[Make]:
"""Returns makes produced by a manufacturer or manufacturers.
Args:
manufacturer: Pass the Manufacturer Id (int) or the complete
manufacturer name (str) to return detail for a single manufacturer.
Pass a partial name to return manufacturers with names that include
the partial name.
model_year: Pass a model year to return only those makes made by
the manufacturer for that model year.
Returns:
A list of ``Makes``s produced by the manufacturer(s)
Raises:
ValueError: if ``manufacturer`` is missing
Examples:
>>> get_makes_for_manufacturer(988)
[
Make(
make_id:474
make:'HONDA'
manufacturer_id:None
manufacturer:'HONDA DEVELOPMENT & MANUFACTURING OF AMERICA...'
),
Make(
make_id=475,
make='ACURA',
manufacturer_id=None,
manufacturer='HONDA DEVELOPMENT & MANUFACTURING OF AMERICA...'
)
...
]
"""
makes = self._client.get_makes_for_manufacturer(
manufacturer, model_year)
schema = desert.schema(Make, meta=self._meta)
return [schema.load(snake_case(m)) for m in makes]
def get_vehicle_variable_list(self) -> List[Variable]:
"""Return a list of vehicle variables tracked by vPIC
Returns:
A list of ``Variable``s
Examples:
>>> get_vehicle_variable_list()
[
Variable(id=1, name='Other Battery Info', data_type='string', descr...),
Variable(id=2, name='Battery Type', data_type='lookup', description...),
Variable(id=3, name='Bed Type', data_type='lookup', description='<p...),
Variable(id=4, name='Cab Type', data_type='lookup', description='<p...),
Variable(id=5, name='Body Class', data_type='lookup', description='...),
Variable(id=9, name='Engine Number of Cylinders', data_type='int', ...),
]
"""
variables = self._client.get_vehicle_variable_list()
schema = desert.schema(Variable, meta=self._meta)
return [schema.load(snake_case(v)) for v in variables]
def decode_vin_batch(self, vins: List[str]) -> List[Vehicle]:
"""Decode a batch of 17-digit VINs or partial VINs.
Model year is required for pre-1980 vehicles, though vPIC recommends
that you always pass it.
If you don't have a complete 17-digit VIN, you can pass a partial
VIN, using asterisk (*) for missing characters. The VIN check digit
(the 9th character) isn't required for partial VINs. The shorter the
partial VIN, the less vehicle information you'll receive in the
response.
Vehicle variables will be returned in key-value pairs, the same
format returned by decode_vin(.., flatten=True).
See get_vehicle_variable_list for the variables returned here.
Args:
vins: A list of 17-digit VIN or partial VINs and optional model year.
Use asterisk for missing characters. For example: ["VIN, model_year",
"VIN, model_year", ...]
Returns:
A list of ``Vehicle``s with the information decoded from ``vins``.
Raises:
ValueError: if ``vin`` is missing or isn't 6 to 17 characters long.
ValueError: if ``model_year`` is earlier than 1981.
Example:
>>> decode_vin_batch(["5UXWX7C5*BA,2011", "5YJSA3DS*EF"])
[Vehicle(...), Vehicle(...)]
"""
vehicles = self._client.decode_vin_batch(vins)
schema = desert.schema(Vehicle, meta=self._meta)
return [schema.load(snake_case(v)) for v in vehicles]
def decode_wmi(self, wmi: str) -> WMI:
"""Decode a WMI to get manufacturer information
Provides information on the World Manufacturer Identifier for a
specific WMI code.
Args:
wmi: A 3-character or 6-character World Manufacturer Index code.
Large volume manufacturers usually have a 3 character WMI
representing positions 1 to 3 ("JTD") of a VIN. Smaller
manufacturers have a 6 character WMI representing positions
1 to 3 and 12 to 14 of a VIN.
Returns:
A ``WorldManufacturerIndex`` with information about the manufacturer.
Raises:
ValueError: if ``wmi`` is missing or isn't 3 or 6 characters long.
Example:
>>> decode_wmi('1FT')
WorldManufacturerIndex(
common_name="Ford",
created_on="2015-03-23",
date_available_to_public="2015-01-01",
make="FORD",
manufacturer="FORD MOTOR COMPANY, USA",
parent_company_name="",
updated_on=None,
url="http://www.ford.com/",
vehicle_type="Truck ",
)
"""
schema = desert.schema(WMI, meta=self._meta)
return schema.load(snake_case(self._client.decode_wmi(wmi)))
def get_models_for_make(
self,
make: Union[int, str],
model_year: Optional[int] = None,
vehicle_type: Optional[str] = None,
) -> List[Model]:
"""Return a list of models for a make or makes.
Optionally filter the results by model year and vehicle type.
Args:
make: Pass the MakeId (int) or the complete make name (str) to return
vehicle types for a single manufacturer. Pass a partial make name
to return vehicle types for all makes that match the partial name.
When you pass a make name, results will include the MakeId and
MakeName because you may get vehicle_types for more than one make.
model_year: pass this to return models made in this model year
vehicle_type: one of the vPIC vehicle_types (for example, "Passenger Car",
"Truck", or "Multipurpose Passenger Vehicle (MPV)")
Returns:
A list of ``Model``s
Raises:
ValueError: if ``year`` is earlier than 2016
Examples:
>>> get_models_for_make("TESLA", model_year=2020)
[
Model(
model_id=1685,
model='Model S',
make_id=441,
make='TESLA',
vehicle_type_id=None
),
Model(
model_id=10199,
model='Model X',
make_id=441,
make='TESLA',
vehicle_type_id=None
),
Model(
model_id=17834,
model='Model 3',
make_id=441,
make='TESLA',
vehicle_type_id=None
),
Model(
model_id=27027,
model='Model Y',
make_id=441,
make='TESLA',
vehicle_type_id=None
)
]
VehicleTypeId and VehicleType are only returned
when you specify vehicle_type.
"""
models = self._client.get_models_for_make(make, model_year,
vehicle_type)
schema = desert.schema(Model, meta=self._meta)
return [schema.load(snake_case(m)) for m in models]
def get_manufacturer_details(
self, manufacturer: Union[str, int]) -> List[ManufacturerDetail]:
"""Returns details for one or more manufacturers.
Args:
manufacturer: Pass the Manufacturer Id (int) or the complete
manufacturer name (str) to return detail for a single
manufacturer. Pass a partial name to return manufacturers
with names that include the partial name.
Returns:
A list of ``ManufacturerDetail``s for the manufacturer(s)
Examples:
>>> get_manufacturer_details(988)
[
ManufacturerDetail(
manufacturer_id=988,
manufacturer="HONDA DEVELOPMENT & MANUFACTURING OF AMER...",
manufacturer_common_name="Honda",
address="1919 Torrance Blvd.",
address2=None,
city="Torrance",
contact_email="*****@*****.**",
contact_fax=None,
contact_phone="...",
country="UNITED STATES (USA)",
dbas="Marysville Auto Plant and East Liberty Auto Plant; ...",
equipment_items=[],
last_updated="/Date(1618422117803-0400)/",
manufacturer_types=[
ManufacturerType(
name="Completed Vehicle Manufacturer")
],
other_manufacturer_details=None,
postal_code="90501",
primary_product=None,
principal_first_name="...",
principal_last_name=None,
principal_position="President & CEO",
state_province="CALIFORNIA",
submitted_name="...",
submitted_on="/Date(1618286400000-0400)/",
submitted_position="Sr. Specialist, II",
vehicle_types=[
VehicleType(
vehicle_type="Passenger Car",
vehicle_type_id=None,
make_id=None,
make=None,
gvwr_from="Class 1A: 3,000 lb or less (1,360 kg or less)",
gvwr_to="Class 1D: 5,001 - 6,000 lb (2,268 - 2,722 kg)",
is_primary=True
),
VehicleType(
vehicle_type="Truck ",
vehicle_type_id=None,
make_id=None,
make=None,
gvwr_from="Class 2E: 6,001 - 7,000 lb (2,722 - 3,175 kg)",
gvwr_to="Class 2E: 6,001 - 7,000 lb (2,722 - 3,175 kg)",
is_primary=False
),
VehicleType(
vehicle_type="Multipurpose Passenger Vehicle (MPV)",
vehicle_type_id=None,
make_id=None,
make=None,
gvwr_from="Class 1B: 3,001 - 4,000 lb (1,360 - 1,814 kg)",
gvwr_to="Class 2E: 6,001 - 7,000 lb (2,722 - 3,175 kg)",
is_primary=False
)
]
)
]
"""
results = self._client.get_manufacturer_details(manufacturer)
for r in results:
r["dbas"] = r["DBAs"]
del r["DBAs"]
# r["ManufacturerTypes"] = [
# ManufacturerType(name=mt["Name"]) for mt in r["ManufacturerTypes"]
# ]
# r["VehicleTypes"] = [
# VehicleType(
# vehicle_type=vt["Name"],
# is_primary=vt["IsPrimary"],
# gvwr_from=vt["GVWRFrom"],
# gvwr_to=vt["GVWRTo"],
# )
# for vt in r["VehicleTypes"]
# ]
# r["ManufacturerTypes"] = [snake_case(mt) for mt in r["ManufacturerTypes"]]
# r["VehicleTypes"] = [snake_case(vt) for vt in r["VehicleTypes"]]
schema = desert.schema(ManufacturerDetail, meta=self._meta)
snake_cased = [snake_case(r) for r in results]
return [schema.load(sc) for sc in snake_cased]
async def get_matches(
self, players: List[Player]) -> Optional[List[PlayerMatches]]:
pms: List[PlayerMatches] = []
# connect to the server's socket
try:
ws = await websockets.connect(uri=self.url,
ssl=True,
extra_headers=self.headers)
except Exception as e:
logging.error(f"unable to connect to {self.url}: {e}")
return
logging.info("socket connected")
# request the last matches for each player
for pl in players:
logging.info(f"getting {pl.name} (id: {pl.profileId}) matches...")
try:
await ws.send(
json.dumps({
"message": "playerrecentmatches",
"id": str(pl.profileId),
}))
except Exception as e:
logging.error(f"error while sending msg: {e}")
break
retry = 3
while retry > 0:
retry -= 1
try:
raw = await ws.recv()
resp = json.loads(raw)
if ("data" in resp and isinstance(resp["data"], list)
and len(resp["data"]) > 0):
prm = desert.schema(PlayerRecentMatches).load(resp)
# remove empty slots from player list
for data in prm.data:
data.players = [
pl for pl in data.players
if pl.name is not None
]
pms.append(PlayerMatches(player=pl, matches=prm.data))
break
else:
logging.info(f"ignoring message: {raw}, {retry} left")
except Exception as e:
logging.error(
f"error while getting {pl.name} matches: {e}")
await ws.close()
logging.info("socket closed")
# log results
msg = f"found matches for {len(pms)}/{len(players)} players"
if len(pms) != len(players):
logging.error(msg)
return
logging.info(msg)
return pms
def decode_vin(self,
vin: str,
model_year: Optional[int] = None,
extend: Optional[bool] = False) -> Vehicle:
"""Decode a 17-digit Vehicle Identification Number (VIN) or partial VIN.
Decode the make, model, series, trim, and other vehicle information
from VIN. Model year is required for pre-1980 vehicles, though vPIC
recommends that you always pass it.
If you don't have a complete 17-digit VIN, you can pass a partial
VIN, using asterisk (*) for missing characters. The VIN check digit
(the 9th character) isn't required for partial VINs. The shorter the
partial VIN, the less vehicle information you'll receive in the
response.
See get_vehicle_variable_list for the variables returned here.
Args:
vin: A 17-digit VIN or partial VIN. Use asterisk for missing
characters.
model_year: The vehicle's model year. Recommended, but not required.
extend: If True, response will include variables for other NHTSA
programs like NCSA. Defaults to False.
Returns:
A ``Vehicle`` with the information decoded from ``vin``.
Raises:
ValueError: if ``vin`` is missing or isn't 6 to 17 characters long.
ValueError: if ``model_year`` is earlier than 1981.
Example:
>>> decode_vin('1FTMW1T88MFA00001')
Vehicle(
abs="",
...
body_cab_type="Crew/ Super Crew/ Crew Max",
body_class="Pickup",
brake_system_desc="",
brake_system_type="Hydraulic",
...
displacement_cc="3500.0",
displacement_ci="213.58310433156",
displacement_l="3.5",
...
drive_type="4WD/4-Wheel Drive/4x4",
...
engine_configuration="V-Shaped",
engine_cycles="",
engine_cylinders="6",
engine_hp="375",
engine_hp_to="",
engine_kw="279.6375",
engine_manufacturer="Ford",
engine_model="GTDI",
entertainment_system="",
error_code="0",
error_text="0 - VIN decoded clean. Check Digit (9th position) is co...",
...
make="FORD",
make_id="460",
manufacturer="FORD MOTOR COMPANY, USA",
manufacturer_id="976",
model="F-150",
model_id="1801",
model_year="2021",
motorcycle_chassis_type="Not Applicable",
motorcycle_suspension_type="Not Applicable",
...
plant_city="DEARBORN",
plant_company_name="",
plant_country="UNITED STATES (USA)",
plant_state="MICHIGAN",
...
series="F-Series",
series2="",
...
trim="SuperCrew-SSV",
...
vin="1FTMW1T88MFA00001",
...
vehicle_type="TRUCK ",
...
)
"""
schema = desert.schema(Vehicle, meta=self._meta)
return schema.load(
snake_case(self._client.decode_vin(vin, model_year, extend)))
@dataclass
class Page:
"""Page resource.
Attributes:
title: The title of the Wikipedia page.
extract: A plain text summary.
"""
title: str
extract: str
schema = desert.schema(Page, meta={"unknown": marshmallow.EXCLUDE})
def random_page(lang: str = "en") -> Page:
"""Return random page.
Performs a GET request to the /page/random/summary endpoint.
Args:
lang: the Wikipedia language edition.
By default, the English Wikipedia is used ("en").
Returns:
A page resource.
Raises:
