Coverage for /var/srv/projects/api.amasfac.comuna18.com/tmp/venv/lib/python3.9/site-packages/faker/providers/user_agent/__init__.py: 40%

1import string 

2 

3from datetime import datetime, timedelta 

4 

5from .. import BaseProvider, ElementsType 

6 

7_DT_ALMOST_MAX = datetime.max - timedelta(1.0) 

8 

9 

10class Provider(BaseProvider): 

11 """Implement default user agent provider for Faker.""" 

12 

13 user_agents: ElementsType[str] = ( 

14 "chrome", 

15 "firefox", 

16 "internet_explorer", 

17 "opera", 

18 "safari", 

19 ) 

20 

21 windows_platform_tokens: ElementsType[str] = ( 

22 "Windows 95", 

23 "Windows 98", 

24 "Windows 98; Win 9x 4.90", 

25 "Windows CE", 

26 "Windows NT 4.0", 

27 "Windows NT 5.0", 

28 "Windows NT 5.01", 

29 "Windows NT 5.1", 

30 "Windows NT 5.2", 

31 "Windows NT 6.0", 

32 "Windows NT 6.1", 

33 "Windows NT 6.2", 

34 "Windows NT 10.0", 

35 ) 

36 

37 linux_processors: ElementsType[str] = ("i686", "x86_64") 

38 

39 mac_processors: ElementsType[str] = ("Intel", "PPC", "U; Intel", "U; PPC") 

40 

41 android_versions: ElementsType[str] = ( 

42 "1.0", 

43 "1.1", 

44 "1.5", 

45 "1.6", 

46 "2.0", 

47 "2.0.1", 

48 "2.1", 

49 "2.2", 

50 "2.2.1", 

51 "2.2.2", 

52 "2.2.3", 

53 "2.3", 

54 "2.3.1", 

55 "2.3.2", 

56 "2.3.3", 

57 "2.3.4", 

58 "2.3.5", 

59 "2.3.6", 

60 "2.3.7", 

61 "3.0", 

62 "3.1", 

63 "3.2", 

64 "3.2.1", 

65 "3.2.2", 

66 "3.2.3", 

67 "3.2.4", 

68 "3.2.5", 

69 "3.2.6", 

70 "4.0", 

71 "4.0.1", 

72 "4.0.2", 

73 "4.0.3", 

74 "4.0.4", 

75 "4.1", 

76 "4.1.1", 

77 "4.1.2", 

78 "4.2", 

79 "4.2.1", 

80 "4.2.2", 

81 "4.3", 

82 "4.3.1", 

83 "4.4", 

84 "4.4.1", 

85 "4.4.2", 

86 "4.4.3", 

87 "4.4.4", 

88 "5.0", 

89 "5.0.1", 

90 "5.0.2", 

91 "5.1", 

92 "5.1.1", 

93 "6.0", 

94 "6.0.1", 

95 "7.0", 

96 "7.1", 

97 "7.1.1", 

98 "7.1.2", 

99 "8.0.0", 

100 "8.1.0", 

101 "9", 

102 "10", 

103 "11", 

104 ) 

105 

106 apple_devices: ElementsType[str] = ("iPhone", "iPad") 

107 

108 ios_versions: ElementsType[str] = ( 

109 "3.1.3", 

110 "4.2.1", 

111 "5.1.1", 

112 "6.1.6", 

113 "7.1.2", 

114 "9.3.5", 

115 "9.3.6", 

116 "10.3.3", 

117 "10.3.4", 

118 "12.4.8", 

119 "14.2", 

120 "14.2.1", 

121 ) 

122 

123 def mac_processor(self) -> str: 

124 """Generate a MacOS processor token used in user agent strings.""" 

125 return self.random_element(self.mac_processors) 

126 

127 def linux_processor(self) -> str: 

128 """Generate a Linux processor token used in user agent strings.""" 

129 return self.random_element(self.linux_processors) 

130 

131 def user_agent(self) -> str: 

132 """Generate a random web browser user agent string.""" 

133 name: str = self.random_element(self.user_agents) 

134 return getattr(self, name)() 

135 

136 def chrome( 

137 self, 

138 version_from: int = 13, 

139 version_to: int = 63, 

140 build_from: int = 800, 

141 build_to: int = 899, 

142 ) -> str: 

143 """Generate a Chrome web browser user agent string.""" 

144 saf: str = f"{self.generator.random.randint(531, 536)}.{self.generator.random.randint(0, 2)}" 

145 bld: str = self.lexify(self.numerify("##?###"), string.ascii_uppercase) 

146 tmplt: str = "({0}) AppleWebKit/{1} (KHTML, like Gecko)" " Chrome/{2}.0.{3}.0 Safari/{4}" 

147 tmplt_ios: str = "({0}) AppleWebKit/{1} (KHTML, like Gecko)" " CriOS/{2}.0.{3}.0 Mobile/{4} Safari/{1}" 

148 platforms: ElementsType[str] = ( 

149 tmplt.format( 

150 self.linux_platform_token(), 

151 saf, 

152 self.generator.random.randint(version_from, version_to), 

153 self.generator.random.randint(build_from, build_to), 

154 saf, 

155 ), 

156 tmplt.format( 

157 self.windows_platform_token(), 

158 saf, 

159 self.generator.random.randint(version_from, version_to), 

160 self.generator.random.randint(build_from, build_to), 

161 saf, 

162 ), 

163 tmplt.format( 

164 self.mac_platform_token(), 

165 saf, 

166 self.generator.random.randint(version_from, version_to), 

167 self.generator.random.randint(build_from, build_to), 

168 saf, 

169 ), 

170 tmplt.format( 

171 "Linux; {}".format(self.android_platform_token()), 

172 saf, 

173 self.generator.random.randint(version_from, version_to), 

174 self.generator.random.randint(build_from, build_to), 

175 saf, 

176 ), 

177 tmplt_ios.format( 

178 self.ios_platform_token(), 

179 saf, 

180 self.generator.random.randint(version_from, version_to), 

181 self.generator.random.randint(build_from, build_to), 

182 bld, 

183 ), 

184 ) 

185 

186 return "Mozilla/5.0 " + self.random_element(platforms) 

187 

188 def firefox(self) -> str: 

189 """Generate a Mozilla Firefox web browser user agent string.""" 

190 ver: ElementsType[str] = ( 

191 ( 

192 f"Gecko/{self.generator.date_time_between(datetime(2011, 1, 1), _DT_ALMOST_MAX)} " 

193 f"Firefox/{self.generator.random.randint(4, 15)}.0" 

194 ), 

195 ( 

196 f"Gecko/{self.generator.date_time_between(datetime(2010, 1, 1), _DT_ALMOST_MAX)} " 

197 f"Firefox/3.6.{self.generator.random.randint(1, 20)}" 

198 ), 

199 f"Gecko/{self.generator.date_time_between(datetime(2010, 1, 1), _DT_ALMOST_MAX)} Firefox/3.8", 

200 ) 

201 tmplt_win: str = "({0}; {1}; rv:1.9.{2}.20) {3}" 

202 tmplt_lin: str = "({0}; rv:1.9.{1}.20) {2}" 

203 tmplt_mac: str = "({0}; rv:1.9.{1}.20) {2}" 

204 tmplt_and: str = "({0}; Mobile; rv:{1}.0) Gecko/{1}.0 Firefox/{1}.0" 

205 tmplt_ios: str = "({0}) AppleWebKit/{1} (KHTML, like Gecko) FxiOS/{2}.{3}.0 Mobile/{4} Safari/{1}" 

206 saf: str = "{}.{}".format(self.generator.random.randint(531, 536), self.generator.random.randint(0, 2)) 

207 bld: str = self.lexify(self.numerify("##?###"), string.ascii_uppercase) 

208 bld2: str = self.lexify(self.numerify("#?####"), string.ascii_lowercase) 

209 platforms: ElementsType[str] = ( 

210 tmplt_win.format( 

211 self.windows_platform_token(), 

212 self.generator.locale().replace("_", "-"), 

213 self.generator.random.randint(0, 2), 

214 self.generator.random.choice(ver), 

215 ), 

216 tmplt_lin.format( 

217 self.linux_platform_token(), 

218 self.generator.random.randint(5, 7), 

219 self.generator.random.choice(ver), 

220 ), 

221 tmplt_mac.format( 

222 self.mac_platform_token(), 

223 self.generator.random.randint(2, 6), 

224 self.generator.random.choice(ver), 

225 ), 

226 tmplt_and.format(self.android_platform_token(), self.generator.random.randint(5, 68)), 

227 tmplt_ios.format( 

228 self.ios_platform_token(), 

229 saf, 

230 self.generator.random.randint(9, 18), 

231 bld2, 

232 bld, 

233 ), 

234 ) 

235 

236 return "Mozilla/5.0 " + self.random_element(platforms) 

237 

238 def safari(self) -> str: 

239 """Generate a Safari web browser user agent string.""" 

240 saf: str = ( 

241 f"{self.generator.random.randint(531, 535)}." 

242 f"{self.generator.random.randint(1, 50)}." 

243 f"{self.generator.random.randint(1, 7)}" 

244 ) 

245 

246 ver: str = ( 

247 f"{self.generator.random.randint(4, 5)}.{self.generator.random.randint(0, 1)}" 

248 if not self.generator.random.getrandbits(1) 

249 else f"{self.generator.random.randint(4, 5)}.0.{self.generator.random.randint(1, 5)}" 

250 ) 

251 

252 tmplt_win: str = "(Windows; U; {0}) AppleWebKit/{1} (KHTML, like Gecko)" " Version/{2} Safari/{3}" 

253 tmplt_mac: str = "({0} rv:{1}.0; {2}) AppleWebKit/{3} (KHTML, like Gecko)" " Version/{4} Safari/{5}" 

254 tmplt_ipod: str = ( 

255 "(iPod; U; CPU iPhone OS {0}_{1} like Mac OS X; {2})" 

256 " AppleWebKit/{3} (KHTML, like Gecko) Version/{4}.0.5" 

257 " Mobile/8B{5} Safari/6{6}" 

258 ) 

259 locale: str = self.generator.locale().replace("_", "-") 

260 platforms: ElementsType[str] = ( 

261 tmplt_win.format(self.windows_platform_token(), saf, ver, saf), 

262 tmplt_mac.format( 

263 self.mac_platform_token(), 

264 self.generator.random.randint(2, 6), 

265 locale, 

266 saf, 

267 ver, 

268 saf, 

269 ), 

270 tmplt_ipod.format( 

271 self.generator.random.randint(3, 4), 

272 self.generator.random.randint(0, 3), 

273 locale, 

274 saf, 

275 self.generator.random.randint(3, 4), 

276 self.generator.random.randint(111, 119), 

277 saf, 

278 ), 

279 ) 

280 

281 return "Mozilla/5.0 " + self.random_element(platforms) 

282 

283 def opera(self) -> str: 

284 """Generate an Opera web browser user agent string.""" 

285 token: str = ( 

286 self.linux_platform_token() if self.generator.random.getrandbits(1) else self.windows_platform_token() 

287 ) 

288 locale: str = self.generator.locale().replace("_", "-") 

289 platform: str = ( 

290 f"({token}; {locale}) Presto/2.9.{self.generator.random.randint(160, 190)} " 

291 f"Version/{self.generator.random.randint(10, 12)}.00" 

292 ) 

293 return f"Opera/{self.generator.random.randint(8, 9)}.{self.generator.random.randint(10, 99)}.{platform}" 

294 

295 def internet_explorer(self) -> str: 

296 """Generate an IE web browser user agent string.""" 

297 return ( 

298 f"Mozilla/5.0 (compatible; MSIE {self.generator.random.randint(5, 9)}.0; " 

299 f"{self.windows_platform_token()}; " 

300 f"Trident/{self.generator.random.randint(3, 5)}.{self.generator.random.randint(0, 1)})" 

301 ) 

302 

303 def windows_platform_token(self) -> str: 

304 """Generate a Windows platform token used in user agent strings.""" 

305 return self.random_element(self.windows_platform_tokens) 

306 

307 def linux_platform_token(self) -> str: 

308 """Generate a Linux platform token used in user agent strings.""" 

309 return f"X11; Linux {self.random_element(self.linux_processors)}" 

310 

311 def mac_platform_token(self) -> str: 

312 """Generate a MacOS platform token used in user agent strings.""" 

313 return ( 

314 f"Macintosh; {self.random_element(self.mac_processors)} Mac OS X 10_" 

315 f"{self.generator.random.randint(5, 12)}_{self.generator.random.randint(0, 9)}" 

316 ) 

317 

318 def android_platform_token(self) -> str: 

319 """Generate an Android platform token used in user agent strings.""" 

320 return f"Android {self.random_element(self.android_versions)}" 

321 

322 def ios_platform_token(self) -> str: 

323 """Generate an iOS platform token used in user agent strings.""" 

324 apple_device: str = self.random_element(self.apple_devices) 

325 ios_version: str = self.random_element(self.ios_versions) 

326 return f"{apple_device}; CPU {apple_device} " f'OS {ios_version.replace(".", "_")} like Mac OS X'