Coverage for src/somesy/package_json/models.py: 90%

1"""package.json validation models.""" 

2 

3import re 

4from logging import getLogger 

5from typing import List, Optional, Union 

6 

7from pydantic import BaseModel, EmailStr, Field, field_validator 

8from typing_extensions import Annotated 

9 

10from somesy.core.types import HttpUrlStr 

11 

12logger = getLogger("somesy") 

13 

14 

15class PackageAuthor(BaseModel): 

16 """Package author model.""" 

17 

18 name: Annotated[Optional[str], Field(description="Author name")] 

19 email: Annotated[Optional[EmailStr], Field(description="Author email")] = None 

20 url: Annotated[ 

21 Optional[HttpUrlStr], Field(description="Author website or orcid page") 

22 ] = None 

23 

24 

25class PackageRepository(BaseModel): 

26 """Package repository model.""" 

27 

28 type: Annotated[Optional[str], Field(description="Repository type")] = None 

29 url: Annotated[str, Field(description="Repository url")] 

30 

31 

32class PackageLicense(BaseModel): 

33 """Package license model.""" 

34 

35 type: Annotated[Optional[str], Field(description="License type")] = None 

36 url: Annotated[str, Field(description="License url")] 

37 

38 

39NPM_PKG_AUTHOR = r"^(.*?)\s*(?:<([^>]+)>)?\s*(?:\(([^)]+)\))?$" 

40NPM_PKG_NAME = r"^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$" 

41NPM_PKG_VERSION = r"^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*)?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$" # noqa: E501 

42 

43 

44class PackageJsonConfig(BaseModel): 

45 """Package.json config model.""" 

46 

47 model_config = dict(populate_by_name=True) 

48 

49 name: Annotated[str, Field(description="Package name")] 

50 version: Annotated[str, Field(description="Package version")] 

51 description: Annotated[Optional[str], Field(description="Package description")] = ( 

52 None 

53 ) 

54 author: Annotated[ 

55 Optional[Union[str, PackageAuthor]], Field(description="Package author") 

56 ] = None 

57 maintainers: Annotated[ 

58 Optional[List[Union[str, PackageAuthor]]], 

59 Field(description="Package maintainers"), 

60 ] = None 

61 contributors: Annotated[ 

62 Optional[List[Union[str, PackageAuthor]]], 

63 Field(description="Package contributors"), 

64 ] = None 

65 license: Annotated[ 

66 Optional[Union[str, PackageLicense]], Field(description="Package license") 

67 ] = None 

68 repository: Annotated[ 

69 Optional[Union[PackageRepository, str]], Field(description="Package repository") 

70 ] = None 

71 homepage: Annotated[Optional[HttpUrlStr], Field(description="Package homepage")] = ( 

72 None 

73 ) 

74 keywords: Annotated[ 

75 Optional[List[str]], Field(description="Keywords that describe the package") 

76 ] = None 

77 

78 # convert package author to dict if it is a string 

79 @classmethod 

80 def convert_author(cls, author: str) -> PackageAuthor: 

81 """Convert author string to PackageAuthor model.""" 

82 # parse author string to "name <email> (url)" format with regex 

83 author_match = re.match(NPM_PKG_AUTHOR, author) 

84 if not author_match: 

85 raise ValueError(f"Invalid author format: {author}") 

86 author_name = author_match[1] 

87 author_email = author_match[2] 

88 author_url = author_match[3] 

89 

90 return PackageAuthor(name=author_name, email=author_email, url=author_url) 

91 

92 @field_validator("name") 

93 @classmethod 

94 def validate_name(cls, v): 

95 """Validate package name.""" 

96 if re.match(NPM_PKG_NAME, v) is None: 

97 raise ValueError("Invalid name") 

98 

99 return v 

100 

101 @field_validator("version") 

102 @classmethod 

103 def validate_version(cls, v): 

104 """Validate package version.""" 

105 if re.match(NPM_PKG_VERSION, v) is None: 

106 raise ValueError("Invalid version") 

107 return v 

108 

109 @field_validator("author") 

110 @classmethod 

111 def validate_author(cls, v): 

112 """Validate package author.""" 

113 return cls.convert_author(v) if isinstance(v, str) else v 

114 

115 @field_validator("maintainers", "contributors") 

116 @classmethod 

117 def validate_people(cls, v): 

118 """Validate package maintainers and contributors.""" 

119 people = [] 

120 for p in v: 

121 if isinstance(p, str): 

122 author = cls.convert_author(p) 

123 if author is not None: 

124 people.append(cls.convert_author(p)) 

125 else: 

126 logger.warning( 

127 f"Invalid email format for maintainer/contributor {p}, omitting." 

128 ) 

129 elif p.email is not None: 

130 people.append(p) 

131 else: 

132 logger.warning( 

133 f"Invalid email format for maintainer/contributor {p}, omitting." 

134 ) 

135 return people