15538132884

Committed 09 Jun 2025 03:22PM UTC coverage: 91.624% (+0.3%) from 91.349%

Build # 15538132884

Build Type

push

github

Committed by

idlesign

Commit Message

Type fix.

Run Details

361 of 394 relevant lines covered (91.62%)

3.66 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

97.83

/src/vininfo/common.py

from datetime import datetime, timezone
from typing import TYPE_CHECKING, Any, ClassVar

if TYPE_CHECKING: # pragma: nocover
    from .details._base import VinDetails


def constant_info(info):
    """Emulate details logic to always return the same information."""
    return lambda details: type("", (), {"get": (lambda code: info)})


def candidate_by_year_model_mapping(mapping: dict[str, dict[str, str]], years: list[int]):
    candidate_mapping = {}
    for model_year_range, candidates in mapping.items():
        start_model_year, end_model_year = model_year_range.split('-')

        if not start_model_year and not end_model_year:
            candidate_mapping.update(candidates)
            continue

        start_model_year = int(start_model_year)
        end_model_year = (
            int(end_model_year)
            if end_model_year else
            max(datetime.now(tz=timezone.utc).year, start_model_year) + 1
        )

        filter_years = [year for year in years if start_model_year <= year <= end_model_year]
        if filter_years:
            candidate_mapping.update(candidates)

    return candidate_mapping


class Annotatable:

    annotate_titles: ClassVar = {}

    def annotate(self) -> dict[str, Any]:

        annotations = {}
        no_attr = set()

        for attr_name, label in self.annotate_titles.items():
            value = getattr(self, attr_name, no_attr)

            if value is no_attr:
                continue

            if isinstance(value, list):
                value = ', '.join(f'{val}' for val in value)

            annotations[label] = f'{value}'

        return dict(sorted(annotations.items(), key=lambda item: item[0]))


class Assembler:
    """Assembler is a manufacturer that has a WMI and assemble vehicles for other brands using its own WMI."""
    __slots__ = ['manufacturer']

    brands: ClassVar[set['Brand']] = None

    def __init__(self, manufacturer: str | None = None):
        self.manufacturer = manufacturer or self.title

    @property
    def title(self) -> str:
        return self.__class__.__name__

    def __str__(self):
        return f'{self.title} ({self.manufacturer})'


class Brand(Assembler):
    extractor: type['VinDetails'] = None

    @property
    def brands(self) -> set['Brand']:
        return {self}


class UnsupportedBrand(Brand):
    """Unsupported brand."""

1	from datetime import datetime, timezone	4✔
2	from typing import TYPE_CHECKING, Any, ClassVar	4✔
3
4	if TYPE_CHECKING: # pragma: nocover
5	from .details._base import VinDetails
6
7
8	def constant_info(info):	4✔
9	"""Emulate details logic to always return the same information."""
10	return lambda details: type("", (), {"get": (lambda code: info)})	4✔
11
12
13	def candidate_by_year_model_mapping(mapping: dict[str, dict[str, str]], years: list[int]):	4✔
14	candidate_mapping = {}	4✔
15	for model_year_range, candidates in mapping.items():	4✔
16	start_model_year, end_model_year = model_year_range.split('-')	4✔
17
18	if not start_model_year and not end_model_year:	4✔
19	candidate_mapping.update(candidates)	4✔
20	continue	4✔
21
22	start_model_year = int(start_model_year)	4✔
23	end_model_year = (	4✔
24	int(end_model_year)
25	if end_model_year else
26	max(datetime.now(tz=timezone.utc).year, start_model_year) + 1
27	)
28
29	filter_years = [year for year in years if start_model_year <= year <= end_model_year]	4✔
30	if filter_years:	4✔
31	candidate_mapping.update(candidates)	4✔
32
33	return candidate_mapping	4✔
34
35
36	class Annotatable:	4✔
37
38	annotate_titles: ClassVar = {}	4✔
39
40	def annotate(self) -> dict[str, Any]:	4✔
41
42	annotations = {}	4✔
43	no_attr = set()	4✔
44
45	for attr_name, label in self.annotate_titles.items():	4✔
46	value = getattr(self, attr_name, no_attr)	4✔
47
48	if value is no_attr:	4✔
49	continue	×
50
51	if isinstance(value, list):	4✔
52	value = ', '.join(f'{val}' for val in value)	4✔
53
54	annotations[label] = f'{value}'	4✔
55
56	return dict(sorted(annotations.items(), key=lambda item: item[0]))	4✔
57
58
59	class Assembler:	4✔
60	"""Assembler is a manufacturer that has a WMI and assemble vehicles for other brands using its own WMI."""
61	__slots__ = ['manufacturer']	4✔
62
63	brands: ClassVar[set['Brand']] = None	4✔
64
65	def __init__(self, manufacturer: str \| None = None):	4✔
66	self.manufacturer = manufacturer or self.title	4✔
67
68	@property	4✔
69	def title(self) -> str:	4✔
70	return self.__class__.__name__	4✔
71
72	def __str__(self):	4✔
73	return f'{self.title} ({self.manufacturer})'	4✔
74
75
76	class Brand(Assembler):	4✔
77	extractor: type['VinDetails'] = None	4✔
78
79	@property	4✔
80	def brands(self) -> set['Brand']:	4✔
81	return {self}	4✔
82
83
84	class UnsupportedBrand(Brand):	4✔
85	"""Unsupported brand."""

idlesign / vininfo / 15538132884

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous