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

1from typing import ( 

2 TypeVar, 

3 Optional, 

4 Union, 

5 List, 

6 Callable, 

7) 

8 

9from debputy.manifest_parser.exceptions import ManifestTypeException 

10from debputy.manifest_parser.parser_data import ParserContextData 

11from debputy.manifest_parser.util import AttributePath 

12from debputy.packages import BinaryPackage 

13from debputy.util import assume_not_none 

14 

15S = TypeVar("S") 

16T = TypeVar("T") 

17 

18 

19def type_mapper_str2package( 

20 raw_package_name: str, 

21 ap: AttributePath, 

22 opc: Optional[ParserContextData], 

23) -> BinaryPackage: 

24 pc = assume_not_none(opc) 

25 if "{{" in raw_package_name: 

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

27 else: 

28 resolved_package_name = raw_package_name 

29 

30 package_name_in_message = raw_package_name 

31 if resolved_package_name != raw_package_name: 

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

33 

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

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

36 raise ManifestTypeException( 

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

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

39 ) 

40 package_data = pc.binary_package_data(resolved_package_name) 

41 if package_data.is_auto_generated_package: 41 ↛ 42line 41 didn't jump to line 42, because the condition on line 41 was never true

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

43 raise ManifestTypeException( 

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

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

46 f" {package_names}" 

47 ) 

48 return package_data.binary_package 

49 

50 

51def wrap_into_list( 

52 x: T, 

53 _ap: AttributePath, 

54 _pc: Optional["ParserContextData"], 

55) -> List[T]: 

56 return [x] 

57 

58 

59def normalize_into_list( 

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

61 _ap: AttributePath, 

62 _pc: Optional["ParserContextData"], 

63) -> List[T]: 

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

65 

66 

67def map_each_element( 

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

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

70 def _generated_mapper( 

71 xs: List[S], 

72 ap: AttributePath, 

73 pc: Optional["ParserContextData"], 

74 ) -> List[T]: 

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

76 

77 return _generated_mapper