Coverage for src/debputy/manifest_parser/mapper_code.py: 84%

1from typing import ( 

2 TypeVar, 

3 Optional, 

4 Union, 

5 List, 

6 Callable, 

7 TYPE_CHECKING, 

8) 

9 

10from debputy.manifest_parser.exceptions import ManifestTypeException 

11from debputy.packages import BinaryPackage 

12from debputy.util import assume_not_none 

13 

14if TYPE_CHECKING: 

15 from debputy.manifest_parser.util import AttributePath 

16 from debputy.manifest_parser.parser_data import ParserContextData 

17 

18S = TypeVar("S") 

19T = TypeVar("T") 

20 

21 

22def type_mapper_str2package( 

23 raw_package_name: str, 

24 ap: "AttributePath", 

25 opc: Optional["ParserContextData"], 

26) -> BinaryPackage: 

27 pc = assume_not_none(opc) 

28 if "{{" in raw_package_name: 

29 resolved_package_name = pc.substitution.substitute(raw_package_name, ap.path) 

30 else: 

31 resolved_package_name = raw_package_name 

32 

33 package_name_in_message = raw_package_name 

34 if resolved_package_name != raw_package_name: 

35 package_name_in_message = f'"{resolved_package_name}" ["{raw_package_name}"]' 

36 

37 if not pc.is_known_package(resolved_package_name): 37 ↛ 38line 37 didn't jump to line 38 because the condition on line 37 was never true

38 package_names = ", ".join(pc.binary_packages) 

39 raise ManifestTypeException( 

40 f'The value {package_name_in_message} (from "{ap.path}") does not reference a package declared in' 

41 f" debian/control. Valid options are: {package_names}" 

42 ) 

43 package_data = pc.binary_package_data(resolved_package_name) 

44 if package_data.is_auto_generated_package: 44 ↛ 45line 44 didn't jump to line 45 because the condition on line 44 was never true

45 package_names = ", ".join(pc.binary_packages) 

46 raise ManifestTypeException( 

47 f'The package name {package_name_in_message} (from "{ap.path}") references an auto-generated package.' 

48 " However, auto-generated packages are now permitted here. Valid options are:" 

49 f" {package_names}" 

50 ) 

51 return package_data.binary_package 

52 

53 

54def wrap_into_list( 

55 x: T, 

56 _ap: "AttributePath", 

57 _pc: Optional["ParserContextData"], 

58) -> List[T]: 

59 return [x] 

60 

61 

62def normalize_into_list( 

63 x: Union[T, List[T]], 

64 _ap: "AttributePath", 

65 _pc: Optional["ParserContextData"], 

66) -> List[T]: 

67 return x if isinstance(x, list) else [x] 

68 

69 

70def map_each_element( 

71 mapper: Callable[[S, "AttributePath", Optional["ParserContextData"]], T], 

72) -> Callable[[List[S], "AttributePath", Optional["ParserContextData"]], List[T]]: 

73 def _generated_mapper( 

74 xs: List[S], 

75 ap: "AttributePath", 

76 pc: Optional["ParserContextData"], 

77 ) -> List[T]: 

78 return [mapper(s, ap[i], pc) for i, s in enumerate(xs)] 

79 

80 return _generated_mapper