[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6,"_7":8,"_9":10},"actionData","errors","root",{"_4790":4791,"_4792":4793},"routes/_app.x.$handle.$name",{"_101":100,"_32":46,"_109":87,"_27":110,"_13":14,"_111":-5,"_11":112,"_113":114,"_115":116,"_117":118,"_119":120,"_20":-5,"_121":122,"_123":124,"_125":25,"_126":127,"_128":59,"_129":-5,"_130":-5,"_131":132},"routes/_app.x.$handle.$name.branch.$branch.version.$version.diff",{"_11":12,"_13":14,"_15":16,"_17":-5,"_18":-5},"project",{"_44":45,"_32":46,"_39":47,"_48":-5,"_49":25,"_50":51,"_52":51,"_53":-5,"_54":-5,"_18":55,"_56":57,"_58":59,"_60":59,"_61":-5,"_62":63,"_64":65,"_66":-5,"_67":-5,"_68":-5,"_69":-5,"_70":71,"_72":71,"_73":74,"_75":74,"_76":74,"_77":71,"_78":71,"_79":80,"_81":82,"_83":84,"_85":25},"version",555,"changes",[19],"aiChatInfo","userId",{"_20":21,"_22":23,"_24":25,"_26":25,"_27":28,"_29":28},"file",{"_30":31,"_32":33,"_34":35,"_36":38,"_39":40,"_41":14,"_42":43,"_24":25},"previous",{"_30":31,"_32":33,"_34":35,"_36":37},"deleted",false,"deletedHere","path","backend/data/posts.ts","latestPath","fileId","c6b236ea-67f2-11f0-9530-0224a6c84d84","name","posts.ts","fileType","script","content","// Load AITA posts from analyzed dataset in blob storage\n\nimport { blob } from \"https://esm.town/v/std/blob\";\n\nexport interface AITAPost {\n id: string;\n title: string;\n content: string;\n assholePct: number;\n}\n\n// In-memory cache for posts\nlet cachedPosts: AITAPost[] | null = null;\n\n// Function to load posts from blob storage\nasync function loadPostsFromBlob(): Promise {\n try {\n // Try to get the data from blob storage\n const jsonlText = await blob.get(\"top100_analyzed\");\n \n if (!jsonlText) {\n console.error('No data found in top100_analyzed blob');\n return [];\n }\n \n // Check what type of data we got and convert to string if needed\n let textData: string;\n if (typeof jsonlText === 'string') {\n textData = jsonlText;\n } else {\n // If it's not a string, try to convert it\n console.log('Data type received:', typeof jsonlText);\n console.log('Data:', jsonlText);\n \n // If it was stored as JSON, convert it back to string\n if (typeof jsonlText === 'object') {\n textData = JSON.stringify(jsonlText);\n } else {\n textData = String(jsonlText);\n }\n }\n \n // Parse the JSONL content\n return textData.split('\\n')\n .filter(line => line.trim().length > 0) // Skip empty lines\n .map(line => {\n try {\n const data = JSON.parse(line);\n \n // Map from the JSONL format to our AITAPost interface\n return {\n id: data.submission_id,\n title: data.title,\n content: data.selftext,\n assholePct: data.yta_percentage\n };\n } catch (e) {\n console.error('Error parsing JSON line:', e);\n return null;\n }\n })\n .filter(Boolean); // Remove any null entries from failed parsing\n } catch (error) {\n console.error('Error loading posts from blob storage:', error);\n return [];\n }\n}\n\n// Export async function to get posts with caching\nexport async function getPosts(): Promise {\n // Return cached posts if they exist\n if (cachedPosts !== null) {\n return cachedPosts;\n }\n \n // Load posts from blob storage\n const posts = await loadPostsFromBlob();\n \n // If loading fails, return a fallback post\n if (posts.length === 0) {\n const fallbackPosts = [{\n id: \"fallback\",\n title: \"Error loading posts\",\n content: \"There was an error loading the AITA posts dataset. Please check the console for details.\",\n assholePct: 0\n }];\n \n // Cache the fallback posts too\n cachedPosts = fallbackPosts;\n return fallbackPosts;\n }\n \n // Cache the loaded posts\n cachedPosts = posts;\n return posts;\n}\n\n// Optional: Function to clear the cache if needed\nexport function clearPostsCache(): void {\n cachedPosts = null;\n}","// Load AITA posts from analyzed dataset in blob storage\n\nimport { blob } from \"https://esm.town/v/std/blob\";\n\nexport interface AITAPost {\n id: string;\n title: string;\n content: string;\n assholePct: number;\n}\n\n// In-memory cache for posts\nlet cachedPosts: AITAPost[] | null = null;\n\n// Function to load posts from blob storage\nasync function loadPostsFromBlob(): Promise {\n try {\n // Use getJSON if the data was stored as JSON\n const data = await blob.getJSON(\"top100_analyzed\");\n \n if (!data) {\n console.error('No data found in top100_analyzed blob');\n return [];\n }\n \n // If it's an array of objects, map them directly\n if (Array.isArray(data)) {\n return data.map(item => ({\n id: item.submission_id,\n title: item.title,\n content: item.selftext,\n assholePct: item.yta_percentage\n }));\n }\n \n console.error('Unexpected data format - expected array, got:', typeof data);\n return [];\n } catch (error) {\n console.error('Error loading posts from blob storage:', error);\n return [];\n }\n}\n\n// Export async function to get posts with caching\nexport async function getPosts(): Promise {\n // Return cached posts if they exist\n if (cachedPosts !== null) {\n return cachedPosts;\n }\n \n // Load posts from blob storage\n const posts = await loadPostsFromBlob();\n \n // If loading fails, return a fallback post\n if (posts.length === 0) {\n const fallbackPosts = [{\n id: \"fallback\",\n title: \"Error loading posts\",\n content: \"There was an error loading the AITA posts dataset. Please check the console for details.\",\n assholePct: 0\n }];\n \n // Cache the fallback posts too\n cachedPosts = fallbackPosts;\n return fallbackPosts;\n }\n \n // Cache the loaded posts\n cachedPosts = posts;\n return posts;\n}\n\n// Optional: Function to clear the cache if needed\nexport function clearPostsCache(): void {\n cachedPosts = null;\n}","createdAt",["D",1753423244143],"branchVersion","branchId","9152d4b2-67ef-11f0-97a8-0224a6c84d84","id","91500c1e-67ef-11f0-97a8-0224a6c84d84","aita",["D",1753293908093],"deletedAt","legacyEnvVars","privacy","public","httpPrivacy","description","imageUrl","01983870-a3b2-73c9-9a1d-1aa63e70e1b2","pinnedFileId","01983875-e8ca-7735-b93b-be439ff044a2","pinPreview",true,"pinMigrated","screenshotVersion","likeCount",1,"orgId","01983870-a3b2-73c9-9a1d-1f44dda566fd","tursoName","tursoHostname","tursoMeasuredAt","pinned","userPerm","r","valPerm","blobPerm","rw","emailPerm","sqlitePerm","projectPerm","telemetryPerm","user",{"_101":100,"_108":104},"org",{"_101":100,"_102":-5,"_103":104,"_18":55,"_105":106,"_107":25},"branch",{"_13":86,"_32":87,"_44":43,"_88":45,"_89":90,"_91":92,"_93":51,"_94":95,"_96":97,"_98":46,"_99":100},"isOwned",559,"main","projectId","forkedBranchId","961078ea-f528-11ef-aa68-569c3dd06744","forkedBranchVersion",67,"forkedProjectPrivacy","forkedProjectId","96102714-f528-11ef-aa68-569c3dd06744","forkedProjectOrgId","019aa807-52c2-709c-928b-2029bae9a558","projectName","userHandle","joost","handle","displayName","avatar","https://img.clerk.com/eyJ0eXBlIjoicHJveHkiLCJzcmMiOiJodHRwczovL2ltYWdlcy5jbGVyay5kZXYvb2F1dGhfZ2l0aHViL2ltZ18zMEhucWlWR2JJOWNvaGtVRnUzaGZGM21xYWoifQ","tier","free","canRestrictVals","profileImageUrl","branchName","","adoptOrgId",{"_44":45,"_32":46,"_39":4786,"_48":-5,"_49":25,"_50":51,"_52":51,"_53":-5,"_54":-5,"_18":55,"_56":57,"_58":59,"_60":59,"_61":-5,"_62":63,"_64":65,"_66":-5,"_67":-5,"_68":-5,"_69":-5,"_70":71,"_72":71,"_73":74,"_75":74,"_76":74,"_77":71,"_78":71,"_79":4787,"_81":4788,"_83":4789,"_85":25},"tree",[234,263,747,751,752,760,764,765,766,767],"files",[234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364,365,366,367,368,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,406,407,408,409,410,411,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428,429,430,431,432,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,477,478,479,480,481,482,483,484,485,486,487,488,489,490,491,492,493,494,495,496,497,498,499,500,501,502,503,504,505,506,507,508,509,510,511,512,513,514,515,516,517,518,519,520,521,522,523,524,525,526,527,528,529,530,531,532,533,534,535,536,537,538,539,540,541,542,543,544,545,546,547,548,549,550,551,552,553,554,555,556,557,558,559,560,561,562,563,564,565,566,567,568,569,570,571,572,573,574,575,576,577,578,579,580,581,582,583,584,585,586,587,588,589,590,591,592,593,594,595,596,597,598,599,600,601,602,603,604,605,606,607,608,609,610,611,612,613,614,615,616,617,618,619,620,621,622,623,624,625,626,627,628,629,630,631,632,633,634,635,636,637,638,639,640,641,642,643,644,645,646,647,648,649,650,651,652,653,654,655,656,657,658,659,660,661,662,663,664,665,666,667,668,669,670,671,672,673,674,675,676,677,678,679,680,681,682,683,684,685,686,687,688,689,690,691,692,693,694,695,696,697,698,699,700,701,702,703,704,705,706,707,708,709,710,711,712,713,714,715,716,717,718,719,720,721,722,723,724,725,726,727,728,729,730,731,732,733,734,735,736,737,738,739,740,741,742,743,744,745,746,747,748,749,750,751,752,753,754,755,756,757,758,759,760,761,762,763,764,765,766,767],"counts",{"_224":162,"_225":63,"_226":162,"_227":228,"_229":230},"contents",[145,146,147,148,149,150,151,152,153,154],"upstreamProject",{"_44":95,"_32":140,"_53":141,"_54":142,"_50":51,"_79":143},"upstreamBranch",{"_44":90,"_39":133,"_134":135,"_32":87,"_88":95,"_13":136,"_89":-5,"_91":-5,"_137":138,"_48":-5,"_85":25,"_50":51,"_99":139,"_64":97,"_98":140},"emptyEnvVars","flags",[],"hasHttpFiles","grants","orgs","customDomains",{},["D",1740674013689],"updatedAt",["D",1785420707976],91,"lockfileKey","1785420708123-esm.town_v_templates_react-hono-starter@91-main","templates","react-hono-starter","Starter template with client-side React & Hono server","https://imagedelivery.net/iHX6Ovru0O7AjmyT5yZRoA/64dc00cc-94d9-47dd-81b1-dde02610d900/square512?exp=1789691510&sig=cf71db307a15150f9b05d9854766e14966e6a6e653dad1c2d22f21806a345f8d",{"_101":139,"_108":144},"https://imagedelivery.net/iHX6Ovru0O7AjmyT5yZRoA/129cab32-3bd7-4c3e-f39b-f12900c76100/square512?exp=1789691510&sig=82baff203b89eba0dc17db70a9a10141410890f4fa3a674aaabc7945c21e8392",{"_44":218,"_32":219,"_30":220,"_158":-5,"_42":43,"_41":221,"_160":59,"_39":222,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_27":223},{"_44":212,"_32":213,"_30":214,"_158":-5,"_42":43,"_41":215,"_160":59,"_39":216,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_27":217},{"_44":207,"_32":208,"_30":209,"_158":-5,"_42":43,"_41":63,"_160":59,"_39":210,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_27":211},{"_44":201,"_32":202,"_30":203,"_158":-5,"_42":43,"_41":204,"_160":59,"_39":205,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_27":206},{"_44":196,"_32":197,"_30":198,"_158":-5,"_42":43,"_41":63,"_160":59,"_39":199,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_27":200},{"_44":189,"_32":190,"_30":191,"_158":-5,"_42":43,"_41":192,"_160":59,"_39":193,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_27":195},{"_44":181,"_32":182,"_30":183,"_158":-5,"_42":43,"_41":184,"_160":59,"_39":185,"_13":186,"_34":20,"_36":187,"_24":25,"_164":-5,"_27":188},{"_44":173,"_32":174,"_30":175,"_158":-5,"_42":43,"_41":176,"_160":59,"_39":177,"_13":178,"_34":20,"_36":179,"_24":25,"_164":-5,"_27":180},{"_44":166,"_32":167,"_30":168,"_158":-5,"_42":43,"_41":169,"_160":59,"_39":170,"_13":63,"_34":20,"_36":171,"_24":25,"_164":-5,"_27":172},{"_44":155,"_32":156,"_30":157,"_158":-5,"_42":43,"_41":159,"_160":59,"_39":161,"_13":162,"_34":20,"_36":163,"_24":25,"_164":-5,"_27":165},"c6b532c8-67f2-11f0-97a0-0224a6c84d84","deno.json","c6b53372-67f2-11f0-97a0-0224a6c84d84","parentId",5,"latest",["D",1753295286180],0,"{\n \"$schema\": \"https://raw.githubusercontent.com/denoland/deno/348900b8b79f4a434cab4c74b3bc8d4d2fa8ee74/cli/schemas/config-file.v1.json\",\n \"lock\": false,\n \"compilerOptions\": {\n \"noImplicitAny\": false,\n \"strict\": false,\n \"types\": [\n \"https://www.val.town/types/valtown.d.ts\"\n ],\n \"lib\": [\n \"dom\",\n \"dom.iterable\",\n \"dom.asynciterable\",\n \"deno.ns\",\n \"deno.unstable\"\n ]\n },\n \"lint\": {\n \"files\": {\n \"include\": [\n \"deno:/https/esm.town/**/*\"\n ]\n },\n \"rules\": {\n \"exclude\": [\n \"no-explicit-any\"\n ]\n }\n },\n \"node_modules_dir\": false,\n \"experimental\": {\n \"unstable-node-globals\": true,\n \"unstable-temporal\": true,\n \"unstable-worker-options\": true,\n \"unstable-sloppy-imports\": true\n }\n}","label",[156],"c709d896-67f2-11f0-8ec1-0224a6c84d84","README.md","01983875-e8ca-7735-b93b-e26da749ec93",16,["D",1753295286718],"# Am I The Asshole? Guessing Game\n\nA web-based guessing game built with React and Hono where users try to guess what percentage of Reddit users thought the poster was the asshole in posts from the r/AmITheAsshole subreddit.\n\n## Game Description\n\nIn this game, players are presented with a post from the \"Am I The Asshole?\" subreddit, where people share situations and ask if they were in the wrong. Players use a slider to guess what percentage of Reddit users voted that the original poster was the asshole. After submitting their guess, they see how close they were to the actual percentage.\n\n## Features\n\n- Beautiful, Reddit-inspired UI\n- Interactive slider for making guesses\n- Feedback on how close your guess was to the actual percentage\n- Responsive design that works on mobile and desktop\n\n## Technical Structure\n\n- **Frontend**: React with TypeScript, modern CSS\n- **Backend**: Hono (lightweight web framework)\n- **Data**: Currently uses static data, with plans to connect to SQL later\n\n## Project Structure\n\n- `/backend/index.ts` - The main server entry point\n- `/backend/data/posts.ts` - Static AITA post data\n- `/frontend/components/AITAGame.tsx` - The main game component\n- `/frontend/components/App.tsx` - The root React component\n- `/frontend/style.css` - Styles for the application\n\n## Future Enhancements\n\n- Connect to a SQL database for storing and retrieving posts\n- Add multiple posts with the ability to cycle through them\n- Add user accounts to track scores\n- Add social sharing features",[167],"296b699c-67fc-11f0-90b5-0224a6c84d84",".vtignore","c6c4281e-67f2-11f0-84e8-0224a6c84d84",549,["D",1753299317259],4,".git\n.vscode\n.cursorrules\n.DS_Store\nnode_modules\nvendor\ndb/\n.venv/\n.idea/\nlocal/",[174],"0ec38192-67fc-11f0-9f6f-0224a6c84d84",".gitignore","78f0477a-67f3-11f0-9b33-0224a6c84d84",543,["D",1753299272550],3,"vcs.xml\nstate.json\ndb/\n.idea/",[182],"f942ed08-67fb-11f0-8ad5-0224a6c84d84","local","f942edbc-67fb-11f0-8ad5-0224a6c84d84",31,["D",1753299236474],"directory",[190],"9158d5b0-67ef-11f0-97a8-0224a6c84d84","frontend","01983875-e8ca-7735-b93b-df00685bcab2",["D",1753293908093],[197],"f9737b08-67fb-11f0-ad3e-0224a6c84d84","db","f9737be4-67fb-11f0-ad3e-0224a6c84d84",33,["D",1753299236795],[202],"9158c5ac-67ef-11f0-97a8-0224a6c84d84","backend","01983875-e8ca-7735-b93b-c2f72a40303c",["D",1753293908093],[208],"f95b701c-67fb-11f0-95df-0224a6c84d84",".venv","f95b7300-67fb-11f0-95df-0224a6c84d84",32,["D",1753299236638],[213],"c67e6fa4-67f2-11f0-84e8-0224a6c84d84",".idea","c67e704e-67f2-11f0-84e8-0224a6c84d84",2,["D",1753295285829],[219],"pulls","branches","forks","envVars",{"_231":63,"_233":162},"connections",{"_231":162,"_232":162},"count","unfilledCount","emptyCount",{"_44":218,"_32":219,"_30":220,"_158":-5,"_42":43,"_41":221,"_160":59,"_39":4783,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":4784,"_27":4785},{"_44":4778,"_32":4663,"_30":4657,"_158":220,"_42":43,"_41":4779,"_160":59,"_39":4780,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":4781,"_27":4782},{"_44":4773,"_32":4754,"_30":4768,"_158":4657,"_42":43,"_41":4774,"_160":59,"_39":4775,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":4776,"_27":4777},{"_44":4767,"_32":4690,"_30":4762,"_158":4768,"_42":43,"_41":4769,"_160":59,"_39":4770,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":4771,"_27":4772},{"_44":4761,"_32":4691,"_30":4756,"_158":4762,"_42":43,"_41":4763,"_160":59,"_39":4764,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":4765,"_27":4766},{"_44":4755,"_32":4692,"_30":4749,"_158":4756,"_42":43,"_41":4757,"_160":59,"_39":4758,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":4759,"_27":4760},{"_44":4747,"_32":4681,"_30":4748,"_158":4749,"_42":43,"_41":4750,"_160":59,"_39":4751,"_13":162,"_34":20,"_36":4686,"_24":25,"_164":-5,"_769":4752,"_27":4753},{"_44":4742,"_32":4723,"_30":4737,"_158":4657,"_42":43,"_41":4743,"_160":59,"_39":4744,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":4745,"_27":4746},{"_44":4736,"_32":4690,"_30":4731,"_158":4737,"_42":43,"_41":4738,"_160":59,"_39":4739,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":4740,"_27":4741},{"_44":4730,"_32":4691,"_30":4725,"_158":4731,"_42":43,"_41":4732,"_160":59,"_39":4733,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":4734,"_27":4735},{"_44":4724,"_32":4692,"_30":4718,"_158":4725,"_42":43,"_41":4726,"_160":59,"_39":4727,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":4728,"_27":4729},{"_44":4716,"_32":4681,"_30":4717,"_158":4718,"_42":43,"_41":4719,"_160":59,"_39":4720,"_13":162,"_34":20,"_36":4686,"_24":25,"_164":-5,"_769":4721,"_27":4722},{"_44":4711,"_32":4689,"_30":4706,"_158":4657,"_42":43,"_41":4712,"_160":59,"_39":4713,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":4714,"_27":4715},{"_44":4705,"_32":4690,"_30":4700,"_158":4706,"_42":43,"_41":4707,"_160":59,"_39":4708,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":4709,"_27":4710},{"_44":4699,"_32":4691,"_30":4694,"_158":4700,"_42":43,"_41":4701,"_160":59,"_39":4702,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":4703,"_27":4704},{"_44":4693,"_32":4692,"_30":4683,"_158":4694,"_42":43,"_41":4695,"_160":59,"_39":4696,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":4697,"_27":4698},{"_44":4680,"_32":4681,"_30":4682,"_158":4683,"_42":43,"_41":4684,"_160":59,"_39":4685,"_13":162,"_34":20,"_36":4686,"_24":25,"_164":-5,"_769":4687,"_27":4688},{"_44":4672,"_32":4673,"_30":4674,"_158":4657,"_42":43,"_41":4675,"_160":59,"_39":4676,"_13":162,"_34":20,"_36":4677,"_24":25,"_164":-5,"_769":4678,"_27":4679},{"_44":4664,"_32":4665,"_30":4666,"_158":4657,"_42":43,"_41":4667,"_160":59,"_39":4668,"_13":162,"_34":20,"_36":4669,"_24":25,"_164":-5,"_769":4670,"_27":4671},{"_44":4654,"_32":4655,"_30":4656,"_158":4657,"_42":43,"_41":4658,"_160":59,"_39":4659,"_13":162,"_34":20,"_36":4660,"_24":25,"_164":-5,"_769":4661,"_27":4662},{"_44":4647,"_32":182,"_30":4648,"_158":220,"_42":43,"_41":4649,"_160":59,"_39":4650,"_13":162,"_34":20,"_36":4651,"_24":25,"_164":-5,"_769":4652,"_27":4653},{"_44":4639,"_32":4640,"_30":4641,"_158":220,"_42":43,"_41":4642,"_160":59,"_39":4643,"_13":63,"_34":20,"_36":4644,"_24":25,"_164":-5,"_769":4645,"_27":4646},{"_44":4631,"_32":4632,"_30":4633,"_158":220,"_42":43,"_41":4634,"_160":59,"_39":4635,"_13":162,"_34":20,"_36":4636,"_24":25,"_164":-5,"_769":4637,"_27":4638},{"_44":4623,"_32":4624,"_30":4625,"_158":220,"_42":43,"_41":4626,"_160":59,"_39":4627,"_13":162,"_34":20,"_36":4628,"_24":25,"_164":-5,"_769":4629,"_27":4630},{"_44":4615,"_32":4616,"_30":4617,"_158":220,"_42":43,"_41":4618,"_160":59,"_39":4619,"_13":162,"_34":20,"_36":4620,"_24":25,"_164":-5,"_769":4621,"_27":4622},{"_44":4607,"_32":4608,"_30":4609,"_158":220,"_42":43,"_41":4610,"_160":59,"_39":4611,"_13":162,"_34":20,"_36":4612,"_24":25,"_164":-5,"_769":4613,"_27":4614},{"_44":4599,"_32":4600,"_30":4601,"_158":220,"_42":43,"_41":4602,"_160":59,"_39":4603,"_13":162,"_34":20,"_36":4604,"_24":25,"_164":-5,"_769":4605,"_27":4606},{"_44":4591,"_32":4592,"_30":4593,"_158":220,"_42":43,"_41":4594,"_160":59,"_39":4595,"_13":162,"_34":20,"_36":4596,"_24":25,"_164":-5,"_769":4597,"_27":4598},{"_44":4582,"_32":4583,"_30":4584,"_158":220,"_42":43,"_41":4585,"_160":59,"_39":4586,"_13":4587,"_34":20,"_36":4588,"_24":25,"_164":-5,"_769":4589,"_27":4590},{"_44":212,"_32":213,"_30":214,"_158":-5,"_42":43,"_41":215,"_160":59,"_39":4579,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":4580,"_27":4581},{"_44":4574,"_32":4505,"_30":4499,"_158":214,"_42":43,"_41":4575,"_160":59,"_39":4576,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":4577,"_27":4578},{"_44":4566,"_32":4567,"_30":4568,"_158":4499,"_42":43,"_41":4569,"_160":59,"_39":4570,"_13":162,"_34":20,"_36":4571,"_24":25,"_164":-5,"_769":4572,"_27":4573},{"_44":4558,"_32":4559,"_30":4560,"_158":4499,"_42":43,"_41":4561,"_160":59,"_39":4562,"_13":162,"_34":20,"_36":4563,"_24":25,"_164":-5,"_769":4564,"_27":4565},{"_44":4550,"_32":4551,"_30":4552,"_158":4499,"_42":43,"_41":4553,"_160":59,"_39":4554,"_13":162,"_34":20,"_36":4555,"_24":25,"_164":-5,"_769":4556,"_27":4557},{"_44":4542,"_32":4543,"_30":4544,"_158":4499,"_42":43,"_41":4545,"_160":59,"_39":4546,"_13":162,"_34":20,"_36":4547,"_24":25,"_164":-5,"_769":4548,"_27":4549},{"_44":4534,"_32":4535,"_30":4536,"_158":4499,"_42":43,"_41":4537,"_160":59,"_39":4538,"_13":162,"_34":20,"_36":4539,"_24":25,"_164":-5,"_769":4540,"_27":4541},{"_44":4526,"_32":4527,"_30":4528,"_158":4499,"_42":43,"_41":4529,"_160":59,"_39":4530,"_13":162,"_34":20,"_36":4531,"_24":25,"_164":-5,"_769":4532,"_27":4533},{"_44":4520,"_32":1016,"_30":4521,"_158":4499,"_42":43,"_41":4522,"_160":59,"_39":4523,"_13":162,"_34":20,"_36":4502,"_24":25,"_164":-5,"_769":4524,"_27":4525},{"_44":4513,"_32":4514,"_30":4515,"_158":4499,"_42":43,"_41":4516,"_160":59,"_39":4517,"_13":162,"_34":20,"_36":4502,"_24":25,"_164":-5,"_769":4518,"_27":4519},{"_44":4506,"_32":4507,"_30":4508,"_158":4499,"_42":43,"_41":4509,"_160":59,"_39":4510,"_13":162,"_34":20,"_36":4502,"_24":25,"_164":-5,"_769":4511,"_27":4512},{"_44":4496,"_32":4497,"_30":4498,"_158":4499,"_42":43,"_41":4500,"_160":59,"_39":4501,"_13":162,"_34":20,"_36":4502,"_24":25,"_164":-5,"_769":4503,"_27":4504},{"_44":4491,"_32":919,"_30":4486,"_158":214,"_42":43,"_41":4492,"_160":59,"_39":4493,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":4494,"_27":4495},{"_44":4485,"_32":920,"_30":4480,"_158":4486,"_42":43,"_41":4487,"_160":59,"_39":4488,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":4489,"_27":4490},{"_44":4479,"_32":921,"_30":913,"_158":4480,"_42":43,"_41":4481,"_160":59,"_39":4482,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":4483,"_27":4484},{"_44":4472,"_32":4473,"_30":4474,"_158":913,"_42":43,"_41":4475,"_160":59,"_39":4476,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":4477,"_27":4478},{"_44":4467,"_32":1016,"_30":1010,"_158":913,"_42":43,"_41":4468,"_160":59,"_39":4469,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":4470,"_27":4471},{"_44":4462,"_32":3238,"_30":3232,"_158":1010,"_42":43,"_41":4463,"_160":59,"_39":4464,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":4465,"_27":4466},{"_44":4457,"_32":4362,"_30":4356,"_158":3232,"_42":43,"_41":4458,"_160":59,"_39":4459,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":4460,"_27":4461},{"_44":4450,"_32":1034,"_30":4451,"_158":4356,"_42":43,"_41":4452,"_160":59,"_39":4453,"_13":162,"_34":20,"_36":4454,"_24":25,"_164":-5,"_769":4455,"_27":4456},{"_44":4442,"_32":4443,"_30":4444,"_158":4356,"_42":43,"_41":4445,"_160":59,"_39":4446,"_13":162,"_34":20,"_36":4447,"_24":25,"_164":-5,"_769":4448,"_27":4449},{"_44":4434,"_32":4435,"_30":4436,"_158":4356,"_42":43,"_41":4437,"_160":59,"_39":4438,"_13":162,"_34":20,"_36":4439,"_24":25,"_164":-5,"_769":4440,"_27":4441},{"_44":4426,"_32":4427,"_30":4428,"_158":4356,"_42":43,"_41":4429,"_160":59,"_39":4430,"_13":162,"_34":20,"_36":4431,"_24":25,"_164":-5,"_769":4432,"_27":4433},{"_44":4418,"_32":4419,"_30":4420,"_158":4356,"_42":43,"_41":4421,"_160":59,"_39":4422,"_13":162,"_34":20,"_36":4423,"_24":25,"_164":-5,"_769":4424,"_27":4425},{"_44":4410,"_32":4411,"_30":4412,"_158":4356,"_42":43,"_41":4413,"_160":59,"_39":4414,"_13":162,"_34":20,"_36":4415,"_24":25,"_164":-5,"_769":4416,"_27":4417},{"_44":4403,"_32":3256,"_30":4404,"_158":4356,"_42":43,"_41":4405,"_160":59,"_39":4406,"_13":162,"_34":20,"_36":4407,"_24":25,"_164":-5,"_769":4408,"_27":4409},{"_44":4395,"_32":4396,"_30":4397,"_158":4356,"_42":43,"_41":4398,"_160":59,"_39":4399,"_13":162,"_34":20,"_36":4400,"_24":25,"_164":-5,"_769":4401,"_27":4402},{"_44":4387,"_32":4388,"_30":4389,"_158":4356,"_42":43,"_41":4390,"_160":59,"_39":4391,"_13":162,"_34":20,"_36":4392,"_24":25,"_164":-5,"_769":4393,"_27":4394},{"_44":4379,"_32":4380,"_30":4381,"_158":4356,"_42":43,"_41":4382,"_160":59,"_39":4383,"_13":162,"_34":20,"_36":4384,"_24":25,"_164":-5,"_769":4385,"_27":4386},{"_44":4371,"_32":4372,"_30":4373,"_158":4356,"_42":43,"_41":4374,"_160":59,"_39":4375,"_13":162,"_34":20,"_36":4376,"_24":25,"_164":-5,"_769":4377,"_27":4378},{"_44":4363,"_32":4364,"_30":4365,"_158":4356,"_42":43,"_41":4366,"_160":59,"_39":4367,"_13":162,"_34":20,"_36":4368,"_24":25,"_164":-5,"_769":4369,"_27":4370},{"_44":4354,"_32":2208,"_30":4355,"_158":4356,"_42":43,"_41":4357,"_160":59,"_39":4358,"_13":162,"_34":20,"_36":4359,"_24":25,"_164":-5,"_769":4360,"_27":4361},{"_44":4350,"_32":4213,"_30":4207,"_158":3232,"_42":43,"_41":92,"_160":59,"_39":4351,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":4352,"_27":4353},{"_44":4343,"_32":1034,"_30":4344,"_158":4207,"_42":43,"_41":4345,"_160":59,"_39":4346,"_13":162,"_34":20,"_36":4347,"_24":25,"_164":-5,"_769":4348,"_27":4349},{"_44":4336,"_32":3159,"_30":4337,"_158":4207,"_42":43,"_41":4338,"_160":59,"_39":4339,"_13":162,"_34":20,"_36":4340,"_24":25,"_164":-5,"_769":4341,"_27":4342},{"_44":4329,"_32":3734,"_30":4330,"_158":4207,"_42":43,"_41":4331,"_160":59,"_39":4332,"_13":162,"_34":20,"_36":4333,"_24":25,"_164":-5,"_769":4334,"_27":4335},{"_44":4321,"_32":4322,"_30":4323,"_158":4207,"_42":43,"_41":4324,"_160":59,"_39":4325,"_13":162,"_34":20,"_36":4326,"_24":25,"_164":-5,"_769":4327,"_27":4328},{"_44":4314,"_32":3271,"_30":4315,"_158":4207,"_42":43,"_41":4316,"_160":59,"_39":4317,"_13":162,"_34":20,"_36":4318,"_24":25,"_164":-5,"_769":4319,"_27":4320},{"_44":4306,"_32":4307,"_30":4308,"_158":4207,"_42":43,"_41":4309,"_160":59,"_39":4310,"_13":162,"_34":20,"_36":4311,"_24":25,"_164":-5,"_769":4312,"_27":4313},{"_44":4299,"_32":3870,"_30":4300,"_158":4207,"_42":43,"_41":4301,"_160":59,"_39":4302,"_13":162,"_34":20,"_36":4303,"_24":25,"_164":-5,"_769":4304,"_27":4305},{"_44":4292,"_32":3726,"_30":4293,"_158":4207,"_42":43,"_41":4294,"_160":59,"_39":4295,"_13":162,"_34":20,"_36":4296,"_24":25,"_164":-5,"_769":4297,"_27":4298},{"_44":4284,"_32":4285,"_30":4286,"_158":4207,"_42":43,"_41":4287,"_160":59,"_39":4288,"_13":162,"_34":20,"_36":4289,"_24":25,"_164":-5,"_769":4290,"_27":4291},{"_44":4277,"_32":2248,"_30":4278,"_158":4207,"_42":43,"_41":4279,"_160":59,"_39":4280,"_13":162,"_34":20,"_36":4281,"_24":25,"_164":-5,"_769":4282,"_27":4283},{"_44":4270,"_32":3001,"_30":4271,"_158":4207,"_42":43,"_41":4272,"_160":59,"_39":4273,"_13":162,"_34":20,"_36":4274,"_24":25,"_164":-5,"_769":4275,"_27":4276},{"_44":4262,"_32":4263,"_30":4264,"_158":4207,"_42":43,"_41":4265,"_160":59,"_39":4266,"_13":162,"_34":20,"_36":4267,"_24":25,"_164":-5,"_769":4268,"_27":4269},{"_44":4254,"_32":4255,"_30":4256,"_158":4207,"_42":43,"_41":4257,"_160":59,"_39":4258,"_13":162,"_34":20,"_36":4259,"_24":25,"_164":-5,"_769":4260,"_27":4261},{"_44":4246,"_32":4247,"_30":4248,"_158":4207,"_42":43,"_41":4249,"_160":59,"_39":4250,"_13":162,"_34":20,"_36":4251,"_24":25,"_164":-5,"_769":4252,"_27":4253},{"_44":4238,"_32":4239,"_30":4240,"_158":4207,"_42":43,"_41":4241,"_160":59,"_39":4242,"_13":162,"_34":20,"_36":4243,"_24":25,"_164":-5,"_769":4244,"_27":4245},{"_44":4230,"_32":4231,"_30":4232,"_158":4207,"_42":43,"_41":4233,"_160":59,"_39":4234,"_13":162,"_34":20,"_36":4235,"_24":25,"_164":-5,"_769":4236,"_27":4237},{"_44":4222,"_32":4223,"_30":4224,"_158":4207,"_42":43,"_41":4225,"_160":59,"_39":4226,"_13":162,"_34":20,"_36":4227,"_24":25,"_164":-5,"_769":4228,"_27":4229},{"_44":4214,"_32":4215,"_30":4216,"_158":4207,"_42":43,"_41":4217,"_160":59,"_39":4218,"_13":162,"_34":20,"_36":4219,"_24":25,"_164":-5,"_769":4220,"_27":4221},{"_44":4205,"_32":2931,"_30":4206,"_158":4207,"_42":43,"_41":4208,"_160":59,"_39":4209,"_13":162,"_34":20,"_36":4210,"_24":25,"_164":-5,"_769":4211,"_27":4212},{"_44":4200,"_32":4169,"_30":4163,"_158":3232,"_42":43,"_41":4201,"_160":59,"_39":4202,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":4203,"_27":4204},{"_44":4193,"_32":1034,"_30":4194,"_158":4163,"_42":43,"_41":4195,"_160":59,"_39":4196,"_13":162,"_34":20,"_36":4197,"_24":25,"_164":-5,"_769":4198,"_27":4199},{"_44":4186,"_32":3558,"_30":4187,"_158":4163,"_42":43,"_41":4188,"_160":59,"_39":4189,"_13":162,"_34":20,"_36":4190,"_24":25,"_164":-5,"_769":4191,"_27":4192},{"_44":4178,"_32":4179,"_30":4180,"_158":4163,"_42":43,"_41":4181,"_160":59,"_39":4182,"_13":162,"_34":20,"_36":4183,"_24":25,"_164":-5,"_769":4184,"_27":4185},{"_44":4170,"_32":4171,"_30":4172,"_158":4163,"_42":43,"_41":4173,"_160":59,"_39":4174,"_13":162,"_34":20,"_36":4175,"_24":25,"_164":-5,"_769":4176,"_27":4177},{"_44":4161,"_32":2931,"_30":4162,"_158":4163,"_42":43,"_41":4164,"_160":59,"_39":4165,"_13":162,"_34":20,"_36":4166,"_24":25,"_164":-5,"_769":4167,"_27":4168},{"_44":4156,"_32":4132,"_30":4126,"_158":3232,"_42":43,"_41":4157,"_160":59,"_39":4158,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":4159,"_27":4160},{"_44":4149,"_32":1034,"_30":4150,"_158":4126,"_42":43,"_41":4151,"_160":59,"_39":4152,"_13":162,"_34":20,"_36":4153,"_24":25,"_164":-5,"_769":4154,"_27":4155},{"_44":4141,"_32":4142,"_30":4143,"_158":4126,"_42":43,"_41":4144,"_160":59,"_39":4145,"_13":162,"_34":20,"_36":4146,"_24":25,"_164":-5,"_769":4147,"_27":4148},{"_44":4133,"_32":4134,"_30":4135,"_158":4126,"_42":43,"_41":4136,"_160":59,"_39":4137,"_13":162,"_34":20,"_36":4138,"_24":25,"_164":-5,"_769":4139,"_27":4140},{"_44":4123,"_32":4124,"_30":4125,"_158":4126,"_42":43,"_41":4127,"_160":59,"_39":4128,"_13":162,"_34":20,"_36":4129,"_24":25,"_164":-5,"_769":4130,"_27":4131},{"_44":4118,"_32":4094,"_30":4088,"_158":3232,"_42":43,"_41":4119,"_160":59,"_39":4120,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":4121,"_27":4122},{"_44":4111,"_32":1034,"_30":4112,"_158":4088,"_42":43,"_41":4113,"_160":59,"_39":4114,"_13":162,"_34":20,"_36":4115,"_24":25,"_164":-5,"_769":4116,"_27":4117},{"_44":4103,"_32":4104,"_30":4105,"_158":4088,"_42":43,"_41":4106,"_160":59,"_39":4107,"_13":162,"_34":20,"_36":4108,"_24":25,"_164":-5,"_769":4109,"_27":4110},{"_44":4095,"_32":4096,"_30":4097,"_158":4088,"_42":43,"_41":4098,"_160":59,"_39":4099,"_13":162,"_34":20,"_36":4100,"_24":25,"_164":-5,"_769":4101,"_27":4102},{"_44":4086,"_32":3558,"_30":4087,"_158":4088,"_42":43,"_41":4089,"_160":59,"_39":4090,"_13":162,"_34":20,"_36":4091,"_24":25,"_164":-5,"_769":4092,"_27":4093},{"_44":4081,"_32":4020,"_30":4014,"_158":3232,"_42":43,"_41":4082,"_160":59,"_39":4083,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":4084,"_27":4085},{"_44":4076,"_32":4052,"_30":4046,"_158":4014,"_42":43,"_41":4077,"_160":59,"_39":4078,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":4079,"_27":4080},{"_44":4069,"_32":1034,"_30":4070,"_158":4046,"_42":43,"_41":4071,"_160":59,"_39":4072,"_13":162,"_34":20,"_36":4073,"_24":25,"_164":-5,"_769":4074,"_27":4075},{"_44":4061,"_32":4062,"_30":4063,"_158":4046,"_42":43,"_41":4064,"_160":59,"_39":4065,"_13":162,"_34":20,"_36":4066,"_24":25,"_164":-5,"_769":4067,"_27":4068},{"_44":4053,"_32":4054,"_30":4055,"_158":4046,"_42":43,"_41":4056,"_160":59,"_39":4057,"_13":162,"_34":20,"_36":4058,"_24":25,"_164":-5,"_769":4059,"_27":4060},{"_44":4043,"_32":4044,"_30":4045,"_158":4046,"_42":43,"_41":4047,"_160":59,"_39":4048,"_13":162,"_34":20,"_36":4049,"_24":25,"_164":-5,"_769":4050,"_27":4051},{"_44":4036,"_32":1034,"_30":4037,"_158":4014,"_42":43,"_41":4038,"_160":59,"_39":4039,"_13":162,"_34":20,"_36":4040,"_24":25,"_164":-5,"_769":4041,"_27":4042},{"_44":4028,"_32":4029,"_30":4030,"_158":4014,"_42":43,"_41":4031,"_160":59,"_39":4032,"_13":162,"_34":20,"_36":4033,"_24":25,"_164":-5,"_769":4034,"_27":4035},{"_44":4021,"_32":3558,"_30":4022,"_158":4014,"_42":43,"_41":4023,"_160":59,"_39":4024,"_13":162,"_34":20,"_36":4025,"_24":25,"_164":-5,"_769":4026,"_27":4027},{"_44":4011,"_32":4012,"_30":4013,"_158":4014,"_42":43,"_41":4015,"_160":59,"_39":4016,"_13":162,"_34":20,"_36":4017,"_24":25,"_164":-5,"_769":4018,"_27":4019},{"_44":4006,"_32":3911,"_30":3905,"_158":3232,"_42":43,"_41":4007,"_160":59,"_39":4008,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":4009,"_27":4010},{"_44":3999,"_32":1034,"_30":4000,"_158":3905,"_42":43,"_41":4001,"_160":59,"_39":4002,"_13":162,"_34":20,"_36":4003,"_24":25,"_164":-5,"_769":4004,"_27":4005},{"_44":3991,"_32":3992,"_30":3993,"_158":3905,"_42":43,"_41":3994,"_160":59,"_39":3995,"_13":162,"_34":20,"_36":3996,"_24":25,"_164":-5,"_769":3997,"_27":3998},{"_44":3983,"_32":3984,"_30":3985,"_158":3905,"_42":43,"_41":3986,"_160":59,"_39":3987,"_13":162,"_34":20,"_36":3988,"_24":25,"_164":-5,"_769":3989,"_27":3990},{"_44":3975,"_32":3976,"_30":3977,"_158":3905,"_42":43,"_41":3978,"_160":59,"_39":3979,"_13":162,"_34":20,"_36":3980,"_24":25,"_164":-5,"_769":3981,"_27":3982},{"_44":3968,"_32":3001,"_30":3969,"_158":3905,"_42":43,"_41":3970,"_160":59,"_39":3971,"_13":162,"_34":20,"_36":3972,"_24":25,"_164":-5,"_769":3973,"_27":3974},{"_44":3960,"_32":3961,"_30":3962,"_158":3905,"_42":43,"_41":3963,"_160":59,"_39":3964,"_13":162,"_34":20,"_36":3965,"_24":25,"_164":-5,"_769":3966,"_27":3967},{"_44":3952,"_32":3953,"_30":3954,"_158":3905,"_42":43,"_41":3955,"_160":59,"_39":3956,"_13":162,"_34":20,"_36":3957,"_24":25,"_164":-5,"_769":3958,"_27":3959},{"_44":3944,"_32":3945,"_30":3946,"_158":3905,"_42":43,"_41":3947,"_160":59,"_39":3948,"_13":162,"_34":20,"_36":3949,"_24":25,"_164":-5,"_769":3950,"_27":3951},{"_44":3936,"_32":3937,"_30":3938,"_158":3905,"_42":43,"_41":3939,"_160":59,"_39":3940,"_13":162,"_34":20,"_36":3941,"_24":25,"_164":-5,"_769":3942,"_27":3943},{"_44":3928,"_32":3929,"_30":3930,"_158":3905,"_42":43,"_41":3931,"_160":59,"_39":3932,"_13":162,"_34":20,"_36":3933,"_24":25,"_164":-5,"_769":3934,"_27":3935},{"_44":3920,"_32":3921,"_30":3922,"_158":3905,"_42":43,"_41":3923,"_160":59,"_39":3924,"_13":162,"_34":20,"_36":3925,"_24":25,"_164":-5,"_769":3926,"_27":3927},{"_44":3912,"_32":3913,"_30":3914,"_158":3905,"_42":43,"_41":3915,"_160":59,"_39":3916,"_13":162,"_34":20,"_36":3917,"_24":25,"_164":-5,"_769":3918,"_27":3919},{"_44":3903,"_32":2931,"_30":3904,"_158":3905,"_42":43,"_41":3906,"_160":59,"_39":3907,"_13":162,"_34":20,"_36":3908,"_24":25,"_164":-5,"_769":3909,"_27":3910},{"_44":3898,"_32":3845,"_30":3839,"_158":3232,"_42":43,"_41":3899,"_160":59,"_39":3900,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":3901,"_27":3902},{"_44":3891,"_32":1034,"_30":3892,"_158":3839,"_42":43,"_41":3893,"_160":59,"_39":3894,"_13":162,"_34":20,"_36":3895,"_24":25,"_164":-5,"_769":3896,"_27":3897},{"_44":3884,"_32":2287,"_30":3885,"_158":3839,"_42":43,"_41":3886,"_160":59,"_39":3887,"_13":162,"_34":20,"_36":3888,"_24":25,"_164":-5,"_769":3889,"_27":3890},{"_44":3877,"_32":3159,"_30":3878,"_158":3839,"_42":43,"_41":3879,"_160":59,"_39":3880,"_13":162,"_34":20,"_36":3881,"_24":25,"_164":-5,"_769":3882,"_27":3883},{"_44":3869,"_32":3870,"_30":3871,"_158":3839,"_42":43,"_41":3872,"_160":59,"_39":3873,"_13":162,"_34":20,"_36":3874,"_24":25,"_164":-5,"_769":3875,"_27":3876},{"_44":3861,"_32":3862,"_30":3863,"_158":3839,"_42":43,"_41":3864,"_160":59,"_39":3865,"_13":162,"_34":20,"_36":3866,"_24":25,"_164":-5,"_769":3867,"_27":3868},{"_44":3853,"_32":3854,"_30":3855,"_158":3839,"_42":43,"_41":3856,"_160":59,"_39":3857,"_13":162,"_34":20,"_36":3858,"_24":25,"_164":-5,"_769":3859,"_27":3860},{"_44":3846,"_32":2190,"_30":3847,"_158":3839,"_42":43,"_41":3848,"_160":59,"_39":3849,"_13":162,"_34":20,"_36":3850,"_24":25,"_164":-5,"_769":3851,"_27":3852},{"_44":3836,"_32":3837,"_30":3838,"_158":3839,"_42":43,"_41":3840,"_160":59,"_39":3841,"_13":162,"_34":20,"_36":3842,"_24":25,"_164":-5,"_769":3843,"_27":3844},{"_44":3831,"_32":3724,"_30":3718,"_158":3232,"_42":43,"_41":3832,"_160":59,"_39":3833,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":3834,"_27":3835},{"_44":3826,"_32":3779,"_30":3773,"_158":3718,"_42":43,"_41":3827,"_160":59,"_39":3828,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":3829,"_27":3830},{"_44":3818,"_32":3819,"_30":3820,"_158":3773,"_42":43,"_41":3821,"_160":59,"_39":3822,"_13":162,"_34":20,"_36":3823,"_24":25,"_164":-5,"_769":3824,"_27":3825},{"_44":3811,"_32":2708,"_30":3812,"_158":3773,"_42":43,"_41":3813,"_160":59,"_39":3814,"_13":162,"_34":20,"_36":3815,"_24":25,"_164":-5,"_769":3816,"_27":3817},{"_44":3803,"_32":3804,"_30":3805,"_158":3773,"_42":43,"_41":3806,"_160":59,"_39":3807,"_13":162,"_34":20,"_36":3808,"_24":25,"_164":-5,"_769":3809,"_27":3810},{"_44":3795,"_32":3796,"_30":3797,"_158":3773,"_42":43,"_41":3798,"_160":59,"_39":3799,"_13":162,"_34":20,"_36":3800,"_24":25,"_164":-5,"_769":3801,"_27":3802},{"_44":3788,"_32":2931,"_30":3789,"_158":3773,"_42":43,"_41":3790,"_160":59,"_39":3791,"_13":162,"_34":20,"_36":3792,"_24":25,"_164":-5,"_769":3793,"_27":3794},{"_44":3780,"_32":3781,"_30":3782,"_158":3773,"_42":43,"_41":3783,"_160":59,"_39":3784,"_13":162,"_34":20,"_36":3785,"_24":25,"_164":-5,"_769":3786,"_27":3787},{"_44":3770,"_32":3771,"_30":3772,"_158":3773,"_42":43,"_41":3774,"_160":59,"_39":3775,"_13":162,"_34":20,"_36":3776,"_24":25,"_164":-5,"_769":3777,"_27":3778},{"_44":3765,"_32":3749,"_30":3743,"_158":3718,"_42":43,"_41":3766,"_160":59,"_39":3767,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":3768,"_27":3769},{"_44":3758,"_32":1034,"_30":3759,"_158":3743,"_42":43,"_41":3760,"_160":59,"_39":3761,"_13":162,"_34":20,"_36":3762,"_24":25,"_164":-5,"_769":3763,"_27":3764},{"_44":3750,"_32":3751,"_30":3752,"_158":3743,"_42":43,"_41":3753,"_160":59,"_39":3754,"_13":162,"_34":20,"_36":3755,"_24":25,"_164":-5,"_769":3756,"_27":3757},{"_44":3741,"_32":2931,"_30":3742,"_158":3743,"_42":43,"_41":3744,"_160":59,"_39":3745,"_13":162,"_34":20,"_36":3746,"_24":25,"_164":-5,"_769":3747,"_27":3748},{"_44":3733,"_32":3734,"_30":3735,"_158":3718,"_42":43,"_41":3736,"_160":59,"_39":3737,"_13":162,"_34":20,"_36":3738,"_24":25,"_164":-5,"_769":3739,"_27":3740},{"_44":3725,"_32":3726,"_30":3727,"_158":3718,"_42":43,"_41":3728,"_160":59,"_39":3729,"_13":162,"_34":20,"_36":3730,"_24":25,"_164":-5,"_769":3731,"_27":3732},{"_44":3715,"_32":3716,"_30":3717,"_158":3718,"_42":43,"_41":3719,"_160":59,"_39":3720,"_13":162,"_34":20,"_36":3721,"_24":25,"_164":-5,"_769":3722,"_27":3723},{"_44":3710,"_32":3662,"_30":3656,"_158":3232,"_42":43,"_41":3711,"_160":59,"_39":3712,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":3713,"_27":3714},{"_44":3703,"_32":1034,"_30":3704,"_158":3656,"_42":43,"_41":3705,"_160":59,"_39":3706,"_13":162,"_34":20,"_36":3707,"_24":25,"_164":-5,"_769":3708,"_27":3709},{"_44":3695,"_32":3696,"_30":3697,"_158":3656,"_42":43,"_41":3698,"_160":59,"_39":3699,"_13":162,"_34":20,"_36":3700,"_24":25,"_164":-5,"_769":3701,"_27":3702},{"_44":3687,"_32":3688,"_30":3689,"_158":3656,"_42":43,"_41":3690,"_160":59,"_39":3691,"_13":162,"_34":20,"_36":3692,"_24":25,"_164":-5,"_769":3693,"_27":3694},{"_44":3679,"_32":3680,"_30":3681,"_158":3656,"_42":43,"_41":3682,"_160":59,"_39":3683,"_13":162,"_34":20,"_36":3684,"_24":25,"_164":-5,"_769":3685,"_27":3686},{"_44":3671,"_32":3672,"_30":3673,"_158":3656,"_42":43,"_41":3674,"_160":59,"_39":3675,"_13":162,"_34":20,"_36":3676,"_24":25,"_164":-5,"_769":3677,"_27":3678},{"_44":3663,"_32":3664,"_30":3665,"_158":3656,"_42":43,"_41":3666,"_160":59,"_39":3667,"_13":162,"_34":20,"_36":3668,"_24":25,"_164":-5,"_769":3669,"_27":3670},{"_44":3653,"_32":3654,"_30":3655,"_158":3656,"_42":43,"_41":3657,"_160":59,"_39":3658,"_13":162,"_34":20,"_36":3659,"_24":25,"_164":-5,"_769":3660,"_27":3661},{"_44":3648,"_32":3566,"_30":3560,"_158":3232,"_42":43,"_41":3649,"_160":59,"_39":3650,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":3651,"_27":3652},{"_44":3644,"_32":3643,"_30":3637,"_158":3560,"_42":43,"_41":136,"_160":59,"_39":3645,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":3646,"_27":3647},{"_44":3635,"_32":3568,"_30":3636,"_158":3637,"_42":43,"_41":3638,"_160":59,"_39":3639,"_13":162,"_34":20,"_36":3640,"_24":25,"_164":-5,"_769":3641,"_27":3642},{"_44":3630,"_32":2115,"_30":3570,"_158":3560,"_42":43,"_41":3631,"_160":59,"_39":3632,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":3633,"_27":3634},{"_44":3623,"_32":3558,"_30":3624,"_158":3570,"_42":43,"_41":3625,"_160":59,"_39":3626,"_13":162,"_34":20,"_36":3627,"_24":25,"_164":-5,"_769":3628,"_27":3629},{"_44":3615,"_32":3616,"_30":3617,"_158":3570,"_42":43,"_41":3618,"_160":59,"_39":3619,"_13":162,"_34":20,"_36":3620,"_24":25,"_164":-5,"_769":3621,"_27":3622},{"_44":3607,"_32":3608,"_30":3609,"_158":3570,"_42":43,"_41":3610,"_160":59,"_39":3611,"_13":162,"_34":20,"_36":3612,"_24":25,"_164":-5,"_769":3613,"_27":3614},{"_44":3599,"_32":3600,"_30":3601,"_158":3570,"_42":43,"_41":3602,"_160":59,"_39":3603,"_13":162,"_34":20,"_36":3604,"_24":25,"_164":-5,"_769":3605,"_27":3606},{"_44":3591,"_32":3592,"_30":3593,"_158":3570,"_42":43,"_41":3594,"_160":59,"_39":3595,"_13":162,"_34":20,"_36":3596,"_24":25,"_164":-5,"_769":3597,"_27":3598},{"_44":3583,"_32":3584,"_30":3585,"_158":3570,"_42":43,"_41":3586,"_160":59,"_39":3587,"_13":162,"_34":20,"_36":3588,"_24":25,"_164":-5,"_769":3589,"_27":3590},{"_44":3576,"_32":2700,"_30":3577,"_158":3570,"_42":43,"_41":3578,"_160":59,"_39":3579,"_13":162,"_34":20,"_36":3580,"_24":25,"_164":-5,"_769":3581,"_27":3582},{"_44":3567,"_32":3568,"_30":3569,"_158":3570,"_42":43,"_41":3571,"_160":59,"_39":3572,"_13":162,"_34":20,"_36":3573,"_24":25,"_164":-5,"_769":3574,"_27":3575},{"_44":3557,"_32":3558,"_30":3559,"_158":3560,"_42":43,"_41":3561,"_160":59,"_39":3562,"_13":162,"_34":20,"_36":3563,"_24":25,"_164":-5,"_769":3564,"_27":3565},{"_44":3552,"_32":3362,"_30":3356,"_158":3232,"_42":43,"_41":3553,"_160":59,"_39":3554,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":3555,"_27":3556},{"_44":3544,"_32":3545,"_30":3546,"_158":3356,"_42":43,"_41":3547,"_160":59,"_39":3548,"_13":162,"_34":20,"_36":3549,"_24":25,"_164":-5,"_769":3550,"_27":3551},{"_44":3536,"_32":3537,"_30":3538,"_158":3356,"_42":43,"_41":3539,"_160":59,"_39":3540,"_13":162,"_34":20,"_36":3541,"_24":25,"_164":-5,"_769":3542,"_27":3543},{"_44":3528,"_32":3529,"_30":3530,"_158":3356,"_42":43,"_41":3531,"_160":59,"_39":3532,"_13":162,"_34":20,"_36":3533,"_24":25,"_164":-5,"_769":3534,"_27":3535},{"_44":3521,"_32":2271,"_30":3522,"_158":3356,"_42":43,"_41":3523,"_160":59,"_39":3524,"_13":162,"_34":20,"_36":3525,"_24":25,"_164":-5,"_769":3526,"_27":3527},{"_44":3513,"_32":3514,"_30":3515,"_158":3356,"_42":43,"_41":3516,"_160":59,"_39":3517,"_13":162,"_34":20,"_36":3518,"_24":25,"_164":-5,"_769":3519,"_27":3520},{"_44":3505,"_32":3506,"_30":3507,"_158":3356,"_42":43,"_41":3508,"_160":59,"_39":3509,"_13":162,"_34":20,"_36":3510,"_24":25,"_164":-5,"_769":3511,"_27":3512},{"_44":3497,"_32":3498,"_30":3499,"_158":3356,"_42":43,"_41":3500,"_160":59,"_39":3501,"_13":162,"_34":20,"_36":3502,"_24":25,"_164":-5,"_769":3503,"_27":3504},{"_44":3489,"_32":3490,"_30":3491,"_158":3356,"_42":43,"_41":3492,"_160":59,"_39":3493,"_13":162,"_34":20,"_36":3494,"_24":25,"_164":-5,"_769":3495,"_27":3496},{"_44":3481,"_32":3482,"_30":3483,"_158":3356,"_42":43,"_41":3484,"_160":59,"_39":3485,"_13":162,"_34":20,"_36":3486,"_24":25,"_164":-5,"_769":3487,"_27":3488},{"_44":3473,"_32":3474,"_30":3475,"_158":3356,"_42":43,"_41":3476,"_160":59,"_39":3477,"_13":162,"_34":20,"_36":3478,"_24":25,"_164":-5,"_769":3479,"_27":3480},{"_44":3465,"_32":3466,"_30":3467,"_158":3356,"_42":43,"_41":3468,"_160":59,"_39":3469,"_13":162,"_34":20,"_36":3470,"_24":25,"_164":-5,"_769":3471,"_27":3472},{"_44":3457,"_32":3458,"_30":3459,"_158":3356,"_42":43,"_41":3460,"_160":59,"_39":3461,"_13":162,"_34":20,"_36":3462,"_24":25,"_164":-5,"_769":3463,"_27":3464},{"_44":3449,"_32":3450,"_30":3451,"_158":3356,"_42":43,"_41":3452,"_160":59,"_39":3453,"_13":162,"_34":20,"_36":3454,"_24":25,"_164":-5,"_769":3455,"_27":3456},{"_44":3441,"_32":3442,"_30":3443,"_158":3356,"_42":43,"_41":3444,"_160":59,"_39":3445,"_13":162,"_34":20,"_36":3446,"_24":25,"_164":-5,"_769":3447,"_27":3448},{"_44":3434,"_32":1737,"_30":3435,"_158":3356,"_42":43,"_41":3436,"_160":59,"_39":3437,"_13":162,"_34":20,"_36":3438,"_24":25,"_164":-5,"_769":3439,"_27":3440},{"_44":3426,"_32":3427,"_30":3428,"_158":3356,"_42":43,"_41":3429,"_160":59,"_39":3430,"_13":162,"_34":20,"_36":3431,"_24":25,"_164":-5,"_769":3432,"_27":3433},{"_44":3418,"_32":3419,"_30":3420,"_158":3356,"_42":43,"_41":3421,"_160":59,"_39":3422,"_13":162,"_34":20,"_36":3423,"_24":25,"_164":-5,"_769":3424,"_27":3425},{"_44":3411,"_32":1198,"_30":3412,"_158":3356,"_42":43,"_41":3413,"_160":59,"_39":3414,"_13":162,"_34":20,"_36":3415,"_24":25,"_164":-5,"_769":3416,"_27":3417},{"_44":3403,"_32":3404,"_30":3405,"_158":3356,"_42":43,"_41":3406,"_160":59,"_39":3407,"_13":162,"_34":20,"_36":3408,"_24":25,"_164":-5,"_769":3409,"_27":3410},{"_44":3395,"_32":3396,"_30":3397,"_158":3356,"_42":43,"_41":3398,"_160":59,"_39":3399,"_13":162,"_34":20,"_36":3400,"_24":25,"_164":-5,"_769":3401,"_27":3402},{"_44":3387,"_32":3388,"_30":3389,"_158":3356,"_42":43,"_41":3390,"_160":59,"_39":3391,"_13":162,"_34":20,"_36":3392,"_24":25,"_164":-5,"_769":3393,"_27":3394},{"_44":3379,"_32":3380,"_30":3381,"_158":3356,"_42":43,"_41":3382,"_160":59,"_39":3383,"_13":162,"_34":20,"_36":3384,"_24":25,"_164":-5,"_769":3385,"_27":3386},{"_44":3371,"_32":3372,"_30":3373,"_158":3356,"_42":43,"_41":3374,"_160":59,"_39":3375,"_13":162,"_34":20,"_36":3376,"_24":25,"_164":-5,"_769":3377,"_27":3378},{"_44":3363,"_32":3364,"_30":3365,"_158":3356,"_42":43,"_41":3366,"_160":59,"_39":3367,"_13":162,"_34":20,"_36":3368,"_24":25,"_164":-5,"_769":3369,"_27":3370},{"_44":3354,"_32":2931,"_30":3355,"_158":3356,"_42":43,"_41":3357,"_160":59,"_39":3358,"_13":162,"_34":20,"_36":3359,"_24":25,"_164":-5,"_769":3360,"_27":3361},{"_44":3349,"_32":3309,"_30":3303,"_158":3232,"_42":43,"_41":3350,"_160":59,"_39":3351,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":3352,"_27":3353},{"_44":3342,"_32":1034,"_30":3343,"_158":3303,"_42":43,"_41":3344,"_160":59,"_39":3345,"_13":162,"_34":20,"_36":3346,"_24":25,"_164":-5,"_769":3347,"_27":3348},{"_44":3334,"_32":3335,"_30":3336,"_158":3303,"_42":43,"_41":3337,"_160":59,"_39":3338,"_13":162,"_34":20,"_36":3339,"_24":25,"_164":-5,"_769":3340,"_27":3341},{"_44":3326,"_32":3327,"_30":3328,"_158":3303,"_42":43,"_41":3329,"_160":59,"_39":3330,"_13":162,"_34":20,"_36":3331,"_24":25,"_164":-5,"_769":3332,"_27":3333},{"_44":3318,"_32":3319,"_30":3320,"_158":3303,"_42":43,"_41":3321,"_160":59,"_39":3322,"_13":162,"_34":20,"_36":3323,"_24":25,"_164":-5,"_769":3324,"_27":3325},{"_44":3310,"_32":3311,"_30":3312,"_158":3303,"_42":43,"_41":3313,"_160":59,"_39":3314,"_13":162,"_34":20,"_36":3315,"_24":25,"_164":-5,"_769":3316,"_27":3317},{"_44":3300,"_32":3301,"_30":3302,"_158":3303,"_42":43,"_41":3304,"_160":59,"_39":3305,"_13":162,"_34":20,"_36":3306,"_24":25,"_164":-5,"_769":3307,"_27":3308},{"_44":3293,"_32":1034,"_30":3294,"_158":3232,"_42":43,"_41":3295,"_160":59,"_39":3296,"_13":162,"_34":20,"_36":3297,"_24":25,"_164":-5,"_769":3298,"_27":3299},{"_44":3285,"_32":3286,"_30":3287,"_158":3232,"_42":43,"_41":3288,"_160":59,"_39":3289,"_13":162,"_34":20,"_36":3290,"_24":25,"_164":-5,"_769":3291,"_27":3292},{"_44":3278,"_32":3159,"_30":3279,"_158":3232,"_42":43,"_41":3280,"_160":59,"_39":3281,"_13":162,"_34":20,"_36":3282,"_24":25,"_164":-5,"_769":3283,"_27":3284},{"_44":3270,"_32":3271,"_30":3272,"_158":3232,"_42":43,"_41":3273,"_160":59,"_39":3274,"_13":162,"_34":20,"_36":3275,"_24":25,"_164":-5,"_769":3276,"_27":3277},{"_44":3263,"_32":1101,"_30":3264,"_158":3232,"_42":43,"_41":3265,"_160":59,"_39":3266,"_13":162,"_34":20,"_36":3267,"_24":25,"_164":-5,"_769":3268,"_27":3269},{"_44":3255,"_32":3256,"_30":3257,"_158":3232,"_42":43,"_41":3258,"_160":59,"_39":3259,"_13":162,"_34":20,"_36":3260,"_24":25,"_164":-5,"_769":3261,"_27":3262},{"_44":3247,"_32":3248,"_30":3249,"_158":3232,"_42":43,"_41":3250,"_160":59,"_39":3251,"_13":162,"_34":20,"_36":3252,"_24":25,"_164":-5,"_769":3253,"_27":3254},{"_44":3239,"_32":3240,"_30":3241,"_158":3232,"_42":43,"_41":3242,"_160":59,"_39":3243,"_13":162,"_34":20,"_36":3244,"_24":25,"_164":-5,"_769":3245,"_27":3246},{"_44":3229,"_32":3230,"_30":3231,"_158":3232,"_42":43,"_41":3233,"_160":59,"_39":3234,"_13":162,"_34":20,"_36":3235,"_24":25,"_164":-5,"_769":3236,"_27":3237},{"_44":3224,"_32":1050,"_30":1044,"_158":1010,"_42":43,"_41":3225,"_160":59,"_39":3226,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":3227,"_27":3228},{"_44":3219,"_32":3125,"_30":3119,"_158":1044,"_42":43,"_41":3220,"_160":59,"_39":3221,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":3222,"_27":3223},{"_44":3214,"_32":3198,"_30":3192,"_158":3119,"_42":43,"_41":3215,"_160":59,"_39":3216,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":3217,"_27":3218},{"_44":3207,"_32":1034,"_30":3208,"_158":3192,"_42":43,"_41":3209,"_160":59,"_39":3210,"_13":162,"_34":20,"_36":3211,"_24":25,"_164":-5,"_769":3212,"_27":3213},{"_44":3199,"_32":3200,"_30":3201,"_158":3192,"_42":43,"_41":3202,"_160":59,"_39":3203,"_13":162,"_34":20,"_36":3204,"_24":25,"_164":-5,"_769":3205,"_27":3206},{"_44":3189,"_32":3190,"_30":3191,"_158":3192,"_42":43,"_41":3193,"_160":59,"_39":3194,"_13":162,"_34":20,"_36":3195,"_24":25,"_164":-5,"_769":3196,"_27":3197},{"_44":3182,"_32":1034,"_30":3183,"_158":3119,"_42":43,"_41":3184,"_160":59,"_39":3185,"_13":162,"_34":20,"_36":3186,"_24":25,"_164":-5,"_769":3187,"_27":3188},{"_44":3174,"_32":3175,"_30":3176,"_158":3119,"_42":43,"_41":3177,"_160":59,"_39":3178,"_13":162,"_34":20,"_36":3179,"_24":25,"_164":-5,"_769":3180,"_27":3181},{"_44":3166,"_32":3167,"_30":3168,"_158":3119,"_42":43,"_41":3169,"_160":59,"_39":3170,"_13":162,"_34":20,"_36":3171,"_24":25,"_164":-5,"_769":3172,"_27":3173},{"_44":3158,"_32":3159,"_30":3160,"_158":3119,"_42":43,"_41":3161,"_160":59,"_39":3162,"_13":162,"_34":20,"_36":3163,"_24":25,"_164":-5,"_769":3164,"_27":3165},{"_44":3150,"_32":3151,"_30":3152,"_158":3119,"_42":43,"_41":3153,"_160":59,"_39":3154,"_13":162,"_34":20,"_36":3155,"_24":25,"_164":-5,"_769":3156,"_27":3157},{"_44":3142,"_32":3143,"_30":3144,"_158":3119,"_42":43,"_41":3145,"_160":59,"_39":3146,"_13":162,"_34":20,"_36":3147,"_24":25,"_164":-5,"_769":3148,"_27":3149},{"_44":3134,"_32":3135,"_30":3136,"_158":3119,"_42":43,"_41":3137,"_160":59,"_39":3138,"_13":162,"_34":20,"_36":3139,"_24":25,"_164":-5,"_769":3140,"_27":3141},{"_44":3126,"_32":3127,"_30":3128,"_158":3119,"_42":43,"_41":3129,"_160":59,"_39":3130,"_13":162,"_34":20,"_36":3131,"_24":25,"_164":-5,"_769":3132,"_27":3133},{"_44":3116,"_32":3117,"_30":3118,"_158":3119,"_42":43,"_41":3120,"_160":59,"_39":3121,"_13":162,"_34":20,"_36":3122,"_24":25,"_164":-5,"_769":3123,"_27":3124},{"_44":3111,"_32":3096,"_30":3090,"_158":1044,"_42":43,"_41":3112,"_160":59,"_39":3113,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":3114,"_27":3115},{"_44":3104,"_32":1034,"_30":3105,"_158":3090,"_42":43,"_41":3106,"_160":59,"_39":3107,"_13":162,"_34":20,"_36":3108,"_24":25,"_164":-5,"_769":3109,"_27":3110},{"_44":3097,"_32":1026,"_30":3098,"_158":3090,"_42":43,"_41":3099,"_160":59,"_39":3100,"_13":162,"_34":20,"_36":3101,"_24":25,"_164":-5,"_769":3102,"_27":3103},{"_44":3088,"_32":2867,"_30":3089,"_158":3090,"_42":43,"_41":3091,"_160":59,"_39":3092,"_13":162,"_34":20,"_36":3093,"_24":25,"_164":-5,"_769":3094,"_27":3095},{"_44":3083,"_32":3044,"_30":3038,"_158":1044,"_42":43,"_41":3084,"_160":59,"_39":3085,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":3086,"_27":3087},{"_44":3076,"_32":1034,"_30":3077,"_158":3038,"_42":43,"_41":3078,"_160":59,"_39":3079,"_13":162,"_34":20,"_36":3080,"_24":25,"_164":-5,"_769":3081,"_27":3082},{"_44":3069,"_32":1026,"_30":3070,"_158":3038,"_42":43,"_41":3071,"_160":59,"_39":3072,"_13":162,"_34":20,"_36":3073,"_24":25,"_164":-5,"_769":3074,"_27":3075},{"_44":3061,"_32":3062,"_30":3063,"_158":3038,"_42":43,"_41":3064,"_160":59,"_39":3065,"_13":162,"_34":20,"_36":3066,"_24":25,"_164":-5,"_769":3067,"_27":3068},{"_44":3053,"_32":3054,"_30":3055,"_158":3038,"_42":43,"_41":3056,"_160":59,"_39":3057,"_13":162,"_34":20,"_36":3058,"_24":25,"_164":-5,"_769":3059,"_27":3060},{"_44":3045,"_32":3046,"_30":3047,"_158":3038,"_42":43,"_41":3048,"_160":59,"_39":3049,"_13":162,"_34":20,"_36":3050,"_24":25,"_164":-5,"_769":3051,"_27":3052},{"_44":3035,"_32":3036,"_30":3037,"_158":3038,"_42":43,"_41":3039,"_160":59,"_39":3040,"_13":162,"_34":20,"_36":3041,"_24":25,"_164":-5,"_769":3042,"_27":3043},{"_44":3030,"_32":2939,"_30":2933,"_158":1044,"_42":43,"_41":3031,"_160":59,"_39":3032,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":3033,"_27":3034},{"_44":3023,"_32":1034,"_30":3024,"_158":2933,"_42":43,"_41":3025,"_160":59,"_39":3026,"_13":162,"_34":20,"_36":3027,"_24":25,"_164":-5,"_769":3028,"_27":3029},{"_44":3016,"_32":2271,"_30":3017,"_158":2933,"_42":43,"_41":3018,"_160":59,"_39":3019,"_13":162,"_34":20,"_36":3020,"_24":25,"_164":-5,"_769":3021,"_27":3022},{"_44":3008,"_32":3009,"_30":3010,"_158":2933,"_42":43,"_41":3011,"_160":59,"_39":3012,"_13":162,"_34":20,"_36":3013,"_24":25,"_164":-5,"_769":3014,"_27":3015},{"_44":3000,"_32":3001,"_30":3002,"_158":2933,"_42":43,"_41":3003,"_160":59,"_39":3004,"_13":162,"_34":20,"_36":3005,"_24":25,"_164":-5,"_769":3006,"_27":3007},{"_44":2992,"_32":2993,"_30":2994,"_158":2933,"_42":43,"_41":2995,"_160":59,"_39":2996,"_13":162,"_34":20,"_36":2997,"_24":25,"_164":-5,"_769":2998,"_27":2999},{"_44":2984,"_32":2985,"_30":2986,"_158":2933,"_42":43,"_41":2987,"_160":59,"_39":2988,"_13":162,"_34":20,"_36":2989,"_24":25,"_164":-5,"_769":2990,"_27":2991},{"_44":2977,"_32":2716,"_30":2978,"_158":2933,"_42":43,"_41":2979,"_160":59,"_39":2980,"_13":162,"_34":20,"_36":2981,"_24":25,"_164":-5,"_769":2982,"_27":2983},{"_44":2970,"_32":2708,"_30":2971,"_158":2933,"_42":43,"_41":2972,"_160":59,"_39":2973,"_13":162,"_34":20,"_36":2974,"_24":25,"_164":-5,"_769":2975,"_27":2976},{"_44":2962,"_32":2963,"_30":2964,"_158":2933,"_42":43,"_41":2965,"_160":59,"_39":2966,"_13":162,"_34":20,"_36":2967,"_24":25,"_164":-5,"_769":2968,"_27":2969},{"_44":2954,"_32":2955,"_30":2956,"_158":2933,"_42":43,"_41":2957,"_160":59,"_39":2958,"_13":162,"_34":20,"_36":2959,"_24":25,"_164":-5,"_769":2960,"_27":2961},{"_44":2947,"_32":2383,"_30":2948,"_158":2933,"_42":43,"_41":2949,"_160":59,"_39":2950,"_13":162,"_34":20,"_36":2951,"_24":25,"_164":-5,"_769":2952,"_27":2953},{"_44":2940,"_32":2603,"_30":2941,"_158":2933,"_42":43,"_41":2942,"_160":59,"_39":2943,"_13":162,"_34":20,"_36":2944,"_24":25,"_164":-5,"_769":2945,"_27":2946},{"_44":2930,"_32":2931,"_30":2932,"_158":2933,"_42":43,"_41":2934,"_160":59,"_39":2935,"_13":162,"_34":20,"_36":2936,"_24":25,"_164":-5,"_769":2937,"_27":2938},{"_44":2925,"_32":2910,"_30":2904,"_158":1044,"_42":43,"_41":2926,"_160":59,"_39":2927,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":2928,"_27":2929},{"_44":2918,"_32":1034,"_30":2919,"_158":2904,"_42":43,"_41":2920,"_160":59,"_39":2921,"_13":162,"_34":20,"_36":2922,"_24":25,"_164":-5,"_769":2923,"_27":2924},{"_44":2911,"_32":1026,"_30":2912,"_158":2904,"_42":43,"_41":2913,"_160":59,"_39":2914,"_13":162,"_34":20,"_36":2915,"_24":25,"_164":-5,"_769":2916,"_27":2917},{"_44":2901,"_32":2902,"_30":2903,"_158":2904,"_42":43,"_41":2905,"_160":59,"_39":2906,"_13":162,"_34":20,"_36":2907,"_24":25,"_164":-5,"_769":2908,"_27":2909},{"_44":2896,"_32":2849,"_30":2843,"_158":1044,"_42":43,"_41":2897,"_160":59,"_39":2898,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":2899,"_27":2900},{"_44":2889,"_32":1034,"_30":2890,"_158":2843,"_42":43,"_41":2891,"_160":59,"_39":2892,"_13":162,"_34":20,"_36":2893,"_24":25,"_164":-5,"_769":2894,"_27":2895},{"_44":2881,"_32":2882,"_30":2883,"_158":2843,"_42":43,"_41":2884,"_160":59,"_39":2885,"_13":162,"_34":20,"_36":2886,"_24":25,"_164":-5,"_769":2887,"_27":2888},{"_44":2874,"_32":2271,"_30":2875,"_158":2843,"_42":43,"_41":2876,"_160":59,"_39":2877,"_13":162,"_34":20,"_36":2878,"_24":25,"_164":-5,"_769":2879,"_27":2880},{"_44":2866,"_32":2867,"_30":2868,"_158":2843,"_42":43,"_41":2869,"_160":59,"_39":2870,"_13":162,"_34":20,"_36":2871,"_24":25,"_164":-5,"_769":2872,"_27":2873},{"_44":2858,"_32":2859,"_30":2860,"_158":2843,"_42":43,"_41":2861,"_160":59,"_39":2862,"_13":162,"_34":20,"_36":2863,"_24":25,"_164":-5,"_769":2864,"_27":2865},{"_44":2850,"_32":2851,"_30":2852,"_158":2843,"_42":43,"_41":2853,"_160":59,"_39":2854,"_13":162,"_34":20,"_36":2855,"_24":25,"_164":-5,"_769":2856,"_27":2857},{"_44":2840,"_32":2841,"_30":2842,"_158":2843,"_42":43,"_41":2844,"_160":59,"_39":2845,"_13":162,"_34":20,"_36":2846,"_24":25,"_164":-5,"_769":2847,"_27":2848},{"_44":2835,"_32":2812,"_30":2806,"_158":1044,"_42":43,"_41":2836,"_160":59,"_39":2837,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":2838,"_27":2839},{"_44":2828,"_32":1034,"_30":2829,"_158":2806,"_42":43,"_41":2830,"_160":59,"_39":2831,"_13":162,"_34":20,"_36":2832,"_24":25,"_164":-5,"_769":2833,"_27":2834},{"_44":2821,"_32":1101,"_30":2822,"_158":2806,"_42":43,"_41":2823,"_160":59,"_39":2824,"_13":162,"_34":20,"_36":2825,"_24":25,"_164":-5,"_769":2826,"_27":2827},{"_44":2813,"_32":2814,"_30":2815,"_158":2806,"_42":43,"_41":2816,"_160":59,"_39":2817,"_13":162,"_34":20,"_36":2818,"_24":25,"_164":-5,"_769":2819,"_27":2820},{"_44":2803,"_32":2804,"_30":2805,"_158":2806,"_42":43,"_41":2807,"_160":59,"_39":2808,"_13":162,"_34":20,"_36":2809,"_24":25,"_164":-5,"_769":2810,"_27":2811},{"_44":2798,"_32":2675,"_30":2669,"_158":1044,"_42":43,"_41":2799,"_160":59,"_39":2800,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":2801,"_27":2802},{"_44":2793,"_32":988,"_30":2780,"_158":2669,"_42":43,"_41":2794,"_160":59,"_39":2795,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":2796,"_27":2797},{"_44":2786,"_32":1034,"_30":2787,"_158":2780,"_42":43,"_41":2788,"_160":59,"_39":2789,"_13":162,"_34":20,"_36":2790,"_24":25,"_164":-5,"_769":2791,"_27":2792},{"_44":2777,"_32":2778,"_30":2779,"_158":2780,"_42":43,"_41":2781,"_160":59,"_39":2782,"_13":162,"_34":20,"_36":2783,"_24":25,"_164":-5,"_769":2784,"_27":2785},{"_44":2770,"_32":1034,"_30":2771,"_158":2669,"_42":43,"_41":2772,"_160":59,"_39":2773,"_13":162,"_34":20,"_36":2774,"_24":25,"_164":-5,"_769":2775,"_27":2776},{"_44":2762,"_32":2763,"_30":2764,"_158":2669,"_42":43,"_41":2765,"_160":59,"_39":2766,"_13":162,"_34":20,"_36":2767,"_24":25,"_164":-5,"_769":2768,"_27":2769},{"_44":2754,"_32":2755,"_30":2756,"_158":2669,"_42":43,"_41":2757,"_160":59,"_39":2758,"_13":162,"_34":20,"_36":2759,"_24":25,"_164":-5,"_769":2760,"_27":2761},{"_44":2746,"_32":2747,"_30":2748,"_158":2669,"_42":43,"_41":2749,"_160":59,"_39":2750,"_13":162,"_34":20,"_36":2751,"_24":25,"_164":-5,"_769":2752,"_27":2753},{"_44":2739,"_32":1483,"_30":2740,"_158":2669,"_42":43,"_41":2741,"_160":59,"_39":2742,"_13":162,"_34":20,"_36":2743,"_24":25,"_164":-5,"_769":2744,"_27":2745},{"_44":2731,"_32":2732,"_30":2733,"_158":2669,"_42":43,"_41":2734,"_160":59,"_39":2735,"_13":162,"_34":20,"_36":2736,"_24":25,"_164":-5,"_769":2737,"_27":2738},{"_44":2723,"_32":2724,"_30":2725,"_158":2669,"_42":43,"_41":2726,"_160":59,"_39":2727,"_13":162,"_34":20,"_36":2728,"_24":25,"_164":-5,"_769":2729,"_27":2730},{"_44":2715,"_32":2716,"_30":2717,"_158":2669,"_42":43,"_41":2718,"_160":59,"_39":2719,"_13":162,"_34":20,"_36":2720,"_24":25,"_164":-5,"_769":2721,"_27":2722},{"_44":2707,"_32":2708,"_30":2709,"_158":2669,"_42":43,"_41":2710,"_160":59,"_39":2711,"_13":162,"_34":20,"_36":2712,"_24":25,"_164":-5,"_769":2713,"_27":2714},{"_44":2699,"_32":2700,"_30":2701,"_158":2669,"_42":43,"_41":2702,"_160":59,"_39":2703,"_13":162,"_34":20,"_36":2704,"_24":25,"_164":-5,"_769":2705,"_27":2706},{"_44":2691,"_32":2692,"_30":2693,"_158":2669,"_42":43,"_41":2694,"_160":59,"_39":2695,"_13":162,"_34":20,"_36":2696,"_24":25,"_164":-5,"_769":2697,"_27":2698},{"_44":2683,"_32":2684,"_30":2685,"_158":2669,"_42":43,"_41":2686,"_160":59,"_39":2687,"_13":162,"_34":20,"_36":2688,"_24":25,"_164":-5,"_769":2689,"_27":2690},{"_44":2676,"_32":2190,"_30":2677,"_158":2669,"_42":43,"_41":2678,"_160":59,"_39":2679,"_13":162,"_34":20,"_36":2680,"_24":25,"_164":-5,"_769":2681,"_27":2682},{"_44":2667,"_32":2603,"_30":2668,"_158":2669,"_42":43,"_41":2670,"_160":59,"_39":2671,"_13":162,"_34":20,"_36":2672,"_24":25,"_164":-5,"_769":2673,"_27":2674},{"_44":2660,"_32":2661,"_30":2662,"_158":1044,"_42":43,"_41":2663,"_160":59,"_39":2664,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":2665,"_27":2666},{"_44":2655,"_32":2601,"_30":2595,"_158":1044,"_42":43,"_41":2656,"_160":59,"_39":2657,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":2658,"_27":2659},{"_44":2648,"_32":1034,"_30":2649,"_158":2595,"_42":43,"_41":2650,"_160":59,"_39":2651,"_13":162,"_34":20,"_36":2652,"_24":25,"_164":-5,"_769":2653,"_27":2654},{"_44":2641,"_32":1026,"_30":2642,"_158":2595,"_42":43,"_41":2643,"_160":59,"_39":2644,"_13":162,"_34":20,"_36":2645,"_24":25,"_164":-5,"_769":2646,"_27":2647},{"_44":2633,"_32":2634,"_30":2635,"_158":2595,"_42":43,"_41":2636,"_160":59,"_39":2637,"_13":162,"_34":20,"_36":2638,"_24":25,"_164":-5,"_769":2639,"_27":2640},{"_44":2626,"_32":2295,"_30":2627,"_158":2595,"_42":43,"_41":2628,"_160":59,"_39":2629,"_13":162,"_34":20,"_36":2630,"_24":25,"_164":-5,"_769":2631,"_27":2632},{"_44":2618,"_32":2619,"_30":2620,"_158":2595,"_42":43,"_41":2621,"_160":59,"_39":2622,"_13":162,"_34":20,"_36":2623,"_24":25,"_164":-5,"_769":2624,"_27":2625},{"_44":2610,"_32":2611,"_30":2612,"_158":2595,"_42":43,"_41":2613,"_160":59,"_39":2614,"_13":162,"_34":20,"_36":2615,"_24":25,"_164":-5,"_769":2616,"_27":2617},{"_44":2602,"_32":2603,"_30":2604,"_158":2595,"_42":43,"_41":2605,"_160":59,"_39":2606,"_13":162,"_34":20,"_36":2607,"_24":25,"_164":-5,"_769":2608,"_27":2609},{"_44":2592,"_32":2593,"_30":2594,"_158":2595,"_42":43,"_41":2596,"_160":59,"_39":2597,"_13":162,"_34":20,"_36":2598,"_24":25,"_164":-5,"_769":2599,"_27":2600},{"_44":2587,"_32":2391,"_30":2385,"_158":1044,"_42":43,"_41":2588,"_160":59,"_39":2589,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":2590,"_27":2591},{"_44":2582,"_32":2581,"_30":2575,"_158":2385,"_42":43,"_41":2583,"_160":59,"_39":2584,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":2585,"_27":2586},{"_44":2573,"_32":1034,"_30":2574,"_158":2575,"_42":43,"_41":2576,"_160":59,"_39":2577,"_13":162,"_34":20,"_36":2578,"_24":25,"_164":-5,"_769":2579,"_27":2580},{"_44":2568,"_32":2560,"_30":2554,"_158":2385,"_42":43,"_41":2569,"_160":59,"_39":2570,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":2571,"_27":2572},{"_44":2561,"_32":1034,"_30":2562,"_158":2554,"_42":43,"_41":2563,"_160":59,"_39":2564,"_13":162,"_34":20,"_36":2565,"_24":25,"_164":-5,"_769":2566,"_27":2567},{"_44":2552,"_32":2502,"_30":2553,"_158":2554,"_42":43,"_41":2555,"_160":59,"_39":2556,"_13":162,"_34":20,"_36":2557,"_24":25,"_164":-5,"_769":2558,"_27":2559},{"_44":2547,"_32":2532,"_30":2526,"_158":2385,"_42":43,"_41":2548,"_160":59,"_39":2549,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":2550,"_27":2551},{"_44":2540,"_32":1034,"_30":2541,"_158":2526,"_42":43,"_41":2542,"_160":59,"_39":2543,"_13":162,"_34":20,"_36":2544,"_24":25,"_164":-5,"_769":2545,"_27":2546},{"_44":2533,"_32":2502,"_30":2534,"_158":2526,"_42":43,"_41":2535,"_160":59,"_39":2536,"_13":162,"_34":20,"_36":2537,"_24":25,"_164":-5,"_769":2538,"_27":2539},{"_44":2523,"_32":2524,"_30":2525,"_158":2526,"_42":43,"_41":2527,"_160":59,"_39":2528,"_13":162,"_34":20,"_36":2529,"_24":25,"_164":-5,"_769":2530,"_27":2531},{"_44":2518,"_32":2510,"_30":2504,"_158":2385,"_42":43,"_41":2519,"_160":59,"_39":2520,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":2521,"_27":2522},{"_44":2511,"_32":1034,"_30":2512,"_158":2504,"_42":43,"_41":2513,"_160":59,"_39":2514,"_13":162,"_34":20,"_36":2515,"_24":25,"_164":-5,"_769":2516,"_27":2517},{"_44":2501,"_32":2502,"_30":2503,"_158":2504,"_42":43,"_41":2505,"_160":59,"_39":2506,"_13":162,"_34":20,"_36":2507,"_24":25,"_164":-5,"_769":2508,"_27":2509},{"_44":2494,"_32":1034,"_30":2495,"_158":2385,"_42":43,"_41":2496,"_160":59,"_39":2497,"_13":162,"_34":20,"_36":2498,"_24":25,"_164":-5,"_769":2499,"_27":2500},{"_44":2487,"_32":1026,"_30":2488,"_158":2385,"_42":43,"_41":2489,"_160":59,"_39":2490,"_13":162,"_34":20,"_36":2491,"_24":25,"_164":-5,"_769":2492,"_27":2493},{"_44":2479,"_32":2480,"_30":2481,"_158":2385,"_42":43,"_41":2482,"_160":59,"_39":2483,"_13":162,"_34":20,"_36":2484,"_24":25,"_164":-5,"_769":2485,"_27":2486},{"_44":2471,"_32":2472,"_30":2473,"_158":2385,"_42":43,"_41":2474,"_160":59,"_39":2475,"_13":162,"_34":20,"_36":2476,"_24":25,"_164":-5,"_769":2477,"_27":2478},{"_44":2463,"_32":2464,"_30":2465,"_158":2385,"_42":43,"_41":2466,"_160":59,"_39":2467,"_13":162,"_34":20,"_36":2468,"_24":25,"_164":-5,"_769":2469,"_27":2470},{"_44":2455,"_32":2456,"_30":2457,"_158":2385,"_42":43,"_41":2458,"_160":59,"_39":2459,"_13":162,"_34":20,"_36":2460,"_24":25,"_164":-5,"_769":2461,"_27":2462},{"_44":2447,"_32":2448,"_30":2449,"_158":2385,"_42":43,"_41":2450,"_160":59,"_39":2451,"_13":162,"_34":20,"_36":2452,"_24":25,"_164":-5,"_769":2453,"_27":2454},{"_44":2439,"_32":2440,"_30":2441,"_158":2385,"_42":43,"_41":2442,"_160":59,"_39":2443,"_13":162,"_34":20,"_36":2444,"_24":25,"_164":-5,"_769":2445,"_27":2446},{"_44":2431,"_32":2432,"_30":2433,"_158":2385,"_42":43,"_41":2434,"_160":59,"_39":2435,"_13":162,"_34":20,"_36":2436,"_24":25,"_164":-5,"_769":2437,"_27":2438},{"_44":2423,"_32":2424,"_30":2425,"_158":2385,"_42":43,"_41":2426,"_160":59,"_39":2427,"_13":162,"_34":20,"_36":2428,"_24":25,"_164":-5,"_769":2429,"_27":2430},{"_44":2415,"_32":2416,"_30":2417,"_158":2385,"_42":43,"_41":2418,"_160":59,"_39":2419,"_13":162,"_34":20,"_36":2420,"_24":25,"_164":-5,"_769":2421,"_27":2422},{"_44":2408,"_32":1577,"_30":2409,"_158":2385,"_42":43,"_41":2410,"_160":59,"_39":2411,"_13":162,"_34":20,"_36":2412,"_24":25,"_164":-5,"_769":2413,"_27":2414},{"_44":2400,"_32":2401,"_30":2402,"_158":2385,"_42":43,"_41":2403,"_160":59,"_39":2404,"_13":162,"_34":20,"_36":2405,"_24":25,"_164":-5,"_769":2406,"_27":2407},{"_44":2392,"_32":2393,"_30":2394,"_158":2385,"_42":43,"_41":2395,"_160":59,"_39":2396,"_13":162,"_34":20,"_36":2397,"_24":25,"_164":-5,"_769":2398,"_27":2399},{"_44":2382,"_32":2383,"_30":2384,"_158":2385,"_42":43,"_41":2386,"_160":59,"_39":2387,"_13":162,"_34":20,"_36":2388,"_24":25,"_164":-5,"_769":2389,"_27":2390},{"_44":2377,"_32":2347,"_30":2341,"_158":1044,"_42":43,"_41":2378,"_160":59,"_39":2379,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":2380,"_27":2381},{"_44":2372,"_32":2364,"_30":2358,"_158":2341,"_42":43,"_41":2373,"_160":59,"_39":2374,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":2375,"_27":2376},{"_44":2365,"_32":1034,"_30":2366,"_158":2358,"_42":43,"_41":2367,"_160":59,"_39":2368,"_13":162,"_34":20,"_36":2369,"_24":25,"_164":-5,"_769":2370,"_27":2371},{"_44":2355,"_32":2356,"_30":2357,"_158":2358,"_42":43,"_41":2359,"_160":59,"_39":2360,"_13":162,"_34":20,"_36":2361,"_24":25,"_164":-5,"_769":2362,"_27":2363},{"_44":2348,"_32":1034,"_30":2349,"_158":2341,"_42":43,"_41":2350,"_160":59,"_39":2351,"_13":162,"_34":20,"_36":2352,"_24":25,"_164":-5,"_769":2353,"_27":2354},{"_44":2338,"_32":2339,"_30":2340,"_158":2341,"_42":43,"_41":2342,"_160":59,"_39":2343,"_13":162,"_34":20,"_36":2344,"_24":25,"_164":-5,"_769":2345,"_27":2346},{"_44":2333,"_32":2198,"_30":2192,"_158":1044,"_42":43,"_41":2334,"_160":59,"_39":2335,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":2336,"_27":2337},{"_44":2326,"_32":1034,"_30":2327,"_158":2192,"_42":43,"_41":2328,"_160":59,"_39":2329,"_13":162,"_34":20,"_36":2330,"_24":25,"_164":-5,"_769":2331,"_27":2332},{"_44":2318,"_32":2319,"_30":2320,"_158":2192,"_42":43,"_41":2321,"_160":59,"_39":2322,"_13":162,"_34":20,"_36":2323,"_24":25,"_164":-5,"_769":2324,"_27":2325},{"_44":2310,"_32":2311,"_30":2312,"_158":2192,"_42":43,"_41":2313,"_160":59,"_39":2314,"_13":162,"_34":20,"_36":2315,"_24":25,"_164":-5,"_769":2316,"_27":2317},{"_44":2302,"_32":2303,"_30":2304,"_158":2192,"_42":43,"_41":2305,"_160":59,"_39":2306,"_13":162,"_34":20,"_36":2307,"_24":25,"_164":-5,"_769":2308,"_27":2309},{"_44":2294,"_32":2295,"_30":2296,"_158":2192,"_42":43,"_41":2297,"_160":59,"_39":2298,"_13":162,"_34":20,"_36":2299,"_24":25,"_164":-5,"_769":2300,"_27":2301},{"_44":2286,"_32":2287,"_30":2288,"_158":2192,"_42":43,"_41":2289,"_160":59,"_39":2290,"_13":162,"_34":20,"_36":2291,"_24":25,"_164":-5,"_769":2292,"_27":2293},{"_44":2278,"_32":2279,"_30":2280,"_158":2192,"_42":43,"_41":2281,"_160":59,"_39":2282,"_13":162,"_34":20,"_36":2283,"_24":25,"_164":-5,"_769":2284,"_27":2285},{"_44":2270,"_32":2271,"_30":2272,"_158":2192,"_42":43,"_41":2273,"_160":59,"_39":2274,"_13":162,"_34":20,"_36":2275,"_24":25,"_164":-5,"_769":2276,"_27":2277},{"_44":2262,"_32":2263,"_30":2264,"_158":2192,"_42":43,"_41":2265,"_160":59,"_39":2266,"_13":162,"_34":20,"_36":2267,"_24":25,"_164":-5,"_769":2268,"_27":2269},{"_44":2255,"_32":1101,"_30":2256,"_158":2192,"_42":43,"_41":2257,"_160":59,"_39":2258,"_13":162,"_34":20,"_36":2259,"_24":25,"_164":-5,"_769":2260,"_27":2261},{"_44":2247,"_32":2248,"_30":2249,"_158":2192,"_42":43,"_41":2250,"_160":59,"_39":2251,"_13":162,"_34":20,"_36":2252,"_24":25,"_164":-5,"_769":2253,"_27":2254},{"_44":2239,"_32":2240,"_30":2241,"_158":2192,"_42":43,"_41":2242,"_160":59,"_39":2243,"_13":162,"_34":20,"_36":2244,"_24":25,"_164":-5,"_769":2245,"_27":2246},{"_44":2231,"_32":2232,"_30":2233,"_158":2192,"_42":43,"_41":2234,"_160":59,"_39":2235,"_13":162,"_34":20,"_36":2236,"_24":25,"_164":-5,"_769":2237,"_27":2238},{"_44":2223,"_32":2224,"_30":2225,"_158":2192,"_42":43,"_41":2226,"_160":59,"_39":2227,"_13":162,"_34":20,"_36":2228,"_24":25,"_164":-5,"_769":2229,"_27":2230},{"_44":2215,"_32":2216,"_30":2217,"_158":2192,"_42":43,"_41":2218,"_160":59,"_39":2219,"_13":162,"_34":20,"_36":2220,"_24":25,"_164":-5,"_769":2221,"_27":2222},{"_44":2207,"_32":2208,"_30":2209,"_158":2192,"_42":43,"_41":2210,"_160":59,"_39":2211,"_13":162,"_34":20,"_36":2212,"_24":25,"_164":-5,"_769":2213,"_27":2214},{"_44":2199,"_32":2200,"_30":2201,"_158":2192,"_42":43,"_41":2202,"_160":59,"_39":2203,"_13":162,"_34":20,"_36":2204,"_24":25,"_164":-5,"_769":2205,"_27":2206},{"_44":2189,"_32":2190,"_30":2191,"_158":2192,"_42":43,"_41":2193,"_160":59,"_39":2194,"_13":162,"_34":20,"_36":2195,"_24":25,"_164":-5,"_769":2196,"_27":2197},{"_44":2184,"_32":2115,"_30":2109,"_158":1044,"_42":43,"_41":2185,"_160":59,"_39":2186,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":2187,"_27":2188},{"_44":2179,"_32":2148,"_30":2142,"_158":2109,"_42":43,"_41":2180,"_160":59,"_39":2181,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":2182,"_27":2183},{"_44":2172,"_32":1034,"_30":2173,"_158":2142,"_42":43,"_41":2174,"_160":59,"_39":2175,"_13":162,"_34":20,"_36":2176,"_24":25,"_164":-5,"_769":2177,"_27":2178},{"_44":2164,"_32":2165,"_30":2166,"_158":2142,"_42":43,"_41":2167,"_160":59,"_39":2168,"_13":162,"_34":20,"_36":2169,"_24":25,"_164":-5,"_769":2170,"_27":2171},{"_44":2156,"_32":2157,"_30":2158,"_158":2142,"_42":43,"_41":2159,"_160":59,"_39":2160,"_13":162,"_34":20,"_36":2161,"_24":25,"_164":-5,"_769":2162,"_27":2163},{"_44":2149,"_32":1101,"_30":2150,"_158":2142,"_42":43,"_41":2151,"_160":59,"_39":2152,"_13":162,"_34":20,"_36":2153,"_24":25,"_164":-5,"_769":2154,"_27":2155},{"_44":2139,"_32":2140,"_30":2141,"_158":2142,"_42":43,"_41":2143,"_160":59,"_39":2144,"_13":162,"_34":20,"_36":2145,"_24":25,"_164":-5,"_769":2146,"_27":2147},{"_44":2132,"_32":1034,"_30":2133,"_158":2109,"_42":43,"_41":2134,"_160":59,"_39":2135,"_13":162,"_34":20,"_36":2136,"_24":25,"_164":-5,"_769":2137,"_27":2138},{"_44":2124,"_32":2125,"_30":2126,"_158":2109,"_42":43,"_41":2127,"_160":59,"_39":2128,"_13":162,"_34":20,"_36":2129,"_24":25,"_164":-5,"_769":2130,"_27":2131},{"_44":2116,"_32":2117,"_30":2118,"_158":2109,"_42":43,"_41":2119,"_160":59,"_39":2120,"_13":162,"_34":20,"_36":2121,"_24":25,"_164":-5,"_769":2122,"_27":2123},{"_44":2106,"_32":2107,"_30":2108,"_158":2109,"_42":43,"_41":2110,"_160":59,"_39":2111,"_13":162,"_34":20,"_36":2112,"_24":25,"_164":-5,"_769":2113,"_27":2114},{"_44":2101,"_32":1511,"_30":1505,"_158":1044,"_42":43,"_41":2102,"_160":59,"_39":2103,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":2104,"_27":2105},{"_44":2094,"_32":1034,"_30":2095,"_158":1505,"_42":43,"_41":2096,"_160":59,"_39":2097,"_13":162,"_34":20,"_36":2098,"_24":25,"_164":-5,"_769":2099,"_27":2100},{"_44":2087,"_32":1026,"_30":2088,"_158":1505,"_42":43,"_41":2089,"_160":59,"_39":2090,"_13":162,"_34":20,"_36":2091,"_24":25,"_164":-5,"_769":2092,"_27":2093},{"_44":2079,"_32":2080,"_30":2081,"_158":1505,"_42":43,"_41":2082,"_160":59,"_39":2083,"_13":162,"_34":20,"_36":2084,"_24":25,"_164":-5,"_769":2085,"_27":2086},{"_44":2071,"_32":2072,"_30":2073,"_158":1505,"_42":43,"_41":2074,"_160":59,"_39":2075,"_13":162,"_34":20,"_36":2076,"_24":25,"_164":-5,"_769":2077,"_27":2078},{"_44":2063,"_32":2064,"_30":2065,"_158":1505,"_42":43,"_41":2066,"_160":59,"_39":2067,"_13":162,"_34":20,"_36":2068,"_24":25,"_164":-5,"_769":2069,"_27":2070},{"_44":2055,"_32":2056,"_30":2057,"_158":1505,"_42":43,"_41":2058,"_160":59,"_39":2059,"_13":162,"_34":20,"_36":2060,"_24":25,"_164":-5,"_769":2061,"_27":2062},{"_44":2047,"_32":2048,"_30":2049,"_158":1505,"_42":43,"_41":2050,"_160":59,"_39":2051,"_13":162,"_34":20,"_36":2052,"_24":25,"_164":-5,"_769":2053,"_27":2054},{"_44":2039,"_32":2040,"_30":2041,"_158":1505,"_42":43,"_41":2042,"_160":59,"_39":2043,"_13":162,"_34":20,"_36":2044,"_24":25,"_164":-5,"_769":2045,"_27":2046},{"_44":2031,"_32":2032,"_30":2033,"_158":1505,"_42":43,"_41":2034,"_160":59,"_39":2035,"_13":162,"_34":20,"_36":2036,"_24":25,"_164":-5,"_769":2037,"_27":2038},{"_44":2023,"_32":2024,"_30":2025,"_158":1505,"_42":43,"_41":2026,"_160":59,"_39":2027,"_13":162,"_34":20,"_36":2028,"_24":25,"_164":-5,"_769":2029,"_27":2030},{"_44":2015,"_32":2016,"_30":2017,"_158":1505,"_42":43,"_41":2018,"_160":59,"_39":2019,"_13":162,"_34":20,"_36":2020,"_24":25,"_164":-5,"_769":2021,"_27":2022},{"_44":2007,"_32":2008,"_30":2009,"_158":1505,"_42":43,"_41":2010,"_160":59,"_39":2011,"_13":162,"_34":20,"_36":2012,"_24":25,"_164":-5,"_769":2013,"_27":2014},{"_44":1999,"_32":2000,"_30":2001,"_158":1505,"_42":43,"_41":2002,"_160":59,"_39":2003,"_13":162,"_34":20,"_36":2004,"_24":25,"_164":-5,"_769":2005,"_27":2006},{"_44":1991,"_32":1992,"_30":1993,"_158":1505,"_42":43,"_41":1994,"_160":59,"_39":1995,"_13":162,"_34":20,"_36":1996,"_24":25,"_164":-5,"_769":1997,"_27":1998},{"_44":1983,"_32":1984,"_30":1985,"_158":1505,"_42":43,"_41":1986,"_160":59,"_39":1987,"_13":162,"_34":20,"_36":1988,"_24":25,"_164":-5,"_769":1989,"_27":1990},{"_44":1975,"_32":1976,"_30":1977,"_158":1505,"_42":43,"_41":1978,"_160":59,"_39":1979,"_13":162,"_34":20,"_36":1980,"_24":25,"_164":-5,"_769":1981,"_27":1982},{"_44":1967,"_32":1968,"_30":1969,"_158":1505,"_42":43,"_41":1970,"_160":59,"_39":1971,"_13":162,"_34":20,"_36":1972,"_24":25,"_164":-5,"_769":1973,"_27":1974},{"_44":1959,"_32":1960,"_30":1961,"_158":1505,"_42":43,"_41":1962,"_160":59,"_39":1963,"_13":162,"_34":20,"_36":1964,"_24":25,"_164":-5,"_769":1965,"_27":1966},{"_44":1952,"_32":1376,"_30":1953,"_158":1505,"_42":43,"_41":1954,"_160":59,"_39":1955,"_13":162,"_34":20,"_36":1956,"_24":25,"_164":-5,"_769":1957,"_27":1958},{"_44":1944,"_32":1945,"_30":1946,"_158":1505,"_42":43,"_41":1947,"_160":59,"_39":1948,"_13":162,"_34":20,"_36":1949,"_24":25,"_164":-5,"_769":1950,"_27":1951},{"_44":1936,"_32":1937,"_30":1938,"_158":1505,"_42":43,"_41":1939,"_160":59,"_39":1940,"_13":162,"_34":20,"_36":1941,"_24":25,"_164":-5,"_769":1942,"_27":1943},{"_44":1928,"_32":1929,"_30":1930,"_158":1505,"_42":43,"_41":1931,"_160":59,"_39":1932,"_13":162,"_34":20,"_36":1933,"_24":25,"_164":-5,"_769":1934,"_27":1935},{"_44":1920,"_32":1921,"_30":1922,"_158":1505,"_42":43,"_41":1923,"_160":59,"_39":1924,"_13":162,"_34":20,"_36":1925,"_24":25,"_164":-5,"_769":1926,"_27":1927},{"_44":1912,"_32":1913,"_30":1914,"_158":1505,"_42":43,"_41":1915,"_160":59,"_39":1916,"_13":162,"_34":20,"_36":1917,"_24":25,"_164":-5,"_769":1918,"_27":1919},{"_44":1904,"_32":1905,"_30":1906,"_158":1505,"_42":43,"_41":1907,"_160":59,"_39":1908,"_13":162,"_34":20,"_36":1909,"_24":25,"_164":-5,"_769":1910,"_27":1911},{"_44":1896,"_32":1897,"_30":1898,"_158":1505,"_42":43,"_41":1899,"_160":59,"_39":1900,"_13":162,"_34":20,"_36":1901,"_24":25,"_164":-5,"_769":1902,"_27":1903},{"_44":1888,"_32":1889,"_30":1890,"_158":1505,"_42":43,"_41":1891,"_160":59,"_39":1892,"_13":162,"_34":20,"_36":1893,"_24":25,"_164":-5,"_769":1894,"_27":1895},{"_44":1880,"_32":1881,"_30":1882,"_158":1505,"_42":43,"_41":1883,"_160":59,"_39":1884,"_13":162,"_34":20,"_36":1885,"_24":25,"_164":-5,"_769":1886,"_27":1887},{"_44":1872,"_32":1873,"_30":1874,"_158":1505,"_42":43,"_41":1875,"_160":59,"_39":1876,"_13":162,"_34":20,"_36":1877,"_24":25,"_164":-5,"_769":1878,"_27":1879},{"_44":1864,"_32":1865,"_30":1866,"_158":1505,"_42":43,"_41":1867,"_160":59,"_39":1868,"_13":162,"_34":20,"_36":1869,"_24":25,"_164":-5,"_769":1870,"_27":1871},{"_44":1856,"_32":1857,"_30":1858,"_158":1505,"_42":43,"_41":1859,"_160":59,"_39":1860,"_13":162,"_34":20,"_36":1861,"_24":25,"_164":-5,"_769":1862,"_27":1863},{"_44":1848,"_32":1849,"_30":1850,"_158":1505,"_42":43,"_41":1851,"_160":59,"_39":1852,"_13":162,"_34":20,"_36":1853,"_24":25,"_164":-5,"_769":1854,"_27":1855},{"_44":1840,"_32":1841,"_30":1842,"_158":1505,"_42":43,"_41":1843,"_160":59,"_39":1844,"_13":162,"_34":20,"_36":1845,"_24":25,"_164":-5,"_769":1846,"_27":1847},{"_44":1832,"_32":1833,"_30":1834,"_158":1505,"_42":43,"_41":1835,"_160":59,"_39":1836,"_13":162,"_34":20,"_36":1837,"_24":25,"_164":-5,"_769":1838,"_27":1839},{"_44":1824,"_32":1825,"_30":1826,"_158":1505,"_42":43,"_41":1827,"_160":59,"_39":1828,"_13":162,"_34":20,"_36":1829,"_24":25,"_164":-5,"_769":1830,"_27":1831},{"_44":1816,"_32":1817,"_30":1818,"_158":1505,"_42":43,"_41":1819,"_160":59,"_39":1820,"_13":162,"_34":20,"_36":1821,"_24":25,"_164":-5,"_769":1822,"_27":1823},{"_44":1808,"_32":1809,"_30":1810,"_158":1505,"_42":43,"_41":1811,"_160":59,"_39":1812,"_13":162,"_34":20,"_36":1813,"_24":25,"_164":-5,"_769":1814,"_27":1815},{"_44":1800,"_32":1801,"_30":1802,"_158":1505,"_42":43,"_41":1803,"_160":59,"_39":1804,"_13":162,"_34":20,"_36":1805,"_24":25,"_164":-5,"_769":1806,"_27":1807},{"_44":1792,"_32":1793,"_30":1794,"_158":1505,"_42":43,"_41":1795,"_160":59,"_39":1796,"_13":162,"_34":20,"_36":1797,"_24":25,"_164":-5,"_769":1798,"_27":1799},{"_44":1784,"_32":1785,"_30":1786,"_158":1505,"_42":43,"_41":1787,"_160":59,"_39":1788,"_13":162,"_34":20,"_36":1789,"_24":25,"_164":-5,"_769":1790,"_27":1791},{"_44":1776,"_32":1777,"_30":1778,"_158":1505,"_42":43,"_41":1779,"_160":59,"_39":1780,"_13":162,"_34":20,"_36":1781,"_24":25,"_164":-5,"_769":1782,"_27":1783},{"_44":1768,"_32":1769,"_30":1770,"_158":1505,"_42":43,"_41":1771,"_160":59,"_39":1772,"_13":162,"_34":20,"_36":1773,"_24":25,"_164":-5,"_769":1774,"_27":1775},{"_44":1760,"_32":1761,"_30":1762,"_158":1505,"_42":43,"_41":1763,"_160":59,"_39":1764,"_13":162,"_34":20,"_36":1765,"_24":25,"_164":-5,"_769":1766,"_27":1767},{"_44":1752,"_32":1753,"_30":1754,"_158":1505,"_42":43,"_41":1755,"_160":59,"_39":1756,"_13":162,"_34":20,"_36":1757,"_24":25,"_164":-5,"_769":1758,"_27":1759},{"_44":1744,"_32":1745,"_30":1746,"_158":1505,"_42":43,"_41":1747,"_160":59,"_39":1748,"_13":162,"_34":20,"_36":1749,"_24":25,"_164":-5,"_769":1750,"_27":1751},{"_44":1736,"_32":1737,"_30":1738,"_158":1505,"_42":43,"_41":1739,"_160":59,"_39":1740,"_13":162,"_34":20,"_36":1741,"_24":25,"_164":-5,"_769":1742,"_27":1743},{"_44":1728,"_32":1729,"_30":1730,"_158":1505,"_42":43,"_41":1731,"_160":59,"_39":1732,"_13":162,"_34":20,"_36":1733,"_24":25,"_164":-5,"_769":1734,"_27":1735},{"_44":1720,"_32":1721,"_30":1722,"_158":1505,"_42":43,"_41":1723,"_160":59,"_39":1724,"_13":162,"_34":20,"_36":1725,"_24":25,"_164":-5,"_769":1726,"_27":1727},{"_44":1712,"_32":1713,"_30":1714,"_158":1505,"_42":43,"_41":1715,"_160":59,"_39":1716,"_13":162,"_34":20,"_36":1717,"_24":25,"_164":-5,"_769":1718,"_27":1719},{"_44":1704,"_32":1705,"_30":1706,"_158":1505,"_42":43,"_41":1707,"_160":59,"_39":1708,"_13":162,"_34":20,"_36":1709,"_24":25,"_164":-5,"_769":1710,"_27":1711},{"_44":1696,"_32":1697,"_30":1698,"_158":1505,"_42":43,"_41":1699,"_160":59,"_39":1700,"_13":162,"_34":20,"_36":1701,"_24":25,"_164":-5,"_769":1702,"_27":1703},{"_44":1688,"_32":1689,"_30":1690,"_158":1505,"_42":43,"_41":1691,"_160":59,"_39":1692,"_13":162,"_34":20,"_36":1693,"_24":25,"_164":-5,"_769":1694,"_27":1695},{"_44":1680,"_32":1681,"_30":1682,"_158":1505,"_42":43,"_41":1683,"_160":59,"_39":1684,"_13":162,"_34":20,"_36":1685,"_24":25,"_164":-5,"_769":1686,"_27":1687},{"_44":1672,"_32":1673,"_30":1674,"_158":1505,"_42":43,"_41":1675,"_160":59,"_39":1676,"_13":162,"_34":20,"_36":1677,"_24":25,"_164":-5,"_769":1678,"_27":1679},{"_44":1664,"_32":1665,"_30":1666,"_158":1505,"_42":43,"_41":1667,"_160":59,"_39":1668,"_13":162,"_34":20,"_36":1669,"_24":25,"_164":-5,"_769":1670,"_27":1671},{"_44":1656,"_32":1657,"_30":1658,"_158":1505,"_42":43,"_41":1659,"_160":59,"_39":1660,"_13":162,"_34":20,"_36":1661,"_24":25,"_164":-5,"_769":1662,"_27":1663},{"_44":1648,"_32":1649,"_30":1650,"_158":1505,"_42":43,"_41":1651,"_160":59,"_39":1652,"_13":162,"_34":20,"_36":1653,"_24":25,"_164":-5,"_769":1654,"_27":1655},{"_44":1640,"_32":1641,"_30":1642,"_158":1505,"_42":43,"_41":1643,"_160":59,"_39":1644,"_13":162,"_34":20,"_36":1645,"_24":25,"_164":-5,"_769":1646,"_27":1647},{"_44":1632,"_32":1633,"_30":1634,"_158":1505,"_42":43,"_41":1635,"_160":59,"_39":1636,"_13":162,"_34":20,"_36":1637,"_24":25,"_164":-5,"_769":1638,"_27":1639},{"_44":1624,"_32":1625,"_30":1626,"_158":1505,"_42":43,"_41":1627,"_160":59,"_39":1628,"_13":162,"_34":20,"_36":1629,"_24":25,"_164":-5,"_769":1630,"_27":1631},{"_44":1616,"_32":1617,"_30":1618,"_158":1505,"_42":43,"_41":1619,"_160":59,"_39":1620,"_13":162,"_34":20,"_36":1621,"_24":25,"_164":-5,"_769":1622,"_27":1623},{"_44":1608,"_32":1609,"_30":1610,"_158":1505,"_42":43,"_41":1611,"_160":59,"_39":1612,"_13":162,"_34":20,"_36":1613,"_24":25,"_164":-5,"_769":1614,"_27":1615},{"_44":1600,"_32":1601,"_30":1602,"_158":1505,"_42":43,"_41":1603,"_160":59,"_39":1604,"_13":162,"_34":20,"_36":1605,"_24":25,"_164":-5,"_769":1606,"_27":1607},{"_44":1592,"_32":1593,"_30":1594,"_158":1505,"_42":43,"_41":1595,"_160":59,"_39":1596,"_13":162,"_34":20,"_36":1597,"_24":25,"_164":-5,"_769":1598,"_27":1599},{"_44":1584,"_32":1585,"_30":1586,"_158":1505,"_42":43,"_41":1587,"_160":59,"_39":1588,"_13":162,"_34":20,"_36":1589,"_24":25,"_164":-5,"_769":1590,"_27":1591},{"_44":1576,"_32":1577,"_30":1578,"_158":1505,"_42":43,"_41":1579,"_160":59,"_39":1580,"_13":162,"_34":20,"_36":1581,"_24":25,"_164":-5,"_769":1582,"_27":1583},{"_44":1568,"_32":1569,"_30":1570,"_158":1505,"_42":43,"_41":1571,"_160":59,"_39":1572,"_13":162,"_34":20,"_36":1573,"_24":25,"_164":-5,"_769":1574,"_27":1575},{"_44":1560,"_32":1561,"_30":1562,"_158":1505,"_42":43,"_41":1563,"_160":59,"_39":1564,"_13":162,"_34":20,"_36":1565,"_24":25,"_164":-5,"_769":1566,"_27":1567},{"_44":1552,"_32":1553,"_30":1554,"_158":1505,"_42":43,"_41":1555,"_160":59,"_39":1556,"_13":162,"_34":20,"_36":1557,"_24":25,"_164":-5,"_769":1558,"_27":1559},{"_44":1544,"_32":1545,"_30":1546,"_158":1505,"_42":43,"_41":1547,"_160":59,"_39":1548,"_13":162,"_34":20,"_36":1549,"_24":25,"_164":-5,"_769":1550,"_27":1551},{"_44":1536,"_32":1537,"_30":1538,"_158":1505,"_42":43,"_41":1539,"_160":59,"_39":1540,"_13":162,"_34":20,"_36":1541,"_24":25,"_164":-5,"_769":1542,"_27":1543},{"_44":1528,"_32":1529,"_30":1530,"_158":1505,"_42":43,"_41":1531,"_160":59,"_39":1532,"_13":162,"_34":20,"_36":1533,"_24":25,"_164":-5,"_769":1534,"_27":1535},{"_44":1520,"_32":1521,"_30":1522,"_158":1505,"_42":43,"_41":1523,"_160":59,"_39":1524,"_13":162,"_34":20,"_36":1525,"_24":25,"_164":-5,"_769":1526,"_27":1527},{"_44":1512,"_32":1513,"_30":1514,"_158":1505,"_42":43,"_41":1515,"_160":59,"_39":1516,"_13":162,"_34":20,"_36":1517,"_24":25,"_164":-5,"_769":1518,"_27":1519},{"_44":1502,"_32":1503,"_30":1504,"_158":1505,"_42":43,"_41":1506,"_160":59,"_39":1507,"_13":162,"_34":20,"_36":1508,"_24":25,"_164":-5,"_769":1509,"_27":1510},{"_44":1497,"_32":1465,"_30":1460,"_158":1044,"_42":43,"_41":1498,"_160":59,"_39":1499,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":1500,"_27":1501},{"_44":1490,"_32":1034,"_30":1491,"_158":1460,"_42":43,"_41":1492,"_160":59,"_39":1493,"_13":162,"_34":20,"_36":1494,"_24":25,"_164":-5,"_769":1495,"_27":1496},{"_44":1482,"_32":1483,"_30":1484,"_158":1460,"_42":43,"_41":1485,"_160":59,"_39":1486,"_13":162,"_34":20,"_36":1487,"_24":25,"_164":-5,"_769":1488,"_27":1489},{"_44":1474,"_32":1475,"_30":1476,"_158":1460,"_42":43,"_41":1477,"_160":59,"_39":1478,"_13":162,"_34":20,"_36":1479,"_24":25,"_164":-5,"_769":1480,"_27":1481},{"_44":1466,"_32":1467,"_30":1468,"_158":1460,"_42":43,"_41":1469,"_160":59,"_39":1470,"_13":162,"_34":20,"_36":1471,"_24":25,"_164":-5,"_769":1472,"_27":1473},{"_44":1458,"_32":1008,"_30":1459,"_158":1460,"_42":43,"_41":1461,"_160":59,"_39":1462,"_13":162,"_34":20,"_36":1434,"_24":25,"_164":-5,"_769":1463,"_27":1464},{"_44":1453,"_32":1437,"_30":1431,"_158":1044,"_42":43,"_41":1454,"_160":59,"_39":1455,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":1456,"_27":1457},{"_44":1446,"_32":1034,"_30":1447,"_158":1431,"_42":43,"_41":1448,"_160":59,"_39":1449,"_13":162,"_34":20,"_36":1450,"_24":25,"_164":-5,"_769":1451,"_27":1452},{"_44":1438,"_32":1439,"_30":1440,"_158":1431,"_42":43,"_41":1441,"_160":59,"_39":1442,"_13":162,"_34":20,"_36":1443,"_24":25,"_164":-5,"_769":1444,"_27":1445},{"_44":1429,"_32":1008,"_30":1430,"_158":1431,"_42":43,"_41":1432,"_160":59,"_39":1433,"_13":162,"_34":20,"_36":1434,"_24":25,"_164":-5,"_769":1435,"_27":1436},{"_44":1424,"_32":1384,"_30":1378,"_158":1044,"_42":43,"_41":1425,"_160":59,"_39":1426,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":1427,"_27":1428},{"_44":1417,"_32":1034,"_30":1418,"_158":1378,"_42":43,"_41":1419,"_160":59,"_39":1420,"_13":162,"_34":20,"_36":1421,"_24":25,"_164":-5,"_769":1422,"_27":1423},{"_44":1409,"_32":1410,"_30":1411,"_158":1378,"_42":43,"_41":1412,"_160":59,"_39":1413,"_13":162,"_34":20,"_36":1414,"_24":25,"_164":-5,"_769":1415,"_27":1416},{"_44":1401,"_32":1402,"_30":1403,"_158":1378,"_42":43,"_41":1404,"_160":59,"_39":1405,"_13":162,"_34":20,"_36":1406,"_24":25,"_164":-5,"_769":1407,"_27":1408},{"_44":1393,"_32":1394,"_30":1395,"_158":1378,"_42":43,"_41":1396,"_160":59,"_39":1397,"_13":162,"_34":20,"_36":1398,"_24":25,"_164":-5,"_769":1399,"_27":1400},{"_44":1385,"_32":1386,"_30":1387,"_158":1378,"_42":43,"_41":1388,"_160":59,"_39":1389,"_13":162,"_34":20,"_36":1390,"_24":25,"_164":-5,"_769":1391,"_27":1392},{"_44":1375,"_32":1376,"_30":1377,"_158":1378,"_42":43,"_41":1379,"_160":59,"_39":1380,"_13":162,"_34":20,"_36":1381,"_24":25,"_164":-5,"_769":1382,"_27":1383},{"_44":1370,"_32":1067,"_30":1061,"_158":1044,"_42":43,"_41":1371,"_160":59,"_39":1372,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":1373,"_27":1374},{"_44":1365,"_32":1301,"_30":1295,"_158":1061,"_42":43,"_41":1366,"_160":59,"_39":1367,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":1368,"_27":1369},{"_44":1360,"_32":1351,"_30":1345,"_158":1295,"_42":43,"_41":1361,"_160":59,"_39":1362,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":1363,"_27":1364},{"_44":1352,"_32":1353,"_30":1354,"_158":1345,"_42":43,"_41":1355,"_160":59,"_39":1356,"_13":162,"_34":20,"_36":1357,"_24":25,"_164":-5,"_769":1358,"_27":1359},{"_44":1342,"_32":1343,"_30":1344,"_158":1345,"_42":43,"_41":1346,"_160":59,"_39":1347,"_13":162,"_34":20,"_36":1348,"_24":25,"_164":-5,"_769":1349,"_27":1350},{"_44":1334,"_32":1335,"_30":1336,"_158":1295,"_42":43,"_41":1337,"_160":59,"_39":1338,"_13":162,"_34":20,"_36":1339,"_24":25,"_164":-5,"_769":1340,"_27":1341},{"_44":1326,"_32":1327,"_30":1328,"_158":1295,"_42":43,"_41":1329,"_160":59,"_39":1330,"_13":162,"_34":20,"_36":1331,"_24":25,"_164":-5,"_769":1332,"_27":1333},{"_44":1318,"_32":1319,"_30":1320,"_158":1295,"_42":43,"_41":1321,"_160":59,"_39":1322,"_13":162,"_34":20,"_36":1323,"_24":25,"_164":-5,"_769":1324,"_27":1325},{"_44":1310,"_32":1311,"_30":1312,"_158":1295,"_42":43,"_41":1313,"_160":59,"_39":1314,"_13":162,"_34":20,"_36":1315,"_24":25,"_164":-5,"_769":1316,"_27":1317},{"_44":1302,"_32":1303,"_30":1304,"_158":1295,"_42":43,"_41":1305,"_160":59,"_39":1306,"_13":162,"_34":20,"_36":1307,"_24":25,"_164":-5,"_769":1308,"_27":1309},{"_44":1292,"_32":1293,"_30":1294,"_158":1295,"_42":43,"_41":1296,"_160":59,"_39":1297,"_13":162,"_34":20,"_36":1298,"_24":25,"_164":-5,"_769":1299,"_27":1300},{"_44":1287,"_32":1263,"_30":1257,"_158":1061,"_42":43,"_41":1288,"_160":59,"_39":1289,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":1290,"_27":1291},{"_44":1282,"_32":1273,"_30":1267,"_158":1257,"_42":43,"_41":1283,"_160":59,"_39":1284,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":1285,"_27":1286},{"_44":1274,"_32":1275,"_30":1276,"_158":1267,"_42":43,"_41":1277,"_160":59,"_39":1278,"_13":162,"_34":20,"_36":1279,"_24":25,"_164":-5,"_769":1280,"_27":1281},{"_44":1264,"_32":1265,"_30":1266,"_158":1267,"_42":43,"_41":1268,"_160":59,"_39":1269,"_13":162,"_34":20,"_36":1270,"_24":25,"_164":-5,"_769":1271,"_27":1272},{"_44":1254,"_32":1255,"_30":1256,"_158":1257,"_42":43,"_41":1258,"_160":59,"_39":1259,"_13":162,"_34":20,"_36":1260,"_24":25,"_164":-5,"_769":1261,"_27":1262},{"_44":1249,"_32":1156,"_30":1150,"_158":1061,"_42":43,"_41":1250,"_160":59,"_39":1251,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":1252,"_27":1253},{"_44":1242,"_32":1034,"_30":1243,"_158":1150,"_42":43,"_41":1244,"_160":59,"_39":1245,"_13":162,"_34":20,"_36":1246,"_24":25,"_164":-5,"_769":1247,"_27":1248},{"_44":1235,"_32":1117,"_30":1236,"_158":1150,"_42":43,"_41":1237,"_160":59,"_39":1238,"_13":162,"_34":20,"_36":1239,"_24":25,"_164":-5,"_769":1240,"_27":1241},{"_44":1227,"_32":1228,"_30":1229,"_158":1150,"_42":43,"_41":1230,"_160":59,"_39":1231,"_13":162,"_34":20,"_36":1232,"_24":25,"_164":-5,"_769":1233,"_27":1234},{"_44":1219,"_32":1220,"_30":1221,"_158":1150,"_42":43,"_41":1222,"_160":59,"_39":1223,"_13":162,"_34":20,"_36":1224,"_24":25,"_164":-5,"_769":1225,"_27":1226},{"_44":1212,"_32":1069,"_30":1213,"_158":1150,"_42":43,"_41":1214,"_160":59,"_39":1215,"_13":162,"_34":20,"_36":1216,"_24":25,"_164":-5,"_769":1217,"_27":1218},{"_44":1205,"_32":1059,"_30":1206,"_158":1150,"_42":43,"_41":1207,"_160":59,"_39":1208,"_13":162,"_34":20,"_36":1209,"_24":25,"_164":-5,"_769":1210,"_27":1211},{"_44":1197,"_32":1198,"_30":1199,"_158":1150,"_42":43,"_41":1200,"_160":59,"_39":1201,"_13":162,"_34":20,"_36":1202,"_24":25,"_164":-5,"_769":1203,"_27":1204},{"_44":1189,"_32":1190,"_30":1191,"_158":1150,"_42":43,"_41":1192,"_160":59,"_39":1193,"_13":162,"_34":20,"_36":1194,"_24":25,"_164":-5,"_769":1195,"_27":1196},{"_44":1181,"_32":1182,"_30":1183,"_158":1150,"_42":43,"_41":1184,"_160":59,"_39":1185,"_13":162,"_34":20,"_36":1186,"_24":25,"_164":-5,"_769":1187,"_27":1188},{"_44":1173,"_32":1174,"_30":1175,"_158":1150,"_42":43,"_41":1176,"_160":59,"_39":1177,"_13":162,"_34":20,"_36":1178,"_24":25,"_164":-5,"_769":1179,"_27":1180},{"_44":1165,"_32":1166,"_30":1167,"_158":1150,"_42":43,"_41":1168,"_160":59,"_39":1169,"_13":162,"_34":20,"_36":1170,"_24":25,"_164":-5,"_769":1171,"_27":1172},{"_44":1157,"_32":1158,"_30":1159,"_158":1150,"_42":43,"_41":1160,"_160":59,"_39":1161,"_13":162,"_34":20,"_36":1162,"_24":25,"_164":-5,"_769":1163,"_27":1164},{"_44":1147,"_32":1148,"_30":1149,"_158":1150,"_42":43,"_41":1151,"_160":59,"_39":1152,"_13":162,"_34":20,"_36":1153,"_24":25,"_164":-5,"_769":1154,"_27":1155},{"_44":1140,"_32":1034,"_30":1141,"_158":1061,"_42":43,"_41":1142,"_160":59,"_39":1143,"_13":162,"_34":20,"_36":1144,"_24":25,"_164":-5,"_769":1145,"_27":1146},{"_44":1132,"_32":1133,"_30":1134,"_158":1061,"_42":43,"_41":1135,"_160":59,"_39":1136,"_13":162,"_34":20,"_36":1137,"_24":25,"_164":-5,"_769":1138,"_27":1139},{"_44":1124,"_32":1125,"_30":1126,"_158":1061,"_42":43,"_41":1127,"_160":59,"_39":1128,"_13":162,"_34":20,"_36":1129,"_24":25,"_164":-5,"_769":1130,"_27":1131},{"_44":1116,"_32":1117,"_30":1118,"_158":1061,"_42":43,"_41":1119,"_160":59,"_39":1120,"_13":162,"_34":20,"_36":1121,"_24":25,"_164":-5,"_769":1122,"_27":1123},{"_44":1108,"_32":1109,"_30":1110,"_158":1061,"_42":43,"_41":1111,"_160":59,"_39":1112,"_13":162,"_34":20,"_36":1113,"_24":25,"_164":-5,"_769":1114,"_27":1115},{"_44":1100,"_32":1101,"_30":1102,"_158":1061,"_42":43,"_41":1103,"_160":59,"_39":1104,"_13":162,"_34":20,"_36":1105,"_24":25,"_164":-5,"_769":1106,"_27":1107},{"_44":1092,"_32":1093,"_30":1094,"_158":1061,"_42":43,"_41":1095,"_160":59,"_39":1096,"_13":162,"_34":20,"_36":1097,"_24":25,"_164":-5,"_769":1098,"_27":1099},{"_44":1084,"_32":1085,"_30":1086,"_158":1061,"_42":43,"_41":1087,"_160":59,"_39":1088,"_13":162,"_34":20,"_36":1089,"_24":25,"_164":-5,"_769":1090,"_27":1091},{"_44":1076,"_32":1077,"_30":1078,"_158":1061,"_42":43,"_41":1079,"_160":59,"_39":1080,"_13":162,"_34":20,"_36":1081,"_24":25,"_164":-5,"_769":1082,"_27":1083},{"_44":1068,"_32":1069,"_30":1070,"_158":1061,"_42":43,"_41":1071,"_160":59,"_39":1072,"_13":162,"_34":20,"_36":1073,"_24":25,"_164":-5,"_769":1074,"_27":1075},{"_44":1058,"_32":1059,"_30":1060,"_158":1061,"_42":43,"_41":1062,"_160":59,"_39":1063,"_13":162,"_34":20,"_36":1064,"_24":25,"_164":-5,"_769":1065,"_27":1066},{"_44":1051,"_32":1034,"_30":1052,"_158":1044,"_42":43,"_41":1053,"_160":59,"_39":1054,"_13":162,"_34":20,"_36":1055,"_24":25,"_164":-5,"_769":1056,"_27":1057},{"_44":1041,"_32":1042,"_30":1043,"_158":1044,"_42":43,"_41":1045,"_160":59,"_39":1046,"_13":162,"_34":20,"_36":1047,"_24":25,"_164":-5,"_769":1048,"_27":1049},{"_44":1033,"_32":1034,"_30":1035,"_158":1010,"_42":43,"_41":1036,"_160":59,"_39":1037,"_13":162,"_34":20,"_36":1038,"_24":25,"_164":-5,"_769":1039,"_27":1040},{"_44":1025,"_32":1026,"_30":1027,"_158":1010,"_42":43,"_41":1028,"_160":59,"_39":1029,"_13":162,"_34":20,"_36":1030,"_24":25,"_164":-5,"_769":1031,"_27":1032},{"_44":1017,"_32":1018,"_30":1019,"_158":1010,"_42":43,"_41":1020,"_160":59,"_39":1021,"_13":162,"_34":20,"_36":1022,"_24":25,"_164":-5,"_769":1023,"_27":1024},{"_44":1007,"_32":1008,"_30":1009,"_158":1010,"_42":43,"_41":1011,"_160":59,"_39":1012,"_13":162,"_34":20,"_36":1013,"_24":25,"_164":-5,"_769":1014,"_27":1015},{"_44":1002,"_32":939,"_30":933,"_158":913,"_42":43,"_41":1003,"_160":59,"_39":1004,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":1005,"_27":1006},{"_44":997,"_32":988,"_30":982,"_158":933,"_42":43,"_41":998,"_160":59,"_39":999,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":1000,"_27":1001},{"_44":989,"_32":990,"_30":991,"_158":982,"_42":43,"_41":992,"_160":59,"_39":993,"_13":162,"_34":20,"_36":994,"_24":25,"_164":-5,"_769":995,"_27":996},{"_44":979,"_32":980,"_30":981,"_158":982,"_42":43,"_41":983,"_160":59,"_39":984,"_13":162,"_34":20,"_36":985,"_24":25,"_164":-5,"_769":986,"_27":987},{"_44":972,"_32":973,"_30":974,"_158":933,"_42":43,"_41":975,"_160":59,"_39":976,"_13":162,"_34":20,"_36":936,"_24":25,"_164":-5,"_769":977,"_27":978},{"_44":964,"_32":965,"_30":966,"_158":933,"_42":43,"_41":967,"_160":59,"_39":968,"_13":162,"_34":20,"_36":969,"_24":25,"_164":-5,"_769":970,"_27":971},{"_44":956,"_32":957,"_30":958,"_158":933,"_42":43,"_41":959,"_160":59,"_39":960,"_13":162,"_34":20,"_36":961,"_24":25,"_164":-5,"_769":962,"_27":963},{"_44":948,"_32":949,"_30":950,"_158":933,"_42":43,"_41":951,"_160":59,"_39":952,"_13":162,"_34":20,"_36":953,"_24":25,"_164":-5,"_769":954,"_27":955},{"_44":940,"_32":941,"_30":942,"_158":933,"_42":43,"_41":943,"_160":59,"_39":944,"_13":162,"_34":20,"_36":945,"_24":25,"_164":-5,"_769":946,"_27":947},{"_44":930,"_32":931,"_30":932,"_158":933,"_42":43,"_41":934,"_160":59,"_39":935,"_13":162,"_34":20,"_36":936,"_24":25,"_164":-5,"_769":937,"_27":938},{"_44":922,"_32":923,"_30":924,"_158":913,"_42":43,"_41":925,"_160":59,"_39":926,"_13":162,"_34":20,"_36":927,"_24":25,"_164":-5,"_769":928,"_27":929},{"_44":910,"_32":911,"_30":912,"_158":913,"_42":43,"_41":914,"_160":59,"_39":915,"_13":162,"_34":20,"_36":916,"_24":25,"_164":-5,"_769":917,"_27":918},{"_44":903,"_32":182,"_30":904,"_158":214,"_42":43,"_41":905,"_160":59,"_39":906,"_13":162,"_34":20,"_36":907,"_24":25,"_164":-5,"_769":908,"_27":909},{"_44":895,"_32":896,"_30":897,"_158":214,"_42":43,"_41":898,"_160":59,"_39":899,"_13":162,"_34":20,"_36":900,"_24":25,"_164":-5,"_769":901,"_27":902},{"_44":887,"_32":888,"_30":889,"_158":214,"_42":43,"_41":890,"_160":59,"_39":891,"_13":162,"_34":20,"_36":892,"_24":25,"_164":-5,"_769":893,"_27":894},{"_44":207,"_32":208,"_30":209,"_158":-5,"_42":43,"_41":63,"_160":59,"_39":884,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":885,"_27":886},{"_44":880,"_32":879,"_30":875,"_158":209,"_42":43,"_41":186,"_160":59,"_39":881,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":882,"_27":883},{"_44":874,"_32":33,"_30":31,"_158":875,"_42":43,"_41":14,"_160":25,"_39":876,"_13":159,"_34":35,"_36":38,"_24":25,"_164":-5,"_769":877,"_27":878},{"_44":866,"_32":867,"_30":57,"_158":209,"_42":43,"_41":868,"_160":59,"_39":869,"_13":221,"_34":870,"_36":871,"_24":25,"_164":46,"_769":872,"_27":873},{"_44":201,"_32":202,"_30":203,"_158":-5,"_42":43,"_41":204,"_160":59,"_39":863,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":864,"_27":865},{"_44":196,"_32":197,"_30":198,"_158":-5,"_42":43,"_41":63,"_160":59,"_39":860,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":861,"_27":862},{"_44":856,"_32":847,"_30":841,"_158":198,"_42":43,"_41":63,"_160":59,"_39":857,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":858,"_27":859},{"_44":848,"_32":849,"_30":850,"_158":841,"_42":43,"_41":851,"_160":59,"_39":852,"_13":63,"_34":35,"_36":853,"_24":25,"_164":-5,"_769":854,"_27":855},{"_44":838,"_32":839,"_30":840,"_158":841,"_42":43,"_41":842,"_160":59,"_39":843,"_13":63,"_34":35,"_36":844,"_24":25,"_164":-5,"_769":845,"_27":846},{"_44":830,"_32":831,"_30":832,"_158":198,"_42":43,"_41":833,"_160":59,"_39":834,"_13":63,"_34":20,"_36":835,"_24":25,"_164":-5,"_769":836,"_27":837},{"_44":822,"_32":823,"_30":824,"_158":198,"_42":43,"_41":825,"_160":59,"_39":826,"_13":63,"_34":20,"_36":827,"_24":25,"_164":-5,"_769":828,"_27":829},{"_44":815,"_32":816,"_30":817,"_158":198,"_42":43,"_41":63,"_160":59,"_39":818,"_13":162,"_34":35,"_36":819,"_24":25,"_164":-5,"_769":820,"_27":821},{"_44":807,"_32":808,"_30":809,"_158":198,"_42":43,"_41":810,"_160":25,"_39":811,"_13":63,"_34":20,"_36":812,"_24":25,"_164":-5,"_769":813,"_27":814},{"_44":189,"_32":190,"_30":191,"_158":-5,"_42":43,"_41":192,"_160":59,"_39":804,"_13":162,"_34":194,"_36":-5,"_24":25,"_164":-5,"_769":805,"_27":806},{"_44":797,"_32":167,"_30":798,"_158":191,"_42":43,"_41":799,"_160":59,"_39":800,"_13":162,"_34":20,"_36":801,"_24":25,"_164":-5,"_769":802,"_27":803},{"_44":789,"_32":790,"_30":791,"_158":191,"_42":43,"_41":792,"_160":59,"_39":793,"_13":162,"_34":20,"_36":794,"_24":25,"_164":-5,"_769":795,"_27":796},{"_44":781,"_32":782,"_30":783,"_158":191,"_42":43,"_41":784,"_160":59,"_39":785,"_13":162,"_34":20,"_36":786,"_24":25,"_164":-5,"_769":787,"_27":788},{"_44":181,"_32":182,"_30":183,"_158":-5,"_42":43,"_41":184,"_160":59,"_39":778,"_13":186,"_34":20,"_36":187,"_24":25,"_164":-5,"_769":779,"_27":780},{"_44":173,"_32":174,"_30":175,"_158":-5,"_42":43,"_41":176,"_160":59,"_39":775,"_13":178,"_34":20,"_36":179,"_24":25,"_164":-5,"_769":776,"_27":777},{"_44":166,"_32":167,"_30":168,"_158":-5,"_42":43,"_41":169,"_160":59,"_39":772,"_13":63,"_34":20,"_36":171,"_24":25,"_164":-5,"_769":773,"_27":774},{"_44":155,"_32":156,"_30":157,"_158":-5,"_42":43,"_41":159,"_160":59,"_39":768,"_13":162,"_34":20,"_36":163,"_24":25,"_164":-5,"_769":770,"_27":771},["D",1753295286180],"children",[],[156],["D",1753295286718],[],[167],["D",1753299317259],[],[174],["D",1753299272550],[],[182],"03bcf472-67fc-11f0-a7d9-0224a6c84d84","extract_top_posts.py","03bcf558-67fc-11f0-a7d9-0224a6c84d84",108,["D",1753299254044],"#!/usr/bin/env python3\n\nimport os\nimport sqlite3\nimport sys\nfrom pathlib import Path\n\n\"\"\"\nThis script extracts the top 100 most popular posts (by score) and all their comments\nfrom AmItheAsshole.sqlite database to a new SQLite database file.\n\"\"\"\n\nSOURCE_DB_PATH = \"../db/AmItheAsshole.sqlite\"\nTARGET_DB_PATH = \"../db/top100.sqlite\"\n\n\ndef main():\n print(f\"Extracting top 100 posts from {SOURCE_DB_PATH} to {TARGET_DB_PATH}...\")\n\n # Check if source file exists before opening\n source_path = Path(SOURCE_DB_PATH)\n if not source_path.exists():\n print(f\"Error: Source database file not found: {SOURCE_DB_PATH}. Please ensure the file exists.\")\n sys.exit(1)\n elif not source_path.is_file():\n print(f\"Error: Source database path exists but is not a file: {SOURCE_DB_PATH}\")\n sys.exit(1)\n\n # Create directory for target database if needed\n target_dir = os.path.dirname(TARGET_DB_PATH)\n os.makedirs(target_dir, exist_ok=True)\n print(f\"Ensured directory {target_dir} exists.\")\n\n # Remove target file if it exists\n if os.path.exists(TARGET_DB_PATH):\n os.remove(TARGET_DB_PATH)\n print(\"Removed existing target database.\")\n\n try:\n # Open source database\n print(\"Opening source database...\")\n source_conn = sqlite3.connect(SOURCE_DB_PATH)\n source_conn.row_factory = sqlite3.Row # Use Row to access columns by name\n source_cursor = source_conn.cursor()\n print(\"Source database opened successfully.\")\n\n # Create target database\n print(\"Creating target database...\")\n target_conn = sqlite3.connect(TARGET_DB_PATH)\n target_conn.row_factory = sqlite3.Row\n target_cursor = target_conn.cursor()\n print(\"Target database created successfully.\")\n\n # Create tables in target database\n target_cursor.executescript(\"\"\"\n CREATE TABLE IF NOT EXISTS \"submission\" (\n \"id\" INTEGER NOT NULL PRIMARY KEY,\n \"submission_id\" VARCHAR(255) NOT NULL,\n \"title\" TEXT NOT NULL,\n \"selftext\" TEXT NOT NULL,\n \"created_utc\" DATE NOT NULL,\n \"permalink\" TEXT NOT NULL,\n \"score\" INTEGER NOT NULL\n );\n CREATE UNIQUE INDEX \"submission_submission_id\" ON \"submission\" (\"submission_id\");\n\n CREATE TABLE IF NOT EXISTS \"comment\" (\n \"id\" INTEGER NOT NULL PRIMARY KEY,\n \"submission_id\" INTEGER NOT NULL,\n \"message\" TEXT NOT NULL,\n \"comment_id\" VARCHAR(255) NOT NULL,\n \"parent_id\" VARCHAR(255) NOT NULL,\n \"created_utc\" DATE NOT NULL,\n \"score\" INTEGER NOT NULL,\n FOREIGN KEY (\"submission_id\") REFERENCES \"submission\" (\"id\")\n );\n CREATE INDEX \"comment_submission_id\" ON \"comment\" (\"submission_id\");\n CREATE UNIQUE INDEX \"comment_comment_id\" ON \"comment\" (\"comment_id\");\n \"\"\")\n print(\"Target database tables created.\")\n\n # Begin transaction for better performance and data integrity\n target_conn.execute('BEGIN TRANSACTION')\n\n # Get top 100 submissions by score\n source_cursor.execute(\"\"\"\n SELECT id, submission_id, title, selftext, created_utc, permalink, score \n FROM submission \n ORDER BY score DESC \n LIMIT 100\n \"\"\")\n top_submissions = source_cursor.fetchall()\n print(f\"Found {len(top_submissions)} top submissions.\")\n\n # Insert submissions into target database\n insert_submission_sql = \"\"\"\n INSERT INTO submission (id, submission_id, title, selftext, created_utc, permalink, score) \n VALUES (?, ?, ?, ?, ?, ?, ?)\n \"\"\"\n\n # Keep track of submission_id values (not the id field) for comment lookup\n submission_id_list = []\n for submission in top_submissions:\n # Convert from sqlite3.Row to tuple\n target_cursor.execute(\n insert_submission_sql, \n (\n submission['id'],\n submission['submission_id'],\n submission['title'],\n submission['selftext'],\n submission['created_utc'],\n submission['permalink'],\n submission['score']\n )\n )\n # Store the actual submission_id (Reddit ID) for comment lookup\n submission_id_list.append(submission['submission_id'])\n print(\"Inserted submissions into target database.\")\n\n # Get and insert comments for each submission\n total_comments = 0\n\n # Updated query to use submission_id instead of id\n get_comments_sql = \"\"\"\n SELECT c.id, c.submission_id, c.message, c.comment_id, c.parent_id, c.created_utc, c.score \n FROM comment c\n WHERE c.submission_id = ?\n \"\"\"\n\n insert_comment_sql = \"\"\"\n INSERT INTO comment (id, submission_id, message, comment_id, parent_id, created_utc, score) \n VALUES (?, ?, ?, ?, ?, ?, ?)\n \"\"\"\n\n for i, submission in enumerate(top_submissions):\n # Use the submission_id field (Reddit ID) to find comments\n reddit_submission_id = submission['submission_id']\n source_cursor.execute(get_comments_sql, (reddit_submission_id,))\n comments = source_cursor.fetchall()\n\n for comment in comments:\n target_cursor.execute(\n insert_comment_sql,\n (\n comment['id'],\n comment['submission_id'],\n comment['message'],\n comment['comment_id'],\n comment['parent_id'],\n comment['created_utc'],\n comment['score']\n )\n )\n\n total_comments += len(comments)\n print(f\"Processed {len(comments)} comments for submission '{reddit_submission_id}' (score: {submission['score']}).\")\n\n print(f\"Total comments processed: {total_comments}\")\n\n # Commit transaction\n target_conn.execute('COMMIT')\n print('Database transaction committed successfully.')\n\n # Close connections\n source_conn.close()\n target_conn.close()\n\n print(\"\\nExtraction complete!\")\n print(f\"Original database: {SOURCE_DB_PATH}\")\n print(f\"New database with top 100 posts: {TARGET_DB_PATH}\")\n print(f\"Total posts extracted: {len(top_submissions)}\")\n print(f\"Total comments extracted: {total_comments}\")\n\n except sqlite3.Error as e:\n print(f\"SQLite error: {e}\")\n try:\n # Try to rollback transaction if possible\n target_conn.execute('ROLLBACK')\n print('Transaction rolled back due to error.')\n except Exception as rollback_error:\n print(f\"Error during rollback: {rollback_error}\")\n sys.exit(1)\n except Exception as e:\n print(f\"Error during extraction: {e}\")\n sys.exit(1)\n\n\nif __name__ == \"__main__\":\n main()",[],[190,782],"03ba4cb8-67fc-11f0-8b06-0224a6c84d84","analyse_posts.py","03ba4d62-67fc-11f0-8b06-0224a6c84d84",107,["D",1753299254039],"#!/usr/bin/env python3\n\nimport os\nimport sqlite3\nimport sys\nimport re\nimport json\nfrom pathlib import Path\n\n\"\"\"\nThis script analyzes the top 100 posts from top100.sqlite and calculates\nthe percentage of comments that contain \"YTA\" (You're The Asshole).\nResults are stored in a new database with enhanced submission data and a JSONL file.\n\"\"\"\n\nSOURCE_DB_PATH = \"../db/top100.sqlite\"\nTARGET_DB_PATH = \"../db/top100_analyzed.sqlite\"\nOUTPUT_JSONL_PATH = \"../backend/data/top100_analyzed.jsonl\"\n\n\ndef contains_yta(comment_text):\n \"\"\"\n Check if a comment contains YTA (You're The Asshole).\n This looks for YTA as a standalone word to avoid false positives.\n \"\"\"\n if not comment_text:\n return False\n \n # Use regex to find YTA as a standalone word (case insensitive)\n # \\b ensures word boundaries to avoid matching \"YTAL\" or \"MYTA\" etc.\n pattern = r'\\bYTA\\b'\n return bool(re.search(pattern, comment_text, re.IGNORECASE))\n\n\ndef main():\n print(f\"Analyzing top 100 posts from {SOURCE_DB_PATH}...\")\n\n # Check if source file exists\n source_path = Path(SOURCE_DB_PATH)\n if not source_path.exists():\n print(f\"Error: Source database file not found: {SOURCE_DB_PATH}\")\n print(\"Please run extract_top_posts.py first to create the top100.sqlite database.\")\n sys.exit(1)\n\n # Create directory for target database if needed\n target_dir = os.path.dirname(TARGET_DB_PATH)\n os.makedirs(target_dir, exist_ok=True)\n print(f\"Ensured directory {target_dir} exists.\")\n\n # Remove target files if they exist\n if os.path.exists(TARGET_DB_PATH):\n os.remove(TARGET_DB_PATH)\n print(\"Removed existing target database.\")\n \n if os.path.exists(OUTPUT_JSONL_PATH):\n os.remove(OUTPUT_JSONL_PATH)\n print(\"Removed existing JSONL file.\")\n\n try:\n # Open source database\n print(\"Opening source database...\")\n source_conn = sqlite3.connect(SOURCE_DB_PATH)\n source_conn.row_factory = sqlite3.Row\n source_cursor = source_conn.cursor()\n print(\"Source database opened successfully.\")\n\n # Create target database\n print(\"Creating target database...\")\n target_conn = sqlite3.connect(TARGET_DB_PATH)\n target_conn.row_factory = sqlite3.Row\n target_cursor = target_conn.cursor()\n print(\"Target database created successfully.\")\n\n # Create enhanced submission table with YTA percentage - separate statements\n target_cursor.execute(\"\"\"\n CREATE TABLE IF NOT EXISTS \"submission_analysis\" (\n \"id\" INTEGER NOT NULL PRIMARY KEY,\n \"submission_id\" VARCHAR(255) NOT NULL,\n \"title\" TEXT NOT NULL,\n \"selftext\" TEXT NOT NULL,\n \"created_utc\" DATE NOT NULL,\n \"permalink\" TEXT NOT NULL,\n \"score\" INTEGER NOT NULL,\n \"total_comments\" INTEGER NOT NULL DEFAULT 0,\n \"yta_comments\" INTEGER NOT NULL DEFAULT 0,\n \"yta_percentage\" REAL NOT NULL DEFAULT 0.0\n )\n \"\"\")\n \n # Create the index in a separate statement\n target_cursor.execute(\"\"\"\n CREATE UNIQUE INDEX \"submission_analysis_submission_id\" ON \"submission_analysis\" (\"submission_id\")\n \"\"\")\n \n print(\"Target database table created.\")\n\n # Begin transaction\n target_conn.execute('BEGIN TRANSACTION')\n\n # Get all submissions from source\n source_cursor.execute(\"\"\"\n SELECT id, submission_id, title, selftext, created_utc, permalink, score \n FROM submission \n ORDER BY score DESC\n \"\"\")\n submissions = source_cursor.fetchall()\n print(f\"Found {len(submissions)} submissions to analyze.\")\n\n # Analyze each submission\n insert_sql = \"\"\"\n INSERT INTO submission_analysis \n (id, submission_id, title, selftext, created_utc, permalink, score, \n total_comments, yta_comments, yta_percentage) \n VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)\n \"\"\"\n\n # Open JSONL file for writing\n with open(OUTPUT_JSONL_PATH, 'w', encoding='utf-8') as jsonl_file:\n total_analyzed = 0\n analyzed_posts = []\n \n for i, submission in enumerate(submissions):\n submission_db_id = submission['submission_id']\n \n # Get all comments for this submission\n source_cursor.execute(\"\"\"\n SELECT message FROM comment \n WHERE submission_id = ?\n \"\"\", (submission_db_id,))\n \n comments = source_cursor.fetchall()\n total_comments = len(comments)\n \n # Count YTA comments\n yta_comments = 0\n for comment in comments:\n if contains_yta(comment['message']):\n yta_comments += 1\n \n # Calculate percentage\n yta_percentage = (yta_comments / total_comments * 100) if total_comments > 0 else 0.0\n \n # Create a post object\n post_data = {\n \"id\": submission['id'],\n \"submission_id\": submission['submission_id'],\n \"title\": submission['title'],\n \"selftext\": submission['selftext'],\n \"created_utc\": submission['created_utc'],\n \"permalink\": submission['permalink'],\n \"score\": submission['score'],\n \"total_comments\": total_comments,\n \"yta_comments\": yta_comments,\n \"yta_percentage\": round(yta_percentage, 2)\n }\n \n # Insert into target database\n target_cursor.execute(insert_sql, (\n submission['id'],\n submission['submission_id'],\n submission['title'],\n submission['selftext'],\n submission['created_utc'],\n submission['permalink'],\n submission['score'],\n total_comments,\n yta_comments,\n round(yta_percentage, 2)\n ))\n \n # Write to JSONL file\n jsonl_file.write(json.dumps(post_data) + '\\n')\n \n total_analyzed += 1\n \n # Show progress for first 10 and every 10th after that\n if i < 10 or (i + 1) % 10 == 0:\n print(f\"Analyzed submission {i+1}: '{submission['submission_id']}' - \"\n f\"{total_comments} comments, {yta_comments} YTA ({yta_percentage:.1f}%)\")\n\n # Commit transaction\n target_conn.execute('COMMIT')\n print('Database transaction committed successfully.')\n\n # Show summary statistics\n target_cursor.execute(\"\"\"\n SELECT \n COUNT(*) as total_posts,\n AVG(yta_percentage) as avg_yta_percentage,\n MIN(yta_percentage) as min_yta_percentage,\n MAX(yta_percentage) as max_yta_percentage,\n SUM(total_comments) as total_comments_analyzed,\n SUM(yta_comments) as total_yta_comments\n FROM submission_analysis\n \"\"\")\n \n stats = target_cursor.fetchone()\n \n print(\"\\n=== ANALYSIS SUMMARY ===\")\n print(f\"Total posts analyzed: {stats['total_posts']}\")\n print(f\"Total comments analyzed: {stats['total_comments_analyzed']}\")\n print(f\"Total YTA comments: {stats['total_yta_comments']}\")\n print(f\"Average YTA percentage: {stats['avg_yta_percentage']:.2f}%\")\n print(f\"Minimum YTA percentage: {stats['min_yta_percentage']:.2f}%\")\n print(f\"Maximum YTA percentage: {stats['max_yta_percentage']:.2f}%\")\n\n # Show top 5 posts with highest YTA percentage\n target_cursor.execute(\"\"\"\n SELECT submission_id, title, total_comments, yta_comments, yta_percentage\n FROM submission_analysis \n WHERE total_comments > 0\n ORDER BY yta_percentage DESC \n LIMIT 5\n \"\"\")\n \n top_yta_posts = target_cursor.fetchall()\n \n print(\"\\n=== TOP 5 POSTS WITH HIGHEST YTA PERCENTAGE ===\")\n for i, post in enumerate(top_yta_posts, 1):\n print(f\"{i}. {post['submission_id']} ({post['yta_percentage']:.1f}% YTA)\")\n print(f\" Comments: {post['yta_comments']}/{post['total_comments']}\")\n print(f\" Title: {post['title'][:80]}{'...' if len(post['title']) > 80 else ''}\")\n print()\n\n # Close connections\n source_conn.close()\n target_conn.close()\n\n print(\"Analysis complete!\")\n print(f\"Source database: {SOURCE_DB_PATH}\")\n print(f\"Analysis results database: {TARGET_DB_PATH}\")\n print(f\"Analysis results JSONL: {OUTPUT_JSONL_PATH}\")\n print(f\"Total posts analyzed: {total_analyzed}\")\n\n except sqlite3.Error as e:\n print(f\"SQLite error: {e}\")\n try:\n # Check if transaction is active before rolling back\n target_conn.execute(\"SELECT 1 FROM sqlite_master LIMIT 1\")\n target_conn.execute('ROLLBACK')\n print('Transaction rolled back due to error.')\n except Exception as rollback_error:\n print(f\"Error during rollback: {rollback_error}\")\n sys.exit(1)\n except Exception as e:\n print(f\"Error during analysis: {e}\")\n sys.exit(1)\n\n\nif __name__ == \"__main__\":\n main()",[],[190,790],"03c2fae8-67fc-11f0-a319-0224a6c84d84","03c2fb92-67fc-11f0-a319-0224a6c84d84",109,["D",1753299254045],"# Reddit AITA Database Extraction Script\n\nThis script extracts the top 100 most popular posts (by score) and all their comments from the AmItheAsshole subreddit database to a new, smaller SQLite database file.\n\n## Prerequisites\n\n- [Deno](https://deno.land/) installed on your system\n- Original database file at `db/AmItheAsshole.sqlite`\n\n## Usage\n\nRun the script with the following command:\n\n```bash\ndeno run --allow-read --allow-write extract_top_posts.ts\n```\n\nAlternatively, you can make the script executable and run it directly:\n\n```bash\nchmod +x extract_top_posts.ts\n./extract_top_posts.ts\n```\n\n## What the Script Does\n\n1. Opens the source database (`db/AmItheAsshole.sqlite`)\n2. Creates a new target database (`db/Top100AmItheAsshole.sqlite`)\n3. Extracts the top 100 posts from the source database based on score\n4. Extracts all comments associated with those posts\n5. Preserves all original data including IDs, timestamps, and relationships\n\n## Database Schema\n\nThe script maintains the original schema structure:\n\n### Submission Table\n```sql\nCREATE TABLE IF NOT EXISTS \"submission\" (\n \"id\" INTEGER NOT NULL PRIMARY KEY,\n \"submission_id\" VARCHAR(255) NOT NULL,\n \"title\" TEXT NOT NULL,\n \"selftext\" TEXT NOT NULL,\n \"created_utc\" DATE NOT NULL,\n \"permalink\" TEXT NOT NULL,\n \"score\" INTEGER NOT NULL\n);\nCREATE UNIQUE INDEX \"submission_submission_id\" ON \"submission\" (\"submission_id\");\n```\n\n### Comment Table\n```sql\nCREATE TABLE IF NOT EXISTS \"comment\" (\n \"id\" INTEGER NOT NULL PRIMARY KEY,\n \"submission_id\" INTEGER NOT NULL,\n \"message\" TEXT NOT NULL,\n \"comment_id\" VARCHAR(255) NOT NULL,\n \"parent_id\" VARCHAR(255) NOT NULL,\n \"created_utc\" DATE NOT NULL,\n \"score\" INTEGER NOT NULL,\n FOREIGN KEY (\"submission_id\") REFERENCES \"submission\" (\"id\")\n);\nCREATE INDEX \"comment_submission_id\" ON \"comment\" (\"submission_id\");\nCREATE UNIQUE INDEX \"comment_comment_id\" ON \"comment\" (\"comment_id\");\n```\n",[],[190,167],["D",1753299236474],[761,762,763],[190],"c6f58288-67f2-11f0-ade2-0224a6c84d84","style.css","01983875-e8ca-7735-b93b-d99a041ace23",13,["D",1753295286556],"body {\n font-family: -apple-system, Arial, sans-serif;\n color: #333;\n background-color: #f8f9fa;\n margin: 0;\n padding: 0;\n}\n\n.container {\n max-width: 800px;\n margin: 0 auto;\n padding: 20px;\n}\n\n.header {\n background-color: #ff4500; /* Reddit orange */\n color: white;\n padding: 20px 0;\n text-align: center;\n margin-bottom: 30px;\n box-shadow: 0 2px 10px rgba(0, 0, 0, 0.1);\n}\n\n.header h1 {\n margin: 0;\n font-size: 2.5rem;\n}\n\n.header p {\n margin: 10px 0 0;\n opacity: 0.9;\n}\n\n.post-card {\n background-color: white;\n border-radius: 8px;\n padding: 25px;\n margin-bottom: 30px;\n box-shadow: 0 2px 15px rgba(0, 0, 0, 0.05);\n}\n\n.post-title {\n font-size: 1.6rem;\n margin-top: 0;\n margin-bottom: 20px;\n color: #1a1a1b;\n}\n\n.post-content {\n line-height: 1.6;\n margin-bottom: 30px;\n white-space: pre-wrap;\n}\n\n.slider-container {\n margin: 40px 0;\n}\n\n.slider-label {\n display: block;\n font-weight: bold;\n margin-bottom: 15px;\n text-align: center;\n font-size: 1.2rem;\n}\n\n.slider {\n width: 100%;\n -webkit-appearance: none;\n height: 10px;\n border-radius: 5px;\n background: #d3d3d3;\n outline: none;\n margin-bottom: 10px;\n}\n\n.slider::-webkit-slider-thumb {\n -webkit-appearance: none;\n appearance: none;\n width: 25px;\n height: 25px;\n border-radius: 50%;\n background: #ff4500;\n cursor: pointer;\n}\n\n.slider::-moz-range-thumb {\n width: 25px;\n height: 25px;\n border-radius: 50%;\n background: #ff4500;\n cursor: pointer;\n border: none;\n}\n\n.slider-value {\n text-align: center;\n font-size: 1.5rem;\n font-weight: bold;\n margin-top: 10px;\n color: #ff4500;\n}\n\nbutton {\n background-color: #ff4500;\n color: white;\n border: none;\n padding: 12px 24px;\n border-radius: 4px;\n cursor: pointer;\n font-size: 1rem;\n font-weight: bold;\n display: block;\n margin: 30px auto 0;\n transition: background-color 0.2s;\n}\n\nbutton:hover {\n background-color: #e03d00;\n}\n\nbutton:disabled {\n background-color: #cccccc;\n cursor: not-allowed;\n}\n\n.result {\n background-color: #f0f7ff;\n border-radius: 8px;\n padding: 20px;\n margin-top: 30px;\n text-align: center;\n animation: fadeIn 0.5s;\n}\n\n.result-heading {\n font-size: 1.3rem;\n margin-top: 0;\n margin-bottom: 15px;\n color: #1a1a1b;\n}\n\n.result-message {\n margin-bottom: 15px;\n font-size: 1.1rem;\n}\n\n.actual-value {\n font-weight: bold;\n font-size: 1.4rem;\n color: #ff4500;\n}\n\n.difference {\n margin-top: 10px;\n font-style: italic;\n}\n\n.play-again {\n background-color: #0079d3; /* Reddit blue */\n margin-top: 20px;\n}\n\n.play-again:hover {\n background-color: #0061a9;\n}\n\n@keyframes fadeIn {\n from { opacity: 0; transform: translateY(10px); }\n to { opacity: 1; transform: translateY(0); }\n}\n\n/* Responsive adjustments */\n@media (max-width: 600px) {\n .header h1 {\n font-size: 2rem;\n }\n\n .post-title {\n font-size: 1.4rem;\n }\n\n .slider-value {\n font-size: 1.3rem;\n }\n}",[],[197,808],"9158d358-67ef-11f0-97a8-0224a6c84d84","index.tsx","01983875-e8ca-7735-b93b-d722f7851bd0",["D",1753293908093],"/** @jsxImportSource https://esm.sh/react@18.2.0 */\nimport { createRoot } from \"https://esm.sh/react-dom@18.2.0/client\";\nimport { App } from \"./components/App.tsx\";\n\nconst root = document.getElementById(\"root\");\nif (!root) {\n throw new Error(\"No root element found\");\n}\n\ncreateRoot(root).render();",[],[197,816],"c6e7bc5c-67f2-11f0-847e-0224a6c84d84","index.html","01983875-e8ca-7735-b93b-d349eb214392",11,["D",1753295286504],"\n\n \n \n \n Am I The Asshole? Guessing Game\n \n \n \n \n

\n \n \n \n",[],[197,823],"c6fdc826-67f2-11f0-8c08-0224a6c84d84","favicon.svg","01983875-e8ca-7735-b93b-cf7591f06a1e",14,["D",1753295286663],"\n",[],[197,831],"c6ec4380-67f2-11f0-8ed4-0224a6c84d84","App.tsx","01983875-e8ca-7735-b93b-c77249497ad5","01983875-e8ca-7735-b93b-cae8cf68bf65",12,["D",1753295286516],"/** @jsxImportSource https://esm.sh/react@18.2.0 */\nimport { AITAGame } from \"./AITAGame.tsx\";\n\nexport function App() {\n return ;\n}",[],[197,847,839],"components","1fe543aa-67fe-11f0-a6ba-0224a6c84d84","AITAGame.tsx","c6bdd950-67f2-11f0-bf9d-0224a6c84d84",551,["D",1753300160284],"/** @jsxImportSource https://esm.sh/react@18.2.0 */\nimport { useState, useEffect } from \"https://esm.sh/react@18.2.0\";\n\ninterface AITAPost {\n id: string;\n title: string;\n content: string;\n assholePct?: number;\n}\n\ninterface GuessResult {\n actualPct: number;\n difference: number;\n message: string;\n}\n\nexport function AITAGame() {\n const [post, setPost] = useState(null);\n const [posts, setPosts] = useState([]);\n const [loading, setLoading] = useState(true);\n const [error, setError] = useState(null);\n const [guess, setGuess] = useState(50);\n const [result, setResult] = useState(null);\n const [postIndex, setPostIndex] = useState(-1);\n\n // Fetch all available posts when component mounts\n useEffect(() => {\n fetchAllPosts();\n }, []);\n\n // When posts are loaded, select a random post\n useEffect(() => {\n if (posts.length > 0 && postIndex === -1) {\n selectRandomPost();\n }\n }, [posts]);\n\n const fetchAllPosts = async () => {\n setLoading(true);\n setError(null);\n\n try {\n const response = await fetch('/api/posts');\n if (!response.ok) {\n throw new Error('Failed to fetch posts');\n }\n const data = await response.json();\n setPosts(data);\n } catch (err) {\n setError('Error loading posts. Please try again.');\n console.error(err);\n } finally {\n setLoading(false);\n }\n };\n\n const selectRandomPost = () => {\n if (posts.length === 0) return;\n \n // Generate a random index different from the current one (if possible)\n let newIndex;\n if (posts.length === 1) {\n newIndex = 0;\n } else {\n do {\n newIndex = Math.floor(Math.random() * posts.length);\n } while (newIndex === postIndex && posts.length > 1);\n }\n \n setPostIndex(newIndex);\n setPost(posts[newIndex]);\n setResult(null);\n setGuess(50);\n };\n\n const handleSliderChange = (e: React.ChangeEvent) => {\n setGuess(parseInt(e.target.value, 10));\n };\n\n const submitGuess = async () => {\n if (!post) return;\n\n try {\n const response = await fetch(`/api/posts/${post.id}/check`, {\n method: 'POST',\n headers: {\n 'Content-Type': 'application/json'\n },\n body: JSON.stringify({ guess })\n });\n\n if (!response.ok) {\n throw new Error('Failed to submit guess');\n }\n\n const result = await response.json();\n setResult(result);\n } catch (err) {\n setError('Error submitting guess. Please try again.');\n console.error(err);\n }\n };\n\n const playAgain = () => {\n selectRandomPost();\n };\n\n if (loading) {\n return

Loading posts...

;\n }\n\n if (error) {\n return (\n

{error}

\n \n

\n );\n }\n\n if (posts.length === 0) {\n return

No posts found. Please check your data source.

;\n }\n\n if (!post) {\n return

Selecting a post...

;\n }\n\n return (\n

Am I The Asshole?

Guess what percentage of Reddit users thought the poster was the asshole

\n Post {postIndex + 1} of {posts.length}\n

\n\n

{post.title}

{post.content}

\n\n {!result ? (\n

\n What percentage of people thought this person was the asshole?\n \n

{guess}%

\n \n

\n ) : (\n

Results

{result.message}

{result.actualPct}% of people thought OP was the asshole

(You were off by {result.difference}%)

\n \n

\n )}\n

\n );\n}",[],[197,847,849],"9158c8f4-67ef-11f0-97a8-0224a6c84d84",["D",1753293908093],[754,755],[197,847],["D",1753293908093],[753,756,757,758,759],[197],["D",1753299236795],[],[202],"cef5c81a-691b-11f0-ab63-0224a6c84d84","index.ts",552,["D",1753422860556],"http","import { serveFile } from \"https://esm.town/v/std/utils@85-main/index.ts\";\nimport { Hono } from \"npm:hono\";\nimport {getPosts} from \"./data/posts.ts\";\n\nconst app = new Hono();\n\n// Serve index.html at the root /\napp.get(\"/\", async c => {\n return serveFile(\"/frontend/index.html\", import.meta.url);\n});\n\n// Serve all /frontend files\napp.get(\"/frontend/**/*\", c => serveFile(c.req.path, import.meta.url));\n\n// API route to get a specific post\napp.get(\"/api/posts/:id\", async (c) => {\n const id = c.req.param(\"id\");\n const posts = await getPosts();\n const post = posts.find(p => p.id === id);\n\n if (!post) {\n return c.json({ error: \"Post not found\" }, 404);\n }\n\n return c.json(post);\n});\n\n// API route to get all posts (without the assholePct to avoid spoilers)\napp.get(\"/api/posts\", async (c) => {\n const posts = await getPosts();\n const postsWithoutPct = posts.map(({ id, title, content }) => ({ id, title, content }));\n return c.json(postsWithoutPct);\n});\n\n// API route to check a guess\napp.post(\"/api/posts/:id/check\", async c => {\n const id = c.req.param(\"id\");\n const posts = await getPosts();\n const post = posts.find(p => p.id === id);\n\n if (!post) {\n return c.json({ error: \"Post not found\" }, 404);\n }\n\n const body = await c.req.json();\n const userGuess = body.guess;\n\n if (typeof userGuess !== \"number\" || userGuess < 0 || userGuess > 100) {\n return c.json({ error: \"Invalid guess\" }, 400);\n }\n\n const difference = Math.abs(userGuess - post.assholePct);\n let message = \"\";\n\n if (difference <= 5) {\n message = \"Excellent guess! You really understand Reddit!\";\n } else if (difference <= 15) {\n message = \"Good guess! You're pretty close.\";\n } else if (difference <= 30) {\n message = \"Not bad, but you were a bit off.\";\n } else {\n message = \"Wow, you were way off! The Reddit hivemind surprised you.\";\n }\n\n return c.json({\n actualPct: post.assholePct,\n difference,\n message\n });\n});\n\n// Unwrap and rethrow Hono errors as the original error\n// If you delete this, all errors will be \"Internal Server Error\"\napp.onError((err, c) => {\n throw err;\n});\n\n// HTTP vals expect an exported \"fetch handler\"\n// This is how you \"run the server\" in Val Town with Hono\nexport default app.fetch;",[],[208,867],"b398440c-691c-11f0-a104-0224a6c84d84","c6975654-67f2-11f0-97a0-0224a6c84d84",["D",1753423244143],[],[208,879,33],"data","c69755b4-67f2-11f0-97a0-0224a6c84d84",["D",1753295285995],[749],[208,879],["D",1753293908093],[748,750],[208],"0406b396-67fc-11f0-928e-0224a6c84d84","pyvenv.cfg","0406b45e-67fc-11f0-928e-0224a6c84d84",120,["D",1753299254535],"home = /usr/local/bin\nimplementation = CPython\nversion_info = 3.13.0.final.0\nvirtualenv = 20.31.2\ninclude-system-site-packages = false\nbase-prefix = /Library/Frameworks/Python.framework/Versions/3.13\nbase-exec-prefix = /Library/Frameworks/Python.framework/Versions/3.13\nbase-executable = /Library/Frameworks/Python.framework/Versions/3.13/bin/python3.13\n",[],[213,888],"040cb91c-67fc-11f0-8b06-0224a6c84d84","CACHEDIR.TAG","040cb9da-67fc-11f0-8b06-0224a6c84d84",121,["D",1753299254579],"Signature: 8a477f597d28d172789f06886806bc55\n# This file is a cache directory tag created by Python virtualenv.\n# For information about cache directory tags, see:\n# https://bford.info/cachedir/",[],[213,896],"040fa122-67fc-11f0-8cc3-0224a6c84d84","040fa1cc-67fc-11f0-8cc3-0224a6c84d84",122,["D",1753299254597],"# created by virtualenv automatically\n*\n",[],[213,182],"0e5ab216-67fc-11f0-9b65-0224a6c84d84","_virtualenv.py","0e5ab2a2-67fc-11f0-9b65-0224a6c84d84","fa3bb604-67fb-11f0-b5ac-0224a6c84d84",530,["D",1753299271853],"\"\"\"Patches that are applied at runtime to the virtual environment.\"\"\"\n\nfrom __future__ import annotations\n\nimport os\nimport sys\n\nVIRTUALENV_PATCH_FILE = os.path.join(__file__)\n\n\ndef patch_dist(dist):\n \"\"\"\n Distutils allows user to configure some arguments via a configuration file:\n https://docs.python.org/3/install/index.html#distutils-configuration-files.\n\n Some of this arguments though don't make sense in context of the virtual environment files, let's fix them up.\n \"\"\" # noqa: D205\n # we cannot allow some install config as that would get packages installed outside of the virtual environment\n old_parse_config_files = dist.Distribution.parse_config_files\n\n def parse_config_files(self, *args, **kwargs):\n result = old_parse_config_files(self, *args, **kwargs)\n install = self.get_option_dict(\"install\")\n\n if \"prefix\" in install: # the prefix governs where to install the libraries\n install[\"prefix\"] = VIRTUALENV_PATCH_FILE, os.path.abspath(sys.prefix)\n for base in (\"purelib\", \"platlib\", \"headers\", \"scripts\", \"data\"):\n key = f\"install_{base}\"\n if key in install: # do not allow global configs to hijack venv paths\n install.pop(key, None)\n return result\n\n dist.Distribution.parse_config_files = parse_config_files\n\n\n# Import hook that patches some modules to ignore configuration values that break package installation in case\n# of virtual environments.\n_DISTUTILS_PATCH = \"distutils.dist\", \"setuptools.dist\"\n# https://docs.python.org/3/library/importlib.html#setting-up-an-importer\n\n\nclass _Finder:\n \"\"\"A meta path finder that allows patching the imported distutils modules.\"\"\"\n\n fullname = None\n\n # lock[0] is threading.Lock(), but initialized lazily to avoid importing threading very early at startup,\n # because there are gevent-based applications that need to be first to import threading by themselves.\n # See https://github.com/pypa/virtualenv/issues/1895 for details.\n lock = [] # noqa: RUF012\n\n def find_spec(self, fullname, path, target=None): # noqa: ARG002\n if fullname in _DISTUTILS_PATCH and self.fullname is None: # noqa: PLR1702\n # initialize lock[0] lazily\n if len(self.lock) == 0:\n import threading # noqa: PLC0415\n\n lock = threading.Lock()\n # there is possibility that two threads T1 and T2 are simultaneously running into find_spec,\n # observing .lock as empty, and further going into hereby initialization. However due to the GIL,\n # list.append() operation is atomic and this way only one of the threads will \"win\" to put the lock\n # - that every thread will use - into .lock[0].\n # https://docs.python.org/3/faq/library.html#what-kinds-of-global-value-mutation-are-thread-safe\n self.lock.append(lock)\n\n from functools import partial # noqa: PLC0415\n from importlib.util import find_spec # noqa: PLC0415\n\n with self.lock[0]:\n self.fullname = fullname\n try:\n spec = find_spec(fullname, path)\n if spec is not None:\n # https://www.python.org/dev/peps/pep-0451/#how-loading-will-work\n is_new_api = hasattr(spec.loader, \"exec_module\")\n func_name = \"exec_module\" if is_new_api else \"load_module\"\n old = getattr(spec.loader, func_name)\n func = self.exec_module if is_new_api else self.load_module\n if old is not func:\n try: # noqa: SIM105\n setattr(spec.loader, func_name, partial(func, old))\n except AttributeError:\n pass # C-Extension loaders are r/o such as zipimporter with <3.7\n return spec\n finally:\n self.fullname = None\n return None\n\n @staticmethod\n def exec_module(old, module):\n old(module)\n if module.__name__ in _DISTUTILS_PATCH:\n patch_dist(module)\n\n @staticmethod\n def load_module(old, name):\n module = old(name)\n if module.__name__ in _DISTUTILS_PATCH:\n patch_dist(module)\n return module\n\n\nsys.meta_path.insert(0, _Finder())\n",[],[213,919,920,921,911],"lib","python3.13","site-packages","0e603560-67fc-11f0-8d4e-0224a6c84d84","_virtualenv.pth","0e603614-67fc-11f0-8d4e-0224a6c84d84",531,["D",1753299271902],"import _virtualenv",[],[213,919,920,921,923],"0440e0f2-67fc-11f0-aedf-0224a6c84d84","top_level.txt","0440e1d8-67fc-11f0-aedf-0224a6c84d84","fa9ff902-67fb-11f0-ad3e-0224a6c84d84",128,["D",1753299254908],"pip\n",[],[213,919,920,921,939,931],"pip-25.1.1.dist-info","0433dbb4-67fc-11f0-8b06-0224a6c84d84","entry_points.txt","0433dc72-67fc-11f0-8b06-0224a6c84d84",126,["D",1753299254833],"[console_scripts]\npip = pip._internal.cli.main:main\npip3 = pip._internal.cli.main:main\n",[],[213,919,920,921,939,941],"04272770-67fc-11f0-9ad5-0224a6c84d84","WHEEL","0427281a-67fc-11f0-9ad5-0224a6c84d84",124,["D",1753299254750],"Wheel-Version: 1.0\nGenerator: setuptools (79.0.0)\nRoot-Is-Purelib: true\nTag: py3-none-any\n\n",[],[213,919,920,921,939,949],"04221faa-67fc-11f0-aedf-0224a6c84d84","RECORD","0422207c-67fc-11f0-aedf-0224a6c84d84",123,["D",1753299254716],"pip/__init__.py,sha256=zQQ7Na8YWi0IN86IUKEzDAJtyVpXdJXYDkQ536caUiQ,357\npip/__main__.py,sha256=WzbhHXTbSE6gBY19mNN9m4s5o_365LOvTYSgqgbdBhE,854\npip/__pip-runner__.py,sha256=JOoEZTwrtv7jRaXBkgSQKAE04yNyfFmGHxqpHiGHvL0,1450\npip/py.typed,sha256=EBVvvPRTn_eIpz5e5QztSCdrMX7Qwd7VP93RSoIlZ2I,286\npip/_internal/__init__.py,sha256=MfcoOluDZ8QMCFYal04IqOJ9q6m2V7a0aOsnI-WOxUo,513\npip/_internal/build_env.py,sha256=60_espLI9X3C2db3Ww2gIcyjNk2cAPNcc5gsVO4DOqg,10924\npip/_internal/cache.py,sha256=SjhJK1C6NbonrU4AyYXKTOH0CGOk5cJrYt60mRANnPM,10368\npip/_internal/configuration.py,sha256=-KOok6jh3hFzXMPQFPJ1_EFjBpAsge-RSreQuLHLmzo,14005\npip/_internal/exceptions.py,sha256=wpE11H0e4L9G6AH70sRG149z82X7wX530HK-9eA_DIQ,28464\npip/_internal/main.py,sha256=r-UnUe8HLo5XFJz8inTcOOTiu_sxNhgHb6VwlGUllOI,340\npip/_internal/pyproject.py,sha256=GLJ6rWRS5_2noKdajohoLyDty57Z7QXhcUAYghmTnWc,7286\npip/_internal/self_outdated_check.py,sha256=1PFtttvLAeyCVR3tPoBq2sOlPD0IJ-KSqU6bc1HUk9c,8318\npip/_internal/wheel_builder.py,sha256=Z5Z2ANADbKdSHY9BHqw9zG5-1AxstO6YM6m9yLWe7Vw,11212\npip/_internal/cli/__init__.py,sha256=Iqg_tKA771XuMO1P4t_sDHnSKPzkUb9D0DqunAmw_ko,131\npip/_internal/cli/autocompletion.py,sha256=fs0Wy16Ga5tX1IZKvww5BDi7i5zyzfCPvu7cgXlgXys,6864\npip/_internal/cli/base_command.py,sha256=0A8YuJVJh2YyXU8pdW0eidLg1eklCW5cU01mpI-FAxA,8351\npip/_internal/cli/cmdoptions.py,sha256=-_V4gjMa0c3U8-vXKAyb5xVViJNzFAxBI3Zx_6Ds5-g,31909\npip/_internal/cli/command_context.py,sha256=RHgIPwtObh5KhMrd3YZTkl8zbVG-6Okml7YbFX4Ehg0,774\npip/_internal/cli/index_command.py,sha256=kplkusUgCZy75jNCo-etaDmSG8UvqcR2W50ALDdm6dk,5720\npip/_internal/cli/main.py,sha256=1bXC7uL3tdb_EZlGVKs6_TgzC9tlKU7zhAZsbZA-IzY,2816\npip/_internal/cli/main_parser.py,sha256=chZqNmCuO_JYt8ynBCumh4crURaRoXBZ0RxoSYQIwCw,4337\npip/_internal/cli/parser.py,sha256=VCMtduzECUV87KaHNu-xJ-wLNL82yT3x16V4XBxOAqI,10825\npip/_internal/cli/progress_bars.py,sha256=r9BD4T2-egcInB1Uh9Jjw3EP9F3INy5kZhGwSePm9jo,4435\npip/_internal/cli/req_command.py,sha256=1yfssBvnUKNer8D7iT3OHqdJJNdCqRhwDqUFWgieppk,12934\npip/_internal/cli/spinners.py,sha256=hIJ83GerdFgFCdobIA23Jggetegl_uC4Sp586nzFbPE,5118\npip/_internal/cli/status_codes.py,sha256=sEFHUaUJbqv8iArL3HAtcztWZmGOFX01hTesSytDEh0,116\npip/_internal/commands/__init__.py,sha256=3405KyFv4l0ruxeF69oosFanxNQcC_fHBGv7Rpt0PXg,4009\npip/_internal/commands/cache.py,sha256=IOezTicHjGE5sWdBx2nwPVgbjuJHM3s-BZEkpZLemuY,8107\npip/_internal/commands/check.py,sha256=Hr_4eiMd9cgVDgEvjtIdw915NmL7ROIWW8enkr8slPQ,2268\npip/_internal/commands/completion.py,sha256=W9QFQTPLjy2tPACJ_y3g9EgB1pbsh7pvCUX8ocuIdPg,4554\npip/_internal/commands/configuration.py,sha256=n98enwp6y0b5G6fiRQjaZo43FlJKYve_daMhN-4BRNc,9766\npip/_internal/commands/debug.py,sha256=DNDRgE9YsKrbYzU0s3VKi8rHtKF4X13CJ_br_8PUXO0,6797\npip/_internal/commands/download.py,sha256=0qB0nys6ZEPsog451lDsjL5Bx7Z97t-B80oFZKhpzKM,5273\npip/_internal/commands/freeze.py,sha256=YW-aMmAzzOaBWWobo9g4DPKuWp0dTC32lWMqXzKFLzE,3144\npip/_internal/commands/hash.py,sha256=EVVOuvGtoPEdFi8SNnmdqlCQrhCxV-kJsdwtdcCnXGQ,1703\npip/_internal/commands/help.py,sha256=gcc6QDkcgHMOuAn5UxaZwAStsRBrnGSn_yxjS57JIoM,1132\npip/_internal/commands/index.py,sha256=8UucFVwx6FmM8cNbaPY8iI5kZdV3f6jhqDa-S8aGgpg,5068\npip/_internal/commands/inspect.py,sha256=PGrY9TRTRCM3y5Ml8Bdk8DEOXquWRfscr4DRo1LOTPc,3189\npip/_internal/commands/install.py,sha256=SRsiLpead7A8bLdxMqxTAJM3sUFHtgN9zgBT98UQz5E,29757\npip/_internal/commands/list.py,sha256=Rwtf8B0d0-WrkM7Qsv41-dWg8I_r9BLuZV30wSWnzgU,13274\npip/_internal/commands/lock.py,sha256=bUYrryKa769UXM61imojoeVVgc_1ZHK-9a0hIJmmlCg,5941\npip/_internal/commands/search.py,sha256=IrfvxcRCSoZY9A5XAlCF1wtl_y2HPcXslQdHcjzwMNk,5784\npip/_internal/commands/show.py,sha256=Yh5rGYhR2Io5TkL0fFCMWE1VqqM4xhPHjhbdS3QgEac,8028\npip/_internal/commands/uninstall.py,sha256=7pOR7enK76gimyxQbzxcG1OsyLXL3DvX939xmM8Fvtg,3892\npip/_internal/commands/wheel.py,sha256=NEfaVF4f41VBNSn93RL8gkfCEDmdGhbP9xu_dE6cdUk,6346\npip/_internal/distributions/__init__.py,sha256=Hq6kt6gXBgjNit5hTTWLAzeCNOKoB-N0pGYSqehrli8,858\npip/_internal/distributions/base.py,sha256=QeB9qvKXDIjLdPBDE5fMgpfGqMMCr-govnuoQnGuiF8,1783\npip/_internal/distributions/installed.py,sha256=QinHFbWAQ8oE0pbD8MFZWkwlnfU1QYTccA1vnhrlYOU,842\npip/_internal/distributions/sdist.py,sha256=PlcP4a6-R6c98XnOM-b6Lkb3rsvh9iG4ok8shaanrzs,6751\npip/_internal/distributions/wheel.py,sha256=THBYfnv7VVt8mYhMYUtH13S1E7FDwtDyDfmUcl8ai0E,1317\npip/_internal/index/__init__.py,sha256=tzwMH_fhQeubwMqHdSivasg1cRgTSbNg2CiMVnzMmyU,29\npip/_internal/index/collector.py,sha256=RdPO0JLAlmyBWPAWYHPyRoGjz3GNAeTngCNkbGey_mE,16265\npip/_internal/index/package_finder.py,sha256=RohRzzLExoXl7QDdTiqyxIaQEcHUn6UNOr9KzC1vjL0,38446\npip/_internal/index/sources.py,sha256=lPBLK5Xiy8Q6IQMio26Wl7ocfZOKkgGklIBNyUJ23fI,8632\npip/_internal/locations/__init__.py,sha256=vvTMNxghT0aEXrSdqpNtuRDGx08bzJxfDAUUfQ0Vb0A,14309\npip/_internal/locations/_distutils.py,sha256=x6nyVLj7X11Y4khIdf-mFlxMl2FWadtVEgeb8upc_WI,6013\npip/_internal/locations/_sysconfig.py,sha256=IGzds60qsFneRogC-oeBaY7bEh3lPt_v47kMJChQXsU,7724\npip/_internal/locations/base.py,sha256=RQiPi1d4FVM2Bxk04dQhXZ2PqkeljEL2fZZ9SYqIQ78,2556\npip/_internal/metadata/__init__.py,sha256=nGWuZvjQlIHudlMz_-bsUs2LDA2ZKNPGevZoEGcd64Y,5723\npip/_internal/metadata/_json.py,sha256=ezrIYazHCINM2QUk1eA9wEAMj3aeGWeDVgGalgUzKpc,2707\npip/_internal/metadata/base.py,sha256=jCbzdIc8MgWnPR4rfrvSQhSVzSoOyKOXhj3xe8BoG8c,25467\npip/_internal/metadata/pkg_resources.py,sha256=U07ETAINSGeSRBfWUG93E4tZZbaW_f7PGzEqZN0hulc,10542\npip/_internal/metadata/importlib/__init__.py,sha256=jUUidoxnHcfITHHaAWG1G2i5fdBYklv_uJcjo2x7VYE,135\npip/_internal/metadata/importlib/_compat.py,sha256=c6av8sP8BBjAZuFSJow1iWfygUXNM3xRTCn5nqw6B9M,2796\npip/_internal/metadata/importlib/_dists.py,sha256=ftmYiyfUGUIjnVwt6W-Ijsimy5c28KgmXly5Q5IQ2P4,8279\npip/_internal/metadata/importlib/_envs.py,sha256=X63CkdAPJCYPhefYSLiQzPf9ijMXm5nL_A_Z68yp2-w,5297\npip/_internal/models/__init__.py,sha256=AjmCEBxX_MH9f_jVjIGNCFJKYCYeSEe18yyvNx4uRKQ,62\npip/_internal/models/candidate.py,sha256=zzgFRuw_kWPjKpGw7LC0ZUMD2CQ2EberUIYs8izjdCA,753\npip/_internal/models/direct_url.py,sha256=lJ1fIVTgk5UG5SzTNR0FpgSGAQjChlH-3otgiEJAhIs,6576\npip/_internal/models/format_control.py,sha256=wtsQqSK9HaUiNxQEuB-C62eVimw6G4_VQFxV9-_KDBE,2486\npip/_internal/models/index.py,sha256=tYnL8oxGi4aSNWur0mG8DAP7rC6yuha_MwJO8xw0crI,1030\npip/_internal/models/installation_report.py,sha256=zRVZoaz-2vsrezj_H3hLOhMZCK9c7TbzWgC-jOalD00,2818\npip/_internal/models/link.py,sha256=wIAgxhiu05ycLhbtAibknXX5L6X9ju_PPLVnMcvh9B4,21511\npip/_internal/models/pylock.py,sha256=n3-I26bf2v-Kn6qcx4ATB_Zel2SLhaUxZBmsMeGgYAo,6196\npip/_internal/models/scheme.py,sha256=PakmHJM3e8OOWSZFtfz1Az7f1meONJnkGuQxFlt3wBE,575\npip/_internal/models/search_scope.py,sha256=67NEnsYY84784S-MM7ekQuo9KXLH-7MzFntXjapvAo0,4531\npip/_internal/models/selection_prefs.py,sha256=qaFfDs3ciqoXPg6xx45N1jPLqccLJw4N0s4P0PyHTQ8,2015\npip/_internal/models/target_python.py,sha256=2XaH2rZ5ZF-K5wcJbEMGEl7SqrTToDDNkrtQ2v_v_-Q,4271\npip/_internal/models/wheel.py,sha256=10NUTXIRjf2P8oe1Wzolv8oUv7-YurrOduVFUIaDhdM,5506\npip/_internal/network/__init__.py,sha256=FMy06P__y6jMjUc8z3ZcQdKF-pmZ2zM14_vBeHPGhUI,49\npip/_internal/network/auth.py,sha256=D4gASjUrqoDFlSt6gQ767KAAjv6PUyJU0puDlhXNVRE,20809\npip/_internal/network/cache.py,sha256=JGYT-BUaSMdEBwII_K1UE6qyBItz7hzGkyLl_JRzkBY,4613\npip/_internal/network/download.py,sha256=6IdZyoERWIsXXFUFL_h_e_xi8Z0G0UlpkodPy8qKv2U,11078\npip/_internal/network/lazy_wheel.py,sha256=PBdoMoNQQIA84Fhgne38jWF52W4x_KtsHjxgv4dkRKA,7622\npip/_internal/network/session.py,sha256=msM4es16LmmNEYNkrYyg8fTc7gAHbKFltawfKP27LOI,18771\npip/_internal/network/utils.py,sha256=Inaxel-NxBu4PQWkjyErdnfewsFCcgHph7dzR1-FboY,4088\npip/_internal/network/xmlrpc.py,sha256=jW9oDSWamMld3iZOO9RbonVC8ZStkHyppCszoevkuJg,1837\npip/_internal/operations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0\npip/_internal/operations/check.py,sha256=4cnD_2eglsDe5s2CoYkxDt4HcRitTywzLMfTZ-tGQ4U,5911\npip/_internal/operations/freeze.py,sha256=1_M79jAQKnCxWr-KCCmHuVXOVFGaUJHmoWLfFzgh7K4,9843\npip/_internal/operations/prepare.py,sha256=-i9dYwwJJjN7h6sZTabcz84tizgn7EAsY0sHnLAfs3Q,28363\npip/_internal/operations/build/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0\npip/_internal/operations/build/build_tracker.py,sha256=-ARW_TcjHCOX7D2NUOGntB4Fgc6b4aolsXkAK6BWL7w,4774\npip/_internal/operations/build/metadata.py,sha256=INHaeiRfOiLYCXApfDNRo9Cw2xI4VwTc0KItvfdfOjk,1421\npip/_internal/operations/build/metadata_editable.py,sha256=oWudMsnjy4loO_Jy7g4N9nxsnaEX_iDlVRgCy7pu1rs,1509\npip/_internal/operations/build/metadata_legacy.py,sha256=wv8cFA0wTqF62Jlm9QwloYZsofOyQ7sWBBmvCcVvn1k,2189\npip/_internal/operations/build/wheel.py,sha256=sT12FBLAxDC6wyrDorh8kvcZ1jG5qInCRWzzP-UkJiQ,1075\npip/_internal/operations/build/wheel_editable.py,sha256=yOtoH6zpAkoKYEUtr8FhzrYnkNHQaQBjWQ2HYae1MQg,1417\npip/_internal/operations/build/wheel_legacy.py,sha256=KXpyGYoCQYcudXNZvohLXgWHaCk4Gf3z0dbS9ol4uu0,3620\npip/_internal/operations/install/__init__.py,sha256=ak-UETcQPKlFZaWoYKWu5QVXbpFBvg0sXc3i0O4vSYY,50\npip/_internal/operations/install/editable_legacy.py,sha256=TI6wT8sLqDTprWZLYEOBOe7a6-1B9uwKb7kTBxLIaWY,1282\npip/_internal/operations/install/wheel.py,sha256=4NYSQ9ypl69iiduh5gUPCK3WNYqouTHZ0rMXoVgkiZw,27553\npip/_internal/req/__init__.py,sha256=dX2QGlfDwEqE5pLjOeM-f2qEgXFn6f2Vdi_zIHAYy1k,3096\npip/_internal/req/constructors.py,sha256=v1qzCN1mIldwx-nCrPc8JO4lxkm3Fv8M5RWvt8LISjc,18430\npip/_internal/req/req_dependency_group.py,sha256=5PGuZidqwDeTHZkP4tnNrlPrasfvJBONd1B5S0146zs,2677\npip/_internal/req/req_file.py,sha256=eys82McgaICOGic2UZRHjD720piKJPwmeSYdXlWwl6w,20234\npip/_internal/req/req_install.py,sha256=gMoFak9zrhjHlHaOQxPFheHKtIobppFgq1WrKel_nTE,35788\npip/_internal/req/req_set.py,sha256=j3esG0s6SzoVReX9rWn4rpYNtyET_fwxbwJPRimvRxo,2858\npip/_internal/req/req_uninstall.py,sha256=PQ6SyocDycUYsLAsTpjkbdwO_qjdo-y8BvQfZ5Avdrw,24075\npip/_internal/resolution/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0\npip/_internal/resolution/base.py,sha256=qlmh325SBVfvG6Me9gc5Nsh5sdwHBwzHBq6aEXtKsLA,583\npip/_internal/resolution/legacy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0\npip/_internal/resolution/legacy/resolver.py,sha256=3HZiJBRd1FTN6jQpI4qRO8-TbLYeIbUTS6PFvXnXs2w,24068\npip/_internal/resolution/resolvelib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0\npip/_internal/resolution/resolvelib/base.py,sha256=DCf669FsqyQY5uqXeePDHQY1e4QO-pBzWH8O0s9-K94,5023\npip/_internal/resolution/resolvelib/candidates.py,sha256=U3Qp83jhM_RiJviyrlPCijbps6wYO6VsTDaTnCf_B3o,20241\npip/_internal/resolution/resolvelib/factory.py,sha256=FCvHc9M8UJ_7iU63QtPiHuq_BmfdnBiMJ8WaDBJNFxk,32668\npip/_internal/resolution/resolvelib/found_candidates.py,sha256=6lAF_pLQ2_Z0CBOHIFxGp6NfvT1uwIpCui6e-GgI5tk,6000\npip/_internal/resolution/resolvelib/provider.py,sha256=8ptYOOjfa336D4FZ751EQHR0LDq8jJhIGJXDou8Cv8Y,11190\npip/_internal/resolution/resolvelib/reporter.py,sha256=EwJAHOjWZ8eTHQWss7zJjmQEj6ooP6oWSwwVXFtgpqQ,3260\npip/_internal/resolution/resolvelib/requirements.py,sha256=7JG4Z72e5Yk4vU0S5ulGvbqTy4FMQGYhY5zQhX9zTtY,8065\npip/_internal/resolution/resolvelib/resolver.py,sha256=9zcR4c7UZV1j2ILTmb68Ck_5HdvQvf4cmTBE2bWHkKg,12785\npip/_internal/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0\npip/_internal/utils/_jaraco_text.py,sha256=M15uUPIh5NpP1tdUGBxRau6q1ZAEtI8-XyLEETscFfE,3350\npip/_internal/utils/_log.py,sha256=-jHLOE_THaZz5BFcCnoSL9EYAtJ0nXem49s9of4jvKw,1015\npip/_internal/utils/appdirs.py,sha256=zrIISCn2QxlXYw-zJZZBTrFNTyy_0WNKiI-TOoN6wJo,1705\npip/_internal/utils/compat.py,sha256=ckkFveBiYQjRWjkNsajt_oWPS57tJvE8XxoC4OIYgCY,2399\npip/_internal/utils/compatibility_tags.py,sha256=q5W7IrNlqC5ke0AqWRG6aX5pimiqh--xuPCCNwCKPsU,6662\npip/_internal/utils/datetime.py,sha256=Gt29Ml4ToPSM88j54iu43WKtrU9A-moP4QmMiiqzedU,241\npip/_internal/utils/deprecation.py,sha256=k7Qg_UBAaaTdyq82YVARA6D7RmcGTXGv7fnfcgigj4Q,3707\npip/_internal/utils/direct_url_helpers.py,sha256=r2MRtkVDACv9AGqYODBUC9CjwgtsUU1s68hmgfCJMtA,3196\npip/_internal/utils/egg_link.py,sha256=0FePZoUYKv4RGQ2t6x7w5Z427wbA_Uo3WZnAkrgsuqo,2463\npip/_internal/utils/entrypoints.py,sha256=4CheZ81OBPPLb3Gn-X_WEPtllUibpwDVzlVQ4RFh7PM,3325\npip/_internal/utils/filesystem.py,sha256=ajvA-q4ocliW9kPp8Yquh-4vssXbu-UKbo5FV9V4X64,4950\npip/_internal/utils/filetypes.py,sha256=OCPzUxq3Aa6k_95MiI8DYgkOzutTs47fA-v-vYUJp9E,715\npip/_internal/utils/glibc.py,sha256=vUkWq_1pJuzcYNcGKLlQmABoUiisK8noYY1yc8Wq4w4,3734\npip/_internal/utils/hashes.py,sha256=XGGLL0AG8-RhWnyz87xF6MFZ--BKadHU35D47eApCKI,4972\npip/_internal/utils/logging.py,sha256=zMZK1NxfhM4QMGUyaU9q1grNuDhLSVbSkGCvZBKmaPw,12076\npip/_internal/utils/misc.py,sha256=DWnYxBUItjRp7hhxEg4ih6P6YpKrykM86dbi_EcU8SQ,23450\npip/_internal/utils/packaging.py,sha256=CjJOqLNENW-U88ojOllVL40f1ab2W2Bm3KHCavwNNfw,1603\npip/_internal/utils/retry.py,sha256=mhFbykXjhTnZfgzeuy-vl9c8nECnYn_CMtwNJX2tYzQ,1392\npip/_internal/utils/setuptools_build.py,sha256=J9EyRantVgu4V-xS_qfQy2mcPLVUM7A-227QdKGUZCA,4482\npip/_internal/utils/subprocess.py,sha256=EsvqSRiSMHF98T8Txmu6NLU3U--MpTTQjtNgKP0P--M,8988\npip/_internal/utils/temp_dir.py,sha256=5qOXe8M4JeY6vaFQM867d5zkp1bSwMZ-KT5jymmP0Zg,9310\npip/_internal/utils/unpacking.py,sha256=4yCqlRAI2zxl5tfxlnLoWLNcEn-k1c3vaet_oaJ42iI,11926\npip/_internal/utils/urls.py,sha256=qceSOZb5lbNDrHNsv7_S4L4Ytszja5NwPKUMnZHbYnM,1599\npip/_internal/utils/virtualenv.py,sha256=S6f7csYorRpiD6cvn3jISZYc3I8PJC43H5iMFpRAEDU,3456\npip/_internal/utils/wheel.py,sha256=MHObYn6d7VyZL10i-W1xoJZ2hT5-wB1WkII70AsYUE8,4493\npip/_internal/vcs/__init__.py,sha256=UAqvzpbi0VbZo3Ub6skEeZAw-ooIZR-zX_WpCbxyCoU,596\npip/_internal/vcs/bazaar.py,sha256=EKStcQaKpNu0NK4p5Q10Oc4xb3DUxFw024XrJy40bFQ,3528\npip/_internal/vcs/git.py,sha256=3KLPrKsDL9xZchmz4H1Obo8fM2Fh8ChrhtDHWjbkj-I,18591\npip/_internal/vcs/mercurial.py,sha256=oULOhzJ2Uie-06d1omkL-_Gc6meGaUkyogvqG9ZCyPs,5249\npip/_internal/vcs/subversion.py,sha256=ddTugHBqHzV3ebKlU5QXHPN4gUqlyXbOx8q8NgXKvs8,11735\npip/_internal/vcs/versioncontrol.py,sha256=cvf_-hnTAjQLXJ3d17FMNhQfcO1AcKWUF10tfrYyP-c,22440\npip/_vendor/__init__.py,sha256=WzusPTGWIMeQQWSVJ0h2rafGkVTa9WKJ2HT-2-EoZrU,4907\npip/_vendor/typing_extensions.py,sha256=ipKHUPtZCqL6c-HfvGl-9t0opsXcSL72y4GYjyJXs_g,172702\npip/_vendor/vendor.txt,sha256=Fym1hhuw75IJOl33NPi5nIJJc66DioBSUWrVRIVtRUE,373\npip/_vendor/cachecontrol/__init__.py,sha256=x9ecUkiwNvAGfE3g0eaRx3VrJZnZWAluA2LRcvab3HQ,677\npip/_vendor/cachecontrol/_cmd.py,sha256=iist2EpzJvDVIhMAxXq8iFnTBsiZAd6iplxfmNboNyk,1737\npip/_vendor/cachecontrol/adapter.py,sha256=8y6rTPXOzVHmDKCW5CR9sivLVuDv-cpdGcZYdRWNaPw,6599\npip/_vendor/cachecontrol/cache.py,sha256=OXwv7Fn2AwnKNiahJHnjtvaKLndvVLv_-zO-ltlV9qI,1953\npip/_vendor/cachecontrol/controller.py,sha256=cx0Hl8xLZgUuXuy78Gih9AYjCtqurmYjVJxyA4yWt7w,19101\npip/_vendor/cachecontrol/filewrapper.py,sha256=2ktXNPE0KqnyzF24aOsKCA58HQq1xeC6l2g6_zwjghc,4291\npip/_vendor/cachecontrol/heuristics.py,sha256=gqMXU8w0gQuEQiSdu3Yg-0vd9kW7nrWKbLca75rheGE,4881\npip/_vendor/cachecontrol/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0\npip/_vendor/cachecontrol/serialize.py,sha256=HQd2IllQ05HzPkVLMXTF2uX5mjEQjDBkxCqUJUODpZk,5163\npip/_vendor/cachecontrol/wrapper.py,sha256=hsGc7g8QGQTT-4f8tgz3AM5qwScg6FO0BSdLSRdEvpU,1417\npip/_vendor/cachecontrol/caches/__init__.py,sha256=dtrrroK5BnADR1GWjCZ19aZ0tFsMfvFBtLQQU1sp_ag,303\npip/_vendor/cachecontrol/caches/file_cache.py,sha256=d8upFmy_zwaCmlbWEVBlLXFddt8Zw8c5SFpxeOZsdfw,4117\npip/_vendor/cachecontrol/caches/redis_cache.py,sha256=9rmqwtYu_ljVkW6_oLqbC7EaX_a8YT_yLuna-eS0dgo,1386\npip/_vendor/certifi/__init__.py,sha256=neIaAf7BM36ygmQCmy-ZsSyjnvjWghFeu13wwEAnjj0,94\npip/_vendor/certifi/__main__.py,sha256=1k3Cr95vCxxGRGDljrW3wMdpZdL3Nhf0u1n-k2qdsCY,255\npip/_vendor/certifi/cacert.pem,sha256=xVsh-Qf3-G1IrdCTVS-1ZRdJ_1-GBQjMu0I9bB-9gMc,297255\npip/_vendor/certifi/core.py,sha256=2SRT5rIcQChFDbe37BQa-kULxAgJ8qN6l1jfqTp4HIs,4486\npip/_vendor/certifi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0\npip/_vendor/dependency_groups/__init__.py,sha256=C3OFu0NGwDzQ4LOmmSOFPsRSvkbBn-mdd4j_5YqJw-s,250\npip/_vendor/dependency_groups/__main__.py,sha256=UNTM7P5mfVtT7wDi9kOTXWgV3fu3e8bTrt1Qp1jvjKo,1709\npip/_vendor/dependency_groups/_implementation.py,sha256=Gqb2DlQELRakeHlKf6QtQSW0M-bcEomxHw4JsvID1ls,8041\npip/_vendor/dependency_groups/_lint_dependency_groups.py,sha256=yp-DDqKXtbkDTNa0ifa-FmOA8ra24lPZEXftW-R5AuI,1710\npip/_vendor/dependency_groups/_pip_wrapper.py,sha256=nuVW_w_ntVxpE26ELEvngMY0N04sFLsijXRyZZROFG8,1865\npip/_vendor/dependency_groups/_toml_compat.py,sha256=BHnXnFacm3DeolsA35GjI6qkDApvua-1F20kv3BfZWE,285\npip/_vendor/dependency_groups/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0\npip/_vendor/distlib/__init__.py,sha256=dcwgYGYGQqAEawBXPDtIx80DO_3cOmFv8HTc8JMzknQ,625\npip/_vendor/distlib/compat.py,sha256=2jRSjRI4o-vlXeTK2BCGIUhkc6e9ZGhSsacRM5oseTw,41467\npip/_vendor/distlib/database.py,sha256=mHy_LxiXIsIVRb-T0-idBrVLw3Ffij5teHCpbjmJ9YU,51160\npip/_vendor/distlib/index.py,sha256=lTbw268rRhj8dw1sib3VZ_0EhSGgoJO3FKJzSFMOaeA,20797\npip/_vendor/distlib/locators.py,sha256=oBeAZpFuPQSY09MgNnLfQGGAXXvVO96BFpZyKMuK4tM,51026\npip/_vendor/distlib/manifest.py,sha256=3qfmAmVwxRqU1o23AlfXrQGZzh6g_GGzTAP_Hb9C5zQ,14168\npip/_vendor/distlib/markers.py,sha256=X6sDvkFGcYS8gUW8hfsWuKEKAqhQZAJ7iXOMLxRYjYk,5164\npip/_vendor/distlib/metadata.py,sha256=zil3sg2EUfLXVigljY2d_03IJt-JSs7nX-73fECMX2s,38724\npip/_vendor/distlib/resources.py,sha256=LwbPksc0A1JMbi6XnuPdMBUn83X7BPuFNWqPGEKI698,10820\npip/_vendor/distlib/scripts.py,sha256=BJliaDAZaVB7WAkwokgC3HXwLD2iWiHaVI50H7C6eG8,18608\npip/_vendor/distlib/t32.exe,sha256=a0GV5kCoWsMutvliiCKmIgV98eRZ33wXoS-XrqvJQVs,97792\npip/_vendor/distlib/t64-arm.exe,sha256=68TAa32V504xVBnufojh0PcenpR3U4wAqTqf-MZqbPw,182784\npip/_vendor/distlib/t64.exe,sha256=gaYY8hy4fbkHYTTnA4i26ct8IQZzkBG2pRdy0iyuBrc,108032\npip/_vendor/distlib/util.py,sha256=vMPGvsS4j9hF6Y9k3Tyom1aaHLb0rFmZAEyzeAdel9w,66682\npip/_vendor/distlib/version.py,sha256=s5VIs8wBn0fxzGxWM_aA2ZZyx525HcZbMvcTlTyZ3Rg,23727\npip/_vendor/distlib/w32.exe,sha256=R4csx3-OGM9kL4aPIzQKRo5TfmRSHZo6QWyLhDhNBks,91648\npip/_vendor/distlib/w64-arm.exe,sha256=xdyYhKj0WDcVUOCb05blQYvzdYIKMbmJn2SZvzkcey4,168448\npip/_vendor/distlib/w64.exe,sha256=ejGf-rojoBfXseGLpya6bFTFPWRG21X5KvU8J5iU-K0,101888\npip/_vendor/distlib/wheel.py,sha256=DFIVguEQHCdxnSdAO0dfFsgMcvVZitg7bCOuLwZ7A_s,43979\npip/_vendor/distro/__init__.py,sha256=2fHjF-SfgPvjyNZ1iHh_wjqWdR_Yo5ODHwZC0jLBPhc,981\npip/_vendor/distro/__main__.py,sha256=bu9d3TifoKciZFcqRBuygV3GSuThnVD_m2IK4cz96Vs,64\npip/_vendor/distro/distro.py,sha256=XqbefacAhDT4zr_trnbA15eY8vdK4GTghgmvUGrEM_4,49430\npip/_vendor/distro/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0\npip/_vendor/idna/__init__.py,sha256=MPqNDLZbXqGaNdXxAFhiqFPKEQXju2jNQhCey6-5eJM,868\npip/_vendor/idna/codec.py,sha256=PEew3ItwzjW4hymbasnty2N2OXvNcgHB-JjrBuxHPYY,3422\npip/_vendor/idna/compat.py,sha256=RzLy6QQCdl9784aFhb2EX9EKGCJjg0P3PilGdeXXcx8,316\npip/_vendor/idna/core.py,sha256=YJYyAMnwiQEPjVC4-Fqu_p4CJ6yKKuDGmppBNQNQpFs,13239\npip/_vendor/idna/idnadata.py,sha256=W30GcIGvtOWYwAjZj4ZjuouUutC6ffgNuyjJy7fZ-lo,78306\npip/_vendor/idna/intranges.py,sha256=amUtkdhYcQG8Zr-CoMM_kVRacxkivC1WgxN1b63KKdU,1898\npip/_vendor/idna/package_data.py,sha256=q59S3OXsc5VI8j6vSD0sGBMyk6zZ4vWFREE88yCJYKs,21\npip/_vendor/idna/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0\npip/_vendor/idna/uts46data.py,sha256=rt90K9J40gUSwppDPCrhjgi5AA6pWM65dEGRSf6rIhM,239289\npip/_vendor/msgpack/__init__.py,sha256=reRaiOtEzSjPnr7TpxjgIvbfln5pV66FhricAs2eC-g,1109\npip/_vendor/msgpack/exceptions.py,sha256=dCTWei8dpkrMsQDcjQk74ATl9HsIBH0ybt8zOPNqMYc,1081\npip/_vendor/msgpack/ext.py,sha256=kteJv03n9tYzd5oo3xYopVTo4vRaAxonBQQJhXohZZo,5726\npip/_vendor/msgpack/fallback.py,sha256=0g1Pzp0vtmBEmJ5w9F3s_-JMVURP8RS4G1cc5TRaAsI,32390\npip/_vendor/packaging/__init__.py,sha256=_0cDiPVf2S-bNfVmZguxxzmrIYWlyASxpqph4qsJWUc,494\npip/_vendor/packaging/_elffile.py,sha256=UkrbDtW7aeq3qqoAfU16ojyHZ1xsTvGke_WqMTKAKd0,3286\npip/_vendor/packaging/_manylinux.py,sha256=t4y_-dTOcfr36gLY-ztiOpxxJFGO2ikC11HgfysGxiM,9596\npip/_vendor/packaging/_musllinux.py,sha256=p9ZqNYiOItGee8KcZFeHF_YcdhVwGHdK6r-8lgixvGQ,2694\npip/_vendor/packaging/_parser.py,sha256=gYfnj0pRHflVc4RHZit13KNTyN9iiVcU2RUCGi22BwM,10221\npip/_vendor/packaging/_structures.py,sha256=q3eVNmbWJGG_S0Dit_S3Ao8qQqz_5PYTXFAKBZe5yr4,1431\npip/_vendor/packaging/_tokenizer.py,sha256=OYzt7qKxylOAJ-q0XyK1qAycyPRYLfMPdGQKRXkZWyI,5310\npip/_vendor/packaging/markers.py,sha256=P0we27jm1xUzgGMJxBjtUFCIWeBxTsMeJTOJ6chZmAY,12049\npip/_vendor/packaging/metadata.py,sha256=8IZErqQQnNm53dZZuYq4FGU4_dpyinMeH1QFBIWIkfE,34739\npip/_vendor/packaging/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0\npip/_vendor/packaging/requirements.py,sha256=gYyRSAdbrIyKDY66ugIDUQjRMvxkH2ALioTmX3tnL6o,2947\npip/_vendor/packaging/specifiers.py,sha256=yc9D_MycJEmwUpZvcs1OZL9HfiNFmyw0RZaeHRNHkPw,40079\npip/_vendor/packaging/tags.py,sha256=41s97W9Zatrq2Ed7Rc3qeBDaHe8pKKvYq2mGjwahfXk,22745\npip/_vendor/packaging/utils.py,sha256=0F3Hh9OFuRgrhTgGZUl5K22Fv1YP2tZl1z_2gO6kJiA,5050\npip/_vendor/packaging/version.py,sha256=oiHqzTUv_p12hpjgsLDVcaF5hT7pDaSOViUNMD4GTW0,16688\npip/_vendor/packaging/licenses/__init__.py,sha256=3bx-gryo4sRv5LsrwApouy65VIs3u6irSORJzALkrzU,5727\npip/_vendor/packaging/licenses/_spdx.py,sha256=oAm1ztPFwlsmCKe7lAAsv_OIOfS1cWDu9bNBkeu-2ns,48398\npip/_vendor/pkg_resources/__init__.py,sha256=jrhDRbOubP74QuPXxd7U7Po42PH2l-LZ2XfcO7llpZ4,124463\npip/_vendor/platformdirs/__init__.py,sha256=UfeSHWl8AeTtbOBOoHAxK4dODOWkZtfy-m_i7cWdJ8c,22344\npip/_vendor/platformdirs/__main__.py,sha256=jBJ8zb7Mpx5ebcqF83xrpO94MaeCpNGHVf9cvDN2JLg,1505\npip/_vendor/platformdirs/android.py,sha256=r0DshVBf-RO1jXJGX8C4Til7F1XWt-bkdWMgmvEiaYg,9013\npip/_vendor/platformdirs/api.py,sha256=U9EzI3EYxcXWUCtIGRllqrcN99i2LSY1mq2-GtsUwEQ,9277\npip/_vendor/platformdirs/macos.py,sha256=UlbyFZ8Rzu3xndCqQEHrfsYTeHwYdFap1Ioz-yxveT4,6154\npip/_vendor/platformdirs/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0\npip/_vendor/platformdirs/unix.py,sha256=WZmkUA--L3JNRGmz32s35YfoD3ica6xKIPdCV_HhLcs,10458\npip/_vendor/platformdirs/version.py,sha256=0fnw4ljascx7O5PfIeZ2yj6w3pAkqwp099vDcivxuvY,511\npip/_vendor/platformdirs/windows.py,sha256=IFpiohUBwxPtCzlyKwNtxyW4Jk8haa6W8o59mfrDXVo,10125\npip/_vendor/pygments/__init__.py,sha256=qMm7-KYqNpMrmjymZaqfH-_9iJtjnexAKodkb9G5D5g,2983\npip/_vendor/pygments/__main__.py,sha256=WrndpSe6i1ckX_SQ1KaxD9CTKGzD0EuCOFxcbwFpoLU,353\npip/_vendor/pygments/console.py,sha256=AagDWqwea2yBWf10KC9ptBgMpMjxKp8yABAmh-NQOVk,1718\npip/_vendor/pygments/filter.py,sha256=YLtpTnZiu07nY3oK9nfR6E9Y1FBHhP5PX8gvkJWcfag,1910\npip/_vendor/pygments/formatter.py,sha256=KZQMmyo_xkOIkQG8g66LYEkBh1bx7a0HyGCBcvhI9Ew,4390\npip/_vendor/pygments/lexer.py,sha256=_kBrOJ_NT5Tl0IVM0rA9c8eysP6_yrlGzEQI0eVYB-A,35349\npip/_vendor/pygments/modeline.py,sha256=K5eSkR8GS1r5OkXXTHOcV0aM_6xpk9eWNEIAW-OOJ2g,1005\npip/_vendor/pygments/plugin.py,sha256=tPx0rJCTIZ9ioRgLNYG4pifCbAwTRUZddvLw-NfAk2w,1891\npip/_vendor/pygments/regexopt.py,sha256=wXaP9Gjp_hKAdnICqoDkRxAOQJSc4v3X6mcxx3z-TNs,3072\npip/_vendor/pygments/scanner.py,sha256=nNcETRR1tRuiTaHmHSTTECVYFPcLf6mDZu1e4u91A9E,3092\npip/_vendor/pygments/sphinxext.py,sha256=5x7Zh9YlU6ISJ31dMwduiaanb5dWZnKg3MyEQsseNnQ,7981\npip/_vendor/pygments/style.py,sha256=PlOZqlsnTVd58RGy50vkA2cXQ_lP5bF5EGMEBTno6DA,6420\npip/_vendor/pygments/token.py,sha256=WbdWGhYm_Vosb0DDxW9lHNPgITXfWTsQmHt6cy9RbcM,6226\npip/_vendor/pygments/unistring.py,sha256=al-_rBemRuGvinsrM6atNsHTmJ6DUbw24q2O2Ru1cBc,63208\npip/_vendor/pygments/util.py,sha256=oRtSpiAo5jM9ulntkvVbgXUdiAW57jnuYGB7t9fYuhc,10031\npip/_vendor/pygments/filters/__init__.py,sha256=4U4jtA0X3iP83uQnB9-TI-HDSw8E8y8zMYHa0UjbbaI,40392\npip/_vendor/pygments/formatters/__init__.py,sha256=KTwBmnXlaopJhQDOemVHYHskiDghuq-08YtP6xPNJPg,5385\npip/_vendor/pygments/formatters/_mapping.py,sha256=1Cw37FuQlNacnxRKmtlPX4nyLoX9_ttko5ZwscNUZZ4,4176\npip/_vendor/pygments/lexers/__init__.py,sha256=wbIME35GH7bI1B9rNPJFqWT-ij_RApZDYPUlZycaLzA,12115\npip/_vendor/pygments/lexers/_mapping.py,sha256=l4tCXM8e9aPC2BD6sjIr0deT-J-z5tHgCwL-p1fS0PE,77602\npip/_vendor/pygments/lexers/python.py,sha256=vxjn1cOHclIKJKxoyiBsQTY65GHbkZtZRuKQ2AVCKaw,53853\npip/_vendor/pygments/styles/__init__.py,sha256=x9ebctfyvCAFpMTlMJ5YxwcNYBzjgq6zJaKkNm78r4M,2042\npip/_vendor/pygments/styles/_mapping.py,sha256=6lovFUE29tz6EsV3XYY4hgozJ7q1JL7cfO3UOlgnS8w,3312\npip/_vendor/pyproject_hooks/__init__.py,sha256=cPB_a9LXz5xvsRbX1o2qyAdjLatZJdQ_Lc5McNX-X7Y,691\npip/_vendor/pyproject_hooks/_impl.py,sha256=jY-raxnmyRyB57ruAitrJRUzEexuAhGTpgMygqx67Z4,14936\npip/_vendor/pyproject_hooks/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0\npip/_vendor/pyproject_hooks/_in_process/__init__.py,sha256=MJNPpfIxcO-FghxpBbxkG1rFiQf6HOUbV4U5mq0HFns,557\npip/_vendor/pyproject_hooks/_in_process/_in_process.py,sha256=qcXMhmx__MIJq10gGHW3mA4Tl8dy8YzHMccwnNoKlw0,12216\npip/_vendor/requests/__init__.py,sha256=HlB_HzhrzGtfD_aaYUwUh1zWXLZ75_YCLyit75d0Vz8,5057\npip/_vendor/requests/__version__.py,sha256=FVfglgZmNQnmYPXpOohDU58F5EUb_-VnSTaAesS187g,435\npip/_vendor/requests/_internal_utils.py,sha256=nMQymr4hs32TqVo5AbCrmcJEhvPUh7xXlluyqwslLiQ,1495\npip/_vendor/requests/adapters.py,sha256=J7VeVxKBvawbtlX2DERVo05J9BXTcWYLMHNd1Baa-bk,27607\npip/_vendor/requests/api.py,sha256=_Zb9Oa7tzVIizTKwFrPjDEY9ejtm_OnSRERnADxGsQs,6449\npip/_vendor/requests/auth.py,sha256=kF75tqnLctZ9Mf_hm9TZIj4cQWnN5uxRz8oWsx5wmR0,10186\npip/_vendor/requests/certs.py,sha256=kHDlkK_beuHXeMPc5jta2wgl8gdKeUWt5f2nTDVrvt8,441\npip/_vendor/requests/compat.py,sha256=Mo9f9xZpefod8Zm-n9_StJcVTmwSukXR2p3IQyyVXvU,1485\npip/_vendor/requests/cookies.py,sha256=bNi-iqEj4NPZ00-ob-rHvzkvObzN3lEpgw3g6paS3Xw,18590\npip/_vendor/requests/exceptions.py,sha256=D1wqzYWne1mS2rU43tP9CeN1G7QAy7eqL9o1god6Ejw,4272\npip/_vendor/requests/help.py,sha256=hRKaf9u0G7fdwrqMHtF3oG16RKktRf6KiwtSq2Fo1_0,3813\npip/_vendor/requests/hooks.py,sha256=CiuysiHA39V5UfcCBXFIx83IrDpuwfN9RcTUgv28ftQ,733\npip/_vendor/requests/models.py,sha256=x4K4CmH-lC0l2Kb-iPfMN4dRXxHEcbOaEWBL_i09AwI,35483\npip/_vendor/requests/packages.py,sha256=_ZQDCJTJ8SP3kVWunSqBsRZNPzj2c1WFVqbdr08pz3U,1057\npip/_vendor/requests/sessions.py,sha256=ykTI8UWGSltOfH07HKollH7kTBGw4WhiBVaQGmckTw4,30495\npip/_vendor/requests/status_codes.py,sha256=iJUAeA25baTdw-6PfD0eF4qhpINDJRJI-yaMqxs4LEI,4322\npip/_vendor/requests/structures.py,sha256=-IbmhVz06S-5aPSZuUthZ6-6D9XOjRuTXHOabY041XM,2912\npip/_vendor/requests/utils.py,sha256=L79vnFbzJ3SFLKtJwpoWe41Tozi3RlZv94pY1TFIyow,33631\npip/_vendor/resolvelib/__init__.py,sha256=4LcBWHMH317EKEkpV5XLVnqiU1lrmCiygjsADuCgz4s,541\npip/_vendor/resolvelib/providers.py,sha256=pIWJbIdJJ9GFtNbtwTH0Ia43Vj6hYCEJj2DOLue15FM,8914\npip/_vendor/resolvelib/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0\npip/_vendor/resolvelib/reporters.py,sha256=8BNa7G9cKW4Lie4BhDhd7Z57J_Vlb1CYPGSgVN2erMA,2038\npip/_vendor/resolvelib/structs.py,sha256=pu-EJiR2IBITr2SQeNPRa0rXhjlStfmO_GEgAhr3004,6420\npip/_vendor/resolvelib/resolvers/__init__.py,sha256=GMYuhrbSsYTIjOij0tuJKLvlk6UXmp3nXQetn2sOvpQ,640\npip/_vendor/resolvelib/resolvers/abstract.py,sha256=jZOBVigE4PUub9i3F-bTvBwaIXX8S9EU3CGASBvFqEU,1558\npip/_vendor/resolvelib/resolvers/criterion.py,sha256=lcmZGv5sKHOnFD_RzZwvlGSj19MeA-5rCMpdf2Sgw7Y,1768\npip/_vendor/resolvelib/resolvers/exceptions.py,sha256=ln_jaQtgLlRUSFY627yiHG2gD7AgaXzRKaElFVh7fDQ,1768\npip/_vendor/resolvelib/resolvers/resolution.py,sha256=yQegMuOmlzAElLLpgD-k6NbPDMCQf29rWhiFC26OdkM,20671\npip/_vendor/rich/__init__.py,sha256=dRxjIL-SbFVY0q3IjSMrfgBTHrm1LZDgLOygVBwiYZc,6090\npip/_vendor/rich/__main__.py,sha256=eO7Cq8JnrgG8zVoeImiAs92q3hXNMIfp0w5lMsO7Q2Y,8477\npip/_vendor/rich/_cell_widths.py,sha256=fbmeyetEdHjzE_Vx2l1uK7tnPOhMs2X1lJfO3vsKDpA,10209\npip/_vendor/rich/_emoji_codes.py,sha256=hu1VL9nbVdppJrVoijVshRlcRRe_v3dju3Mmd2sKZdY,140235\npip/_vendor/rich/_emoji_replace.py,sha256=n-kcetsEUx2ZUmhQrfeMNc-teeGhpuSQ5F8VPBsyvDo,1064\npip/_vendor/rich/_export_format.py,sha256=RI08pSrm5tBSzPMvnbTqbD9WIalaOoN5d4M1RTmLq1Y,2128\npip/_vendor/rich/_extension.py,sha256=Xt47QacCKwYruzjDi-gOBq724JReDj9Cm9xUi5fr-34,265\npip/_vendor/rich/_fileno.py,sha256=HWZxP5C2ajMbHryvAQZseflVfQoGzsKOHzKGsLD8ynQ,799\npip/_vendor/rich/_inspect.py,sha256=QM05lEFnFoTaFqpnbx-zBEI6k8oIKrD3cvjEOQNhKig,9655\npip/_vendor/rich/_log_render.py,sha256=1ByI0PA1ZpxZY3CGJOK54hjlq4X-Bz_boIjIqCd8Kns,3225\npip/_vendor/rich/_loop.py,sha256=hV_6CLdoPm0va22Wpw4zKqM0RYsz3TZxXj0PoS-9eDQ,1236\npip/_vendor/rich/_null_file.py,sha256=ADGKp1yt-k70FMKV6tnqCqecB-rSJzp-WQsD7LPL-kg,1394\npip/_vendor/rich/_palettes.py,sha256=cdev1JQKZ0JvlguV9ipHgznTdnvlIzUFDBb0It2PzjI,7063\npip/_vendor/rich/_pick.py,sha256=evDt8QN4lF5CiwrUIXlOJCntitBCOsI3ZLPEIAVRLJU,423\npip/_vendor/rich/_ratio.py,sha256=Zt58apszI6hAAcXPpgdWKpu3c31UBWebOeR4mbyptvU,5471\npip/_vendor/rich/_spinners.py,sha256=U2r1_g_1zSjsjiUdAESc2iAMc3i4ri_S8PYP6kQ5z1I,19919\npip/_vendor/rich/_stack.py,sha256=-C8OK7rxn3sIUdVwxZBBpeHhIzX0eI-VM3MemYfaXm0,351\npip/_vendor/rich/_timer.py,sha256=zelxbT6oPFZnNrwWPpc1ktUeAT-Vc4fuFcRZLQGLtMI,417\npip/_vendor/rich/_win32_console.py,sha256=BSaDRIMwBLITn_m0mTRLPqME5q-quGdSMuYMpYeYJwc,22755\npip/_vendor/rich/_windows.py,sha256=aBwaD_S56SbgopIvayVmpk0Y28uwY2C5Bab1wl3Bp-I,1925\npip/_vendor/rich/_windows_renderer.py,sha256=t74ZL3xuDCP3nmTp9pH1L5LiI2cakJuQRQleHCJerlk,2783\npip/_vendor/rich/_wrap.py,sha256=FlSsom5EX0LVkA3KWy34yHnCfLtqX-ZIepXKh-70rpc,3404\npip/_vendor/rich/abc.py,sha256=ON-E-ZqSSheZ88VrKX2M3PXpFbGEUUZPMa_Af0l-4f0,890\npip/_vendor/rich/align.py,sha256=Rh-3adnDaN1Ao07EjR2PhgE62PGLPgO8SMwJBku1urQ,10469\npip/_vendor/rich/ansi.py,sha256=Avs1LHbSdcyOvDOdpELZUoULcBiYewY76eNBp6uFBhs,6921\npip/_vendor/rich/bar.py,sha256=ldbVHOzKJOnflVNuv1xS7g6dLX2E3wMnXkdPbpzJTcs,3263\npip/_vendor/rich/box.py,sha256=nr5fYIUghB_iUCEq6y0Z3LlCT8gFPDrzN9u2kn7tJl4,10831\npip/_vendor/rich/cells.py,sha256=KrQkj5-LghCCpJLSNQIyAZjndc4bnEqOEmi5YuZ9UCY,5130\npip/_vendor/rich/color.py,sha256=3HSULVDj7qQkXUdFWv78JOiSZzfy5y1nkcYhna296V0,18211\npip/_vendor/rich/color_triplet.py,sha256=3lhQkdJbvWPoLDO-AnYImAWmJvV5dlgYNCVZ97ORaN4,1054\npip/_vendor/rich/columns.py,sha256=HUX0KcMm9dsKNi11fTbiM_h2iDtl8ySCaVcxlalEzq8,7131\npip/_vendor/rich/console.py,sha256=_RJizBQIn9qxr4Ln7Q_SC5N9ekPWPAxH0KGVxsgg69Y,100565\npip/_vendor/rich/constrain.py,sha256=1VIPuC8AgtKWrcncQrjBdYqA3JVWysu6jZo1rrh7c7Q,1288\npip/_vendor/rich/containers.py,sha256=c_56TxcedGYqDepHBMTuZdUIijitAQgnox-Qde0Z1qo,5502\npip/_vendor/rich/control.py,sha256=DSkHTUQLorfSERAKE_oTAEUFefZnZp4bQb4q8rHbKws,6630\npip/_vendor/rich/default_styles.py,sha256=khQFqqaoDs3bprMqWpHw8nO5UpG2DN6QtuTd6LzZwYc,8257\npip/_vendor/rich/diagnose.py,sha256=WNPjU2pEdrPICJ24KOaTD_hzP839qArpmF1JIM5x_EQ,998\npip/_vendor/rich/emoji.py,sha256=omTF9asaAnsM4yLY94eR_9dgRRSm1lHUszX20D1yYCQ,2501\npip/_vendor/rich/errors.py,sha256=5pP3Kc5d4QJ_c0KFsxrfyhjiPVe7J1zOqSFbFAzcV-Y,642\npip/_vendor/rich/file_proxy.py,sha256=Tl9THMDZ-Pk5Wm8sI1gGg_U5DhusmxD-FZ0fUbcU0W0,1683\npip/_vendor/rich/filesize.py,sha256=_iz9lIpRgvW7MNSeCZnLg-HwzbP4GETg543WqD8SFs0,2484\npip/_vendor/rich/highlighter.py,sha256=G_sn-8DKjM1sEjLG_oc4ovkWmiUpWvj8bXi0yed2LnY,9586\npip/_vendor/rich/json.py,sha256=vVEoKdawoJRjAFayPwXkMBPLy7RSTs-f44wSQDR2nJ0,5031\npip/_vendor/rich/jupyter.py,sha256=QyoKoE_8IdCbrtiSHp9TsTSNyTHY0FO5whE7jOTd9UE,3252\npip/_vendor/rich/layout.py,sha256=ajkSFAtEVv9EFTcFs-w4uZfft7nEXhNzL7ZVdgrT5rI,14004\npip/_vendor/rich/live.py,sha256=DhzAPEnjTxQuq9_0Y2xh2MUwQcP_aGPkenLfKETslwM,14270\npip/_vendor/rich/live_render.py,sha256=zJtB471jGziBtEwxc54x12wEQtH4BuQr1SA8v9kU82w,3666\npip/_vendor/rich/logging.py,sha256=ZgpKMMBY_BuMAI_BYzo-UtXak6t5oH9VK8m9Q2Lm0f4,12458\npip/_vendor/rich/markup.py,sha256=3euGKP5s41NCQwaSjTnJxus5iZMHjxpIM0W6fCxra38,8451\npip/_vendor/rich/measure.py,sha256=HmrIJX8sWRTHbgh8MxEay_83VkqNW_70s8aKP5ZcYI8,5305\npip/_vendor/rich/padding.py,sha256=KVEI3tOwo9sgK1YNSuH__M1_jUWmLZwRVV_KmOtVzyM,4908\npip/_vendor/rich/pager.py,sha256=SO_ETBFKbg3n_AgOzXm41Sv36YxXAyI3_R-KOY2_uSc,828\npip/_vendor/rich/palette.py,sha256=lInvR1ODDT2f3UZMfL1grq7dY_pDdKHw4bdUgOGaM4Y,3396\npip/_vendor/rich/panel.py,sha256=SUDaa3z4MU7vIjzvbi0SXuc6BslDzADwdY1AX4TbTdY,11225\npip/_vendor/rich/pretty.py,sha256=gy3S72u4FRg2ytoo7N1ZDWDIvB4unbzd5iUGdgm-8fc,36391\npip/_vendor/rich/progress.py,sha256=MtmCjTk5zYU_XtRHxRHTAEHG6hF9PeF7EMWbEPleIC0,60357\npip/_vendor/rich/progress_bar.py,sha256=mZTPpJUwcfcdgQCTTz3kyY-fc79ddLwtx6Ghhxfo064,8162\npip/_vendor/rich/prompt.py,sha256=l0RhQU-0UVTV9e08xW1BbIj0Jq2IXyChX4lC0lFNzt4,12447\npip/_vendor/rich/protocol.py,sha256=5hHHDDNHckdk8iWH5zEbi-zuIVSF5hbU2jIo47R7lTE,1391\npip/_vendor/rich/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0\npip/_vendor/rich/region.py,sha256=rNT9xZrVZTYIXZC0NYn41CJQwYNbR-KecPOxTgQvB8Y,166\npip/_vendor/rich/repr.py,sha256=5MZJZmONgC6kud-QW-_m1okXwL2aR6u6y-pUcUCJz28,4431\npip/_vendor/rich/rule.py,sha256=0fNaS_aERa3UMRc3T5WMpN_sumtDxfaor2y3of1ftBk,4602\npip/_vendor/rich/scope.py,sha256=TMUU8qo17thyqQCPqjDLYpg_UU1k5qVd-WwiJvnJVas,2843\npip/_vendor/rich/screen.py,sha256=YoeReESUhx74grqb0mSSb9lghhysWmFHYhsbMVQjXO8,1591\npip/_vendor/rich/segment.py,sha256=otnKeKGEV-WRlQVosfJVeFDcDxAKHpvJ_hLzSu5lumM,24743\npip/_vendor/rich/spinner.py,sha256=PT5qgXPG3ZpqRj7n3EZQ6NW56mx3ldZqZCU7gEMyZk4,4364\npip/_vendor/rich/status.py,sha256=kkPph3YeAZBo-X-4wPp8gTqZyU466NLwZBA4PZTTewo,4424\npip/_vendor/rich/style.py,sha256=xpj4uMBZMtuNuNomfUiamigl3p1sDvTCZwrG1tcTVeg,27059\npip/_vendor/rich/styled.py,sha256=eZNnzGrI4ki_54pgY3Oj0T-x3lxdXTYh4_ryDB24wBU,1258\npip/_vendor/rich/syntax.py,sha256=qqAnEUZ4K57Po81_5RBxnsuU4KRzSdvDPAhKw8ma_3E,35763\npip/_vendor/rich/table.py,sha256=ZmT7V7MMCOYKw7TGY9SZLyYDf6JdM-WVf07FdVuVhTI,40049\npip/_vendor/rich/terminal_theme.py,sha256=1j5-ufJfnvlAo5Qsi_ACZiXDmwMXzqgmFByObT9-yJY,3370\npip/_vendor/rich/text.py,sha256=AO7JPCz6-gaN1thVLXMBntEmDPVYFgFNG1oM61_sanU,47552\npip/_vendor/rich/theme.py,sha256=oNyhXhGagtDlbDye3tVu3esWOWk0vNkuxFw-_unlaK0,3771\npip/_vendor/rich/themes.py,sha256=0xgTLozfabebYtcJtDdC5QkX5IVUEaviqDUJJh4YVFk,102\npip/_vendor/rich/traceback.py,sha256=ZA8Q67DyP5a_stpIh6GPf9IiXj_s3dAhDIr6Zbfkahk,35170\npip/_vendor/rich/tree.py,sha256=yWnQ6rAvRGJ3qZGqBrxS2SW2TKBTNrP0SdY8QxOFPuw,9451\npip/_vendor/tomli/__init__.py,sha256=PhNw_eyLgdn7McJ6nrAN8yIm3dXC75vr1sVGVVwDSpA,314\npip/_vendor/tomli/_parser.py,sha256=9w8LG0jB7fwmZZWB0vVXbeejDHcl4ANIJxB2scEnDlA,25591\npip/_vendor/tomli/_re.py,sha256=sh4sBDRgO94KJZwNIrgdcyV_qQast50YvzOAUGpRDKA,3171\npip/_vendor/tomli/_types.py,sha256=-GTG2VUqkpxwMqzmVO4F7ybKddIbAnuAHXfmWQcTi3Q,254\npip/_vendor/tomli/py.typed,sha256=8PjyZ1aVoQpRVvt71muvuq5qE-jTFZkK-GLHkhdebmc,26\npip/_vendor/tomli_w/__init__.py,sha256=0F8yDtXx3Uunhm874KrAcP76srsM98y7WyHQwCulZbo,169\npip/_vendor/tomli_w/_writer.py,sha256=dsifFS2xYf1i76mmRyfz9y125xC7Z_HQ845ZKhJsYXs,6961\npip/_vendor/tomli_w/py.typed,sha256=8PjyZ1aVoQpRVvt71muvuq5qE-jTFZkK-GLHkhdebmc,26\npip/_vendor/truststore/__init__.py,sha256=2wRSVijjRzPLVXUzWqvdZLNsEOhDfopKLd2EKAYLwKU,1320\npip/_vendor/truststore/_api.py,sha256=40I0ojO2DnITiHvOnUYvJ1bfQMBKHOkci14noNxEnCs,11246\npip/_vendor/truststore/_macos.py,sha256=nZlLkOmszUE0g6ryRwBVGY5COzPyudcsiJtDWarM5LQ,20503\npip/_vendor/truststore/_openssl.py,sha256=LLUZ7ZGaio-i5dpKKjKCSeSufmn6T8pi9lDcFnvSyq0,2324\npip/_vendor/truststore/_ssl_constants.py,sha256=NUD4fVKdSD02ri7-db0tnO0VqLP9aHuzmStcW7tAl08,1130\npip/_vendor/truststore/_windows.py,sha256=rAHyKYD8M7t-bXfG8VgOVa3TpfhVhbt4rZQlO45YuP8,17993\npip/_vendor/truststore/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0\npip/_vendor/urllib3/__init__.py,sha256=iXLcYiJySn0GNbWOOZDDApgBL1JgP44EZ8i1760S8Mc,3333\npip/_vendor/urllib3/_collections.py,sha256=pyASJJhW7wdOpqJj9QJA8FyGRfr8E8uUUhqUvhF0728,11372\npip/_vendor/urllib3/_version.py,sha256=t9wGB6ooOTXXgiY66K1m6BZS1CJyXHAU8EoWDTe6Shk,64\npip/_vendor/urllib3/connection.py,sha256=ttIA909BrbTUzwkqEe_TzZVh4JOOj7g61Ysei2mrwGg,20314\npip/_vendor/urllib3/connectionpool.py,sha256=e2eiAwNbFNCKxj4bwDKNK-w7HIdSz3OmMxU_TIt-evQ,40408\npip/_vendor/urllib3/exceptions.py,sha256=0Mnno3KHTNfXRfY7638NufOPkUb6mXOm-Lqj-4x2w8A,8217\npip/_vendor/urllib3/fields.py,sha256=kvLDCg_JmH1lLjUUEY_FLS8UhY7hBvDPuVETbY8mdrM,8579\npip/_vendor/urllib3/filepost.py,sha256=5b_qqgRHVlL7uLtdAYBzBh-GHmU5AfJVt_2N0XS3PeY,2440\npip/_vendor/urllib3/poolmanager.py,sha256=aWyhXRtNO4JUnCSVVqKTKQd8EXTvUm1VN9pgs2bcONo,19990\npip/_vendor/urllib3/request.py,sha256=YTWFNr7QIwh7E1W9dde9LM77v2VWTJ5V78XuTTw7D1A,6691\npip/_vendor/urllib3/response.py,sha256=fmDJAFkG71uFTn-sVSTh2Iw0WmcXQYqkbRjihvwBjU8,30641\npip/_vendor/urllib3/contrib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0\npip/_vendor/urllib3/contrib/_appengine_environ.py,sha256=bDbyOEhW2CKLJcQqAKAyrEHN-aklsyHFKq6vF8ZFsmk,957\npip/_vendor/urllib3/contrib/appengine.py,sha256=VR68eAVE137lxTgjBDwCna5UiBZTOKa01Aj_-5BaCz4,11036\npip/_vendor/urllib3/contrib/ntlmpool.py,sha256=NlfkW7WMdW8ziqudopjHoW299og1BTWi0IeIibquFwk,4528\npip/_vendor/urllib3/contrib/pyopenssl.py,sha256=hDJh4MhyY_p-oKlFcYcQaVQRDv6GMmBGuW9yjxyeejM,17081\npip/_vendor/urllib3/contrib/securetransport.py,sha256=Fef1IIUUFHqpevzXiDPbIGkDKchY2FVKeVeLGR1Qq3g,34446\npip/_vendor/urllib3/contrib/socks.py,sha256=aRi9eWXo9ZEb95XUxef4Z21CFlnnjbEiAo9HOseoMt4,7097\npip/_vendor/urllib3/contrib/_securetransport/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0\npip/_vendor/urllib3/contrib/_securetransport/bindings.py,sha256=4Xk64qIkPBt09A5q-RIFUuDhNc9mXilVapm7WnYnzRw,17632\npip/_vendor/urllib3/contrib/_securetransport/low_level.py,sha256=B2JBB2_NRP02xK6DCa1Pa9IuxrPwxzDzZbixQkb7U9M,13922\npip/_vendor/urllib3/packages/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0\npip/_vendor/urllib3/packages/six.py,sha256=b9LM0wBXv7E7SrbCjAm4wwN-hrH-iNxv18LgWNMMKPo,34665\npip/_vendor/urllib3/packages/backports/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0\npip/_vendor/urllib3/packages/backports/makefile.py,sha256=nbzt3i0agPVP07jqqgjhaYjMmuAi_W5E0EywZivVO8E,1417\npip/_vendor/urllib3/packages/backports/weakref_finalize.py,sha256=tRCal5OAhNSRyb0DhHp-38AtIlCsRP8BxF3NX-6rqIA,5343\npip/_vendor/urllib3/util/__init__.py,sha256=JEmSmmqqLyaw8P51gUImZh8Gwg9i1zSe-DoqAitn2nc,1155\npip/_vendor/urllib3/util/connection.py,sha256=5Lx2B1PW29KxBn2T0xkN1CBgRBa3gGVJBKoQoRogEVk,4901\npip/_vendor/urllib3/util/proxy.py,sha256=zUvPPCJrp6dOF0N4GAVbOcl6o-4uXKSrGiTkkr5vUS4,1605\npip/_vendor/urllib3/util/queue.py,sha256=nRgX8_eX-_VkvxoX096QWoz8Ps0QHUAExILCY_7PncM,498\npip/_vendor/urllib3/util/request.py,sha256=C0OUt2tcU6LRiQJ7YYNP9GvPrSvl7ziIBekQ-5nlBZk,3997\npip/_vendor/urllib3/util/response.py,sha256=GJpg3Egi9qaJXRwBh5wv-MNuRWan5BIu40oReoxWP28,3510\npip/_vendor/urllib3/util/retry.py,sha256=6ENvOZ8PBDzh8kgixpql9lIrb2dxH-k7ZmBanJF2Ng4,22050\npip/_vendor/urllib3/util/ssl_.py,sha256=QDuuTxPSCj1rYtZ4xpD7Ux-r20TD50aHyqKyhQ7Bq4A,17460\npip/_vendor/urllib3/util/ssl_match_hostname.py,sha256=Ir4cZVEjmAk8gUAIHWSi7wtOO83UCYABY2xFD1Ql_WA,5758\npip/_vendor/urllib3/util/ssltransport.py,sha256=NA-u5rMTrDFDFC8QzRKUEKMG0561hOD4qBTr3Z4pv6E,6895\npip/_vendor/urllib3/util/timeout.py,sha256=cwq4dMk87mJHSBktK1miYJ-85G-3T3RmT20v7SFCpno,10168\npip/_vendor/urllib3/util/url.py,sha256=lCAE7M5myA8EDdW0sJuyyZhVB9K_j38ljWhHAnFaWoE,14296\npip/_vendor/urllib3/util/wait.py,sha256=fOX0_faozG2P7iVojQoE1mbydweNyTcm-hXEfFrTtLI,5403\npip-25.1.1.dist-info/licenses/AUTHORS.txt,sha256=YzDFTYpeYnwpmODDFTgyKZNKWcfdO10L5Ex_U6kJLRc,11223\npip-25.1.1.dist-info/licenses/LICENSE.txt,sha256=Y0MApmnUmurmWxLGxIySTFGkzfPR_whtw0VtyLyqIQQ,1093\npip-25.1.1.dist-info/METADATA,sha256=QFxj1tLpk8hGWrgQLRhJYUpwo_1FqBr43OT0srIZcmU,3649\npip-25.1.1.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91\npip-25.1.1.dist-info/entry_points.txt,sha256=eeIjuzfnfR2PrhbjnbzFU6MnSS70kZLxwaHHq6M-bD0,87\npip-25.1.1.dist-info/top_level.txt,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4\npip-25.1.1.dist-info/RECORD,,\npip/_internal/cli/spinners.cpython-313.pyc,,\npip/_vendor/rich/palette.cpython-313.pyc,,\npip/_internal/operations/prepare.cpython-313.pyc,,\npip/_internal/resolution/resolvelib/provider.cpython-313.pyc,,\npip/_internal/operations/freeze.cpython-313.pyc,,\npip/_internal/vcs/mercurial.cpython-313.pyc,,\npip/_vendor/requests/status_codes.cpython-313.pyc,,\npip/_internal/cli/parser.cpython-313.pyc,,\npip/_internal/cli/index_command.cpython-313.pyc,,\npip/_vendor/urllib3/util/ssl_match_hostname.cpython-313.pyc,,\npip/_vendor/rich/_windows.cpython-313.pyc,,\npip/_vendor/urllib3/util/ssltransport.cpython-313.pyc,,\npip/_vendor/packaging/tags.cpython-313.pyc,,\npip/_internal/metadata/importlib/__pycache__,,\npip/_vendor/packaging/__init__.cpython-313.pyc,,\npip/_vendor/tomli/_parser.cpython-313.pyc,,\npip/_vendor/rich/rule.cpython-313.pyc,,\npip/_internal/utils/_log.cpython-313.pyc,,\npip/_vendor/pygments/styles/__init__.cpython-313.pyc,,\n../../../bin/pip3.13,,\npip-25.1.1.dist-info/__pycache__,,\npip/_internal/self_outdated_check.cpython-313.pyc,,\npip/_vendor/tomli/__pycache__,,\npip/_vendor/rich/traceback.cpython-313.pyc,,\npip/_internal/cli/main_parser.cpython-313.pyc,,\npip/_vendor/rich/live.cpython-313.pyc,,\npip/_vendor/rich/filesize.cpython-313.pyc,,\npip/_internal/vcs/subversion.cpython-313.pyc,,\npip/_vendor/requests/exceptions.cpython-313.pyc,,\npip/_vendor/pygments/console.cpython-313.pyc,,\npip/_internal/cli/cmdoptions.cpython-313.pyc,,\npip/_internal/__init__.cpython-313.pyc,,\npip/_internal/utils/logging.cpython-313.pyc,,\npip/_internal/utils/datetime.cpython-313.pyc,,\npip/_vendor/typing_extensions.cpython-313.pyc,,\npip/_vendor/urllib3/contrib/securetransport.cpython-313.pyc,,\npip/_vendor/requests/_internal_utils.cpython-313.pyc,,\npip/_vendor/rich/syntax.cpython-313.pyc,,\npip/_internal/network/session.cpython-313.pyc,,\npip/_vendor/pygments/styles/_mapping.cpython-313.pyc,,\npip/_internal/commands/freeze.cpython-313.pyc,,\npip/_vendor/rich/control.cpython-313.pyc,,\npip/_internal/commands/hash.cpython-313.pyc,,\npip/_internal/network/__pycache__,,\npip/_internal/locations/_sysconfig.cpython-313.pyc,,\npip/_vendor/pygments/formatters/_mapping.cpython-313.pyc,,\npip/_internal/utils/compatibility_tags.cpython-313.pyc,,\npip/_internal/utils/temp_dir.cpython-313.pyc,,\npip/_vendor/rich/color_triplet.cpython-313.pyc,,\npip/_vendor/idna/compat.cpython-313.pyc,,\npip/_vendor/rich/json.cpython-313.pyc,,\npip/_vendor/platformdirs/macos.cpython-313.pyc,,\npip/_internal/metadata/pkg_resources.cpython-313.pyc,,\npip/_vendor/rich/columns.cpython-313.pyc,,\npip/_vendor/rich/progress_bar.cpython-313.pyc,,\npip/_internal/operations/build/metadata_editable.cpython-313.pyc,,\npip/_vendor/resolvelib/resolvers/resolution.cpython-313.pyc,,\npip/_internal/cli/progress_bars.cpython-313.pyc,,\npip/_vendor/rich/__pycache__,,\npip/_vendor/rich/tree.cpython-313.pyc,,\npip/_vendor/urllib3/exceptions.cpython-313.pyc,,\npip/_internal/utils/subprocess.cpython-313.pyc,,\npip/_vendor/rich/text.cpython-313.pyc,,\npip/_vendor/rich/pretty.cpython-313.pyc,,\npip-25.1.1.virtualenv,,\npip/_vendor/rich/box.cpython-313.pyc,,\npip/_internal/metadata/__init__.cpython-313.pyc,,\npip/_vendor/packaging/metadata.cpython-313.pyc,,\npip/_vendor/rich/_null_file.cpython-313.pyc,,\npip/_internal/cli/base_command.cpython-313.pyc,,\npip/_vendor/urllib3/contrib/_securetransport/bindings.cpython-313.pyc,,\npip/_internal/commands/inspect.cpython-313.pyc,,\npip/_vendor/urllib3/contrib/_securetransport/__init__.cpython-313.pyc,,\npip/_internal/commands/completion.cpython-313.pyc,,\npip/_vendor/msgpack/__pycache__,,\npip/_vendor/cachecontrol/adapter.cpython-313.pyc,,\npip/_vendor/rich/abc.cpython-313.pyc,,\npip/_vendor/rich/_emoji_replace.cpython-313.pyc,,\npip/_internal/models/search_scope.cpython-313.pyc,,\npip/_vendor/rich/live_render.cpython-313.pyc,,\npip/_internal/operations/build/build_tracker.cpython-313.pyc,,\npip/_vendor/packaging/_tokenizer.cpython-313.pyc,,\npip/_vendor/pygments/styles/__pycache__,,\npip/_vendor/idna/idnadata.cpython-313.pyc,,\npip/_internal/commands/uninstall.cpython-313.pyc,,\npip/_vendor/rich/_log_render.cpython-313.pyc,,\npip/_internal/distributions/wheel.cpython-313.pyc,,\npip/_vendor/dependency_groups/_pip_wrapper.cpython-313.pyc,,\npip/_vendor/rich/segment.cpython-313.pyc,,\npip/_internal/resolution/base.cpython-313.pyc,,\npip/_internal/req/constructors.cpython-313.pyc,,\npip/_internal/operations/build/wheel_legacy.cpython-313.pyc,,\npip/_vendor/packaging/licenses/_spdx.cpython-313.pyc,,\npip/_vendor/rich/logging.cpython-313.pyc,,\npip/_vendor/pygments/regexopt.cpython-313.pyc,,\npip/_vendor/distro/__main__.cpython-313.pyc,,\npip/_vendor/idna/__pycache__,,\npip/_vendor/pygments/plugin.cpython-313.pyc,,\npip/_internal/vcs/git.cpython-313.pyc,,\npip/_vendor/platformdirs/__pycache__,,\npip/_internal/index/__init__.cpython-313.pyc,,\npip/_vendor/rich/file_proxy.cpython-313.pyc,,\npip/_internal/distributions/sdist.cpython-313.pyc,,\npip/_vendor/rich/_inspect.cpython-313.pyc,,\npip/_internal/utils/compat.cpython-313.pyc,,\npip/_internal/models/wheel.cpython-313.pyc,,\npip/_internal/network/cache.cpython-313.pyc,,\npip/_vendor/rich/_stack.cpython-313.pyc,,\npip/_internal/commands/wheel.cpython-313.pyc,,\npip/_internal/resolution/resolvelib/factory.cpython-313.pyc,,\npip/_vendor/resolvelib/resolvers/abstract.cpython-313.pyc,,\npip/_internal/exceptions.cpython-313.pyc,,\npip/_vendor/pygments/modeline.cpython-313.pyc,,\npip/_vendor/cachecontrol/caches/__pycache__,,\npip/_vendor/rich/console.cpython-313.pyc,,\npip/_vendor/rich/scope.cpython-313.pyc,,\npip/_vendor/urllib3/connection.cpython-313.pyc,,\npip/_vendor/requests/api.cpython-313.pyc,,\npip/_internal/utils/__pycache__,,\npip/_vendor/urllib3/_version.cpython-313.pyc,,\npip/_vendor/tomli_w/_writer.cpython-313.pyc,,\npip/_vendor/resolvelib/resolvers/__pycache__,,\npip/_vendor/rich/_windows_renderer.cpython-313.pyc,,\npip/_vendor/platformdirs/__main__.cpython-313.pyc,,\npip/_vendor/packaging/specifiers.cpython-313.pyc,,\npip/_vendor/__pycache__,,\npip/_vendor/packaging/licenses/__init__.cpython-313.pyc,,\npip/_vendor/truststore/_ssl_constants.cpython-313.pyc,,\npip/_vendor/urllib3/contrib/__init__.cpython-313.pyc,,\npip/_internal/operations/install/wheel.cpython-313.pyc,,\npip/_vendor/cachecontrol/caches/redis_cache.cpython-313.pyc,,\npip-25.1.1.dist-info/licenses/__pycache__,,\npip/_internal/utils/retry.cpython-313.pyc,,\npip/_vendor/rich/_loop.cpython-313.pyc,,\npip/_internal/models/candidate.cpython-313.pyc,,\npip/_vendor/packaging/_musllinux.cpython-313.pyc,,\npip/_internal/__pycache__,,\npip/_vendor/pygments/formatters/__init__.cpython-313.pyc,,\npip/_internal/utils/filetypes.cpython-313.pyc,,\npip/_vendor/dependency_groups/_lint_dependency_groups.cpython-313.pyc,,\npip/_vendor/urllib3/request.cpython-313.pyc,,\npip/_vendor/urllib3/response.cpython-313.pyc,,\npip/_vendor/requests/sessions.cpython-313.pyc,,\n../../../bin/pip3,,\npip/_vendor/urllib3/__pycache__,,\npip/_vendor/resolvelib/resolvers/criterion.cpython-313.pyc,,\npip/_vendor/rich/jupyter.cpython-313.pyc,,\npip/_internal/metadata/importlib/_compat.cpython-313.pyc,,\npip/_vendor/pygments/__main__.cpython-313.pyc,,\npip/_vendor/certifi/core.cpython-313.pyc,,\npip/_vendor/distlib/__init__.cpython-313.pyc,,\npip/_internal/req/req_dependency_group.cpython-313.pyc,,\npip/_vendor/idna/package_data.cpython-313.pyc,,\npip/_internal/utils/deprecation.cpython-313.pyc,,\npip/_internal/network/xmlrpc.cpython-313.pyc,,\npip/_internal/req/req_file.cpython-313.pyc,,\npip/__pycache__,,\npip/_vendor/rich/screen.cpython-313.pyc,,\npip/_vendor/urllib3/util/response.cpython-313.pyc,,\npip/_vendor/resolvelib/structs.cpython-313.pyc,,\npip/_internal/operations/build/wheel_editable.cpython-313.pyc,,\npip/_vendor/resolvelib/__init__.cpython-313.pyc,,\npip/_internal/commands/index.cpython-313.pyc,,\npip/_vendor/dependency_groups/_implementation.cpython-313.pyc,,\npip/_vendor/distlib/version.cpython-313.pyc,,\npip/_vendor/rich/emoji.cpython-313.pyc,,\npip/_vendor/requests/packages.cpython-313.pyc,,\npip/_internal/wheel_builder.cpython-313.pyc,,\npip/_vendor/pygments/lexers/__init__.cpython-313.pyc,,\npip/_vendor/rich/pager.cpython-313.pyc,,\npip/_vendor/cachecontrol/serialize.cpython-313.pyc,,\npip/_internal/network/__init__.cpython-313.pyc,,\npip/_vendor/dependency_groups/__init__.cpython-313.pyc,,\npip/_internal/models/scheme.cpython-313.pyc,,\npip/_vendor/truststore/_api.cpython-313.pyc,,\npip/_vendor/urllib3/contrib/_securetransport/__pycache__,,\npip/_vendor/cachecontrol/wrapper.cpython-313.pyc,,\npip/_vendor/rich/_wrap.cpython-313.pyc,,\npip/_internal/network/lazy_wheel.cpython-313.pyc,,\npip/_internal/utils/wheel.cpython-313.pyc,,\npip/_vendor/urllib3/packages/backports/weakref_finalize.cpython-313.pyc,,\npip/_internal/models/direct_url.cpython-313.pyc,,\npip/_internal/cli/command_context.cpython-313.pyc,,\npip/_internal/resolution/resolvelib/reporter.cpython-313.pyc,,\npip/_vendor/requests/adapters.cpython-313.pyc,,\npip/_internal/configuration.cpython-313.pyc,,\npip/_vendor/rich/__init__.cpython-313.pyc,,\npip/_vendor/urllib3/util/__init__.cpython-313.pyc,,\npip/_internal/metadata/importlib/_dists.cpython-313.pyc,,\npip/_internal/models/selection_prefs.cpython-313.pyc,,\npip/_vendor/resolvelib/reporters.cpython-313.pyc,,\npip/_vendor/pkg_resources/__pycache__,,\npip/_internal/cli/autocompletion.cpython-313.pyc,,\npip/_internal/commands/check.cpython-313.pyc,,\npip/_vendor/__init__.cpython-313.pyc,,\npip/_vendor/platformdirs/unix.cpython-313.pyc,,\npip/_vendor/pygments/lexers/_mapping.cpython-313.pyc,,\npip/_vendor/certifi/__init__.cpython-313.pyc,,\npip/_vendor/distlib/__pycache__,,\npip/_internal/metadata/__pycache__,,\npip/_vendor/cachecontrol/filewrapper.cpython-313.pyc,,\npip/_vendor/cachecontrol/heuristics.cpython-313.pyc,,\npip/_vendor/rich/_palettes.cpython-313.pyc,,\npip/_vendor/requests/structures.cpython-313.pyc,,\npip/_vendor/urllib3/contrib/__pycache__,,\npip/_internal/locations/base.cpython-313.pyc,,\npip/_internal/locations/__pycache__,,\npip/_internal/resolution/resolvelib/candidates.cpython-313.pyc,,\npip/_vendor/rich/table.cpython-313.pyc,,\npip/_vendor/dependency_groups/_toml_compat.cpython-313.pyc,,\npip/_internal/utils/filesystem.cpython-313.pyc,,\npip/_vendor/rich/spinner.cpython-313.pyc,,\npip/_vendor/pygments/sphinxext.cpython-313.pyc,,\npip/_vendor/pygments/unistring.cpython-313.pyc,,\npip/_vendor/pygments/filters/__init__.cpython-313.pyc,,\npip/_vendor/requests/compat.cpython-313.pyc,,\npip/_vendor/cachecontrol/_cmd.cpython-313.pyc,,\npip/_internal/metadata/_json.cpython-313.pyc,,\npip/_vendor/truststore/_macos.cpython-313.pyc,,\npip/_vendor/urllib3/__init__.cpython-313.pyc,,\npip/_vendor/pygments/lexers/__pycache__,,\npip/_internal/req/__pycache__,,\n../../../bin/pip-3.13,,\npip/_vendor/urllib3/util/retry.cpython-313.pyc,,\npip/_vendor/distlib/wheel.cpython-313.pyc,,\npip/_internal/resolution/__init__.cpython-313.pyc,,\npip/_vendor/urllib3/poolmanager.cpython-313.pyc,,\npip/_vendor/pkg_resources/__init__.cpython-313.pyc,,\npip/_vendor/resolvelib/resolvers/__init__.cpython-313.pyc,,\npip/_vendor/cachecontrol/cache.cpython-313.pyc,,\npip/_internal/utils/setuptools_build.cpython-313.pyc,,\npip/_vendor/urllib3/util/request.cpython-313.pyc,,\npip/_vendor/distlib/manifest.cpython-313.pyc,,\npip/_vendor/rich/containers.cpython-313.pyc,,\npip/_vendor/rich/_pick.cpython-313.pyc,,\npip/_internal/resolution/resolvelib/__pycache__,,\npip/_vendor/cachecontrol/caches/__init__.cpython-313.pyc,,\npip/_vendor/cachecontrol/__pycache__,,\npip/_internal/main.cpython-313.pyc,,\npip/_internal/utils/hashes.cpython-313.pyc,,\npip/__main__.cpython-313.pyc,,\npip/_vendor/rich/theme.cpython-313.pyc,,\npip/_vendor/idna/core.cpython-313.pyc,,\npip/_internal/utils/packaging.cpython-313.pyc,,\npip/_vendor/idna/intranges.cpython-313.pyc,,\npip/_internal/network/auth.cpython-313.pyc,,\npip/_internal/index/__pycache__,,\npip/_internal/utils/egg_link.cpython-313.pyc,,\npip/_vendor/requests/__version__.cpython-313.pyc,,\npip/_internal/commands/lock.cpython-313.pyc,,\npip/_vendor/packaging/version.cpython-313.pyc,,\npip/_vendor/rich/panel.cpython-313.pyc,,\npip/_vendor/packaging/__pycache__,,\npip/_vendor/msgpack/ext.cpython-313.pyc,,\npip/_internal/vcs/versioncontrol.cpython-313.pyc,,\npip/_internal/commands/__pycache__,,\npip/_internal/cli/req_command.cpython-313.pyc,,\npip/_internal/distributions/__init__.cpython-313.pyc,,\npip/_vendor/urllib3/packages/backports/__pycache__,,\npip/_internal/distributions/base.cpython-313.pyc,,\npip/_vendor/rich/status.cpython-313.pyc,,\npip/_internal/commands/search.cpython-313.pyc,,\npip/_vendor/rich/markup.cpython-313.pyc,,\npip/_vendor/pyproject_hooks/_in_process/__init__.cpython-313.pyc,,\npip/_internal/req/req_set.cpython-313.pyc,,\npip/_internal/commands/install.cpython-313.pyc,,\npip/_internal/cli/__pycache__,,\npip/_vendor/urllib3/_collections.cpython-313.pyc,,\npip/_vendor/urllib3/packages/backports/makefile.cpython-313.pyc,,\npip/_vendor/rich/region.cpython-313.pyc,,\npip/_vendor/dependency_groups/__pycache__,,\npip/_internal/operations/build/wheel.cpython-313.pyc,,\npip/_vendor/urllib3/contrib/_securetransport/low_level.cpython-313.pyc,,\npip/_vendor/cachecontrol/__init__.cpython-313.pyc,,\npip/_vendor/urllib3/util/wait.cpython-313.pyc,,\npip/_vendor/cachecontrol/caches/file_cache.cpython-313.pyc,,\npip/_vendor/distro/distro.cpython-313.pyc,,\npip/_vendor/requests/cookies.cpython-313.pyc,,\n../../../bin/pip,,\npip/_internal/commands/debug.cpython-313.pyc,,\npip/_vendor/cachecontrol/controller.cpython-313.pyc,,\npip/_vendor/urllib3/fields.cpython-313.pyc,,\npip/_vendor/rich/themes.cpython-313.pyc,,\npip/_internal/operations/install/editable_legacy.cpython-313.pyc,,\npip/_vendor/platformdirs/android.cpython-313.pyc,,\npip-25.1.1.dist-info/INSTALLER,,\npip/_vendor/packaging/_parser.cpython-313.pyc,,\npip/_vendor/tomli_w/__init__.cpython-313.pyc,,\npip/_internal/models/target_python.cpython-313.pyc,,\npip/_internal/pyproject.cpython-313.pyc,,\npip/_vendor/idna/__init__.cpython-313.pyc,,\npip/_vendor/rich/_win32_console.cpython-313.pyc,,\npip/_vendor/platformdirs/windows.cpython-313.pyc,,\npip/_internal/resolution/legacy/resolver.cpython-313.pyc,,\npip/_vendor/pygments/util.cpython-313.pyc,,\npip/_internal/utils/unpacking.cpython-313.pyc,,\npip/_vendor/urllib3/util/url.cpython-313.pyc,,\npip/_vendor/pyproject_hooks/_in_process/__pycache__,,\npip/_vendor/urllib3/contrib/socks.cpython-313.pyc,,\npip/_vendor/certifi/__pycache__,,\npip/_vendor/rich/repr.cpython-313.pyc,,\npip/_vendor/urllib3/util/connection.cpython-313.pyc,,\npip/_vendor/rich/terminal_theme.cpython-313.pyc,,\npip/_internal/req/req_install.cpython-313.pyc,,\npip/_internal/network/download.cpython-313.pyc,,\npip/_internal/operations/install/__pycache__,,\npip/_vendor/pygments/filters/__pycache__,,\npip/_vendor/pygments/scanner.cpython-313.pyc,,\npip/_internal/resolution/resolvelib/__init__.cpython-313.pyc,,\npip/_vendor/urllib3/util/__pycache__,,\npip/_vendor/urllib3/packages/backports/__init__.cpython-313.pyc,,\npip/_vendor/platformdirs/__init__.cpython-313.pyc,,\npip/_vendor/pygments/formatters/__pycache__,,\npip/_vendor/distlib/locators.cpython-313.pyc,,\npip/_vendor/rich/bar.cpython-313.pyc,,\npip/_vendor/requests/certs.cpython-313.pyc,,\npip/_vendor/rich/constrain.cpython-313.pyc,,\npip/_vendor/packaging/_elffile.cpython-313.pyc,,\npip/_vendor/distlib/scripts.cpython-313.pyc,,\npip/_internal/utils/__init__.cpython-313.pyc,,\npip/_internal/utils/direct_url_helpers.cpython-313.pyc,,\npip/_vendor/rich/protocol.cpython-313.pyc,,\npip/_vendor/packaging/_manylinux.cpython-313.pyc,,\npip/_vendor/msgpack/exceptions.cpython-313.pyc,,\npip/_internal/commands/help.cpython-313.pyc,,\npip/_vendor/resolvelib/__pycache__,,\npip/_vendor/distro/__init__.cpython-313.pyc,,\npip/__pip-runner__.cpython-313.pyc,,\npip/_vendor/distlib/database.cpython-313.pyc,,\npip/_vendor/pyproject_hooks/_in_process/_in_process.cpython-313.pyc,,\npip/_vendor/rich/highlighter.cpython-313.pyc,,\npip/_vendor/rich/diagnose.cpython-313.pyc,,\npip/_internal/req/req_uninstall.cpython-313.pyc,,\npip/_vendor/rich/__main__.cpython-313.pyc,,\npip/_vendor/rich/prompt.cpython-313.pyc,,\npip/_vendor/msgpack/fallback.cpython-313.pyc,,\npip/_vendor/rich/_fileno.cpython-313.pyc,,\npip/_internal/operations/build/__pycache__,,\npip/_internal/vcs/__init__.cpython-313.pyc,,\npip/_internal/operations/__init__.cpython-313.pyc,,\npip/_vendor/requests/__init__.cpython-313.pyc,,\npip/_internal/cli/main.cpython-313.pyc,,\npip/_internal/utils/_jaraco_text.cpython-313.pyc,,\npip/_vendor/urllib3/util/proxy.cpython-313.pyc,,\npip/_vendor/rich/_ratio.cpython-313.pyc,,\npip/_internal/utils/misc.cpython-313.pyc,,\npip/_internal/cache.cpython-313.pyc,,\npip/_internal/index/collector.cpython-313.pyc,,\npip/_vendor/tomli/_re.cpython-313.pyc,,\npip/_internal/commands/show.cpython-313.pyc,,\npip/_vendor/pygments/filter.cpython-313.pyc,,\npip/_internal/vcs/__pycache__,,\npip/_vendor/packaging/licenses/__pycache__,,\npip/_internal/metadata/base.cpython-313.pyc,,\npip/_vendor/platformdirs/api.cpython-313.pyc,,\npip/_vendor/requests/hooks.cpython-313.pyc,,\npip/_vendor/rich/layout.cpython-313.pyc,,\npip/_vendor/urllib3/contrib/_appengine_environ.cpython-313.pyc,,\npip/_vendor/urllib3/packages/__init__.cpython-313.pyc,,\npip/_vendor/rich/align.cpython-313.pyc,,\npip/_vendor/rich/_spinners.cpython-313.pyc,,\npip/_vendor/distlib/compat.cpython-313.pyc,,\npip/_internal/resolution/resolvelib/resolver.cpython-313.pyc,,\npip/_internal/resolution/legacy/__init__.cpython-313.pyc,,\npip/_vendor/rich/default_styles.cpython-313.pyc,,\npip/_vendor/urllib3/filepost.cpython-313.pyc,,\npip/_vendor/distlib/util.cpython-313.pyc,,\npip/_vendor/urllib3/packages/__pycache__,,\npip/_internal/operations/install/__init__.cpython-313.pyc,,\npip/_vendor/msgpack/__init__.cpython-313.pyc,,\npip/_vendor/idna/codec.cpython-313.pyc,,\npip/_internal/commands/cache.cpython-313.pyc,,\npip/_internal/operations/build/__init__.cpython-313.pyc,,\npip/_internal/index/sources.cpython-313.pyc,,\npip/_vendor/rich/styled.cpython-313.pyc,,\npip/_internal/models/__init__.cpython-313.pyc,,\npip/_internal/network/utils.cpython-313.pyc,,\npip/_internal/operations/check.cpython-313.pyc,,\npip/_internal/resolution/legacy/__pycache__,,\npip/_internal/metadata/importlib/__init__.cpython-313.pyc,,\npip/_internal/models/__pycache__,,\npip/_internal/index/package_finder.cpython-313.pyc,,\npip/_internal/metadata/importlib/_envs.cpython-313.pyc,,\npip/_vendor/distlib/metadata.cpython-313.pyc,,\npip/_vendor/packaging/markers.cpython-313.pyc,,\npip/__init__.cpython-313.pyc,,\npip/_vendor/requests/models.cpython-313.pyc,,\npip/_vendor/tomli_w/__pycache__,,\npip/_internal/models/index.cpython-313.pyc,,\npip/_internal/resolution/resolvelib/found_candidates.cpython-313.pyc,,\npip/_vendor/truststore/__init__.cpython-313.pyc,,\npip/_vendor/pyproject_hooks/_impl.cpython-313.pyc,,\npip/_vendor/requests/__pycache__,,\npip/_internal/operations/__pycache__,,\npip/_vendor/tomli/_types.cpython-313.pyc,,\npip/_vendor/packaging/requirements.cpython-313.pyc,,\npip/_vendor/tomli/__init__.cpython-313.pyc,,\npip/_vendor/rich/measure.cpython-313.pyc,,\npip/_vendor/rich/progress.cpython-313.pyc,,\npip/_vendor/distlib/markers.cpython-313.pyc,,\npip/_internal/operations/build/metadata_legacy.cpython-313.pyc,,\npip/_internal/commands/configuration.cpython-313.pyc,,\npip/_internal/utils/glibc.cpython-313.pyc,,\npip/_vendor/requests/help.cpython-313.pyc,,\npip/_internal/models/link.cpython-313.pyc,,\npip/_internal/utils/virtualenv.cpython-313.pyc,,\npip/_vendor/pygments/formatter.cpython-313.pyc,,\npip/_vendor/pyproject_hooks/__init__.cpython-313.pyc,,\npip/_internal/req/__init__.cpython-313.pyc,,\npip/_vendor/pygments/token.cpython-313.pyc,,\npip/_vendor/resolvelib/providers.cpython-313.pyc,,\npip/_vendor/rich/errors.cpython-313.pyc,,\npip/_vendor/requests/auth.cpython-313.pyc,,\npip/_vendor/urllib3/contrib/ntlmpool.cpython-313.pyc,,\npip/_vendor/urllib3/util/timeout.cpython-313.pyc,,\npip/_vendor/truststore/_windows.cpython-313.pyc,,\npip/_vendor/requests/utils.cpython-313.pyc,,\npip/_internal/utils/entrypoints.cpython-313.pyc,,\npip/_vendor/pygments/__pycache__,,\npip/_vendor/pygments/lexers/python.cpython-313.pyc,,\npip/_internal/models/format_control.cpython-313.pyc,,\npip/_vendor/idna/uts46data.cpython-313.pyc,,\npip/_vendor/rich/_extension.cpython-313.pyc,,\npip/_vendor/urllib3/connectionpool.cpython-313.pyc,,\npip/_internal/operations/build/metadata.cpython-313.pyc,,\npip/_vendor/rich/ansi.cpython-313.pyc,,\npip/_vendor/pyproject_hooks/__pycache__,,\npip/_vendor/packaging/utils.cpython-313.pyc,,\npip/_internal/utils/urls.cpython-313.pyc,,\npip/_internal/vcs/bazaar.cpython-313.pyc,,\npip/_internal/distributions/__pycache__,,\npip/_vendor/resolvelib/resolvers/exceptions.cpython-313.pyc,,\npip/_vendor/urllib3/packages/six.cpython-313.pyc,,\npip/_vendor/rich/_export_format.cpython-313.pyc,,\npip/_vendor/pygments/__init__.cpython-313.pyc,,\npip/_vendor/urllib3/util/queue.cpython-313.pyc,,\npip/_vendor/urllib3/util/ssl_.cpython-313.pyc,,\npip/_vendor/pygments/style.cpython-313.pyc,,\npip/_internal/utils/appdirs.cpython-313.pyc,,\npip/_vendor/rich/cells.cpython-313.pyc,,\npip/_internal/cli/status_codes.cpython-313.pyc,,\npip/_internal/resolution/__pycache__,,\npip/_vendor/rich/padding.cpython-313.pyc,,\npip/_vendor/distlib/resources.cpython-313.pyc,,\npip/_vendor/rich/_emoji_codes.cpython-313.pyc,,\npip/_vendor/certifi/__main__.cpython-313.pyc,,\npip/_internal/models/installation_report.cpython-313.pyc,,\npip/_internal/locations/__init__.cpython-313.pyc,,\npip/_vendor/distro/__pycache__,,\npip/_internal/locations/_distutils.cpython-313.pyc,,\npip/_vendor/rich/color.cpython-313.pyc,,\npip/_vendor/platformdirs/version.cpython-313.pyc,,\npip/_vendor/pygments/lexer.cpython-313.pyc,,\npip/_vendor/urllib3/contrib/appengine.cpython-313.pyc,,\npip/_internal/commands/list.cpython-313.pyc,,\npip/_internal/commands/__init__.cpython-313.pyc,,\npip/_internal/build_env.cpython-313.pyc,,\npip/_vendor/dependency_groups/__main__.cpython-313.pyc,,\npip/_vendor/rich/_cell_widths.cpython-313.pyc,,\npip/_vendor/rich/_timer.cpython-313.pyc,,\npip/_internal/models/pylock.cpython-313.pyc,,\npip/_vendor/truststore/_openssl.cpython-313.pyc,,\npip/_internal/cli/__init__.cpython-313.pyc,,\npip/_vendor/packaging/_structures.cpython-313.pyc,,\npip/_vendor/rich/style.cpython-313.pyc,,\npip/_vendor/truststore/__pycache__,,\npip/_vendor/urllib3/contrib/pyopenssl.cpython-313.pyc,,\npip/_internal/resolution/resolvelib/requirements.cpython-313.pyc,,\npip/_internal/distributions/installed.cpython-313.pyc,,\npip/_internal/resolution/resolvelib/base.cpython-313.pyc,,\npip/_vendor/distlib/index.cpython-313.pyc,,\npip/_internal/commands/download.cpython-313.pyc,,",[],[213,919,920,921,939,957],"044895e0-67fc-11f0-b654-0224a6c84d84","METADATA","0448969e-67fc-11f0-b654-0224a6c84d84",130,["D",1753299254959],"Metadata-Version: 2.4\nName: pip\nVersion: 25.1.1\nSummary: The PyPA recommended tool for installing Python packages.\nAuthor-email: The pip developers \nLicense: MIT\nProject-URL: Homepage, https://pip.pypa.io/\nProject-URL: Documentation, https://pip.pypa.io\nProject-URL: Source, https://github.com/pypa/pip\nProject-URL: Changelog, https://pip.pypa.io/en/stable/news/\nClassifier: Development Status :: 5 - Production/Stable\nClassifier: Intended Audience :: Developers\nClassifier: License :: OSI Approved :: MIT License\nClassifier: Topic :: Software Development :: Build Tools\nClassifier: Programming Language :: Python\nClassifier: Programming Language :: Python :: 3\nClassifier: Programming Language :: Python :: 3 :: Only\nClassifier: Programming Language :: Python :: 3.9\nClassifier: Programming Language :: Python :: 3.10\nClassifier: Programming Language :: Python :: 3.11\nClassifier: Programming Language :: Python :: 3.12\nClassifier: Programming Language :: Python :: 3.13\nClassifier: Programming Language :: Python :: Implementation :: CPython\nClassifier: Programming Language :: Python :: Implementation :: PyPy\nRequires-Python: >=3.9\nDescription-Content-Type: text/x-rst\nLicense-File: LICENSE.txt\nLicense-File: AUTHORS.txt\nDynamic: license-file\n\npip - The Python Package Installer\n==================================\n\n.. |pypi-version| image:: https://img.shields.io/pypi/v/pip.svg\n :target: https://pypi.org/project/pip/\n :alt: PyPI\n\n.. |python-versions| image:: https://img.shields.io/pypi/pyversions/pip\n :target: https://pypi.org/project/pip\n :alt: PyPI - Python Version\n\n.. |docs-badge| image:: https://readthedocs.org/projects/pip/badge/?version=latest\n :target: https://pip.pypa.io/en/latest\n :alt: Documentation\n\n|pypi-version| |python-versions| |docs-badge|\n\npip is the `package installer`_ for Python. You can use pip to install packages from the `Python Package Index`_ and other indexes.\n\nPlease take a look at our documentation for how to install and use pip:\n\n* `Installation`_\n* `Usage`_\n\nWe release updates regularly, with a new version every 3 months. Find more details in our documentation:\n\n* `Release notes`_\n* `Release process`_\n\nIf you find bugs, need help, or want to talk to the developers, please use our mailing lists or chat rooms:\n\n* `Issue tracking`_\n* `Discourse channel`_\n* `User IRC`_\n\nIf you want to get involved head over to GitHub to get the source code, look at our development documentation and feel free to jump on the developer mailing lists and chat rooms:\n\n* `GitHub page`_\n* `Development documentation`_\n* `Development IRC`_\n\nCode of Conduct\n---------------\n\nEveryone interacting in the pip project's codebases, issue trackers, chat\nrooms, and mailing lists is expected to follow the `PSF Code of Conduct`_.\n\n.. _package installer: https://packaging.python.org/guides/tool-recommendations/\n.. _Python Package Index: https://pypi.org\n.. _Installation: https://pip.pypa.io/en/stable/installation/\n.. _Usage: https://pip.pypa.io/en/stable/\n.. _Release notes: https://pip.pypa.io/en/stable/news.html\n.. _Release process: https://pip.pypa.io/en/latest/development/release-process/\n.. _GitHub page: https://github.com/pypa/pip\n.. _Development documentation: https://pip.pypa.io/en/latest/development\n.. _Issue tracking: https://github.com/pypa/pip/issues\n.. _Discourse channel: https://discuss.python.org/c/packaging\n.. _User IRC: https://kiwiirc.com/nextclient/#ircs://irc.libera.chat:+6697/pypa\n.. _Development IRC: https://kiwiirc.com/nextclient/#ircs://irc.libera.chat:+6697/pypa-dev\n.. _PSF Code of Conduct: https://github.com/pypa/.github/blob/main/CODE_OF_CONDUCT.md\n",[],[213,919,920,921,939,965],"04457f68-67fc-11f0-84bb-0224a6c84d84","INSTALLER","04458012-67fc-11f0-84bb-0224a6c84d84",129,["D",1753299254950],[],[213,919,920,921,939,973],"042df88e-67fc-11f0-8cc3-0224a6c84d84","LICENSE.txt","042df96a-67fc-11f0-8cc3-0224a6c84d84","fb41e67c-67fb-11f0-b712-0224a6c84d84",125,["D",1753299254720],"Copyright (c) 2008-present The pip developers (see AUTHORS.txt file)\n\nPermission is hereby granted, free of charge, to any person obtaining\na copy of this software and associated documentation files (the\n\"Software\"), to deal in the Software without restriction, including\nwithout limitation the rights to use, copy, modify, merge, publish,\ndistribute, sublicense, and/or sell copies of the Software, and to\npermit persons to whom the Software is furnished to do so, subject to\nthe following conditions:\n\nThe above copyright notice and this permission notice shall be\nincluded in all copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\nEXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\nMERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\nNONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE\nLIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION\nOF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION\nWITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n",[],[213,919,920,921,939,988,980],"licenses","043bd814-67fc-11f0-928e-0224a6c84d84","AUTHORS.txt","043bd8dc-67fc-11f0-928e-0224a6c84d84",127,["D",1753299254723],"@Switch01\nA_Rog\nAakanksha Agrawal\nAbhinav Sagar\nABHYUDAY PRATAP SINGH\nabs51295\nAceGentile\nAdam Chainz\nAdam Tse\nAdam Turner\nAdam Wentz\nadmin\nAdolfo Ochagavía\nAdrien Morison\nAgus\nahayrapetyan\nAhilya\nAinsworthK\nAkash Srivastava\nAlan Yee\nAlbert Tugushev\nAlbert-Guan\nalbertg\nAlberto Sottile\nAleks Bunin\nAles Erjavec\nAlethea Flowers\nAlex Gaynor\nAlex Grönholm\nAlex Hedges\nAlex Loosley\nAlex Morega\nAlex Stachowiak\nAlexander Regueiro\nAlexander Shtyrov\nAlexandre Conrad\nAlexey Popravka\nAleš Erjavec\nAlli\nAmi Fischman\nAnanya Maiti\nAnatoly Techtonik\nAnders Kaseorg\nAndre Aguiar\nAndreas Lutro\nAndrei Geacar\nAndrew Gaul\nAndrew Shymanel\nAndrey Bienkowski\nAndrey Bulgakov\nAndrés Delfino\nAndy Freeland\nAndy Kluger\nAni Hayrapetyan\nAniruddha Basak\nAnish Tambe\nAnrs Hu\nAnthony Sottile\nAntoine Musso\nAnton Ovchinnikov\nAnton Patrushev\nAnton Zelenov\nAntonio Alvarado Hernandez\nAntony Lee\nAntti Kaihola\nAnubhav Patel\nAnudit Nagar\nAnuj Godase\nAQNOUCH Mohammed\nAraHaan\narena\narenasys\nArindam Choudhury\nArmin Ronacher\nArnon Yaari\nArtem\nArun Babu Neelicattu\nAshley Manton\nAshwin Ramaswami\natse\nAtsushi Odagiri\nAvinash Karhana\nAvner Cohen\nAwit (Ah-Wit) Ghirmai\nBaptiste Mispelon\nBarney Gale\nbarneygale\nBartek Ogryczak\nBastian Venthur\nBen Bodenmiller\nBen Darnell\nBen Hoyt\nBen Mares\nBen Rosser\nBence Nagy\nBenjamin Peterson\nBenjamin VanEvery\nBenoit Pierre\nBerker Peksag\nBernard\nBernard Tyers\nBernardo B. Marques\nBernhard M. Wiedemann\nBertil Hatt\nBhavam Vidyarthi\nBlazej Michalik\nBogdan Opanchuk\nBorisZZZ\nBrad Erickson\nBradley Ayers\nBradley Reynolds\nBranch Vincent\nBrandon L. Reiss\nBrandt Bucher\nBrannon Dorsey\nBrett Randall\nBrett Rosen\nBrian Cristante\nBrian Rosner\nbriantracy\nBrownTruck\nBruno Oliveira\nBruno Renié\nBruno S\nBstrdsmkr\nBuck Golemon\nburrows\nBussonnier Matthias\nbwoodsend\nc22\nCaleb Brown\nCaleb Martinez\nCalvin Smith\nCarl Meyer\nCarlos Liam\nCarol Willing\nCarter Thayer\nCass\nChandrasekhar Atina\nCharlie Marsh\ncharwick\nChih-Hsuan Yen\nChris Brinker\nChris Hunt\nChris Jerdonek\nChris Kuehl\nChris Markiewicz\nChris McDonough\nChris Pawley\nChris Pryer\nChris Wolfe\nChristian Clauss\nChristian Heimes\nChristian Oudard\nChristoph Reiter\nChristopher Hunt\nChristopher Snyder\nchrysle\ncjc7373\nClark Boylan\nClaudio Jolowicz\nClay McClure\nCody\nCody Soyland\nColin Watson\nCollin Anderson\nConnor Osborn\nCooper Lees\nCooper Ry Lees\nCory Benfield\nCory Wright\nCraig Kerstiens\nCristian Sorinel\nCristina\nCristina Muñoz\nctg123\nCurtis Doty\ncytolentino\nDaan De Meyer\nDale\nDamian\nDamian Quiroga\nDamian Shaw\nDan Black\nDan Savilonis\nDan Sully\nDane Hillard\ndaniel\nDaniel Collins\nDaniel Hahler\nDaniel Holth\nDaniel Jost\nDaniel Katz\nDaniel Shaulov\nDaniele Esposti\nDaniele Nicolodi\nDaniele Procida\nDaniil Konovalenko\nDanny Hermes\nDanny McClanahan\nDarren Kavanagh\nDav Clark\nDave Abrahams\nDave Jones\nDavid Aguilar\nDavid Black\nDavid Bordeynik\nDavid Caro\nDavid D Lowe\nDavid Evans\nDavid Hewitt\nDavid Linke\nDavid Poggi\nDavid Poznik\nDavid Pursehouse\nDavid Runge\nDavid Tucker\nDavid Wales\nDavidovich\nddelange\nDeepak Sharma\nDeepyaman Datta\nDenise Yu\ndependabot[bot]\nderwolfe\nDesetude\ndeveloper\nDevesh Kumar Singh\ndevsagul\nDiego Caraballo\nDiego Ramirez\nDiegoCaraballo\nDimitri Merejkowsky\nDimitri Papadopoulos\nDimitri Papadopoulos Orfanos\nDirk Stolle\nDmitry Gladkov\nDmitry Volodin\nDomen Kožar\nDominic Davis-Foster\nDonald Stufft\nDongweiming\ndoron zarhi\nDos Moonen\nDouglas Thor\nDrFeathers\nDustin Ingram\nDustin Rodrigues\nDwayne Bailey\nEd Morley\nEdgar Ramírez\nEdgar Ramírez Mondragón\nEe Durbin\nEfflam Lemaillet\nefflamlemaillet\nEitan Adler\nekristina\nelainechan\nEli Schwartz\nElisha Hollander\nEllen Marie Dash\nEmil Burzo\nEmil Styrke\nEmmanuel Arias\nEndoh Takanao\nenoch\nErdinc Mutlu\nEric Cousineau\nEric Gillingham\nEric Hanchrow\nEric Hopper\nErik M. Bray\nErik Rose\nErwin Janssen\nEugene Vereshchagin\neverdimension\nFederico\nFelipe Peter\nFelix Yan\nfiber-space\nFilip Kokosiński\nFilipe Laíns\nFinn Womack\nfinnagin\nFlavio Amurrio\nFlorian Briand\nFlorian Rathgeber\nFrancesco\nFrancesco Montesano\nFredrik Orderud\nFredrik Roubert\nFrost Ming\nGabriel Curio\nGabriel de Perthuis\nGarry Polley\ngavin\ngdanielson\nGeoffrey Sneddon\nGeorge Margaritis\nGeorge Song\nGeorgi Valkov\nGeorgy Pchelkin\nghost\nGiftlin Rajaiah\ngizmoguy1\ngkdoc\nGodefroid Chapelle\nGopinath M\nGOTO Hayato\ngousaiyang\ngpiks\nGreg Roodt\nGreg Ward\nGuilherme Espada\nGuillaume Seguin\ngutsytechster\nGuy Rozendorn\nGuy Tuval\ngzpan123\nHanjun Kim\nHari Charan\nHarsh Vardhan\nharupy\nHarutaka Kawamura\nhauntsaninja\nHenrich Hartzer\nHenry Schreiner\nHerbert Pfennig\nHolly Stotelmyer\nHonnix\nHsiaoming Yang\nHugo Lopes Tavares\nHugo van Kemenade\nHugues Bruant\nHynek Schlawack\nIan Bicking\nIan Cordasco\nIan Lee\nIan Stapleton Cordasco\nIan Wienand\nIgor Kuzmitshov\nIgor Sobreira\nIkko Ashimine\nIlan Schnell\nIllia Volochii\nIlya Baryshev\nInada Naoki\nIonel Cristian Mărieș\nIonel Maries Cristian\nItamar Turner-Trauring\niTrooz\nIvan Pozdeev\nJ. Nick Koston\nJacob Kim\nJacob Walls\nJaime Sanz\nJake Lishman\njakirkham\nJakub Kuczys\nJakub Stasiak\nJakub Vysoky\nJakub Wilk\nJames Cleveland\nJames Curtin\nJames Firth\nJames Gerity\nJames Polley\nJan Pokorný\nJannis Leidel\nJarek Potiuk\njarondl\nJason Curtis\nJason R. Coombs\nJasonMo\nJasonMo1\nJay Graves\nJean Abou Samra\nJean-Christophe Fillion-Robin\nJeff Barber\nJeff Dairiki\nJeff Widman\nJelmer Vernooĳ\njenix21\nJeremy Fleischman\nJeremy Stanley\nJeremy Zafran\nJesse Rittner\nJiashuo Li\nJim Fisher\nJim Garrison\nJinzhe Zeng\nJiun Bae\nJivan Amara\nJoa\nJoe Bylund\nJoe Michelini\nJohannes Altmanninger\nJohn Paton\nJohn Sirois\nJohn T. Wodder II\nJohn-Scott Atlakson\njohnthagen\nJon Banafato\nJon Dufresne\nJon Parise\nJonas Nockert\nJonathan Herbert\nJoonatan Partanen\nJoost Molenaar\nJorge Niedbalski\nJoseph Bylund\nJoseph Long\nJosh Bronson\nJosh Cannon\nJosh Hansen\nJosh Schneier\nJoshua\nJoshuaPerdue\nJuan Luis Cano Rodríguez\nJuanjo Bazán\nJudah Rand\nJulian Berman\nJulian Gethmann\nJulien Demoor\nJuly Tikhonov\nJussi Kukkonen\nJustin van Heek\njwg4\nJyrki Pulliainen\nKai Chen\nKai Mueller\nKamal Bin Mustafa\nKarolina Surma\nkasium\nkaustav haldar\nkeanemind\nKeith Maxwell\nKelsey Hightower\nKenneth Belitzky\nKenneth Reitz\nKevin Burke\nKevin Carter\nKevin Frommelt\nKevin R Patterson\nKexuan Sun\nKit Randel\nKlaas van Schelven\nKOLANICH\nkonstin\nkpinc\nKrishan Bhasin\nKrishna Oza\nKumar McMillan\nKuntal Majumder\nKurt McKee\nKyle Persohn\nlakshmanaram\nLaszlo Kiss-Kollar\nLaurent Bristiel\nLaurent LAPORTE\nLaurie O\nLaurie Opperman\nlayday\nLeon Sasson\nLev Givon\nLincoln de Sousa\nLipis\nlorddavidiii\nLoren Carvalho\nLucas Cimon\nLudovic Gasc\nLuis Medel\nLukas Geiger\nLukas Juhrich\nLuke Macken\nLuo Jiebin\nluojiebin\nluz.paz\nLászló Kiss Kollár\nM00nL1ght\nMalcolm Smith\nMarc Abramowitz\nMarc Tamlyn\nMarcus Smith\nMariatta\nMark Kohler\nMark McLoughlin\nMark Williams\nMarkus Hametner\nMartey Dodoo\nMartin Fischer\nMartin Häcker\nMartin Pavlasek\nMasaki\nMasklinn\nMatej Stuchlik\nMathew Jennings\nMathieu Bridon\nMathieu Kniewallner\nMatt Bacchi\nMatt Good\nMatt Maker\nMatt Robenolt\nMatt Wozniski\nmatthew\nMatthew Einhorn\nMatthew Feickert\nMatthew Gilliard\nMatthew Hughes\nMatthew Iversen\nMatthew Treinish\nMatthew Trumbell\nMatthew Willson\nMatthias Bussonnier\nmattip\nMaurits van Rees\nMax W Chase\nMaxim Kurnikov\nMaxime Rouyrre\nmayeut\nmbaluna\nMd Sujauddin Sekh\nmdebi\nmemoselyk\nmeowmeowcat\nMichael\nMichael Aquilina\nMichael E. Karpeles\nMichael Klich\nMichael Mintz\nMichael Williamson\nmichaelpacer\nMichał Górny\nMickaël Schoentgen\nMiguel Araujo Perez\nMihir Singh\nMike\nMike Hendricks\nMin RK\nMinRK\nMiro Hrončok\nMonica Baluna\nmontefra\nMonty Taylor\nmorotti\nmrKazzila\nMuha Ajjan\nNadav Wexler\nNahuel Ambrosini\nNate Coraor\nNate Prewitt\nNathan Houghton\nNathaniel J. Smith\nNehal J Wani\nNeil Botelho\nNguyễn Gia Phong\nNicholas Serra\nNick Coghlan\nNick Stenning\nNick Timkovich\nNicolas Bock\nNicole Harris\nNikhil Benesch\nNikhil Ladha\nNikita Chepanov\nNikolay Korolev\nNipunn Koorapati\nNitesh Sharma\nNiyas Sait\nNoah\nNoah Gorny\nNowell Strite\nNtaleGrey\nnucccc\nnvdv\nOBITORASU\nOfek Lev\nofrinevo\nOleg Burnaev\nOliver Freund\nOliver Jeeves\nOliver Mannion\nOliver Tonnhofer\nOlivier Girardot\nOlivier Grisel\nOllie Rutherfurd\nOMOTO Kenji\nOmry Yadan\nonlinejudge95\nOren Held\nOscar Benjamin\nOz N Tiram\nPachwenko\nPatrick Dubroy\nPatrick Jenkins\nPatrick Lawson\npatricktokeeffe\nPatrik Kopkan\nPaul Ganssle\nPaul Kehrer\nPaul Moore\nPaul Nasrat\nPaul Oswald\nPaul van der Linden\nPaulus Schoutsen\nPavel Safronov\nPavithra Eswaramoorthy\nPawel Jasinski\nPaweł Szramowski\nPekka Klärck\nPeter Gessler\nPeter Lisák\nPeter Shen\nPeter Waller\nPetr Viktorin\npetr-tik\nPhaneendra Chiruvella\nPhil Elson\nPhil Freo\nPhil Pennock\nPhil Whelan\nPhilip Jägenstedt\nPhilip Molloy\nPhilippe Ombredanne\nPi Delport\nPierre-Yves Rofes\nPieter Degroote\npip\nPrabakaran Kumaresshan\nPrabhjyotsing Surjit Singh Sodhi\nPrabhu Marappan\nPradyun Gedam\nPrashant Sharma\nPratik Mallya\npre-commit-ci[bot]\nPreet Thakkar\nPreston Holmes\nPrzemek Wrzos\nPulkit Goyal\nq0w\nQiangning Hong\nQiming Xu\nQuentin Lee\nQuentin Pradet\nR. David Murray\nRafael Caricio\nRalf Schmitt\nRan Benita\nRandy Döring\nRazzi Abuissa\nrdb\nReece Dunham\nRemi Rampin\nRene Dudfield\nRiccardo Magliocchetti\nRiccardo Schirone\nRichard Jones\nRichard Si\nRicky Ng-Adam\nRishi\nrmorotti\nRobberPhex\nRobert Collins\nRobert McGibbon\nRobert Pollak\nRobert T. McGibbon\nrobin elisha robinson\nRoey Berman\nRohan Jain\nRoman Bogorodskiy\nRoman Donchenko\nRomuald Brunet\nronaudinho\nRonny Pfannschmidt\nRory McCann\nRoss Brattain\nRoy Wellington Ⅳ\nRuairidh MacLeod\nRussell Keith-Magee\nRyan Shepherd\nRyan Wooden\nryneeverett\nS. Guliaev\nSachi King\nSalvatore Rinchiera\nsandeepkiran-js\nSander Van Balen\nSavio Jomton\nschlamar\nScott Kitterman\nSean\nseanj\nSebastian Jordan\nSebastian Schaetz\nSegev Finer\nSeongSoo Cho\nSergey Vasilyev\nSeth Michael Larson\nSeth Woodworth\nShahar Epstein\nShantanu\nshenxianpeng\nshireenrao\nShivansh-007\nShixian Sheng\nShlomi Fish\nShovan Maity\nSimeon Visser\nSimon Cross\nSimon Pichugin\nsinoroc\nsinscary\nsnook92\nsocketubs\nSorin Sbarnea\nSrinivas Nyayapati\nSrishti Hegde\nStavros Korokithakis\nStefan Scherfke\nStefano Rivera\nStephan Erb\nStephen Rosen\nstepshal\nSteve (Gadget) Barnes\nSteve Barnes\nSteve Dower\nSteve Kowalik\nSteven Myint\nSteven Silvester\nstonebig\nstudioj\nStéphane Bidoul\nStéphane Bidoul (ACSONE)\nStéphane Klein\nSumana Harihareswara\nSurbhi Sharma\nSviatoslav Sydorenko\nSviatoslav Sydorenko (Святослав Сидоренко)\nSwat009\nSylvain\nTakayuki SHIMIZUKAWA\nTaneli Hukkinen\ntbeswick\nThiago\nThijs Triemstra\nThomas Fenzl\nThomas Grainger\nThomas Guettler\nThomas Johansson\nThomas Kluyver\nThomas Smith\nThomas VINCENT\nTim D. Smith\nTim Gates\nTim Harder\nTim Heap\ntim smith\ntinruufu\nTobias Hermann\nTom Forbes\nTom Freudenheim\nTom V\nTomas Hrnciar\nTomas Orsava\nTomer Chachamu\nTommi Enenkel | AnB\nTomáš Hrnčiar\nTony Beswick\nTony Narlock\nTony Zhaocheng Tan\nTonyBeswick\ntoonarmycaptain\nToshio Kuratomi\ntoxinu\nTravis Swicegood\nTushar Sadhwani\nTzu-ping Chung\nValentin Haenel\nVictor Stinner\nvictorvpaulo\nVikram - Google\nViktor Szépe\nVille Skyttä\nVinay Sajip\nVincent Philippon\nVinicyus Macedo\nVipul Kumar\nVitaly Babiy\nVladimir Fokow\nVladimir Rutsky\nW. Trevor King\nWil Tan\nWilfred Hughes\nWilliam Edwards\nWilliam ML Leslie\nWilliam T Olson\nWilliam Woodruff\nWilson Mo\nwim glenn\nWinson Luk\nWolfgang Maier\nWu Zhenyu\nXAMES3\nXavier Fernandez\nXianpeng Shen\nxoviat\nxtreak\nYAMAMOTO Takashi\nYen Chi Hsuan\nYeray Diaz Diaz\nYoval P\nYu Jian\nYuan Jing Vincent Yan\nYusuke Hayashi\nZearin\nZhiping Deng\nziebam\nZvezdan Petkovic\nŁukasz Langa\nРоман Донченко\nСемён Марьясин\n",[],[213,919,920,921,939,988,990],"fb41e5d2-67fb-11f0-b712-0224a6c84d84",51,["D",1753299239826],[734,735],[213,919,920,921,939,988],"fa9ff7f4-67fb-11f0-ad3e-0224a6c84d84",45,["D",1753299238766],[733,736,737,738,739,740,741],[213,919,920,921,939],"0e40dd82-67fc-11f0-9ad5-0224a6c84d84","py.typed","0e40de18-67fc-11f0-9ad5-0224a6c84d84","fad27332-67fb-11f0-a988-0224a6c84d84",527,["D",1753299271696],"pip is a command line program. While it is implemented in Python, and so is\navailable for import, you must not use pip's internal APIs in this way. Typing\ninformation is provided as a convenience only and is not a guarantee. Expect\nunannounced changes to the API and types in releases.\n",[],[213,919,920,921,1016,1008],"pip","0e465f50-67fc-11f0-9080-0224a6c84d84","__pip-runner__.py","0e465fe6-67fc-11f0-9080-0224a6c84d84",528,["D",1753299271703],"\"\"\"Execute exactly this copy of pip, within a different environment.\n\nThis file is named as it is, to ensure that this module can't be imported via\nan import statement.\n\"\"\"\n\n# /!\\ This version compatibility check section must be Python 2 compatible. /!\\\n\nimport sys\n\n# Copied from pyproject.toml\nPYTHON_REQUIRES = (3, 9)\n\n\ndef version_str(version): # type: ignore\n return \".\".join(str(v) for v in version)\n\n\nif sys.version_info[:2] < PYTHON_REQUIRES:\n raise SystemExit(\n \"This version of pip does not support python {} (requires >={}).\".format(\n version_str(sys.version_info[:2]), version_str(PYTHON_REQUIRES)\n )\n )\n\n# From here on, we can use Python 3 features, but the syntax must remain\n# Python 2 compatible.\n\nimport runpy # noqa: E402\nfrom importlib.machinery import PathFinder # noqa: E402\nfrom os.path import dirname # noqa: E402\n\nPIP_SOURCES_ROOT = dirname(dirname(__file__))\n\n\nclass PipImportRedirectingFinder:\n @classmethod\n def find_spec(self, fullname, path=None, target=None): # type: ignore\n if fullname != \"pip\":\n return None\n\n spec = PathFinder.find_spec(fullname, [PIP_SOURCES_ROOT], target)\n assert spec, (PIP_SOURCES_ROOT, fullname)\n return spec\n\n\nsys.meta_path.insert(0, PipImportRedirectingFinder())\n\nassert __name__ == \"__main__\", \"Cannot run __pip-runner__.py as a non-main module\"\nrunpy.run_module(\"pip\", run_name=\"__main__\", alter_sys=True)\n",[],[213,919,920,921,1016,1018],"0e530b92-67fc-11f0-9f6f-0224a6c84d84","__main__.py","0e530c46-67fc-11f0-9f6f-0224a6c84d84",529,["D",1753299271809],"import os\nimport sys\n\n# Remove '' and current working directory from the first entry\n# of sys.path, if present to avoid using current directory\n# in pip commands check, freeze, install, list and show,\n# when invoked as python -m pip \nif sys.path[0] in (\"\", os.getcwd()):\n sys.path.pop(0)\n\n# If we are running from a wheel, add the wheel to sys.path\n# This allows the usage python pip-*.whl/pip install pip-*.whl\nif __package__ == \"\":\n # __file__ is pip-*.whl/pip/__main__.py\n # first dirname call strips of '/__main__.py', second strips off '/pip'\n # Resulting path is the name of the wheel itself\n # Add that to sys.path so we can import pip\n path = os.path.dirname(os.path.dirname(__file__))\n sys.path.insert(0, path)\n\nif __name__ == \"__main__\":\n from pip._internal.cli.main import main as _main\n\n sys.exit(_main())\n",[],[213,919,920,921,1016,1026],"0e383e5c-67fc-11f0-a559-0224a6c84d84","__init__.py","0e383ee8-67fc-11f0-a559-0224a6c84d84",526,["D",1753299271639],"from typing import List, Optional\n\n__version__ = \"25.1.1\"\n\n\ndef main(args: Optional[List[str]] = None) -> int:\n \"\"\"This is an internal API only meant for use by pip's own console scripts.\n\n For additional details, see https://github.com/pypa/pip/issues/7498.\n \"\"\"\n from pip._internal.utils.entrypoints import _wrapper\n\n return _wrapper(args)\n",[],[213,919,920,921,1016,1034],"0809a052-67fc-11f0-8d4e-0224a6c84d84","vendor.txt","0809a124-67fc-11f0-8d4e-0224a6c84d84","fb750bb0-67fb-11f0-b654-0224a6c84d84",291,["D",1753299261268],"CacheControl==0.14.2\ndistlib==0.3.9\ndistro==1.9.0\nmsgpack==1.1.0\npackaging==25.0\nplatformdirs==4.3.7\npyproject-hooks==1.2.0\nrequests==2.32.3\n certifi==2025.1.31\n idna==3.10\n urllib3==1.26.20\nrich==14.0.0\n pygments==2.19.1\n typing_extensions==4.13.2\nresolvelib==1.1.0\nsetuptools==70.3.0\ntomli==2.2.1\ntomli-w==1.2.0\ntruststore==0.10.1\ndependency-groups==1.3.1\n",[],[213,919,920,921,1016,1050,1042],"_vendor","0a172914-67fc-11f0-8371-0224a6c84d84","0a172aea-67fc-11f0-8371-0224a6c84d84",366,["D",1753299264711],"\"\"\"\npip._vendor is for vendoring dependencies of pip to prevent needing pip to\ndepend on something external.\n\nFiles inside of pip._vendor should be considered immutable and should only be\nupdated to versions from upstream.\n\"\"\"\nfrom __future__ import absolute_import\n\nimport glob\nimport os.path\nimport sys\n\n# Downstream redistributors which have debundled our dependencies should also\n# patch this value to be true. This will trigger the additional patching\n# to cause things like \"six\" to be available as pip.\nDEBUNDLED = False\n\n# By default, look in this directory for a bunch of .whl files which we will\n# add to the beginning of sys.path before attempting to import anything. This\n# is done to support downstream re-distributors like Debian and Fedora who\n# wish to create their own Wheels for our dependencies to aid in debundling.\nWHEEL_DIR = os.path.abspath(os.path.dirname(__file__))\n\n\n# Define a small helper function to alias our vendored modules to the real ones\n# if the vendored ones do not exist. This idea of this was taken from\n# https://github.com/kennethreitz/requests/pull/2567.\ndef vendored(modulename):\n vendored_name = \"{0}.{1}\".format(__name__, modulename)\n\n try:\n __import__(modulename, globals(), locals(), level=0)\n except ImportError:\n # We can just silently allow import failures to pass here. If we\n # got to this point it means that ``import pip._vendor.whatever``\n # failed and so did ``import whatever``. Since we're importing this\n # upfront in an attempt to alias imports, not erroring here will\n # just mean we get a regular import error whenever pip *actually*\n # tries to import one of these modules to use it, which actually\n # gives us a better error message than we would have otherwise\n # gotten.\n pass\n else:\n sys.modules[vendored_name] = sys.modules[modulename]\n base, head = vendored_name.rsplit(\".\", 1)\n setattr(sys.modules[base], head, sys.modules[modulename])\n\n\n# If we're operating in a debundled setup, then we want to go ahead and trigger\n# the aliasing of our vendored libraries as well as looking for wheels to add\n# to our sys.path. This will cause all of this code to be a no-op typically\n# however downstream redistributors can enable it in a consistent way across\n# all platforms.\nif DEBUNDLED:\n # Actually look inside of WHEEL_DIR to find .whl files and add them to the\n # front of our sys.path.\n sys.path[:] = glob.glob(os.path.join(WHEEL_DIR, \"*.whl\")) + sys.path\n\n # Actually alias all of our vendored dependencies.\n vendored(\"cachecontrol\")\n vendored(\"certifi\")\n vendored(\"dependency-groups\")\n vendored(\"distlib\")\n vendored(\"distro\")\n vendored(\"packaging\")\n vendored(\"packaging.version\")\n vendored(\"packaging.specifiers\")\n vendored(\"pkg_resources\")\n vendored(\"platformdirs\")\n vendored(\"progress\")\n vendored(\"pyproject_hooks\")\n vendored(\"requests\")\n vendored(\"requests.exceptions\")\n vendored(\"requests.packages\")\n vendored(\"requests.packages.urllib3\")\n vendored(\"requests.packages.urllib3._collections\")\n vendored(\"requests.packages.urllib3.connection\")\n vendored(\"requests.packages.urllib3.connectionpool\")\n vendored(\"requests.packages.urllib3.contrib\")\n vendored(\"requests.packages.urllib3.contrib.ntlmpool\")\n vendored(\"requests.packages.urllib3.contrib.pyopenssl\")\n vendored(\"requests.packages.urllib3.exceptions\")\n vendored(\"requests.packages.urllib3.fields\")\n vendored(\"requests.packages.urllib3.filepost\")\n vendored(\"requests.packages.urllib3.packages\")\n vendored(\"requests.packages.urllib3.packages.ordered_dict\")\n vendored(\"requests.packages.urllib3.packages.six\")\n vendored(\"requests.packages.urllib3.packages.ssl_match_hostname\")\n vendored(\"requests.packages.urllib3.packages.ssl_match_hostname.\"\n \"_implementation\")\n vendored(\"requests.packages.urllib3.poolmanager\")\n vendored(\"requests.packages.urllib3.request\")\n vendored(\"requests.packages.urllib3.response\")\n vendored(\"requests.packages.urllib3.util\")\n vendored(\"requests.packages.urllib3.util.connection\")\n vendored(\"requests.packages.urllib3.util.request\")\n vendored(\"requests.packages.urllib3.util.response\")\n vendored(\"requests.packages.urllib3.util.retry\")\n vendored(\"requests.packages.urllib3.util.ssl_\")\n vendored(\"requests.packages.urllib3.util.timeout\")\n vendored(\"requests.packages.urllib3.util.url\")\n vendored(\"resolvelib\")\n vendored(\"rich\")\n vendored(\"rich.console\")\n vendored(\"rich.highlighter\")\n vendored(\"rich.logging\")\n vendored(\"rich.markup\")\n vendored(\"rich.progress\")\n vendored(\"rich.segment\")\n vendored(\"rich.style\")\n vendored(\"rich.text\")\n vendored(\"rich.traceback\")\n if sys.version_info < (3, 11):\n vendored(\"tomli\")\n vendored(\"truststore\")\n vendored(\"urllib3\")\n",[],[213,919,920,921,1016,1050,1034],"0d498ae6-67fc-11f0-bfb3-0224a6c84d84","response.py","0d498be0-67fc-11f0-bfb3-0224a6c84d84","fee07d8e-67fb-11f0-928e-0224a6c84d84",493,["D",1753299270076],"from __future__ import absolute_import\n\nimport io\nimport logging\nimport sys\nimport warnings\nimport zlib\nfrom contextlib import contextmanager\nfrom socket import error as SocketError\nfrom socket import timeout as SocketTimeout\n\nbrotli = None\n\nfrom . import util\nfrom ._collections import HTTPHeaderDict\nfrom .connection import BaseSSLError, HTTPException\nfrom .exceptions import (\n BodyNotHttplibCompatible,\n DecodeError,\n HTTPError,\n IncompleteRead,\n InvalidChunkLength,\n InvalidHeader,\n ProtocolError,\n ReadTimeoutError,\n ResponseNotChunked,\n SSLError,\n)\nfrom .packages import six\nfrom .util.response import is_fp_closed, is_response_to_head\n\nlog = logging.getLogger(__name__)\n\n\nclass DeflateDecoder(object):\n def __init__(self):\n self._first_try = True\n self._data = b\"\"\n self._obj = zlib.decompressobj()\n\n def __getattr__(self, name):\n return getattr(self._obj, name)\n\n def decompress(self, data):\n if not data:\n return data\n\n if not self._first_try:\n return self._obj.decompress(data)\n\n self._data += data\n try:\n decompressed = self._obj.decompress(data)\n if decompressed:\n self._first_try = False\n self._data = None\n return decompressed\n except zlib.error:\n self._first_try = False\n self._obj = zlib.decompressobj(-zlib.MAX_WBITS)\n try:\n return self.decompress(self._data)\n finally:\n self._data = None\n\n\nclass GzipDecoderState(object):\n\n FIRST_MEMBER = 0\n OTHER_MEMBERS = 1\n SWALLOW_DATA = 2\n\n\nclass GzipDecoder(object):\n def __init__(self):\n self._obj = zlib.decompressobj(16 + zlib.MAX_WBITS)\n self._state = GzipDecoderState.FIRST_MEMBER\n\n def __getattr__(self, name):\n return getattr(self._obj, name)\n\n def decompress(self, data):\n ret = bytearray()\n if self._state == GzipDecoderState.SWALLOW_DATA or not data:\n return bytes(ret)\n while True:\n try:\n ret += self._obj.decompress(data)\n except zlib.error:\n previous_state = self._state\n # Ignore data after the first error\n self._state = GzipDecoderState.SWALLOW_DATA\n if previous_state == GzipDecoderState.OTHER_MEMBERS:\n # Allow trailing garbage acceptable in other gzip clients\n return bytes(ret)\n raise\n data = self._obj.unused_data\n if not data:\n return bytes(ret)\n self._state = GzipDecoderState.OTHER_MEMBERS\n self._obj = zlib.decompressobj(16 + zlib.MAX_WBITS)\n\n\nif brotli is not None:\n\n class BrotliDecoder(object):\n # Supports both 'brotlipy' and 'Brotli' packages\n # since they share an import name. The top branches\n # are for 'brotlipy' and bottom branches for 'Brotli'\n def __init__(self):\n self._obj = brotli.Decompressor()\n if hasattr(self._obj, \"decompress\"):\n self.decompress = self._obj.decompress\n else:\n self.decompress = self._obj.process\n\n def flush(self):\n if hasattr(self._obj, \"flush\"):\n return self._obj.flush()\n return b\"\"\n\n\nclass MultiDecoder(object):\n \"\"\"\n From RFC7231:\n If one or more encodings have been applied to a representation, the\n sender that applied the encodings MUST generate a Content-Encoding\n header field that lists the content codings in the order in which\n they were applied.\n \"\"\"\n\n def __init__(self, modes):\n self._decoders = [_get_decoder(m.strip()) for m in modes.split(\",\")]\n\n def flush(self):\n return self._decoders[0].flush()\n\n def decompress(self, data):\n for d in reversed(self._decoders):\n data = d.decompress(data)\n return data\n\n\ndef _get_decoder(mode):\n if \",\" in mode:\n return MultiDecoder(mode)\n\n if mode == \"gzip\":\n return GzipDecoder()\n\n if brotli is not None and mode == \"br\":\n return BrotliDecoder()\n\n return DeflateDecoder()\n\n\nclass HTTPResponse(io.IOBase):\n \"\"\"\n HTTP Response container.\n\n Backwards-compatible with :class:`http.client.HTTPResponse` but the response ``body`` is\n loaded and decoded on-demand when the ``data`` property is accessed. This\n class is also compatible with the Python standard library's :mod:`io`\n module, and can hence be treated as a readable object in the context of that\n framework.\n\n Extra parameters for behaviour not present in :class:`http.client.HTTPResponse`:\n\n :param preload_content:\n If True, the response's body will be preloaded during construction.\n\n :param decode_content:\n If True, will attempt to decode the body based on the\n 'content-encoding' header.\n\n :param original_response:\n When this HTTPResponse wrapper is generated from an :class:`http.client.HTTPResponse`\n object, it's convenient to include the original for debug purposes. It's\n otherwise unused.\n\n :param retries:\n The retries contains the last :class:`~urllib3.util.retry.Retry` that\n was used during the request.\n\n :param enforce_content_length:\n Enforce content length checking. Body returned by server must match\n value of Content-Length header, if present. Otherwise, raise error.\n \"\"\"\n\n CONTENT_DECODERS = [\"gzip\", \"deflate\"]\n if brotli is not None:\n CONTENT_DECODERS += [\"br\"]\n REDIRECT_STATUSES = [301, 302, 303, 307, 308]\n\n def __init__(\n self,\n body=\"\",\n headers=None,\n status=0,\n version=0,\n reason=None,\n strict=0,\n preload_content=True,\n decode_content=True,\n original_response=None,\n pool=None,\n connection=None,\n msg=None,\n retries=None,\n enforce_content_length=False,\n request_method=None,\n request_url=None,\n auto_close=True,\n ):\n\n if isinstance(headers, HTTPHeaderDict):\n self.headers = headers\n else:\n self.headers = HTTPHeaderDict(headers)\n self.status = status\n self.version = version\n self.reason = reason\n self.strict = strict\n self.decode_content = decode_content\n self.retries = retries\n self.enforce_content_length = enforce_content_length\n self.auto_close = auto_close\n\n self._decoder = None\n self._body = None\n self._fp = None\n self._original_response = original_response\n self._fp_bytes_read = 0\n self.msg = msg\n self._request_url = request_url\n\n if body and isinstance(body, (six.string_types, bytes)):\n self._body = body\n\n self._pool = pool\n self._connection = connection\n\n if hasattr(body, \"read\"):\n self._fp = body\n\n # Are we using the chunked-style of transfer encoding?\n self.chunked = False\n self.chunk_left = None\n tr_enc = self.headers.get(\"transfer-encoding\", \"\").lower()\n # Don't incur the penalty of creating a list and then discarding it\n encodings = (enc.strip() for enc in tr_enc.split(\",\"))\n if \"chunked\" in encodings:\n self.chunked = True\n\n # Determine length of response\n self.length_remaining = self._init_length(request_method)\n\n # If requested, preload the body.\n if preload_content and not self._body:\n self._body = self.read(decode_content=decode_content)\n\n def get_redirect_location(self):\n \"\"\"\n Should we redirect and where to?\n\n :returns: Truthy redirect location string if we got a redirect status\n code and valid location. ``None`` if redirect status and no\n location. ``False`` if not a redirect status code.\n \"\"\"\n if self.status in self.REDIRECT_STATUSES:\n return self.headers.get(\"location\")\n\n return False\n\n def release_conn(self):\n if not self._pool or not self._connection:\n return\n\n self._pool._put_conn(self._connection)\n self._connection = None\n\n def drain_conn(self):\n \"\"\"\n Read and discard any remaining HTTP response data in the response connection.\n\n Unread data in the HTTPResponse connection blocks the connection from being released back to the pool.\n \"\"\"\n try:\n self.read()\n except (HTTPError, SocketError, BaseSSLError, HTTPException):\n pass\n\n @property\n def data(self):\n # For backwards-compat with earlier urllib3 0.4 and earlier.\n if self._body:\n return self._body\n\n if self._fp:\n return self.read(cache_content=True)\n\n @property\n def connection(self):\n return self._connection\n\n def isclosed(self):\n return is_fp_closed(self._fp)\n\n def tell(self):\n \"\"\"\n Obtain the number of bytes pulled over the wire so far. May differ from\n the amount of content returned by :meth:``urllib3.response.HTTPResponse.read``\n if bytes are encoded on the wire (e.g, compressed).\n \"\"\"\n return self._fp_bytes_read\n\n def _init_length(self, request_method):\n \"\"\"\n Set initial length value for Response content if available.\n \"\"\"\n length = self.headers.get(\"content-length\")\n\n if length is not None:\n if self.chunked:\n # This Response will fail with an IncompleteRead if it can't be\n # received as chunked. This method falls back to attempt reading\n # the response before raising an exception.\n log.warning(\n \"Received response with both Content-Length and \"\n \"Transfer-Encoding set. This is expressly forbidden \"\n \"by RFC 7230 sec 3.3.2. Ignoring Content-Length and \"\n \"attempting to process response as Transfer-Encoding: \"\n \"chunked.\"\n )\n return None\n\n try:\n # RFC 7230 section 3.3.2 specifies multiple content lengths can\n # be sent in a single Content-Length header\n # (e.g. Content-Length: 42, 42). This line ensures the values\n # are all valid ints and that as long as the `set` length is 1,\n # all values are the same. Otherwise, the header is invalid.\n lengths = set([int(val) for val in length.split(\",\")])\n if len(lengths) > 1:\n raise InvalidHeader(\n \"Content-Length contained multiple \"\n \"unmatching values (%s)\" % length\n )\n length = lengths.pop()\n except ValueError:\n length = None\n else:\n if length < 0:\n length = None\n\n # Convert status to int for comparison\n # In some cases, httplib returns a status of \"_UNKNOWN\"\n try:\n status = int(self.status)\n except ValueError:\n status = 0\n\n # Check for responses that shouldn't include a body\n if status in (204, 304) or 100 <= status < 200 or request_method == \"HEAD\":\n length = 0\n\n return length\n\n def _init_decoder(self):\n \"\"\"\n Set-up the _decoder attribute if necessary.\n \"\"\"\n # Note: content-encoding value should be case-insensitive, per RFC 7230\n # Section 3.2\n content_encoding = self.headers.get(\"content-encoding\", \"\").lower()\n if self._decoder is None:\n if content_encoding in self.CONTENT_DECODERS:\n self._decoder = _get_decoder(content_encoding)\n elif \",\" in content_encoding:\n encodings = [\n e.strip()\n for e in content_encoding.split(\",\")\n if e.strip() in self.CONTENT_DECODERS\n ]\n if len(encodings):\n self._decoder = _get_decoder(content_encoding)\n\n DECODER_ERROR_CLASSES = (IOError, zlib.error)\n if brotli is not None:\n DECODER_ERROR_CLASSES += (brotli.error,)\n\n def _decode(self, data, decode_content, flush_decoder):\n \"\"\"\n Decode the data passed in and potentially flush the decoder.\n \"\"\"\n if not decode_content:\n return data\n\n try:\n if self._decoder:\n data = self._decoder.decompress(data)\n except self.DECODER_ERROR_CLASSES as e:\n content_encoding = self.headers.get(\"content-encoding\", \"\").lower()\n raise DecodeError(\n \"Received response with content-encoding: %s, but \"\n \"failed to decode it.\" % content_encoding,\n e,\n )\n if flush_decoder:\n data += self._flush_decoder()\n\n return data\n\n def _flush_decoder(self):\n \"\"\"\n Flushes the decoder. Should only be called if the decoder is actually\n being used.\n \"\"\"\n if self._decoder:\n buf = self._decoder.decompress(b\"\")\n return buf + self._decoder.flush()\n\n return b\"\"\n\n @contextmanager\n def _error_catcher(self):\n \"\"\"\n Catch low-level python exceptions, instead re-raising urllib3\n variants, so that low-level exceptions are not leaked in the\n high-level api.\n\n On exit, release the connection back to the pool.\n \"\"\"\n clean_exit = False\n\n try:\n try:\n yield\n\n except SocketTimeout:\n # FIXME: Ideally we'd like to include the url in the ReadTimeoutError but\n # there is yet no clean way to get at it from this context.\n raise ReadTimeoutError(self._pool, None, \"Read timed out.\")\n\n except BaseSSLError as e:\n # FIXME: Is there a better way to differentiate between SSLErrors?\n if \"read operation timed out\" not in str(e):\n # SSL errors related to framing/MAC get wrapped and reraised here\n raise SSLError(e)\n\n raise ReadTimeoutError(self._pool, None, \"Read timed out.\")\n\n except (HTTPException, SocketError) as e:\n # This includes IncompleteRead.\n raise ProtocolError(\"Connection broken: %r\" % e, e)\n\n # If no exception is thrown, we should avoid cleaning up\n # unnecessarily.\n clean_exit = True\n finally:\n # If we didn't terminate cleanly, we need to throw away our\n # connection.\n if not clean_exit:\n # The response may not be closed but we're not going to use it\n # anymore so close it now to ensure that the connection is\n # released back to the pool.\n if self._original_response:\n self._original_response.close()\n\n # Closing the response may not actually be sufficient to close\n # everything, so if we have a hold of the connection close that\n # too.\n if self._connection:\n self._connection.close()\n\n # If we hold the original response but it's closed now, we should\n # return the connection back to the pool.\n if self._original_response and self._original_response.isclosed():\n self.release_conn()\n\n def _fp_read(self, amt):\n \"\"\"\n Read a response with the thought that reading the number of bytes\n larger than can fit in a 32-bit int at a time via SSL in some\n known cases leads to an overflow error that has to be prevented\n if `amt` or `self.length_remaining` indicate that a problem may\n happen.\n\n The known cases:\n * 3.8 <= CPython < 3.9.7 because of a bug\n https://github.com/urllib3/urllib3/issues/2513#issuecomment-1152559900.\n * urllib3 injected with pyOpenSSL-backed SSL-support.\n * CPython < 3.10 only when `amt` does not fit 32-bit int.\n \"\"\"\n assert self._fp\n c_int_max = 2 ** 31 - 1\n if (\n (\n (amt and amt > c_int_max)\n or (self.length_remaining and self.length_remaining > c_int_max)\n )\n and not util.IS_SECURETRANSPORT\n and (util.IS_PYOPENSSL or sys.version_info < (3, 10))\n ):\n buffer = io.BytesIO()\n # Besides `max_chunk_amt` being a maximum chunk size, it\n # affects memory overhead of reading a response by this\n # method in CPython.\n # `c_int_max` equal to 2 GiB - 1 byte is the actual maximum\n # chunk size that does not lead to an overflow error, but\n # 256 MiB is a compromise.\n max_chunk_amt = 2 ** 28\n while amt is None or amt != 0:\n if amt is not None:\n chunk_amt = min(amt, max_chunk_amt)\n amt -= chunk_amt\n else:\n chunk_amt = max_chunk_amt\n data = self._fp.read(chunk_amt)\n if not data:\n break\n buffer.write(data)\n del data # to reduce peak memory usage by `max_chunk_amt`.\n return buffer.getvalue()\n else:\n # StringIO doesn't like amt=None\n return self._fp.read(amt) if amt is not None else self._fp.read()\n\n def read(self, amt=None, decode_content=None, cache_content=False):\n \"\"\"\n Similar to :meth:`http.client.HTTPResponse.read`, but with two additional\n parameters: ``decode_content`` and ``cache_content``.\n\n :param amt:\n How much of the content to read. If specified, caching is skipped\n because it doesn't make sense to cache partial content as the full\n response.\n\n :param decode_content:\n If True, will attempt to decode the body based on the\n 'content-encoding' header.\n\n :param cache_content:\n If True, will save the returned data such that the same result is\n returned despite of the state of the underlying file object. This\n is useful if you want the ``.data`` property to continue working\n after having ``.read()`` the file object. (Overridden if ``amt`` is\n set.)\n \"\"\"\n self._init_decoder()\n if decode_content is None:\n decode_content = self.decode_content\n\n if self._fp is None:\n return\n\n flush_decoder = False\n fp_closed = getattr(self._fp, \"closed\", False)\n\n with self._error_catcher():\n data = self._fp_read(amt) if not fp_closed else b\"\"\n if amt is None:\n flush_decoder = True\n else:\n cache_content = False\n if (\n amt != 0 and not data\n ): # Platform-specific: Buggy versions of Python.\n # Close the connection when no data is returned\n #\n # This is redundant to what httplib/http.client _should_\n # already do. However, versions of python released before\n # December 15, 2012 (http://bugs.python.org/issue16298) do\n # not properly close the connection in all cases. There is\n # no harm in redundantly calling close.\n self._fp.close()\n flush_decoder = True\n if self.enforce_content_length and self.length_remaining not in (\n 0,\n None,\n ):\n # This is an edge case that httplib failed to cover due\n # to concerns of backward compatibility. We're\n # addressing it here to make sure IncompleteRead is\n # raised during streaming, so all calls with incorrect\n # Content-Length are caught.\n raise IncompleteRead(self._fp_bytes_read, self.length_remaining)\n\n if data:\n self._fp_bytes_read += len(data)\n if self.length_remaining is not None:\n self.length_remaining -= len(data)\n\n data = self._decode(data, decode_content, flush_decoder)\n\n if cache_content:\n self._body = data\n\n return data\n\n def stream(self, amt=2 ** 16, decode_content=None):\n \"\"\"\n A generator wrapper for the read() method. A call will block until\n ``amt`` bytes have been read from the connection or until the\n connection is closed.\n\n :param amt:\n How much of the content to read. The generator will return up to\n much data per iteration, but may return less. This is particularly\n likely when using compressed data. However, the empty string will\n never be returned.\n\n :param decode_content:\n If True, will attempt to decode the body based on the\n 'content-encoding' header.\n \"\"\"\n if self.chunked and self.supports_chunked_reads():\n for line in self.read_chunked(amt, decode_content=decode_content):\n yield line\n else:\n while not is_fp_closed(self._fp):\n data = self.read(amt=amt, decode_content=decode_content)\n\n if data:\n yield data\n\n @classmethod\n def from_httplib(ResponseCls, r, **response_kw):\n \"\"\"\n Given an :class:`http.client.HTTPResponse` instance ``r``, return a\n corresponding :class:`urllib3.response.HTTPResponse` object.\n\n Remaining parameters are passed to the HTTPResponse constructor, along\n with ``original_response=r``.\n \"\"\"\n headers = r.msg\n\n if not isinstance(headers, HTTPHeaderDict):\n if six.PY2:\n # Python 2.7\n headers = HTTPHeaderDict.from_httplib(headers)\n else:\n headers = HTTPHeaderDict(headers.items())\n\n # HTTPResponse objects in Python 3 don't have a .strict attribute\n strict = getattr(r, \"strict\", 0)\n resp = ResponseCls(\n body=r,\n headers=headers,\n status=r.status,\n version=r.version,\n reason=r.reason,\n strict=strict,\n original_response=r,\n **response_kw\n )\n return resp\n\n # Backwards-compatibility methods for http.client.HTTPResponse\n def getheaders(self):\n warnings.warn(\n \"HTTPResponse.getheaders() is deprecated and will be removed \"\n \"in urllib3 v2.1.0. Instead access HTTPResponse.headers directly.\",\n category=DeprecationWarning,\n stacklevel=2,\n )\n return self.headers\n\n def getheader(self, name, default=None):\n warnings.warn(\n \"HTTPResponse.getheader() is deprecated and will be removed \"\n \"in urllib3 v2.1.0. Instead use HTTPResponse.headers.get(name, default).\",\n category=DeprecationWarning,\n stacklevel=2,\n )\n return self.headers.get(name, default)\n\n # Backwards compatibility for http.cookiejar\n def info(self):\n return self.headers\n\n # Overrides from io.IOBase\n def close(self):\n if not self.closed:\n self._fp.close()\n\n if self._connection:\n self._connection.close()\n\n if not self.auto_close:\n io.IOBase.close(self)\n\n @property\n def closed(self):\n if not self.auto_close:\n return io.IOBase.closed.__get__(self)\n elif self._fp is None:\n return True\n elif hasattr(self._fp, \"isclosed\"):\n return self._fp.isclosed()\n elif hasattr(self._fp, \"closed\"):\n return self._fp.closed\n else:\n return True\n\n def fileno(self):\n if self._fp is None:\n raise IOError(\"HTTPResponse has no file to get a fileno from\")\n elif hasattr(self._fp, \"fileno\"):\n return self._fp.fileno()\n else:\n raise IOError(\n \"The file-like object this HTTPResponse is wrapped \"\n \"around has no file descriptor\"\n )\n\n def flush(self):\n if (\n self._fp is not None\n and hasattr(self._fp, \"flush\")\n and not getattr(self._fp, \"closed\", False)\n ):\n return self._fp.flush()\n\n def readable(self):\n # This method is required for `io` module compatibility.\n return True\n\n def readinto(self, b):\n # This method is required for `io` module compatibility.\n temp = self.read(len(b))\n if len(temp) == 0:\n return 0\n else:\n b[: len(temp)] = temp\n return len(temp)\n\n def supports_chunked_reads(self):\n \"\"\"\n Checks if the underlying file-like object looks like a\n :class:`http.client.HTTPResponse` object. We do this by testing for\n the fp attribute. If it is present we assume it returns raw chunks as\n processed by read_chunked().\n \"\"\"\n return hasattr(self._fp, \"fp\")\n\n def _update_chunk_length(self):\n # First, we'll figure out length of a chunk and then\n # we'll try to read it from socket.\n if self.chunk_left is not None:\n return\n line = self._fp.fp.readline()\n line = line.split(b\";\", 1)[0]\n try:\n self.chunk_left = int(line, 16)\n except ValueError:\n # Invalid chunked protocol response, abort.\n self.close()\n raise InvalidChunkLength(self, line)\n\n def _handle_chunk(self, amt):\n returned_chunk = None\n if amt is None:\n chunk = self._fp._safe_read(self.chunk_left)\n returned_chunk = chunk\n self._fp._safe_read(2) # Toss the CRLF at the end of the chunk.\n self.chunk_left = None\n elif amt < self.chunk_left:\n value = self._fp._safe_read(amt)\n self.chunk_left = self.chunk_left - amt\n returned_chunk = value\n elif amt == self.chunk_left:\n value = self._fp._safe_read(amt)\n self._fp._safe_read(2) # Toss the CRLF at the end of the chunk.\n self.chunk_left = None\n returned_chunk = value\n else: # amt > self.chunk_left\n returned_chunk = self._fp._safe_read(self.chunk_left)\n self._fp._safe_read(2) # Toss the CRLF at the end of the chunk.\n self.chunk_left = None\n return returned_chunk\n\n def read_chunked(self, amt=None, decode_content=None):\n \"\"\"\n Similar to :meth:`HTTPResponse.read`, but with an additional\n parameter: ``decode_content``.\n\n :param amt:\n How much of the content to read. If specified, caching is skipped\n because it doesn't make sense to cache partial content as the full\n response.\n\n :param decode_content:\n If True, will attempt to decode the body based on the\n 'content-encoding' header.\n \"\"\"\n self._init_decoder()\n # FIXME: Rewrite this method and make it a class with a better structured logic.\n if not self.chunked:\n raise ResponseNotChunked(\n \"Response is not chunked. \"\n \"Header 'transfer-encoding: chunked' is missing.\"\n )\n if not self.supports_chunked_reads():\n raise BodyNotHttplibCompatible(\n \"Body should be http.client.HTTPResponse like. \"\n \"It should have have an fp attribute which returns raw chunks.\"\n )\n\n with self._error_catcher():\n # Don't bother reading the body of a HEAD request.\n if self._original_response and is_response_to_head(self._original_response):\n self._original_response.close()\n return\n\n # If a response is already read and closed\n # then return immediately.\n if self._fp.fp is None:\n return\n\n while True:\n self._update_chunk_length()\n if self.chunk_left == 0:\n break\n chunk = self._handle_chunk(amt)\n decoded = self._decode(\n chunk, decode_content=decode_content, flush_decoder=False\n )\n if decoded:\n yield decoded\n\n if decode_content:\n # On CPython and PyPy, we should never need to flush the\n # decoder. However, on Jython we *might* need to, so\n # lets defensively do it anyway.\n decoded = self._flush_decoder()\n if decoded: # Platform-specific: Jython.\n yield decoded\n\n # Chunk content ends with \\r\\n: discard it.\n while True:\n line = self._fp.fp.readline()\n if not line:\n # Some sites may not end with '\\r\\n'.\n break\n if line == b\"\\r\\n\":\n break\n\n # We read everything; close the \"file\".\n if self._original_response:\n self._original_response.close()\n\n def geturl(self):\n \"\"\"\n Returns the URL that was the source of this response.\n If the request that generated this response redirected, this method\n will return the final redirect location.\n \"\"\"\n if self.retries is not None and len(self.retries.history):\n return self.retries.history[-1].redirect_location\n else:\n return self._request_url\n\n def __iter__(self):\n buffer = []\n for chunk in self.stream(decode_content=True):\n if b\"\\n\" in chunk:\n chunk = chunk.split(b\"\\n\")\n yield b\"\".join(buffer) + chunk[0] + b\"\\n\"\n for x in chunk[1:-1]:\n yield x + b\"\\n\"\n if chunk[-1]:\n buffer = [chunk[-1]]\n else:\n buffer = []\n else:\n buffer.append(chunk)\n if buffer:\n yield b\"\".join(buffer)\n",[],[213,919,920,921,1016,1050,1067,1059],"urllib3","0d5264d6-67fc-11f0-a99a-0224a6c84d84","request.py","0d5265b2-67fc-11f0-a99a-0224a6c84d84",494,["D",1753299269978],"from __future__ import absolute_import\n\nimport sys\n\nfrom .filepost import encode_multipart_formdata\nfrom .packages import six\nfrom .packages.six.moves.urllib.parse import urlencode\n\n__all__ = [\"RequestMethods\"]\n\n\nclass RequestMethods(object):\n \"\"\"\n Convenience mixin for classes who implement a :meth:`urlopen` method, such\n as :class:`urllib3.HTTPConnectionPool` and\n :class:`urllib3.PoolManager`.\n\n Provides behavior for making common types of HTTP request methods and\n decides which type of request field encoding to use.\n\n Specifically,\n\n :meth:`.request_encode_url` is for sending requests whose fields are\n encoded in the URL (such as GET, HEAD, DELETE).\n\n :meth:`.request_encode_body` is for sending requests whose fields are\n encoded in the *body* of the request using multipart or www-form-urlencoded\n (such as for POST, PUT, PATCH).\n\n :meth:`.request` is for making any kind of request, it will look up the\n appropriate encoding format and use one of the above two methods to make\n the request.\n\n Initializer parameters:\n\n :param headers:\n Headers to include with all requests, unless other headers are given\n explicitly.\n \"\"\"\n\n _encode_url_methods = {\"DELETE\", \"GET\", \"HEAD\", \"OPTIONS\"}\n\n def __init__(self, headers=None):\n self.headers = headers or {}\n\n def urlopen(\n self,\n method,\n url,\n body=None,\n headers=None,\n encode_multipart=True,\n multipart_boundary=None,\n **kw\n ): # Abstract\n raise NotImplementedError(\n \"Classes extending RequestMethods must implement \"\n \"their own ``urlopen`` method.\"\n )\n\n def request(self, method, url, fields=None, headers=None, **urlopen_kw):\n \"\"\"\n Make a request using :meth:`urlopen` with the appropriate encoding of\n ``fields`` based on the ``method`` used.\n\n This is a convenience method that requires the least amount of manual\n effort. It can be used in most situations, while still having the\n option to drop down to more specific methods when necessary, such as\n :meth:`request_encode_url`, :meth:`request_encode_body`,\n or even the lowest level :meth:`urlopen`.\n \"\"\"\n method = method.upper()\n\n urlopen_kw[\"request_url\"] = url\n\n if method in self._encode_url_methods:\n return self.request_encode_url(\n method, url, fields=fields, headers=headers, **urlopen_kw\n )\n else:\n return self.request_encode_body(\n method, url, fields=fields, headers=headers, **urlopen_kw\n )\n\n def request_encode_url(self, method, url, fields=None, headers=None, **urlopen_kw):\n \"\"\"\n Make a request using :meth:`urlopen` with the ``fields`` encoded in\n the url. This is useful for request methods like GET, HEAD, DELETE, etc.\n \"\"\"\n if headers is None:\n headers = self.headers\n\n extra_kw = {\"headers\": headers}\n extra_kw.update(urlopen_kw)\n\n if fields:\n url += \"?\" + urlencode(fields)\n\n return self.urlopen(method, url, **extra_kw)\n\n def request_encode_body(\n self,\n method,\n url,\n fields=None,\n headers=None,\n encode_multipart=True,\n multipart_boundary=None,\n **urlopen_kw\n ):\n \"\"\"\n Make a request using :meth:`urlopen` with the ``fields`` encoded in\n the body. This is useful for request methods like POST, PUT, PATCH, etc.\n\n When ``encode_multipart=True`` (default), then\n :func:`urllib3.encode_multipart_formdata` is used to encode\n the payload with the appropriate content type. Otherwise\n :func:`urllib.parse.urlencode` is used with the\n 'application/x-www-form-urlencoded' content type.\n\n Multipart encoding must be used when posting files, and it's reasonably\n safe to use it in other times too. However, it may break request\n signing, such as with OAuth.\n\n Supports an optional ``fields`` parameter of key/value strings AND\n key/filetuple. A filetuple is a (filename, data, MIME type) tuple where\n the MIME type is optional. For example::\n\n fields = {\n 'foo': 'bar',\n 'fakefile': ('foofile.txt', 'contents of foofile'),\n 'realfile': ('barfile.txt', open('realfile').read()),\n 'typedfile': ('bazfile.bin', open('bazfile').read(),\n 'image/jpeg'),\n 'nonamefile': 'contents of nonamefile field',\n }\n\n When uploading a file, providing a filename (the first parameter of the\n tuple) is optional but recommended to best mimic behavior of browsers.\n\n Note that if ``headers`` are supplied, the 'Content-Type' header will\n be overwritten because it depends on the dynamic random boundary string\n which is used to compose the body of the request. The random boundary\n string can be explicitly set with the ``multipart_boundary`` parameter.\n \"\"\"\n if headers is None:\n headers = self.headers\n\n extra_kw = {\"headers\": {}}\n\n if fields:\n if \"body\" in urlopen_kw:\n raise TypeError(\n \"request got values for both 'fields' and 'body', can only specify one.\"\n )\n\n if encode_multipart:\n body, content_type = encode_multipart_formdata(\n fields, boundary=multipart_boundary\n )\n else:\n body, content_type = (\n urlencode(fields),\n \"application/x-www-form-urlencoded\",\n )\n\n extra_kw[\"body\"] = body\n extra_kw[\"headers\"] = {\"Content-Type\": content_type}\n\n extra_kw[\"headers\"].update(headers)\n extra_kw.update(urlopen_kw)\n\n return self.urlopen(method, url, **extra_kw)\n\n\nif not six.PY2:\n\n class RequestModule(sys.modules[__name__].__class__):\n def __call__(self, *args, **kwargs):\n \"\"\"\n If user tries to call this module directly urllib3 v2.x style raise an error to the user\n suggesting they may need urllib3 v2\n \"\"\"\n raise TypeError(\n \"'module' object is not callable\\n\"\n \"urllib3.request() method is not supported in this release, \"\n \"upgrade to urllib3 v2 to use it\\n\"\n \"see https://urllib3.readthedocs.io/en/stable/v2-migration-guide.html\"\n )\n\n sys.modules[__name__].__class__ = RequestModule\n",[],[213,919,920,921,1016,1050,1067,1069],"0d43c9b2-67fc-11f0-befa-0224a6c84d84","poolmanager.py","0d43ca48-67fc-11f0-befa-0224a6c84d84",492,["D",1753299270028],"from __future__ import absolute_import\n\nimport collections\nimport functools\nimport logging\n\nfrom ._collections import HTTPHeaderDict, RecentlyUsedContainer\nfrom .connectionpool import HTTPConnectionPool, HTTPSConnectionPool, port_by_scheme\nfrom .exceptions import (\n LocationValueError,\n MaxRetryError,\n ProxySchemeUnknown,\n ProxySchemeUnsupported,\n URLSchemeUnknown,\n)\nfrom .packages import six\nfrom .packages.six.moves.urllib.parse import urljoin\nfrom .request import RequestMethods\nfrom .util.proxy import connection_requires_http_tunnel\nfrom .util.retry import Retry\nfrom .util.url import parse_url\n\n__all__ = [\"PoolManager\", \"ProxyManager\", \"proxy_from_url\"]\n\n\nlog = logging.getLogger(__name__)\n\nSSL_KEYWORDS = (\n \"key_file\",\n \"cert_file\",\n \"cert_reqs\",\n \"ca_certs\",\n \"ssl_version\",\n \"ca_cert_dir\",\n \"ssl_context\",\n \"key_password\",\n \"server_hostname\",\n)\n\n# All known keyword arguments that could be provided to the pool manager, its\n# pools, or the underlying connections. This is used to construct a pool key.\n_key_fields = (\n \"key_scheme\", # str\n \"key_host\", # str\n \"key_port\", # int\n \"key_timeout\", # int or float or Timeout\n \"key_retries\", # int or Retry\n \"key_strict\", # bool\n \"key_block\", # bool\n \"key_source_address\", # str\n \"key_key_file\", # str\n \"key_key_password\", # str\n \"key_cert_file\", # str\n \"key_cert_reqs\", # str\n \"key_ca_certs\", # str\n \"key_ssl_version\", # str\n \"key_ca_cert_dir\", # str\n \"key_ssl_context\", # instance of ssl.SSLContext or urllib3.util.ssl_.SSLContext\n \"key_maxsize\", # int\n \"key_headers\", # dict\n \"key__proxy\", # parsed proxy url\n \"key__proxy_headers\", # dict\n \"key__proxy_config\", # class\n \"key_socket_options\", # list of (level (int), optname (int), value (int or str)) tuples\n \"key__socks_options\", # dict\n \"key_assert_hostname\", # bool or string\n \"key_assert_fingerprint\", # str\n \"key_server_hostname\", # str\n)\n\n#: The namedtuple class used to construct keys for the connection pool.\n#: All custom key schemes should include the fields in this key at a minimum.\nPoolKey = collections.namedtuple(\"PoolKey\", _key_fields)\n\n_proxy_config_fields = (\"ssl_context\", \"use_forwarding_for_https\")\nProxyConfig = collections.namedtuple(\"ProxyConfig\", _proxy_config_fields)\n\n\ndef _default_key_normalizer(key_class, request_context):\n \"\"\"\n Create a pool key out of a request context dictionary.\n\n According to RFC 3986, both the scheme and host are case-insensitive.\n Therefore, this function normalizes both before constructing the pool\n key for an HTTPS request. If you wish to change this behaviour, provide\n alternate callables to ``key_fn_by_scheme``.\n\n :param key_class:\n The class to use when constructing the key. This should be a namedtuple\n with the ``scheme`` and ``host`` keys at a minimum.\n :type key_class: namedtuple\n :param request_context:\n A dictionary-like object that contain the context for a request.\n :type request_context: dict\n\n :return: A namedtuple that can be used as a connection pool key.\n :rtype: PoolKey\n \"\"\"\n # Since we mutate the dictionary, make a copy first\n context = request_context.copy()\n context[\"scheme\"] = context[\"scheme\"].lower()\n context[\"host\"] = context[\"host\"].lower()\n\n # These are both dictionaries and need to be transformed into frozensets\n for key in (\"headers\", \"_proxy_headers\", \"_socks_options\"):\n if key in context and context[key] is not None:\n context[key] = frozenset(context[key].items())\n\n # The socket_options key may be a list and needs to be transformed into a\n # tuple.\n socket_opts = context.get(\"socket_options\")\n if socket_opts is not None:\n context[\"socket_options\"] = tuple(socket_opts)\n\n # Map the kwargs to the names in the namedtuple - this is necessary since\n # namedtuples can't have fields starting with '_'.\n for key in list(context.keys()):\n context[\"key_\" + key] = context.pop(key)\n\n # Default to ``None`` for keys missing from the context\n for field in key_class._fields:\n if field not in context:\n context[field] = None\n\n return key_class(**context)\n\n\n#: A dictionary that maps a scheme to a callable that creates a pool key.\n#: This can be used to alter the way pool keys are constructed, if desired.\n#: Each PoolManager makes a copy of this dictionary so they can be configured\n#: globally here, or individually on the instance.\nkey_fn_by_scheme = {\n \"http\": functools.partial(_default_key_normalizer, PoolKey),\n \"https\": functools.partial(_default_key_normalizer, PoolKey),\n}\n\npool_classes_by_scheme = {\"http\": HTTPConnectionPool, \"https\": HTTPSConnectionPool}\n\n\nclass PoolManager(RequestMethods):\n \"\"\"\n Allows for arbitrary requests while transparently keeping track of\n necessary connection pools for you.\n\n :param num_pools:\n Number of connection pools to cache before discarding the least\n recently used pool.\n\n :param headers:\n Headers to include with all requests, unless other headers are given\n explicitly.\n\n :param \\\\**connection_pool_kw:\n Additional parameters are used to create fresh\n :class:`urllib3.connectionpool.ConnectionPool` instances.\n\n Example::\n\n >>> manager = PoolManager(num_pools=2)\n >>> r = manager.request('GET', 'http://google.com/')\n >>> r = manager.request('GET', 'http://google.com/mail')\n >>> r = manager.request('GET', 'http://yahoo.com/')\n >>> len(manager.pools)\n 2\n\n \"\"\"\n\n proxy = None\n proxy_config = None\n\n def __init__(self, num_pools=10, headers=None, **connection_pool_kw):\n RequestMethods.__init__(self, headers)\n self.connection_pool_kw = connection_pool_kw\n self.pools = RecentlyUsedContainer(num_pools)\n\n # Locally set the pool classes and keys so other PoolManagers can\n # override them.\n self.pool_classes_by_scheme = pool_classes_by_scheme\n self.key_fn_by_scheme = key_fn_by_scheme.copy()\n\n def __enter__(self):\n return self\n\n def __exit__(self, exc_type, exc_val, exc_tb):\n self.clear()\n # Return False to re-raise any potential exceptions\n return False\n\n def _new_pool(self, scheme, host, port, request_context=None):\n \"\"\"\n Create a new :class:`urllib3.connectionpool.ConnectionPool` based on host, port, scheme, and\n any additional pool keyword arguments.\n\n If ``request_context`` is provided, it is provided as keyword arguments\n to the pool class used. This method is used to actually create the\n connection pools handed out by :meth:`connection_from_url` and\n companion methods. It is intended to be overridden for customization.\n \"\"\"\n pool_cls = self.pool_classes_by_scheme[scheme]\n if request_context is None:\n request_context = self.connection_pool_kw.copy()\n\n # Although the context has everything necessary to create the pool,\n # this function has historically only used the scheme, host, and port\n # in the positional args. When an API change is acceptable these can\n # be removed.\n for key in (\"scheme\", \"host\", \"port\"):\n request_context.pop(key, None)\n\n if scheme == \"http\":\n for kw in SSL_KEYWORDS:\n request_context.pop(kw, None)\n\n return pool_cls(host, port, **request_context)\n\n def clear(self):\n \"\"\"\n Empty our store of pools and direct them all to close.\n\n This will not affect in-flight connections, but they will not be\n re-used after completion.\n \"\"\"\n self.pools.clear()\n\n def connection_from_host(self, host, port=None, scheme=\"http\", pool_kwargs=None):\n \"\"\"\n Get a :class:`urllib3.connectionpool.ConnectionPool` based on the host, port, and scheme.\n\n If ``port`` isn't given, it will be derived from the ``scheme`` using\n ``urllib3.connectionpool.port_by_scheme``. If ``pool_kwargs`` is\n provided, it is merged with the instance's ``connection_pool_kw``\n variable and used to create the new connection pool, if one is\n needed.\n \"\"\"\n\n if not host:\n raise LocationValueError(\"No host specified.\")\n\n request_context = self._merge_pool_kwargs(pool_kwargs)\n request_context[\"scheme\"] = scheme or \"http\"\n if not port:\n port = port_by_scheme.get(request_context[\"scheme\"].lower(), 80)\n request_context[\"port\"] = port\n request_context[\"host\"] = host\n\n return self.connection_from_context(request_context)\n\n def connection_from_context(self, request_context):\n \"\"\"\n Get a :class:`urllib3.connectionpool.ConnectionPool` based on the request context.\n\n ``request_context`` must at least contain the ``scheme`` key and its\n value must be a key in ``key_fn_by_scheme`` instance variable.\n \"\"\"\n scheme = request_context[\"scheme\"].lower()\n pool_key_constructor = self.key_fn_by_scheme.get(scheme)\n if not pool_key_constructor:\n raise URLSchemeUnknown(scheme)\n pool_key = pool_key_constructor(request_context)\n\n return self.connection_from_pool_key(pool_key, request_context=request_context)\n\n def connection_from_pool_key(self, pool_key, request_context=None):\n \"\"\"\n Get a :class:`urllib3.connectionpool.ConnectionPool` based on the provided pool key.\n\n ``pool_key`` should be a namedtuple that only contains immutable\n objects. At a minimum it must have the ``scheme``, ``host``, and\n ``port`` fields.\n \"\"\"\n with self.pools.lock:\n # If the scheme, host, or port doesn't match existing open\n # connections, open a new ConnectionPool.\n pool = self.pools.get(pool_key)\n if pool:\n return pool\n\n # Make a fresh ConnectionPool of the desired type\n scheme = request_context[\"scheme\"]\n host = request_context[\"host\"]\n port = request_context[\"port\"]\n pool = self._new_pool(scheme, host, port, request_context=request_context)\n self.pools[pool_key] = pool\n\n return pool\n\n def connection_from_url(self, url, pool_kwargs=None):\n \"\"\"\n Similar to :func:`urllib3.connectionpool.connection_from_url`.\n\n If ``pool_kwargs`` is not provided and a new pool needs to be\n constructed, ``self.connection_pool_kw`` is used to initialize\n the :class:`urllib3.connectionpool.ConnectionPool`. If ``pool_kwargs``\n is provided, it is used instead. Note that if a new pool does not\n need to be created for the request, the provided ``pool_kwargs`` are\n not used.\n \"\"\"\n u = parse_url(url)\n return self.connection_from_host(\n u.host, port=u.port, scheme=u.scheme, pool_kwargs=pool_kwargs\n )\n\n def _merge_pool_kwargs(self, override):\n \"\"\"\n Merge a dictionary of override values for self.connection_pool_kw.\n\n This does not modify self.connection_pool_kw and returns a new dict.\n Any keys in the override dictionary with a value of ``None`` are\n removed from the merged dictionary.\n \"\"\"\n base_pool_kwargs = self.connection_pool_kw.copy()\n if override:\n for key, value in override.items():\n if value is None:\n try:\n del base_pool_kwargs[key]\n except KeyError:\n pass\n else:\n base_pool_kwargs[key] = value\n return base_pool_kwargs\n\n def _proxy_requires_url_absolute_form(self, parsed_url):\n \"\"\"\n Indicates if the proxy requires the complete destination URL in the\n request. Normally this is only needed when not using an HTTP CONNECT\n tunnel.\n \"\"\"\n if self.proxy is None:\n return False\n\n return not connection_requires_http_tunnel(\n self.proxy, self.proxy_config, parsed_url.scheme\n )\n\n def _validate_proxy_scheme_url_selection(self, url_scheme):\n \"\"\"\n Validates that were not attempting to do TLS in TLS connections on\n Python2 or with unsupported SSL implementations.\n \"\"\"\n if self.proxy is None or url_scheme != \"https\":\n return\n\n if self.proxy.scheme != \"https\":\n return\n\n if six.PY2 and not self.proxy_config.use_forwarding_for_https:\n raise ProxySchemeUnsupported(\n \"Contacting HTTPS destinations through HTTPS proxies \"\n \"'via CONNECT tunnels' is not supported in Python 2\"\n )\n\n def urlopen(self, method, url, redirect=True, **kw):\n \"\"\"\n Same as :meth:`urllib3.HTTPConnectionPool.urlopen`\n with custom cross-host redirect logic and only sends the request-uri\n portion of the ``url``.\n\n The given ``url`` parameter must be absolute, such that an appropriate\n :class:`urllib3.connectionpool.ConnectionPool` can be chosen for it.\n \"\"\"\n u = parse_url(url)\n self._validate_proxy_scheme_url_selection(u.scheme)\n\n conn = self.connection_from_host(u.host, port=u.port, scheme=u.scheme)\n\n kw[\"assert_same_host\"] = False\n kw[\"redirect\"] = False\n\n if \"headers\" not in kw:\n kw[\"headers\"] = self.headers.copy()\n\n if self._proxy_requires_url_absolute_form(u):\n response = conn.urlopen(method, url, **kw)\n else:\n response = conn.urlopen(method, u.request_uri, **kw)\n\n redirect_location = redirect and response.get_redirect_location()\n if not redirect_location:\n return response\n\n # Support relative URLs for redirecting.\n redirect_location = urljoin(url, redirect_location)\n\n if response.status == 303:\n # Change the method according to RFC 9110, Section 15.4.4.\n method = \"GET\"\n # And lose the body not to transfer anything sensitive.\n kw[\"body\"] = None\n kw[\"headers\"] = HTTPHeaderDict(kw[\"headers\"])._prepare_for_method_change()\n\n retries = kw.get(\"retries\")\n if not isinstance(retries, Retry):\n retries = Retry.from_int(retries, redirect=redirect)\n\n # Strip headers marked as unsafe to forward to the redirected location.\n # Check remove_headers_on_redirect to avoid a potential network call within\n # conn.is_same_host() which may use socket.gethostbyname() in the future.\n if retries.remove_headers_on_redirect and not conn.is_same_host(\n redirect_location\n ):\n headers = list(six.iterkeys(kw[\"headers\"]))\n for header in headers:\n if header.lower() in retries.remove_headers_on_redirect:\n kw[\"headers\"].pop(header, None)\n\n try:\n retries = retries.increment(method, url, response=response, _pool=conn)\n except MaxRetryError:\n if retries.raise_on_redirect:\n response.drain_conn()\n raise\n return response\n\n kw[\"retries\"] = retries\n kw[\"redirect\"] = redirect\n\n log.info(\"Redirecting %s -> %s\", url, redirect_location)\n\n response.drain_conn()\n return self.urlopen(method, redirect_location, **kw)\n\n\nclass ProxyManager(PoolManager):\n \"\"\"\n Behaves just like :class:`PoolManager`, but sends all requests through\n the defined proxy, using the CONNECT method for HTTPS URLs.\n\n :param proxy_url:\n The URL of the proxy to be used.\n\n :param proxy_headers:\n A dictionary containing headers that will be sent to the proxy. In case\n of HTTP they are being sent with each request, while in the\n HTTPS/CONNECT case they are sent only once. Could be used for proxy\n authentication.\n\n :param proxy_ssl_context:\n The proxy SSL context is used to establish the TLS connection to the\n proxy when using HTTPS proxies.\n\n :param use_forwarding_for_https:\n (Defaults to False) If set to True will forward requests to the HTTPS\n proxy to be made on behalf of the client instead of creating a TLS\n tunnel via the CONNECT method. **Enabling this flag means that request\n and response headers and content will be visible from the HTTPS proxy**\n whereas tunneling keeps request and response headers and content\n private. IP address, target hostname, SNI, and port are always visible\n to an HTTPS proxy even when this flag is disabled.\n\n Example:\n >>> proxy = urllib3.ProxyManager('http://localhost:3128/')\n >>> r1 = proxy.request('GET', 'http://google.com/')\n >>> r2 = proxy.request('GET', 'http://httpbin.org/')\n >>> len(proxy.pools)\n 1\n >>> r3 = proxy.request('GET', 'https://httpbin.org/')\n >>> r4 = proxy.request('GET', 'https://twitter.com/')\n >>> len(proxy.pools)\n 3\n\n \"\"\"\n\n def __init__(\n self,\n proxy_url,\n num_pools=10,\n headers=None,\n proxy_headers=None,\n proxy_ssl_context=None,\n use_forwarding_for_https=False,\n **connection_pool_kw\n ):\n\n if isinstance(proxy_url, HTTPConnectionPool):\n proxy_url = \"%s://%s:%i\" % (\n proxy_url.scheme,\n proxy_url.host,\n proxy_url.port,\n )\n proxy = parse_url(proxy_url)\n\n if proxy.scheme not in (\"http\", \"https\"):\n raise ProxySchemeUnknown(proxy.scheme)\n\n if not proxy.port:\n port = port_by_scheme.get(proxy.scheme, 80)\n proxy = proxy._replace(port=port)\n\n self.proxy = proxy\n self.proxy_headers = proxy_headers or {}\n self.proxy_ssl_context = proxy_ssl_context\n self.proxy_config = ProxyConfig(proxy_ssl_context, use_forwarding_for_https)\n\n connection_pool_kw[\"_proxy\"] = self.proxy\n connection_pool_kw[\"_proxy_headers\"] = self.proxy_headers\n connection_pool_kw[\"_proxy_config\"] = self.proxy_config\n\n super(ProxyManager, self).__init__(num_pools, headers, **connection_pool_kw)\n\n def connection_from_host(self, host, port=None, scheme=\"http\", pool_kwargs=None):\n if scheme == \"https\":\n return super(ProxyManager, self).connection_from_host(\n host, port, scheme, pool_kwargs=pool_kwargs\n )\n\n return super(ProxyManager, self).connection_from_host(\n self.proxy.host, self.proxy.port, self.proxy.scheme, pool_kwargs=pool_kwargs\n )\n\n def _set_proxy_headers(self, url, headers=None):\n \"\"\"\n Sets headers needed by proxies: specifically, the Accept and Host\n headers. Only sets headers not provided by the user.\n \"\"\"\n headers_ = {\"Accept\": \"*/*\"}\n\n netloc = parse_url(url).netloc\n if netloc:\n headers_[\"Host\"] = netloc\n\n if headers:\n headers_.update(headers)\n return headers_\n\n def urlopen(self, method, url, redirect=True, **kw):\n \"Same as HTTP(S)ConnectionPool.urlopen, ``url`` must be absolute.\"\n u = parse_url(url)\n if not connection_requires_http_tunnel(self.proxy, self.proxy_config, u.scheme):\n # For connections using HTTP CONNECT, httplib sets the necessary\n # headers on the CONNECT to the proxy. If we're not using CONNECT,\n # we'll definitely need to set 'Host' at the very least.\n headers = kw.get(\"headers\", self.headers)\n kw[\"headers\"] = self._set_proxy_headers(url, headers)\n\n return super(ProxyManager, self).urlopen(method, url, redirect=redirect, **kw)\n\n\ndef proxy_from_url(url, **kw):\n return ProxyManager(proxy_url=url, **kw)\n",[],[213,919,920,921,1016,1050,1067,1077],"0cd45d16-67fc-11f0-a29b-0224a6c84d84","filepost.py","0cd45dd4-67fc-11f0-a29b-0224a6c84d84",474,["D",1753299269308],"from __future__ import absolute_import\n\nimport binascii\nimport codecs\nimport os\nfrom io import BytesIO\n\nfrom .fields import RequestField\nfrom .packages import six\nfrom .packages.six import b\n\nwriter = codecs.lookup(\"utf-8\")[3]\n\n\ndef choose_boundary():\n \"\"\"\n Our embarrassingly-simple replacement for mimetools.choose_boundary.\n \"\"\"\n boundary = binascii.hexlify(os.urandom(16))\n if not six.PY2:\n boundary = boundary.decode(\"ascii\")\n return boundary\n\n\ndef iter_field_objects(fields):\n \"\"\"\n Iterate over fields.\n\n Supports list of (k, v) tuples and dicts, and lists of\n :class:`~urllib3.fields.RequestField`.\n\n \"\"\"\n if isinstance(fields, dict):\n i = six.iteritems(fields)\n else:\n i = iter(fields)\n\n for field in i:\n if isinstance(field, RequestField):\n yield field\n else:\n yield RequestField.from_tuples(*field)\n\n\ndef iter_fields(fields):\n \"\"\"\n .. deprecated:: 1.6\n\n Iterate over fields.\n\n The addition of :class:`~urllib3.fields.RequestField` makes this function\n obsolete. Instead, use :func:`iter_field_objects`, which returns\n :class:`~urllib3.fields.RequestField` objects.\n\n Supports list of (k, v) tuples and dicts.\n \"\"\"\n if isinstance(fields, dict):\n return ((k, v) for k, v in six.iteritems(fields))\n\n return ((k, v) for k, v in fields)\n\n\ndef encode_multipart_formdata(fields, boundary=None):\n \"\"\"\n Encode a dictionary of ``fields`` using the multipart/form-data MIME format.\n\n :param fields:\n Dictionary of fields or list of (key, :class:`~urllib3.fields.RequestField`).\n\n :param boundary:\n If not specified, then a random boundary will be generated using\n :func:`urllib3.filepost.choose_boundary`.\n \"\"\"\n body = BytesIO()\n if boundary is None:\n boundary = choose_boundary()\n\n for field in iter_field_objects(fields):\n body.write(b(\"--%s\\r\\n\" % (boundary)))\n\n writer(body).write(field.render_headers())\n data = field.data\n\n if isinstance(data, int):\n data = str(data) # Backwards compatibility\n\n if isinstance(data, six.text_type):\n writer(body).write(data)\n else:\n body.write(data)\n\n body.write(b\"\\r\\n\")\n\n body.write(b(\"--%s--\\r\\n\" % (boundary)))\n\n content_type = str(\"multipart/form-data; boundary=%s\" % boundary)\n\n return body.getvalue(), content_type\n",[],[213,919,920,921,1016,1050,1067,1085],"0cd82f7c-67fc-11f0-a7d9-0224a6c84d84","fields.py","0cd83012-67fc-11f0-a7d9-0224a6c84d84",475,["D",1753299269334],"from __future__ import absolute_import\n\nimport email.utils\nimport mimetypes\nimport re\n\nfrom .packages import six\n\n\ndef guess_content_type(filename, default=\"application/octet-stream\"):\n \"\"\"\n Guess the \"Content-Type\" of a file.\n\n :param filename:\n The filename to guess the \"Content-Type\" of using :mod:`mimetypes`.\n :param default:\n If no \"Content-Type\" can be guessed, default to `default`.\n \"\"\"\n if filename:\n return mimetypes.guess_type(filename)[0] or default\n return default\n\n\ndef format_header_param_rfc2231(name, value):\n \"\"\"\n Helper function to format and quote a single header parameter using the\n strategy defined in RFC 2231.\n\n Particularly useful for header parameters which might contain\n non-ASCII values, like file names. This follows\n `RFC 2388 Section 4.4 `_.\n\n :param name:\n The name of the parameter, a string expected to be ASCII only.\n :param value:\n The value of the parameter, provided as ``bytes`` or `str``.\n :ret:\n An RFC-2231-formatted unicode string.\n \"\"\"\n if isinstance(value, six.binary_type):\n value = value.decode(\"utf-8\")\n\n if not any(ch in value for ch in '\"\\\\\\r\\n'):\n result = u'%s=\"%s\"' % (name, value)\n try:\n result.encode(\"ascii\")\n except (UnicodeEncodeError, UnicodeDecodeError):\n pass\n else:\n return result\n\n if six.PY2: # Python 2:\n value = value.encode(\"utf-8\")\n\n # encode_rfc2231 accepts an encoded string and returns an ascii-encoded\n # string in Python 2 but accepts and returns unicode strings in Python 3\n value = email.utils.encode_rfc2231(value, \"utf-8\")\n value = \"%s*=%s\" % (name, value)\n\n if six.PY2: # Python 2:\n value = value.decode(\"utf-8\")\n\n return value\n\n\n_HTML5_REPLACEMENTS = {\n u\"\\u0022\": u\"%22\",\n # Replace \"\\\" with \"\\\\\".\n u\"\\u005C\": u\"\\u005C\\u005C\",\n}\n\n# All control characters from 0x00 to 0x1F *except* 0x1B.\n_HTML5_REPLACEMENTS.update(\n {\n six.unichr(cc): u\"%{:02X}\".format(cc)\n for cc in range(0x00, 0x1F + 1)\n if cc not in (0x1B,)\n }\n)\n\n\ndef _replace_multiple(value, needles_and_replacements):\n def replacer(match):\n return needles_and_replacements[match.group(0)]\n\n pattern = re.compile(\n r\"|\".join([re.escape(needle) for needle in needles_and_replacements.keys()])\n )\n\n result = pattern.sub(replacer, value)\n\n return result\n\n\ndef format_header_param_html5(name, value):\n \"\"\"\n Helper function to format and quote a single header parameter using the\n HTML5 strategy.\n\n Particularly useful for header parameters which might contain\n non-ASCII values, like file names. This follows the `HTML5 Working Draft\n Section 4.10.22.7`_ and matches the behavior of curl and modern browsers.\n\n .. _HTML5 Working Draft Section 4.10.22.7:\n https://w3c.github.io/html/sec-forms.html#multipart-form-data\n\n :param name:\n The name of the parameter, a string expected to be ASCII only.\n :param value:\n The value of the parameter, provided as ``bytes`` or `str``.\n :ret:\n A unicode string, stripped of troublesome characters.\n \"\"\"\n if isinstance(value, six.binary_type):\n value = value.decode(\"utf-8\")\n\n value = _replace_multiple(value, _HTML5_REPLACEMENTS)\n\n return u'%s=\"%s\"' % (name, value)\n\n\n# For backwards-compatibility.\nformat_header_param = format_header_param_html5\n\n\nclass RequestField(object):\n \"\"\"\n A data container for request body parameters.\n\n :param name:\n The name of this request field. Must be unicode.\n :param data:\n The data/value body.\n :param filename:\n An optional filename of the request field. Must be unicode.\n :param headers:\n An optional dict-like object of headers to initially use for the field.\n :param header_formatter:\n An optional callable that is used to encode and format the headers. By\n default, this is :func:`format_header_param_html5`.\n \"\"\"\n\n def __init__(\n self,\n name,\n data,\n filename=None,\n headers=None,\n header_formatter=format_header_param_html5,\n ):\n self._name = name\n self._filename = filename\n self.data = data\n self.headers = {}\n if headers:\n self.headers = dict(headers)\n self.header_formatter = header_formatter\n\n @classmethod\n def from_tuples(cls, fieldname, value, header_formatter=format_header_param_html5):\n \"\"\"\n A :class:`~urllib3.fields.RequestField` factory from old-style tuple parameters.\n\n Supports constructing :class:`~urllib3.fields.RequestField` from\n parameter of key/value strings AND key/filetuple. A filetuple is a\n (filename, data, MIME type) tuple where the MIME type is optional.\n For example::\n\n 'foo': 'bar',\n 'fakefile': ('foofile.txt', 'contents of foofile'),\n 'realfile': ('barfile.txt', open('realfile').read()),\n 'typedfile': ('bazfile.bin', open('bazfile').read(), 'image/jpeg'),\n 'nonamefile': 'contents of nonamefile field',\n\n Field names and filenames must be unicode.\n \"\"\"\n if isinstance(value, tuple):\n if len(value) == 3:\n filename, data, content_type = value\n else:\n filename, data = value\n content_type = guess_content_type(filename)\n else:\n filename = None\n content_type = None\n data = value\n\n request_param = cls(\n fieldname, data, filename=filename, header_formatter=header_formatter\n )\n request_param.make_multipart(content_type=content_type)\n\n return request_param\n\n def _render_part(self, name, value):\n \"\"\"\n Overridable helper function to format a single header parameter. By\n default, this calls ``self.header_formatter``.\n\n :param name:\n The name of the parameter, a string expected to be ASCII only.\n :param value:\n The value of the parameter, provided as a unicode string.\n \"\"\"\n\n return self.header_formatter(name, value)\n\n def _render_parts(self, header_parts):\n \"\"\"\n Helper function to format and quote a single header.\n\n Useful for single headers that are composed of multiple items. E.g.,\n 'Content-Disposition' fields.\n\n :param header_parts:\n A sequence of (k, v) tuples or a :class:`dict` of (k, v) to format\n as `k1=\"v1\"; k2=\"v2\"; ...`.\n \"\"\"\n parts = []\n iterable = header_parts\n if isinstance(header_parts, dict):\n iterable = header_parts.items()\n\n for name, value in iterable:\n if value is not None:\n parts.append(self._render_part(name, value))\n\n return u\"; \".join(parts)\n\n def render_headers(self):\n \"\"\"\n Renders the headers for this request field.\n \"\"\"\n lines = []\n\n sort_keys = [\"Content-Disposition\", \"Content-Type\", \"Content-Location\"]\n for sort_key in sort_keys:\n if self.headers.get(sort_key, False):\n lines.append(u\"%s: %s\" % (sort_key, self.headers[sort_key]))\n\n for header_name, header_value in self.headers.items():\n if header_name not in sort_keys:\n if header_value:\n lines.append(u\"%s: %s\" % (header_name, header_value))\n\n lines.append(u\"\\r\\n\")\n return u\"\\r\\n\".join(lines)\n\n def make_multipart(\n self, content_disposition=None, content_type=None, content_location=None\n ):\n \"\"\"\n Makes this request field into a multipart request field.\n\n This method overrides \"Content-Disposition\", \"Content-Type\" and\n \"Content-Location\" headers to the request parameter.\n\n :param content_type:\n The 'Content-Type' of the request body.\n :param content_location:\n The 'Content-Location' of the request body.\n\n \"\"\"\n self.headers[\"Content-Disposition\"] = content_disposition or u\"form-data\"\n self.headers[\"Content-Disposition\"] += u\"; \".join(\n [\n u\"\",\n self._render_parts(\n ((u\"name\", self._name), (u\"filename\", self._filename))\n ),\n ]\n )\n self.headers[\"Content-Type\"] = content_type\n self.headers[\"Content-Location\"] = content_location\n",[],[213,919,920,921,1016,1050,1067,1093],"0dc3a722-67fc-11f0-847e-0224a6c84d84","exceptions.py","0dc3a7cc-67fc-11f0-847e-0224a6c84d84",511,["D",1753299270719],"from __future__ import absolute_import\n\nfrom .packages.six.moves.http_client import IncompleteRead as httplib_IncompleteRead\n\n# Base Exceptions\n\n\nclass HTTPError(Exception):\n \"\"\"Base exception used by this module.\"\"\"\n\n pass\n\n\nclass HTTPWarning(Warning):\n \"\"\"Base warning used by this module.\"\"\"\n\n pass\n\n\nclass PoolError(HTTPError):\n \"\"\"Base exception for errors caused within a pool.\"\"\"\n\n def __init__(self, pool, message):\n self.pool = pool\n HTTPError.__init__(self, \"%s: %s\" % (pool, message))\n\n def __reduce__(self):\n # For pickling purposes.\n return self.__class__, (None, None)\n\n\nclass RequestError(PoolError):\n \"\"\"Base exception for PoolErrors that have associated URLs.\"\"\"\n\n def __init__(self, pool, url, message):\n self.url = url\n PoolError.__init__(self, pool, message)\n\n def __reduce__(self):\n # For pickling purposes.\n return self.__class__, (None, self.url, None)\n\n\nclass SSLError(HTTPError):\n \"\"\"Raised when SSL certificate fails in an HTTPS connection.\"\"\"\n\n pass\n\n\nclass ProxyError(HTTPError):\n \"\"\"Raised when the connection to a proxy fails.\"\"\"\n\n def __init__(self, message, error, *args):\n super(ProxyError, self).__init__(message, error, *args)\n self.original_error = error\n\n\nclass DecodeError(HTTPError):\n \"\"\"Raised when automatic decoding based on Content-Type fails.\"\"\"\n\n pass\n\n\nclass ProtocolError(HTTPError):\n \"\"\"Raised when something unexpected happens mid-request/response.\"\"\"\n\n pass\n\n\n#: Renamed to ProtocolError but aliased for backwards compatibility.\nConnectionError = ProtocolError\n\n\n# Leaf Exceptions\n\n\nclass MaxRetryError(RequestError):\n \"\"\"Raised when the maximum number of retries is exceeded.\n\n :param pool: The connection pool\n :type pool: :class:`~urllib3.connectionpool.HTTPConnectionPool`\n :param string url: The requested Url\n :param exceptions.Exception reason: The underlying error\n\n \"\"\"\n\n def __init__(self, pool, url, reason=None):\n self.reason = reason\n\n message = \"Max retries exceeded with url: %s (Caused by %r)\" % (url, reason)\n\n RequestError.__init__(self, pool, url, message)\n\n\nclass HostChangedError(RequestError):\n \"\"\"Raised when an existing pool gets a request for a foreign host.\"\"\"\n\n def __init__(self, pool, url, retries=3):\n message = \"Tried to open a foreign host with url: %s\" % url\n RequestError.__init__(self, pool, url, message)\n self.retries = retries\n\n\nclass TimeoutStateError(HTTPError):\n \"\"\"Raised when passing an invalid state to a timeout\"\"\"\n\n pass\n\n\nclass TimeoutError(HTTPError):\n \"\"\"Raised when a socket timeout error occurs.\n\n Catching this error will catch both :exc:`ReadTimeoutErrors\n ` and :exc:`ConnectTimeoutErrors `.\n \"\"\"\n\n pass\n\n\nclass ReadTimeoutError(TimeoutError, RequestError):\n \"\"\"Raised when a socket timeout occurs while receiving data from a server\"\"\"\n\n pass\n\n\n# This timeout error does not have a URL attached and needs to inherit from the\n# base HTTPError\nclass ConnectTimeoutError(TimeoutError):\n \"\"\"Raised when a socket timeout occurs while connecting to a server\"\"\"\n\n pass\n\n\nclass NewConnectionError(ConnectTimeoutError, PoolError):\n \"\"\"Raised when we fail to establish a new connection. Usually ECONNREFUSED.\"\"\"\n\n pass\n\n\nclass EmptyPoolError(PoolError):\n \"\"\"Raised when a pool runs out of connections and no more are allowed.\"\"\"\n\n pass\n\n\nclass ClosedPoolError(PoolError):\n \"\"\"Raised when a request enters a pool after the pool has been closed.\"\"\"\n\n pass\n\n\nclass LocationValueError(ValueError, HTTPError):\n \"\"\"Raised when there is something wrong with a given URL input.\"\"\"\n\n pass\n\n\nclass LocationParseError(LocationValueError):\n \"\"\"Raised when get_host or similar fails to parse the URL input.\"\"\"\n\n def __init__(self, location):\n message = \"Failed to parse: %s\" % location\n HTTPError.__init__(self, message)\n\n self.location = location\n\n\nclass URLSchemeUnknown(LocationValueError):\n \"\"\"Raised when a URL input has an unsupported scheme.\"\"\"\n\n def __init__(self, scheme):\n message = \"Not supported URL scheme %s\" % scheme\n super(URLSchemeUnknown, self).__init__(message)\n\n self.scheme = scheme\n\n\nclass ResponseError(HTTPError):\n \"\"\"Used as a container for an error reason supplied in a MaxRetryError.\"\"\"\n\n GENERIC_ERROR = \"too many error responses\"\n SPECIFIC_ERROR = \"too many {status_code} error responses\"\n\n\nclass SecurityWarning(HTTPWarning):\n \"\"\"Warned when performing security reducing actions\"\"\"\n\n pass\n\n\nclass SubjectAltNameWarning(SecurityWarning):\n \"\"\"Warned when connecting to a host with a certificate missing a SAN.\"\"\"\n\n pass\n\n\nclass InsecureRequestWarning(SecurityWarning):\n \"\"\"Warned when making an unverified HTTPS request.\"\"\"\n\n pass\n\n\nclass SystemTimeWarning(SecurityWarning):\n \"\"\"Warned when system time is suspected to be wrong\"\"\"\n\n pass\n\n\nclass InsecurePlatformWarning(SecurityWarning):\n \"\"\"Warned when certain TLS/SSL configuration is not available on a platform.\"\"\"\n\n pass\n\n\nclass SNIMissingWarning(HTTPWarning):\n \"\"\"Warned when making a HTTPS request without SNI available.\"\"\"\n\n pass\n\n\nclass DependencyWarning(HTTPWarning):\n \"\"\"\n Warned when an attempt is made to import a module with missing optional\n dependencies.\n \"\"\"\n\n pass\n\n\nclass ResponseNotChunked(ProtocolError, ValueError):\n \"\"\"Response needs to be chunked in order to read it as chunks.\"\"\"\n\n pass\n\n\nclass BodyNotHttplibCompatible(HTTPError):\n \"\"\"\n Body should be :class:`http.client.HTTPResponse` like\n (have an fp attribute which returns raw chunks) for read_chunked().\n \"\"\"\n\n pass\n\n\nclass IncompleteRead(HTTPError, httplib_IncompleteRead):\n \"\"\"\n Response length doesn't match expected Content-Length\n\n Subclass of :class:`http.client.IncompleteRead` to allow int value\n for ``partial`` to avoid creating large objects on streamed reads.\n \"\"\"\n\n def __init__(self, partial, expected):\n super(IncompleteRead, self).__init__(partial, expected)\n\n def __repr__(self):\n return \"IncompleteRead(%i bytes read, %i more expected)\" % (\n self.partial,\n self.expected,\n )\n\n\nclass InvalidChunkLength(HTTPError, httplib_IncompleteRead):\n \"\"\"Invalid chunk length in a chunked response.\"\"\"\n\n def __init__(self, response, length):\n super(InvalidChunkLength, self).__init__(\n response.tell(), response.length_remaining\n )\n self.response = response\n self.length = length\n\n def __repr__(self):\n return \"InvalidChunkLength(got length %r, %i bytes read)\" % (\n self.length,\n self.partial,\n )\n\n\nclass InvalidHeader(HTTPError):\n \"\"\"The header provided was somehow invalid.\"\"\"\n\n pass\n\n\nclass ProxySchemeUnknown(AssertionError, URLSchemeUnknown):\n \"\"\"ProxyManager does not support the supplied scheme\"\"\"\n\n # TODO(t-8ch): Stop inheriting from AssertionError in v2.0.\n\n def __init__(self, scheme):\n # 'localhost' is here because our URL parser parses\n # localhost:8080 -> scheme=localhost, remove if we fix this.\n if scheme == \"localhost\":\n scheme = None\n if scheme is None:\n message = \"Proxy URL had no scheme, should start with http:// or https://\"\n else:\n message = (\n \"Proxy URL had unsupported scheme %s, should use http:// or https://\"\n % scheme\n )\n super(ProxySchemeUnknown, self).__init__(message)\n\n\nclass ProxySchemeUnsupported(ValueError):\n \"\"\"Fetching HTTPS resources through HTTPS proxies is unsupported\"\"\"\n\n pass\n\n\nclass HeaderParsingError(HTTPError):\n \"\"\"Raised by assert_header_parsing, but we convert it to a log.warning statement.\"\"\"\n\n def __init__(self, defects, unparsed_data):\n message = \"%s, unparsed data: %r\" % (defects or \"Unknown\", unparsed_data)\n super(HeaderParsingError, self).__init__(message)\n\n\nclass UnrewindableBodyError(HTTPError):\n \"\"\"urllib3 encountered an error when trying to rewind a body\"\"\"\n\n pass\n",[],[213,919,920,921,1016,1050,1067,1101],"0dbff690-67fc-11f0-8d4e-0224a6c84d84","connectionpool.py","0dbff758-67fc-11f0-8d4e-0224a6c84d84",510,["D",1753299270776],"from __future__ import absolute_import\n\nimport errno\nimport logging\nimport re\nimport socket\nimport sys\nimport warnings\nfrom socket import error as SocketError\nfrom socket import timeout as SocketTimeout\n\nfrom ._collections import HTTPHeaderDict\nfrom .connection import (\n BaseSSLError,\n BrokenPipeError,\n DummyConnection,\n HTTPConnection,\n HTTPException,\n HTTPSConnection,\n VerifiedHTTPSConnection,\n port_by_scheme,\n)\nfrom .exceptions import (\n ClosedPoolError,\n EmptyPoolError,\n HeaderParsingError,\n HostChangedError,\n InsecureRequestWarning,\n LocationValueError,\n MaxRetryError,\n NewConnectionError,\n ProtocolError,\n ProxyError,\n ReadTimeoutError,\n SSLError,\n TimeoutError,\n)\nfrom .packages import six\nfrom .packages.six.moves import queue\nfrom .request import RequestMethods\nfrom .response import HTTPResponse\nfrom .util.connection import is_connection_dropped\nfrom .util.proxy import connection_requires_http_tunnel\nfrom .util.queue import LifoQueue\nfrom .util.request import set_file_position\nfrom .util.response import assert_header_parsing\nfrom .util.retry import Retry\nfrom .util.ssl_match_hostname import CertificateError\nfrom .util.timeout import Timeout\nfrom .util.url import Url, _encode_target\nfrom .util.url import _normalize_host as normalize_host\nfrom .util.url import get_host, parse_url\n\ntry: # Platform-specific: Python 3\n import weakref\n\n weakref_finalize = weakref.finalize\nexcept AttributeError: # Platform-specific: Python 2\n from .packages.backports.weakref_finalize import weakref_finalize\n\nxrange = six.moves.xrange\n\nlog = logging.getLogger(__name__)\n\n_Default = object()\n\n\n# Pool objects\nclass ConnectionPool(object):\n \"\"\"\n Base class for all connection pools, such as\n :class:`.HTTPConnectionPool` and :class:`.HTTPSConnectionPool`.\n\n .. note::\n ConnectionPool.urlopen() does not normalize or percent-encode target URIs\n which is useful if your target server doesn't support percent-encoded\n target URIs.\n \"\"\"\n\n scheme = None\n QueueCls = LifoQueue\n\n def __init__(self, host, port=None):\n if not host:\n raise LocationValueError(\"No host specified.\")\n\n self.host = _normalize_host(host, scheme=self.scheme)\n self._proxy_host = host.lower()\n self.port = port\n\n def __str__(self):\n return \"%s(host=%r, port=%r)\" % (type(self).__name__, self.host, self.port)\n\n def __enter__(self):\n return self\n\n def __exit__(self, exc_type, exc_val, exc_tb):\n self.close()\n # Return False to re-raise any potential exceptions\n return False\n\n def close(self):\n \"\"\"\n Close all pooled connections and disable the pool.\n \"\"\"\n pass\n\n\n# This is taken from http://hg.python.org/cpython/file/7aaba721ebc0/Lib/socket.py#l252\n_blocking_errnos = {errno.EAGAIN, errno.EWOULDBLOCK}\n\n\nclass HTTPConnectionPool(ConnectionPool, RequestMethods):\n \"\"\"\n Thread-safe connection pool for one host.\n\n :param host:\n Host used for this HTTP Connection (e.g. \"localhost\"), passed into\n :class:`http.client.HTTPConnection`.\n\n :param port:\n Port used for this HTTP Connection (None is equivalent to 80), passed\n into :class:`http.client.HTTPConnection`.\n\n :param strict:\n Causes BadStatusLine to be raised if the status line can't be parsed\n as a valid HTTP/1.0 or 1.1 status line, passed into\n :class:`http.client.HTTPConnection`.\n\n .. note::\n Only works in Python 2. This parameter is ignored in Python 3.\n\n :param timeout:\n Socket timeout in seconds for each individual connection. This can\n be a float or integer, which sets the timeout for the HTTP request,\n or an instance of :class:`urllib3.util.Timeout` which gives you more\n fine-grained control over request timeouts. After the constructor has\n been parsed, this is always a `urllib3.util.Timeout` object.\n\n :param maxsize:\n Number of connections to save that can be reused. More than 1 is useful\n in multithreaded situations. If ``block`` is set to False, more\n connections will be created but they will not be saved once they've\n been used.\n\n :param block:\n If set to True, no more than ``maxsize`` connections will be used at\n a time. When no free connections are available, the call will block\n until a connection has been released. This is a useful side effect for\n particular multithreaded situations where one does not want to use more\n than maxsize connections per host to prevent flooding.\n\n :param headers:\n Headers to include with all requests, unless other headers are given\n explicitly.\n\n :param retries:\n Retry configuration to use by default with requests in this pool.\n\n :param _proxy:\n Parsed proxy URL, should not be used directly, instead, see\n :class:`urllib3.ProxyManager`\n\n :param _proxy_headers:\n A dictionary with proxy headers, should not be used directly,\n instead, see :class:`urllib3.ProxyManager`\n\n :param \\\\**conn_kw:\n Additional parameters are used to create fresh :class:`urllib3.connection.HTTPConnection`,\n :class:`urllib3.connection.HTTPSConnection` instances.\n \"\"\"\n\n scheme = \"http\"\n ConnectionCls = HTTPConnection\n ResponseCls = HTTPResponse\n\n def __init__(\n self,\n host,\n port=None,\n strict=False,\n timeout=Timeout.DEFAULT_TIMEOUT,\n maxsize=1,\n block=False,\n headers=None,\n retries=None,\n _proxy=None,\n _proxy_headers=None,\n _proxy_config=None,\n **conn_kw\n ):\n ConnectionPool.__init__(self, host, port)\n RequestMethods.__init__(self, headers)\n\n self.strict = strict\n\n if not isinstance(timeout, Timeout):\n timeout = Timeout.from_float(timeout)\n\n if retries is None:\n retries = Retry.DEFAULT\n\n self.timeout = timeout\n self.retries = retries\n\n self.pool = self.QueueCls(maxsize)\n self.block = block\n\n self.proxy = _proxy\n self.proxy_headers = _proxy_headers or {}\n self.proxy_config = _proxy_config\n\n # Fill the queue up so that doing get() on it will block properly\n for _ in xrange(maxsize):\n self.pool.put(None)\n\n # These are mostly for testing and debugging purposes.\n self.num_connections = 0\n self.num_requests = 0\n self.conn_kw = conn_kw\n\n if self.proxy:\n # Enable Nagle's algorithm for proxies, to avoid packet fragmentation.\n # We cannot know if the user has added default socket options, so we cannot replace the\n # list.\n self.conn_kw.setdefault(\"socket_options\", [])\n\n self.conn_kw[\"proxy\"] = self.proxy\n self.conn_kw[\"proxy_config\"] = self.proxy_config\n\n # Do not pass 'self' as callback to 'finalize'.\n # Then the 'finalize' would keep an endless living (leak) to self.\n # By just passing a reference to the pool allows the garbage collector\n # to free self if nobody else has a reference to it.\n pool = self.pool\n\n # Close all the HTTPConnections in the pool before the\n # HTTPConnectionPool object is garbage collected.\n weakref_finalize(self, _close_pool_connections, pool)\n\n def _new_conn(self):\n \"\"\"\n Return a fresh :class:`HTTPConnection`.\n \"\"\"\n self.num_connections += 1\n log.debug(\n \"Starting new HTTP connection (%d): %s:%s\",\n self.num_connections,\n self.host,\n self.port or \"80\",\n )\n\n conn = self.ConnectionCls(\n host=self.host,\n port=self.port,\n timeout=self.timeout.connect_timeout,\n strict=self.strict,\n **self.conn_kw\n )\n return conn\n\n def _get_conn(self, timeout=None):\n \"\"\"\n Get a connection. Will return a pooled connection if one is available.\n\n If no connections are available and :prop:`.block` is ``False``, then a\n fresh connection is returned.\n\n :param timeout:\n Seconds to wait before giving up and raising\n :class:`urllib3.exceptions.EmptyPoolError` if the pool is empty and\n :prop:`.block` is ``True``.\n \"\"\"\n conn = None\n try:\n conn = self.pool.get(block=self.block, timeout=timeout)\n\n except AttributeError: # self.pool is None\n raise ClosedPoolError(self, \"Pool is closed.\")\n\n except queue.Empty:\n if self.block:\n raise EmptyPoolError(\n self,\n \"Pool reached maximum size and no more connections are allowed.\",\n )\n pass # Oh well, we'll create a new connection then\n\n # If this is a persistent connection, check if it got disconnected\n if conn and is_connection_dropped(conn):\n log.debug(\"Resetting dropped connection: %s\", self.host)\n conn.close()\n if getattr(conn, \"auto_open\", 1) == 0:\n # This is a proxied connection that has been mutated by\n # http.client._tunnel() and cannot be reused (since it would\n # attempt to bypass the proxy)\n conn = None\n\n return conn or self._new_conn()\n\n def _put_conn(self, conn):\n \"\"\"\n Put a connection back into the pool.\n\n :param conn:\n Connection object for the current host and port as returned by\n :meth:`._new_conn` or :meth:`._get_conn`.\n\n If the pool is already full, the connection is closed and discarded\n because we exceeded maxsize. If connections are discarded frequently,\n then maxsize should be increased.\n\n If the pool is closed, then the connection will be closed and discarded.\n \"\"\"\n try:\n self.pool.put(conn, block=False)\n return # Everything is dandy, done.\n except AttributeError:\n # self.pool is None.\n pass\n except queue.Full:\n # This should never happen if self.block == True\n log.warning(\n \"Connection pool is full, discarding connection: %s. Connection pool size: %s\",\n self.host,\n self.pool.qsize(),\n )\n # Connection never got put back into the pool, close it.\n if conn:\n conn.close()\n\n def _validate_conn(self, conn):\n \"\"\"\n Called right before a request is made, after the socket is created.\n \"\"\"\n pass\n\n def _prepare_proxy(self, conn):\n # Nothing to do for HTTP connections.\n pass\n\n def _get_timeout(self, timeout):\n \"\"\"Helper that always returns a :class:`urllib3.util.Timeout`\"\"\"\n if timeout is _Default:\n return self.timeout.clone()\n\n if isinstance(timeout, Timeout):\n return timeout.clone()\n else:\n # User passed us an int/float. This is for backwards compatibility,\n # can be removed later\n return Timeout.from_float(timeout)\n\n def _raise_timeout(self, err, url, timeout_value):\n \"\"\"Is the error actually a timeout? Will raise a ReadTimeout or pass\"\"\"\n\n if isinstance(err, SocketTimeout):\n raise ReadTimeoutError(\n self, url, \"Read timed out. (read timeout=%s)\" % timeout_value\n )\n\n # See the above comment about EAGAIN in Python 3. In Python 2 we have\n # to specifically catch it and throw the timeout error\n if hasattr(err, \"errno\") and err.errno in _blocking_errnos:\n raise ReadTimeoutError(\n self, url, \"Read timed out. (read timeout=%s)\" % timeout_value\n )\n\n # Catch possible read timeouts thrown as SSL errors. If not the\n # case, rethrow the original. We need to do this because of:\n # http://bugs.python.org/issue10272\n if \"timed out\" in str(err) or \"did not complete (read)\" in str(\n err\n ): # Python < 2.7.4\n raise ReadTimeoutError(\n self, url, \"Read timed out. (read timeout=%s)\" % timeout_value\n )\n\n def _make_request(\n self, conn, method, url, timeout=_Default, chunked=False, **httplib_request_kw\n ):\n \"\"\"\n Perform a request on a given urllib connection object taken from our\n pool.\n\n :param conn:\n a connection from one of our connection pools\n\n :param timeout:\n Socket timeout in seconds for the request. This can be a\n float or integer, which will set the same timeout value for\n the socket connect and the socket read, or an instance of\n :class:`urllib3.util.Timeout`, which gives you more fine-grained\n control over your timeouts.\n \"\"\"\n self.num_requests += 1\n\n timeout_obj = self._get_timeout(timeout)\n timeout_obj.start_connect()\n conn.timeout = Timeout.resolve_default_timeout(timeout_obj.connect_timeout)\n\n # Trigger any extra validation we need to do.\n try:\n self._validate_conn(conn)\n except (SocketTimeout, BaseSSLError) as e:\n # Py2 raises this as a BaseSSLError, Py3 raises it as socket timeout.\n self._raise_timeout(err=e, url=url, timeout_value=conn.timeout)\n raise\n\n # conn.request() calls http.client.*.request, not the method in\n # urllib3.request. It also calls makefile (recv) on the socket.\n try:\n if chunked:\n conn.request_chunked(method, url, **httplib_request_kw)\n else:\n conn.request(method, url, **httplib_request_kw)\n\n # We are swallowing BrokenPipeError (errno.EPIPE) since the server is\n # legitimately able to close the connection after sending a valid response.\n # With this behaviour, the received response is still readable.\n except BrokenPipeError:\n # Python 3\n pass\n except IOError as e:\n # Python 2 and macOS/Linux\n # EPIPE and ESHUTDOWN are BrokenPipeError on Python 2, and EPROTOTYPE/ECONNRESET are needed on macOS\n # https://erickt.github.io/blog/2014/11/19/adventures-in-debugging-a-potential-osx-kernel-bug/\n if e.errno not in {\n errno.EPIPE,\n errno.ESHUTDOWN,\n errno.EPROTOTYPE,\n errno.ECONNRESET,\n }:\n raise\n\n # Reset the timeout for the recv() on the socket\n read_timeout = timeout_obj.read_timeout\n\n # App Engine doesn't have a sock attr\n if getattr(conn, \"sock\", None):\n # In Python 3 socket.py will catch EAGAIN and return None when you\n # try and read into the file pointer created by http.client, which\n # instead raises a BadStatusLine exception. Instead of catching\n # the exception and assuming all BadStatusLine exceptions are read\n # timeouts, check for a zero timeout before making the request.\n if read_timeout == 0:\n raise ReadTimeoutError(\n self, url, \"Read timed out. (read timeout=%s)\" % read_timeout\n )\n if read_timeout is Timeout.DEFAULT_TIMEOUT:\n conn.sock.settimeout(socket.getdefaulttimeout())\n else: # None or a value\n conn.sock.settimeout(read_timeout)\n\n # Receive the response from the server\n try:\n try:\n # Python 2.7, use buffering of HTTP responses\n httplib_response = conn.getresponse(buffering=True)\n except TypeError:\n # Python 3\n try:\n httplib_response = conn.getresponse()\n except BaseException as e:\n # Remove the TypeError from the exception chain in\n # Python 3 (including for exceptions like SystemExit).\n # Otherwise it looks like a bug in the code.\n six.raise_from(e, None)\n except (SocketTimeout, BaseSSLError, SocketError) as e:\n self._raise_timeout(err=e, url=url, timeout_value=read_timeout)\n raise\n\n # AppEngine doesn't have a version attr.\n http_version = getattr(conn, \"_http_vsn_str\", \"HTTP/?\")\n log.debug(\n '%s://%s:%s \"%s %s %s\" %s %s',\n self.scheme,\n self.host,\n self.port,\n method,\n url,\n http_version,\n httplib_response.status,\n httplib_response.length,\n )\n\n try:\n assert_header_parsing(httplib_response.msg)\n except (HeaderParsingError, TypeError) as hpe: # Platform-specific: Python 3\n log.warning(\n \"Failed to parse headers (url=%s): %s\",\n self._absolute_url(url),\n hpe,\n exc_info=True,\n )\n\n return httplib_response\n\n def _absolute_url(self, path):\n return Url(scheme=self.scheme, host=self.host, port=self.port, path=path).url\n\n def close(self):\n \"\"\"\n Close all pooled connections and disable the pool.\n \"\"\"\n if self.pool is None:\n return\n # Disable access to the pool\n old_pool, self.pool = self.pool, None\n\n # Close all the HTTPConnections in the pool.\n _close_pool_connections(old_pool)\n\n def is_same_host(self, url):\n \"\"\"\n Check if the given ``url`` is a member of the same host as this\n connection pool.\n \"\"\"\n if url.startswith(\"/\"):\n return True\n\n # TODO: Add optional support for socket.gethostbyname checking.\n scheme, host, port = get_host(url)\n if host is not None:\n host = _normalize_host(host, scheme=scheme)\n\n # Use explicit default port for comparison when none is given\n if self.port and not port:\n port = port_by_scheme.get(scheme)\n elif not self.port and port == port_by_scheme.get(scheme):\n port = None\n\n return (scheme, host, port) == (self.scheme, self.host, self.port)\n\n def urlopen(\n self,\n method,\n url,\n body=None,\n headers=None,\n retries=None,\n redirect=True,\n assert_same_host=True,\n timeout=_Default,\n pool_timeout=None,\n release_conn=None,\n chunked=False,\n body_pos=None,\n **response_kw\n ):\n \"\"\"\n Get a connection from the pool and perform an HTTP request. This is the\n lowest level call for making a request, so you'll need to specify all\n the raw details.\n\n .. note::\n\n More commonly, it's appropriate to use a convenience method provided\n by :class:`.RequestMethods`, such as :meth:`request`.\n\n .. note::\n\n `release_conn` will only behave as expected if\n `preload_content=False` because we want to make\n `preload_content=False` the default behaviour someday soon without\n breaking backwards compatibility.\n\n :param method:\n HTTP request method (such as GET, POST, PUT, etc.)\n\n :param url:\n The URL to perform the request on.\n\n :param body:\n Data to send in the request body, either :class:`str`, :class:`bytes`,\n an iterable of :class:`str`/:class:`bytes`, or a file-like object.\n\n :param headers:\n Dictionary of custom headers to send, such as User-Agent,\n If-None-Match, etc. If None, pool headers are used. If provided,\n these headers completely replace any pool-specific headers.\n\n :param retries:\n Configure the number of retries to allow before raising a\n :class:`~urllib3.exceptions.MaxRetryError` exception.\n\n Pass ``None`` to retry until you receive a response. Pass a\n :class:`~urllib3.util.retry.Retry` object for fine-grained control\n over different types of retries.\n Pass an integer number to retry connection errors that many times,\n but no other types of errors. Pass zero to never retry.\n\n If ``False``, then retries are disabled and any exception is raised\n immediately. Also, instead of raising a MaxRetryError on redirects,\n the redirect response will be returned.\n\n :type retries: :class:`~urllib3.util.retry.Retry`, False, or an int.\n\n :param redirect:\n If True, automatically handle redirects (status codes 301, 302,\n 303, 307, 308). Each redirect counts as a retry. Disabling retries\n will disable redirect, too.\n\n :param assert_same_host:\n If ``True``, will make sure that the host of the pool requests is\n consistent else will raise HostChangedError. When ``False``, you can\n use the pool on an HTTP proxy and request foreign hosts.\n\n :param timeout:\n If specified, overrides the default timeout for this one\n request. It may be a float (in seconds) or an instance of\n :class:`urllib3.util.Timeout`.\n\n :param pool_timeout:\n If set and the pool is set to block=True, then this method will\n block for ``pool_timeout`` seconds and raise EmptyPoolError if no\n connection is available within the time period.\n\n :param release_conn:\n If False, then the urlopen call will not release the connection\n back into the pool once a response is received (but will release if\n you read the entire contents of the response such as when\n `preload_content=True`). This is useful if you're not preloading\n the response's content immediately. You will need to call\n ``r.release_conn()`` on the response ``r`` to return the connection\n back into the pool. If None, it takes the value of\n ``response_kw.get('preload_content', True)``.\n\n :param chunked:\n If True, urllib3 will send the body using chunked transfer\n encoding. Otherwise, urllib3 will send the body using the standard\n content-length form. Defaults to False.\n\n :param int body_pos:\n Position to seek to in file-like body in the event of a retry or\n redirect. Typically this won't need to be set because urllib3 will\n auto-populate the value when needed.\n\n :param \\\\**response_kw:\n Additional parameters are passed to\n :meth:`urllib3.response.HTTPResponse.from_httplib`\n \"\"\"\n\n parsed_url = parse_url(url)\n destination_scheme = parsed_url.scheme\n\n if headers is None:\n headers = self.headers\n\n if not isinstance(retries, Retry):\n retries = Retry.from_int(retries, redirect=redirect, default=self.retries)\n\n if release_conn is None:\n release_conn = response_kw.get(\"preload_content\", True)\n\n # Check host\n if assert_same_host and not self.is_same_host(url):\n raise HostChangedError(self, url, retries)\n\n # Ensure that the URL we're connecting to is properly encoded\n if url.startswith(\"/\"):\n url = six.ensure_str(_encode_target(url))\n else:\n url = six.ensure_str(parsed_url.url)\n\n conn = None\n\n # Track whether `conn` needs to be released before\n # returning/raising/recursing. Update this variable if necessary, and\n # leave `release_conn` constant throughout the function. That way, if\n # the function recurses, the original value of `release_conn` will be\n # passed down into the recursive call, and its value will be respected.\n #\n # See issue #651 [1] for details.\n #\n # [1] \n release_this_conn = release_conn\n\n http_tunnel_required = connection_requires_http_tunnel(\n self.proxy, self.proxy_config, destination_scheme\n )\n\n # Merge the proxy headers. Only done when not using HTTP CONNECT. We\n # have to copy the headers dict so we can safely change it without those\n # changes being reflected in anyone else's copy.\n if not http_tunnel_required:\n headers = headers.copy()\n headers.update(self.proxy_headers)\n\n # Must keep the exception bound to a separate variable or else Python 3\n # complains about UnboundLocalError.\n err = None\n\n # Keep track of whether we cleanly exited the except block. This\n # ensures we do proper cleanup in finally.\n clean_exit = False\n\n # Rewind body position, if needed. Record current position\n # for future rewinds in the event of a redirect/retry.\n body_pos = set_file_position(body, body_pos)\n\n try:\n # Request a connection from the queue.\n timeout_obj = self._get_timeout(timeout)\n conn = self._get_conn(timeout=pool_timeout)\n\n conn.timeout = timeout_obj.connect_timeout\n\n is_new_proxy_conn = self.proxy is not None and not getattr(\n conn, \"sock\", None\n )\n if is_new_proxy_conn and http_tunnel_required:\n self._prepare_proxy(conn)\n\n # Make the request on the httplib connection object.\n httplib_response = self._make_request(\n conn,\n method,\n url,\n timeout=timeout_obj,\n body=body,\n headers=headers,\n chunked=chunked,\n )\n\n # If we're going to release the connection in ``finally:``, then\n # the response doesn't need to know about the connection. Otherwise\n # it will also try to release it and we'll have a double-release\n # mess.\n response_conn = conn if not release_conn else None\n\n # Pass method to Response for length checking\n response_kw[\"request_method\"] = method\n\n # Import httplib's response into our own wrapper object\n response = self.ResponseCls.from_httplib(\n httplib_response,\n pool=self,\n connection=response_conn,\n retries=retries,\n **response_kw\n )\n\n # Everything went great!\n clean_exit = True\n\n except EmptyPoolError:\n # Didn't get a connection from the pool, no need to clean up\n clean_exit = True\n release_this_conn = False\n raise\n\n except (\n TimeoutError,\n HTTPException,\n SocketError,\n ProtocolError,\n BaseSSLError,\n SSLError,\n CertificateError,\n ) as e:\n # Discard the connection for these exceptions. It will be\n # replaced during the next _get_conn() call.\n clean_exit = False\n\n def _is_ssl_error_message_from_http_proxy(ssl_error):\n # We're trying to detect the message 'WRONG_VERSION_NUMBER' but\n # SSLErrors are kinda all over the place when it comes to the message,\n # so we try to cover our bases here!\n message = \" \".join(re.split(\"[^a-z]\", str(ssl_error).lower()))\n return (\n \"wrong version number\" in message\n or \"unknown protocol\" in message\n or \"record layer failure\" in message\n )\n\n # Try to detect a common user error with proxies which is to\n # set an HTTP proxy to be HTTPS when it should be 'http://'\n # (ie {'http': 'http://proxy', 'https': 'https://proxy'})\n # Instead we add a nice error message and point to a URL.\n if (\n isinstance(e, BaseSSLError)\n and self.proxy\n and _is_ssl_error_message_from_http_proxy(e)\n and conn.proxy\n and conn.proxy.scheme == \"https\"\n ):\n e = ProxyError(\n \"Your proxy appears to only use HTTP and not HTTPS, \"\n \"try changing your proxy URL to be HTTP. See: \"\n \"https://urllib3.readthedocs.io/en/1.26.x/advanced-usage.html\"\n \"#https-proxy-error-http-proxy\",\n SSLError(e),\n )\n elif isinstance(e, (BaseSSLError, CertificateError)):\n e = SSLError(e)\n elif isinstance(e, (SocketError, NewConnectionError)) and self.proxy:\n e = ProxyError(\"Cannot connect to proxy.\", e)\n elif isinstance(e, (SocketError, HTTPException)):\n e = ProtocolError(\"Connection aborted.\", e)\n\n retries = retries.increment(\n method, url, error=e, _pool=self, _stacktrace=sys.exc_info()[2]\n )\n retries.sleep()\n\n # Keep track of the error for the retry warning.\n err = e\n\n finally:\n if not clean_exit:\n # We hit some kind of exception, handled or otherwise. We need\n # to throw the connection away unless explicitly told not to.\n # Close the connection, set the variable to None, and make sure\n # we put the None back in the pool to avoid leaking it.\n conn = conn and conn.close()\n release_this_conn = True\n\n if release_this_conn:\n # Put the connection back to be reused. If the connection is\n # expired then it will be None, which will get replaced with a\n # fresh connection during _get_conn.\n self._put_conn(conn)\n\n if not conn:\n # Try again\n log.warning(\n \"Retrying (%r) after connection broken by '%r': %s\", retries, err, url\n )\n return self.urlopen(\n method,\n url,\n body,\n headers,\n retries,\n redirect,\n assert_same_host,\n timeout=timeout,\n pool_timeout=pool_timeout,\n release_conn=release_conn,\n chunked=chunked,\n body_pos=body_pos,\n **response_kw\n )\n\n # Handle redirect?\n redirect_location = redirect and response.get_redirect_location()\n if redirect_location:\n if response.status == 303:\n # Change the method according to RFC 9110, Section 15.4.4.\n method = \"GET\"\n # And lose the body not to transfer anything sensitive.\n body = None\n headers = HTTPHeaderDict(headers)._prepare_for_method_change()\n\n try:\n retries = retries.increment(method, url, response=response, _pool=self)\n except MaxRetryError:\n if retries.raise_on_redirect:\n response.drain_conn()\n raise\n return response\n\n response.drain_conn()\n retries.sleep_for_retry(response)\n log.debug(\"Redirecting %s -> %s\", url, redirect_location)\n return self.urlopen(\n method,\n redirect_location,\n body,\n headers,\n retries=retries,\n redirect=redirect,\n assert_same_host=assert_same_host,\n timeout=timeout,\n pool_timeout=pool_timeout,\n release_conn=release_conn,\n chunked=chunked,\n body_pos=body_pos,\n **response_kw\n )\n\n # Check if we should retry the HTTP response.\n has_retry_after = bool(response.headers.get(\"Retry-After\"))\n if retries.is_retry(method, response.status, has_retry_after):\n try:\n retries = retries.increment(method, url, response=response, _pool=self)\n except MaxRetryError:\n if retries.raise_on_status:\n response.drain_conn()\n raise\n return response\n\n response.drain_conn()\n retries.sleep(response)\n log.debug(\"Retry: %s\", url)\n return self.urlopen(\n method,\n url,\n body,\n headers,\n retries=retries,\n redirect=redirect,\n assert_same_host=assert_same_host,\n timeout=timeout,\n pool_timeout=pool_timeout,\n release_conn=release_conn,\n chunked=chunked,\n body_pos=body_pos,\n **response_kw\n )\n\n return response\n\n\nclass HTTPSConnectionPool(HTTPConnectionPool):\n \"\"\"\n Same as :class:`.HTTPConnectionPool`, but HTTPS.\n\n :class:`.HTTPSConnection` uses one of ``assert_fingerprint``,\n ``assert_hostname`` and ``host`` in this order to verify connections.\n If ``assert_hostname`` is False, no verification is done.\n\n The ``key_file``, ``cert_file``, ``cert_reqs``, ``ca_certs``,\n ``ca_cert_dir``, ``ssl_version``, ``key_password`` are only used if :mod:`ssl`\n is available and are fed into :meth:`urllib3.util.ssl_wrap_socket` to upgrade\n the connection socket into an SSL socket.\n \"\"\"\n\n scheme = \"https\"\n ConnectionCls = HTTPSConnection\n\n def __init__(\n self,\n host,\n port=None,\n strict=False,\n timeout=Timeout.DEFAULT_TIMEOUT,\n maxsize=1,\n block=False,\n headers=None,\n retries=None,\n _proxy=None,\n _proxy_headers=None,\n key_file=None,\n cert_file=None,\n cert_reqs=None,\n key_password=None,\n ca_certs=None,\n ssl_version=None,\n assert_hostname=None,\n assert_fingerprint=None,\n ca_cert_dir=None,\n **conn_kw\n ):\n\n HTTPConnectionPool.__init__(\n self,\n host,\n port,\n strict,\n timeout,\n maxsize,\n block,\n headers,\n retries,\n _proxy,\n _proxy_headers,\n **conn_kw\n )\n\n self.key_file = key_file\n self.cert_file = cert_file\n self.cert_reqs = cert_reqs\n self.key_password = key_password\n self.ca_certs = ca_certs\n self.ca_cert_dir = ca_cert_dir\n self.ssl_version = ssl_version\n self.assert_hostname = assert_hostname\n self.assert_fingerprint = assert_fingerprint\n\n def _prepare_conn(self, conn):\n \"\"\"\n Prepare the ``connection`` for :meth:`urllib3.util.ssl_wrap_socket`\n and establish the tunnel if proxy is used.\n \"\"\"\n\n if isinstance(conn, VerifiedHTTPSConnection):\n conn.set_cert(\n key_file=self.key_file,\n key_password=self.key_password,\n cert_file=self.cert_file,\n cert_reqs=self.cert_reqs,\n ca_certs=self.ca_certs,\n ca_cert_dir=self.ca_cert_dir,\n assert_hostname=self.assert_hostname,\n assert_fingerprint=self.assert_fingerprint,\n )\n conn.ssl_version = self.ssl_version\n return conn\n\n def _prepare_proxy(self, conn):\n \"\"\"\n Establishes a tunnel connection through HTTP CONNECT.\n\n Tunnel connection is established early because otherwise httplib would\n improperly set Host: header to proxy's IP:port.\n \"\"\"\n\n conn.set_tunnel(self._proxy_host, self.port, self.proxy_headers)\n\n if self.proxy.scheme == \"https\":\n conn.tls_in_tls_required = True\n\n conn.connect()\n\n def _new_conn(self):\n \"\"\"\n Return a fresh :class:`http.client.HTTPSConnection`.\n \"\"\"\n self.num_connections += 1\n log.debug(\n \"Starting new HTTPS connection (%d): %s:%s\",\n self.num_connections,\n self.host,\n self.port or \"443\",\n )\n\n if not self.ConnectionCls or self.ConnectionCls is DummyConnection:\n raise SSLError(\n \"Can't connect to HTTPS URL because the SSL module is not available.\"\n )\n\n actual_host = self.host\n actual_port = self.port\n if self.proxy is not None:\n actual_host = self.proxy.host\n actual_port = self.proxy.port\n\n conn = self.ConnectionCls(\n host=actual_host,\n port=actual_port,\n timeout=self.timeout.connect_timeout,\n strict=self.strict,\n cert_file=self.cert_file,\n key_file=self.key_file,\n key_password=self.key_password,\n **self.conn_kw\n )\n\n return self._prepare_conn(conn)\n\n def _validate_conn(self, conn):\n \"\"\"\n Called right before a request is made, after the socket is created.\n \"\"\"\n super(HTTPSConnectionPool, self)._validate_conn(conn)\n\n # Force connect early to allow us to validate the connection.\n if not getattr(conn, \"sock\", None): # AppEngine might not have `.sock`\n conn.connect()\n\n if not conn.is_verified:\n warnings.warn(\n (\n \"Unverified HTTPS request is being made to host '%s'. \"\n \"Adding certificate verification is strongly advised. See: \"\n \"https://urllib3.readthedocs.io/en/1.26.x/advanced-usage.html\"\n \"#ssl-warnings\" % conn.host\n ),\n InsecureRequestWarning,\n )\n\n if getattr(conn, \"proxy_is_verified\", None) is False:\n warnings.warn(\n (\n \"Unverified HTTPS connection done to an HTTPS proxy. \"\n \"Adding certificate verification is strongly advised. See: \"\n \"https://urllib3.readthedocs.io/en/1.26.x/advanced-usage.html\"\n \"#ssl-warnings\"\n ),\n InsecureRequestWarning,\n )\n\n\ndef connection_from_url(url, **kw):\n \"\"\"\n Given a url, return an :class:`.ConnectionPool` instance of its host.\n\n This is a shortcut for not having to parse out the scheme, host, and port\n of the url before creating an :class:`.ConnectionPool` instance.\n\n :param url:\n Absolute URL string that must include the scheme. Port is optional.\n\n :param \\\\**kw:\n Passes additional parameters to the constructor of the appropriate\n :class:`.ConnectionPool`. Useful for specifying things like\n timeout, maxsize, headers, etc.\n\n Example::\n\n >>> conn = connection_from_url('http://google.com/')\n >>> r = conn.request('GET', '/')\n \"\"\"\n scheme, host, port = get_host(url)\n port = port or port_by_scheme.get(scheme, 80)\n if scheme == \"https\":\n return HTTPSConnectionPool(host, port=port, **kw)\n else:\n return HTTPConnectionPool(host, port=port, **kw)\n\n\ndef _normalize_host(host, scheme):\n \"\"\"\n Normalize hosts for comparisons and use with sockets.\n \"\"\"\n\n host = normalize_host(host, scheme)\n\n # httplib doesn't like it when we include brackets in IPv6 addresses\n # Specifically, if we include brackets but also pass the port then\n # httplib crazily doubles up the square brackets on the Host header.\n # Instead, we need to make sure we never pass ``None`` as the port.\n # However, for backward compatibility reasons we can't actually\n # *assert* that. See http://bugs.python.org/issue28539\n if host.startswith(\"[\") and host.endswith(\"]\"):\n host = host[1:-1]\n return host\n\n\ndef _close_pool_connections(pool):\n \"\"\"Drains a queue of connections and closes each one.\"\"\"\n try:\n while True:\n conn = pool.get(block=False)\n if conn:\n conn.close()\n except queue.Empty:\n pass # Done.\n",[],[213,919,920,921,1016,1050,1067,1109],"0d84cc14-67fc-11f0-a99a-0224a6c84d84","connection.py","0d84ccaa-67fc-11f0-a99a-0224a6c84d84",502,["D",1753299270461],"from __future__ import absolute_import\n\nimport datetime\nimport logging\nimport os\nimport re\nimport socket\nimport warnings\nfrom socket import error as SocketError\nfrom socket import timeout as SocketTimeout\n\nfrom .packages import six\nfrom .packages.six.moves.http_client import HTTPConnection as _HTTPConnection\nfrom .packages.six.moves.http_client import HTTPException # noqa: F401\nfrom .util.proxy import create_proxy_ssl_context\n\ntry: # Compiled with SSL?\n import ssl\n\n BaseSSLError = ssl.SSLError\nexcept (ImportError, AttributeError): # Platform-specific: No SSL.\n ssl = None\n\n class BaseSSLError(BaseException):\n pass\n\n\ntry:\n # Python 3: not a no-op, we're adding this to the namespace so it can be imported.\n ConnectionError = ConnectionError\nexcept NameError:\n # Python 2\n class ConnectionError(Exception):\n pass\n\n\ntry: # Python 3:\n # Not a no-op, we're adding this to the namespace so it can be imported.\n BrokenPipeError = BrokenPipeError\nexcept NameError: # Python 2:\n\n class BrokenPipeError(Exception):\n pass\n\n\nfrom ._collections import HTTPHeaderDict # noqa (historical, removed in v2)\nfrom ._version import __version__\nfrom .exceptions import (\n ConnectTimeoutError,\n NewConnectionError,\n SubjectAltNameWarning,\n SystemTimeWarning,\n)\nfrom .util import SKIP_HEADER, SKIPPABLE_HEADERS, connection\nfrom .util.ssl_ import (\n assert_fingerprint,\n create_urllib3_context,\n is_ipaddress,\n resolve_cert_reqs,\n resolve_ssl_version,\n ssl_wrap_socket,\n)\nfrom .util.ssl_match_hostname import CertificateError, match_hostname\n\nlog = logging.getLogger(__name__)\n\nport_by_scheme = {\"http\": 80, \"https\": 443}\n\n# When it comes time to update this value as a part of regular maintenance\n# (ie test_recent_date is failing) update it to ~6 months before the current date.\nRECENT_DATE = datetime.date(2024, 1, 1)\n\n_CONTAINS_CONTROL_CHAR_RE = re.compile(r\"[^-!#$%&'*+.^_`|~0-9a-zA-Z]\")\n\n\nclass HTTPConnection(_HTTPConnection, object):\n \"\"\"\n Based on :class:`http.client.HTTPConnection` but provides an extra constructor\n backwards-compatibility layer between older and newer Pythons.\n\n Additional keyword parameters are used to configure attributes of the connection.\n Accepted parameters include:\n\n - ``strict``: See the documentation on :class:`urllib3.connectionpool.HTTPConnectionPool`\n - ``source_address``: Set the source address for the current connection.\n - ``socket_options``: Set specific options on the underlying socket. If not specified, then\n defaults are loaded from ``HTTPConnection.default_socket_options`` which includes disabling\n Nagle's algorithm (sets TCP_NODELAY to 1) unless the connection is behind a proxy.\n\n For example, if you wish to enable TCP Keep Alive in addition to the defaults,\n you might pass:\n\n .. code-block:: python\n\n HTTPConnection.default_socket_options + [\n (socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1),\n ]\n\n Or you may want to disable the defaults by passing an empty list (e.g., ``[]``).\n \"\"\"\n\n default_port = port_by_scheme[\"http\"]\n\n #: Disable Nagle's algorithm by default.\n #: ``[(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)]``\n default_socket_options = [(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)]\n\n #: Whether this connection verifies the host's certificate.\n is_verified = False\n\n #: Whether this proxy connection (if used) verifies the proxy host's\n #: certificate.\n proxy_is_verified = None\n\n def __init__(self, *args, **kw):\n if not six.PY2:\n kw.pop(\"strict\", None)\n\n # Pre-set source_address.\n self.source_address = kw.get(\"source_address\")\n\n #: The socket options provided by the user. If no options are\n #: provided, we use the default options.\n self.socket_options = kw.pop(\"socket_options\", self.default_socket_options)\n\n # Proxy options provided by the user.\n self.proxy = kw.pop(\"proxy\", None)\n self.proxy_config = kw.pop(\"proxy_config\", None)\n\n _HTTPConnection.__init__(self, *args, **kw)\n\n @property\n def host(self):\n \"\"\"\n Getter method to remove any trailing dots that indicate the hostname is an FQDN.\n\n In general, SSL certificates don't include the trailing dot indicating a\n fully-qualified domain name, and thus, they don't validate properly when\n checked against a domain name that includes the dot. In addition, some\n servers may not expect to receive the trailing dot when provided.\n\n However, the hostname with trailing dot is critical to DNS resolution; doing a\n lookup with the trailing dot will properly only resolve the appropriate FQDN,\n whereas a lookup without a trailing dot will search the system's search domain\n list. Thus, it's important to keep the original host around for use only in\n those cases where it's appropriate (i.e., when doing DNS lookup to establish the\n actual TCP connection across which we're going to send HTTP requests).\n \"\"\"\n return self._dns_host.rstrip(\".\")\n\n @host.setter\n def host(self, value):\n \"\"\"\n Setter for the `host` property.\n\n We assume that only urllib3 uses the _dns_host attribute; httplib itself\n only uses `host`, and it seems reasonable that other libraries follow suit.\n \"\"\"\n self._dns_host = value\n\n def _new_conn(self):\n \"\"\"Establish a socket connection and set nodelay settings on it.\n\n :return: New socket connection.\n \"\"\"\n extra_kw = {}\n if self.source_address:\n extra_kw[\"source_address\"] = self.source_address\n\n if self.socket_options:\n extra_kw[\"socket_options\"] = self.socket_options\n\n try:\n conn = connection.create_connection(\n (self._dns_host, self.port), self.timeout, **extra_kw\n )\n\n except SocketTimeout:\n raise ConnectTimeoutError(\n self,\n \"Connection to %s timed out. (connect timeout=%s)\"\n % (self.host, self.timeout),\n )\n\n except SocketError as e:\n raise NewConnectionError(\n self, \"Failed to establish a new connection: %s\" % e\n )\n\n return conn\n\n def _is_using_tunnel(self):\n # Google App Engine's httplib does not define _tunnel_host\n return getattr(self, \"_tunnel_host\", None)\n\n def _prepare_conn(self, conn):\n self.sock = conn\n if self._is_using_tunnel():\n # TODO: Fix tunnel so it doesn't depend on self.sock state.\n self._tunnel()\n # Mark this connection as not reusable\n self.auto_open = 0\n\n def connect(self):\n conn = self._new_conn()\n self._prepare_conn(conn)\n\n def putrequest(self, method, url, *args, **kwargs):\n \"\"\" \"\"\"\n # Empty docstring because the indentation of CPython's implementation\n # is broken but we don't want this method in our documentation.\n match = _CONTAINS_CONTROL_CHAR_RE.search(method)\n if match:\n raise ValueError(\n \"Method cannot contain non-token characters %r (found at least %r)\"\n % (method, match.group())\n )\n\n return _HTTPConnection.putrequest(self, method, url, *args, **kwargs)\n\n def putheader(self, header, *values):\n \"\"\" \"\"\"\n if not any(isinstance(v, str) and v == SKIP_HEADER for v in values):\n _HTTPConnection.putheader(self, header, *values)\n elif six.ensure_str(header.lower()) not in SKIPPABLE_HEADERS:\n raise ValueError(\n \"urllib3.util.SKIP_HEADER only supports '%s'\"\n % (\"', '\".join(map(str.title, sorted(SKIPPABLE_HEADERS))),)\n )\n\n def request(self, method, url, body=None, headers=None):\n # Update the inner socket's timeout value to send the request.\n # This only triggers if the connection is re-used.\n if getattr(self, \"sock\", None) is not None:\n self.sock.settimeout(self.timeout)\n\n if headers is None:\n headers = {}\n else:\n # Avoid modifying the headers passed into .request()\n headers = headers.copy()\n if \"user-agent\" not in (six.ensure_str(k.lower()) for k in headers):\n headers[\"User-Agent\"] = _get_default_user_agent()\n super(HTTPConnection, self).request(method, url, body=body, headers=headers)\n\n def request_chunked(self, method, url, body=None, headers=None):\n \"\"\"\n Alternative to the common request method, which sends the\n body with chunked encoding and not as one block\n \"\"\"\n headers = headers or {}\n header_keys = set([six.ensure_str(k.lower()) for k in headers])\n skip_accept_encoding = \"accept-encoding\" in header_keys\n skip_host = \"host\" in header_keys\n self.putrequest(\n method, url, skip_accept_encoding=skip_accept_encoding, skip_host=skip_host\n )\n if \"user-agent\" not in header_keys:\n self.putheader(\"User-Agent\", _get_default_user_agent())\n for header, value in headers.items():\n self.putheader(header, value)\n if \"transfer-encoding\" not in header_keys:\n self.putheader(\"Transfer-Encoding\", \"chunked\")\n self.endheaders()\n\n if body is not None:\n stringish_types = six.string_types + (bytes,)\n if isinstance(body, stringish_types):\n body = (body,)\n for chunk in body:\n if not chunk:\n continue\n if not isinstance(chunk, bytes):\n chunk = chunk.encode(\"utf8\")\n len_str = hex(len(chunk))[2:]\n to_send = bytearray(len_str.encode())\n to_send += b\"\\r\\n\"\n to_send += chunk\n to_send += b\"\\r\\n\"\n self.send(to_send)\n\n # After the if clause, to always have a closed body\n self.send(b\"0\\r\\n\\r\\n\")\n\n\nclass HTTPSConnection(HTTPConnection):\n \"\"\"\n Many of the parameters to this constructor are passed to the underlying SSL\n socket by means of :py:func:`urllib3.util.ssl_wrap_socket`.\n \"\"\"\n\n default_port = port_by_scheme[\"https\"]\n\n cert_reqs = None\n ca_certs = None\n ca_cert_dir = None\n ca_cert_data = None\n ssl_version = None\n assert_fingerprint = None\n tls_in_tls_required = False\n\n def __init__(\n self,\n host,\n port=None,\n key_file=None,\n cert_file=None,\n key_password=None,\n strict=None,\n timeout=socket._GLOBAL_DEFAULT_TIMEOUT,\n ssl_context=None,\n server_hostname=None,\n **kw\n ):\n\n HTTPConnection.__init__(self, host, port, strict=strict, timeout=timeout, **kw)\n\n self.key_file = key_file\n self.cert_file = cert_file\n self.key_password = key_password\n self.ssl_context = ssl_context\n self.server_hostname = server_hostname\n\n # Required property for Google AppEngine 1.9.0 which otherwise causes\n # HTTPS requests to go out as HTTP. (See Issue #356)\n self._protocol = \"https\"\n\n def set_cert(\n self,\n key_file=None,\n cert_file=None,\n cert_reqs=None,\n key_password=None,\n ca_certs=None,\n assert_hostname=None,\n assert_fingerprint=None,\n ca_cert_dir=None,\n ca_cert_data=None,\n ):\n \"\"\"\n This method should only be called once, before the connection is used.\n \"\"\"\n # If cert_reqs is not provided we'll assume CERT_REQUIRED unless we also\n # have an SSLContext object in which case we'll use its verify_mode.\n if cert_reqs is None:\n if self.ssl_context is not None:\n cert_reqs = self.ssl_context.verify_mode\n else:\n cert_reqs = resolve_cert_reqs(None)\n\n self.key_file = key_file\n self.cert_file = cert_file\n self.cert_reqs = cert_reqs\n self.key_password = key_password\n self.assert_hostname = assert_hostname\n self.assert_fingerprint = assert_fingerprint\n self.ca_certs = ca_certs and os.path.expanduser(ca_certs)\n self.ca_cert_dir = ca_cert_dir and os.path.expanduser(ca_cert_dir)\n self.ca_cert_data = ca_cert_data\n\n def connect(self):\n # Add certificate verification\n self.sock = conn = self._new_conn()\n hostname = self.host\n tls_in_tls = False\n\n if self._is_using_tunnel():\n if self.tls_in_tls_required:\n self.sock = conn = self._connect_tls_proxy(hostname, conn)\n tls_in_tls = True\n\n # Calls self._set_hostport(), so self.host is\n # self._tunnel_host below.\n self._tunnel()\n # Mark this connection as not reusable\n self.auto_open = 0\n\n # Override the host with the one we're requesting data from.\n hostname = self._tunnel_host\n\n server_hostname = hostname\n if self.server_hostname is not None:\n server_hostname = self.server_hostname\n\n is_time_off = datetime.date.today() < RECENT_DATE\n if is_time_off:\n warnings.warn(\n (\n \"System time is way off (before {0}). This will probably \"\n \"lead to SSL verification errors\"\n ).format(RECENT_DATE),\n SystemTimeWarning,\n )\n\n # Wrap socket using verification with the root certs in\n # trusted_root_certs\n default_ssl_context = False\n if self.ssl_context is None:\n default_ssl_context = True\n self.ssl_context = create_urllib3_context(\n ssl_version=resolve_ssl_version(self.ssl_version),\n cert_reqs=resolve_cert_reqs(self.cert_reqs),\n )\n\n context = self.ssl_context\n context.verify_mode = resolve_cert_reqs(self.cert_reqs)\n\n # Try to load OS default certs if none are given.\n # Works well on Windows (requires Python3.4+)\n if (\n not self.ca_certs\n and not self.ca_cert_dir\n and not self.ca_cert_data\n and default_ssl_context\n and hasattr(context, \"load_default_certs\")\n ):\n context.load_default_certs()\n\n self.sock = ssl_wrap_socket(\n sock=conn,\n keyfile=self.key_file,\n certfile=self.cert_file,\n key_password=self.key_password,\n ca_certs=self.ca_certs,\n ca_cert_dir=self.ca_cert_dir,\n ca_cert_data=self.ca_cert_data,\n server_hostname=server_hostname,\n ssl_context=context,\n tls_in_tls=tls_in_tls,\n )\n\n # If we're using all defaults and the connection\n # is TLSv1 or TLSv1.1 we throw a DeprecationWarning\n # for the host.\n if (\n default_ssl_context\n and self.ssl_version is None\n and hasattr(self.sock, \"version\")\n and self.sock.version() in {\"TLSv1\", \"TLSv1.1\"}\n ): # Defensive:\n warnings.warn(\n \"Negotiating TLSv1/TLSv1.1 by default is deprecated \"\n \"and will be disabled in urllib3 v2.0.0. Connecting to \"\n \"'%s' with '%s' can be enabled by explicitly opting-in \"\n \"with 'ssl_version'\" % (self.host, self.sock.version()),\n DeprecationWarning,\n )\n\n if self.assert_fingerprint:\n assert_fingerprint(\n self.sock.getpeercert(binary_form=True), self.assert_fingerprint\n )\n elif (\n context.verify_mode != ssl.CERT_NONE\n and not getattr(context, \"check_hostname\", False)\n and self.assert_hostname is not False\n ):\n # While urllib3 attempts to always turn off hostname matching from\n # the TLS library, this cannot always be done. So we check whether\n # the TLS Library still thinks it's matching hostnames.\n cert = self.sock.getpeercert()\n if not cert.get(\"subjectAltName\", ()):\n warnings.warn(\n (\n \"Certificate for {0} has no `subjectAltName`, falling back to check for a \"\n \"`commonName` for now. This feature is being removed by major browsers and \"\n \"deprecated by RFC 2818. (See https://github.com/urllib3/urllib3/issues/497 \"\n \"for details.)\".format(hostname)\n ),\n SubjectAltNameWarning,\n )\n _match_hostname(cert, self.assert_hostname or server_hostname)\n\n self.is_verified = (\n context.verify_mode == ssl.CERT_REQUIRED\n or self.assert_fingerprint is not None\n )\n\n def _connect_tls_proxy(self, hostname, conn):\n \"\"\"\n Establish a TLS connection to the proxy using the provided SSL context.\n \"\"\"\n proxy_config = self.proxy_config\n ssl_context = proxy_config.ssl_context\n if ssl_context:\n # If the user provided a proxy context, we assume CA and client\n # certificates have already been set\n return ssl_wrap_socket(\n sock=conn,\n server_hostname=hostname,\n ssl_context=ssl_context,\n )\n\n ssl_context = create_proxy_ssl_context(\n self.ssl_version,\n self.cert_reqs,\n self.ca_certs,\n self.ca_cert_dir,\n self.ca_cert_data,\n )\n\n # If no cert was provided, use only the default options for server\n # certificate validation\n socket = ssl_wrap_socket(\n sock=conn,\n ca_certs=self.ca_certs,\n ca_cert_dir=self.ca_cert_dir,\n ca_cert_data=self.ca_cert_data,\n server_hostname=hostname,\n ssl_context=ssl_context,\n )\n\n if ssl_context.verify_mode != ssl.CERT_NONE and not getattr(\n ssl_context, \"check_hostname\", False\n ):\n # While urllib3 attempts to always turn off hostname matching from\n # the TLS library, this cannot always be done. So we check whether\n # the TLS Library still thinks it's matching hostnames.\n cert = socket.getpeercert()\n if not cert.get(\"subjectAltName\", ()):\n warnings.warn(\n (\n \"Certificate for {0} has no `subjectAltName`, falling back to check for a \"\n \"`commonName` for now. This feature is being removed by major browsers and \"\n \"deprecated by RFC 2818. (See https://github.com/urllib3/urllib3/issues/497 \"\n \"for details.)\".format(hostname)\n ),\n SubjectAltNameWarning,\n )\n _match_hostname(cert, hostname)\n\n self.proxy_is_verified = ssl_context.verify_mode == ssl.CERT_REQUIRED\n return socket\n\n\ndef _match_hostname(cert, asserted_hostname):\n # Our upstream implementation of ssl.match_hostname()\n # only applies this normalization to IP addresses so it doesn't\n # match DNS SANs so we do the same thing!\n stripped_hostname = asserted_hostname.strip(\"u[]\")\n if is_ipaddress(stripped_hostname):\n asserted_hostname = stripped_hostname\n\n try:\n match_hostname(cert, asserted_hostname)\n except CertificateError as e:\n log.warning(\n \"Certificate did not match expected hostname: %s. Certificate: %s\",\n asserted_hostname,\n cert,\n )\n # Add cert to exception and reraise so client code can inspect\n # the cert when catching the exception, if they want to\n e._peer_cert = cert\n raise\n\n\ndef _get_default_user_agent():\n return \"python-urllib3/%s\" % __version__\n\n\nclass DummyConnection(object):\n \"\"\"Used to detect a failed ConnectionCls import.\"\"\"\n\n pass\n\n\nif not ssl:\n HTTPSConnection = DummyConnection # noqa: F811\n\n\nVerifiedHTTPSConnection = HTTPSConnection\n",[],[213,919,920,921,1016,1050,1067,1117],"0d395950-67fc-11f0-b0dc-0224a6c84d84","_version.py","0d3959e6-67fc-11f0-b0dc-0224a6c84d84",490,["D",1753299269967],"# This file is protected via CODEOWNERS\n__version__ = \"1.26.20\"\n",[],[213,919,920,921,1016,1050,1067,1125],"0d92d53e-67fc-11f0-a516-0224a6c84d84","_collections.py","0d92d638-67fc-11f0-a516-0224a6c84d84",504,["D",1753299270513],"from __future__ import absolute_import\n\ntry:\n from collections.abc import Mapping, MutableMapping\nexcept ImportError:\n from collections import Mapping, MutableMapping\ntry:\n from threading import RLock\nexcept ImportError: # Platform-specific: No threads available\n\n class RLock:\n def __enter__(self):\n pass\n\n def __exit__(self, exc_type, exc_value, traceback):\n pass\n\n\nfrom collections import OrderedDict\n\nfrom .exceptions import InvalidHeader\nfrom .packages import six\nfrom .packages.six import iterkeys, itervalues\n\n__all__ = [\"RecentlyUsedContainer\", \"HTTPHeaderDict\"]\n\n\n_Null = object()\n\n\nclass RecentlyUsedContainer(MutableMapping):\n \"\"\"\n Provides a thread-safe dict-like container which maintains up to\n ``maxsize`` keys while throwing away the least-recently-used keys beyond\n ``maxsize``.\n\n :param maxsize:\n Maximum number of recent elements to retain.\n\n :param dispose_func:\n Every time an item is evicted from the container,\n ``dispose_func(value)`` is called. Callback which will get called\n \"\"\"\n\n ContainerCls = OrderedDict\n\n def __init__(self, maxsize=10, dispose_func=None):\n self._maxsize = maxsize\n self.dispose_func = dispose_func\n\n self._container = self.ContainerCls()\n self.lock = RLock()\n\n def __getitem__(self, key):\n # Re-insert the item, moving it to the end of the eviction line.\n with self.lock:\n item = self._container.pop(key)\n self._container[key] = item\n return item\n\n def __setitem__(self, key, value):\n evicted_value = _Null\n with self.lock:\n # Possibly evict the existing value of 'key'\n evicted_value = self._container.get(key, _Null)\n self._container[key] = value\n\n # If we didn't evict an existing value, we might have to evict the\n # least recently used item from the beginning of the container.\n if len(self._container) > self._maxsize:\n _key, evicted_value = self._container.popitem(last=False)\n\n if self.dispose_func and evicted_value is not _Null:\n self.dispose_func(evicted_value)\n\n def __delitem__(self, key):\n with self.lock:\n value = self._container.pop(key)\n\n if self.dispose_func:\n self.dispose_func(value)\n\n def __len__(self):\n with self.lock:\n return len(self._container)\n\n def __iter__(self):\n raise NotImplementedError(\n \"Iteration over this class is unlikely to be threadsafe.\"\n )\n\n def clear(self):\n with self.lock:\n # Copy pointers to all values, then wipe the mapping\n values = list(itervalues(self._container))\n self._container.clear()\n\n if self.dispose_func:\n for value in values:\n self.dispose_func(value)\n\n def keys(self):\n with self.lock:\n return list(iterkeys(self._container))\n\n\nclass HTTPHeaderDict(MutableMapping):\n \"\"\"\n :param headers:\n An iterable of field-value pairs. Must not contain multiple field names\n when compared case-insensitively.\n\n :param kwargs:\n Additional field-value pairs to pass in to ``dict.update``.\n\n A ``dict`` like container for storing HTTP Headers.\n\n Field names are stored and compared case-insensitively in compliance with\n RFC 7230. Iteration provides the first case-sensitive key seen for each\n case-insensitive pair.\n\n Using ``__setitem__`` syntax overwrites fields that compare equal\n case-insensitively in order to maintain ``dict``'s api. For fields that\n compare equal, instead create a new ``HTTPHeaderDict`` and use ``.add``\n in a loop.\n\n If multiple fields that are equal case-insensitively are passed to the\n constructor or ``.update``, the behavior is undefined and some will be\n lost.\n\n >>> headers = HTTPHeaderDict()\n >>> headers.add('Set-Cookie', 'foo=bar')\n >>> headers.add('set-cookie', 'baz=quxx')\n >>> headers['content-length'] = '7'\n >>> headers['SET-cookie']\n 'foo=bar, baz=quxx'\n >>> headers['Content-Length']\n '7'\n \"\"\"\n\n def __init__(self, headers=None, **kwargs):\n super(HTTPHeaderDict, self).__init__()\n self._container = OrderedDict()\n if headers is not None:\n if isinstance(headers, HTTPHeaderDict):\n self._copy_from(headers)\n else:\n self.extend(headers)\n if kwargs:\n self.extend(kwargs)\n\n def __setitem__(self, key, val):\n self._container[key.lower()] = [key, val]\n return self._container[key.lower()]\n\n def __getitem__(self, key):\n val = self._container[key.lower()]\n return \", \".join(val[1:])\n\n def __delitem__(self, key):\n del self._container[key.lower()]\n\n def __contains__(self, key):\n return key.lower() in self._container\n\n def __eq__(self, other):\n if not isinstance(other, Mapping) and not hasattr(other, \"keys\"):\n return False\n if not isinstance(other, type(self)):\n other = type(self)(other)\n return dict((k.lower(), v) for k, v in self.itermerged()) == dict(\n (k.lower(), v) for k, v in other.itermerged()\n )\n\n def __ne__(self, other):\n return not self.__eq__(other)\n\n if six.PY2: # Python 2\n iterkeys = MutableMapping.iterkeys\n itervalues = MutableMapping.itervalues\n\n __marker = object()\n\n def __len__(self):\n return len(self._container)\n\n def __iter__(self):\n # Only provide the originally cased names\n for vals in self._container.values():\n yield vals[0]\n\n def pop(self, key, default=__marker):\n \"\"\"D.pop(k[,d]) -> v, remove specified key and return the corresponding value.\n If key is not found, d is returned if given, otherwise KeyError is raised.\n \"\"\"\n # Using the MutableMapping function directly fails due to the private marker.\n # Using ordinary dict.pop would expose the internal structures.\n # So let's reinvent the wheel.\n try:\n value = self[key]\n except KeyError:\n if default is self.__marker:\n raise\n return default\n else:\n del self[key]\n return value\n\n def discard(self, key):\n try:\n del self[key]\n except KeyError:\n pass\n\n def add(self, key, val):\n \"\"\"Adds a (name, value) pair, doesn't overwrite the value if it already\n exists.\n\n >>> headers = HTTPHeaderDict(foo='bar')\n >>> headers.add('Foo', 'baz')\n >>> headers['foo']\n 'bar, baz'\n \"\"\"\n key_lower = key.lower()\n new_vals = [key, val]\n # Keep the common case aka no item present as fast as possible\n vals = self._container.setdefault(key_lower, new_vals)\n if new_vals is not vals:\n vals.append(val)\n\n def extend(self, *args, **kwargs):\n \"\"\"Generic import function for any type of header-like object.\n Adapted version of MutableMapping.update in order to insert items\n with self.add instead of self.__setitem__\n \"\"\"\n if len(args) > 1:\n raise TypeError(\n \"extend() takes at most 1 positional \"\n \"arguments ({0} given)\".format(len(args))\n )\n other = args[0] if len(args) >= 1 else ()\n\n if isinstance(other, HTTPHeaderDict):\n for key, val in other.iteritems():\n self.add(key, val)\n elif isinstance(other, Mapping):\n for key in other:\n self.add(key, other[key])\n elif hasattr(other, \"keys\"):\n for key in other.keys():\n self.add(key, other[key])\n else:\n for key, value in other:\n self.add(key, value)\n\n for key, value in kwargs.items():\n self.add(key, value)\n\n def getlist(self, key, default=__marker):\n \"\"\"Returns a list of all the values for the named field. Returns an\n empty list if the key doesn't exist.\"\"\"\n try:\n vals = self._container[key.lower()]\n except KeyError:\n if default is self.__marker:\n return []\n return default\n else:\n return vals[1:]\n\n def _prepare_for_method_change(self):\n \"\"\"\n Remove content-specific header fields before changing the request\n method to GET or HEAD according to RFC 9110, Section 15.4.\n \"\"\"\n content_specific_headers = [\n \"Content-Encoding\",\n \"Content-Language\",\n \"Content-Location\",\n \"Content-Type\",\n \"Content-Length\",\n \"Digest\",\n \"Last-Modified\",\n ]\n for header in content_specific_headers:\n self.discard(header)\n return self\n\n # Backwards compatibility for httplib\n getheaders = getlist\n getallmatchingheaders = getlist\n iget = getlist\n\n # Backwards compatibility for http.cookiejar\n get_all = getlist\n\n def __repr__(self):\n return \"%s(%s)\" % (type(self).__name__, dict(self.itermerged()))\n\n def _copy_from(self, other):\n for key in other:\n val = other.getlist(key)\n if isinstance(val, list):\n # Don't need to convert tuples\n val = list(val)\n self._container[key.lower()] = [key] + val\n\n def copy(self):\n clone = type(self)()\n clone._copy_from(self)\n return clone\n\n def iteritems(self):\n \"\"\"Iterate over all header lines, including duplicate ones.\"\"\"\n for key in self:\n vals = self._container[key.lower()]\n for val in vals[1:]:\n yield vals[0], val\n\n def itermerged(self):\n \"\"\"Iterate over all headers, merging duplicate ones together.\"\"\"\n for key in self:\n val = self._container[key.lower()]\n yield val[0], \", \".join(val[1:])\n\n def items(self):\n return list(self.iteritems())\n\n @classmethod\n def from_httplib(cls, message): # Python 2\n \"\"\"Read headers from a Python 2 httplib message object.\"\"\"\n # python2.7 does not expose a proper API for exporting multiheaders\n # efficiently. This function re-reads raw lines from the message\n # object and extracts the multiheaders properly.\n obs_fold_continued_leaders = (\" \", \"\\t\")\n headers = []\n\n for line in message.headers:\n if line.startswith(obs_fold_continued_leaders):\n if not headers:\n # We received a header line that starts with OWS as described\n # in RFC-7230 S3.2.4. This indicates a multiline header, but\n # there exists no previous header to which we can attach it.\n raise InvalidHeader(\n \"Header continuation with no previous header: %s\" % line\n )\n else:\n key, value = headers[-1]\n headers[-1] = (key, value + \" \" + line.strip())\n continue\n\n key, value = line.split(\":\", 1)\n headers.append((key, value.strip()))\n\n return cls(headers)\n",[],[213,919,920,921,1016,1050,1067,1133],"0d3f4374-67fc-11f0-a29b-0224a6c84d84","0d3f4414-67fc-11f0-a29b-0224a6c84d84",491,["D",1753299269993],"\"\"\"\nPython HTTP library with thread-safe connection pooling, file post support, user friendly, and more\n\"\"\"\nfrom __future__ import absolute_import\n\n# Set default logging handler to avoid \"No handler found\" warnings.\nimport logging\nimport warnings\nfrom logging import NullHandler\n\nfrom . import exceptions\nfrom ._version import __version__\nfrom .connectionpool import HTTPConnectionPool, HTTPSConnectionPool, connection_from_url\nfrom .filepost import encode_multipart_formdata\nfrom .poolmanager import PoolManager, ProxyManager, proxy_from_url\nfrom .response import HTTPResponse\nfrom .util.request import make_headers\nfrom .util.retry import Retry\nfrom .util.timeout import Timeout\nfrom .util.url import get_host\n\n# === NOTE TO REPACKAGERS AND VENDORS ===\n# Please delete this block, this logic is only\n# for urllib3 being distributed via PyPI.\n# See: https://github.com/urllib3/urllib3/issues/2680\ntry:\n import urllib3_secure_extra # type: ignore # noqa: F401\nexcept ImportError:\n pass\nelse:\n warnings.warn(\n \"'urllib3[secure]' extra is deprecated and will be removed \"\n \"in a future release of urllib3 2.x. Read more in this issue: \"\n \"https://github.com/urllib3/urllib3/issues/2680\",\n category=DeprecationWarning,\n stacklevel=2,\n )\n\n__author__ = \"Andrey Petrov (andrey.petrov@shazow.net)\"\n__license__ = \"MIT\"\n__version__ = __version__\n\n__all__ = (\n \"HTTPConnectionPool\",\n \"HTTPSConnectionPool\",\n \"PoolManager\",\n \"ProxyManager\",\n \"HTTPResponse\",\n \"Retry\",\n \"Timeout\",\n \"add_stderr_logger\",\n \"connection_from_url\",\n \"disable_warnings\",\n \"encode_multipart_formdata\",\n \"get_host\",\n \"make_headers\",\n \"proxy_from_url\",\n)\n\nlogging.getLogger(__name__).addHandler(NullHandler())\n\n\ndef add_stderr_logger(level=logging.DEBUG):\n \"\"\"\n Helper for quickly adding a StreamHandler to the logger. Useful for\n debugging.\n\n Returns the handler after adding it.\n \"\"\"\n # This method needs to be in this __init__.py to get the __name__ correct\n # even if urllib3 is vendored within another package.\n logger = logging.getLogger(__name__)\n handler = logging.StreamHandler()\n handler.setFormatter(logging.Formatter(\"%(asctime)s %(levelname)s %(message)s\"))\n logger.addHandler(handler)\n logger.setLevel(level)\n logger.debug(\"Added a stderr logging handler to logger: %s\", __name__)\n return handler\n\n\n# ... Clean up.\ndel NullHandler\n\n\n# All warning filters *must* be appended unless you're really certain that they\n# shouldn't be: otherwise, it's very hard for users to use most Python\n# mechanisms to silence them.\n# SecurityWarning's always go off by default.\nwarnings.simplefilter(\"always\", exceptions.SecurityWarning, append=True)\n# SubjectAltNameWarning's should go off once per host\nwarnings.simplefilter(\"default\", exceptions.SubjectAltNameWarning, append=True)\n# InsecurePlatformWarning's don't vary between requests, so we keep it default.\nwarnings.simplefilter(\"default\", exceptions.InsecurePlatformWarning, append=True)\n# SNIMissingWarnings should go off only once.\nwarnings.simplefilter(\"default\", exceptions.SNIMissingWarning, append=True)\n\n\ndef disable_warnings(category=exceptions.HTTPWarning):\n \"\"\"\n Helper for quickly disabling all urllib3 warnings.\n \"\"\"\n warnings.simplefilter(\"ignore\", category)\n",[],[213,919,920,921,1016,1050,1067,1034],"0cf63bac-67fc-11f0-a319-0224a6c84d84","wait.py","0cf63c56-67fc-11f0-a319-0224a6c84d84","031d8cca-67fc-11f0-b800-0224a6c84d84",480,["D",1753299269516],"import errno\nimport select\nimport sys\nfrom functools import partial\n\ntry:\n from time import monotonic\nexcept ImportError:\n from time import time as monotonic\n\n__all__ = [\"NoWayToWaitForSocketError\", \"wait_for_read\", \"wait_for_write\"]\n\n\nclass NoWayToWaitForSocketError(Exception):\n pass\n\n\n# How should we wait on sockets?\n#\n# There are two types of APIs you can use for waiting on sockets: the fancy\n# modern stateful APIs like epoll/kqueue, and the older stateless APIs like\n# select/poll. The stateful APIs are more efficient when you have a lots of\n# sockets to keep track of, because you can set them up once and then use them\n# lots of times. But we only ever want to wait on a single socket at a time\n# and don't want to keep track of state, so the stateless APIs are actually\n# more efficient. So we want to use select() or poll().\n#\n# Now, how do we choose between select() and poll()? On traditional Unixes,\n# select() has a strange calling convention that makes it slow, or fail\n# altogether, for high-numbered file descriptors. The point of poll() is to fix\n# that, so on Unixes, we prefer poll().\n#\n# On Windows, there is no poll() (or at least Python doesn't provide a wrapper\n# for it), but that's OK, because on Windows, select() doesn't have this\n# strange calling convention; plain select() works fine.\n#\n# So: on Windows we use select(), and everywhere else we use poll(). We also\n# fall back to select() in case poll() is somehow broken or missing.\n\nif sys.version_info >= (3, 5):\n # Modern Python, that retries syscalls by default\n def _retry_on_intr(fn, timeout):\n return fn(timeout)\n\nelse:\n # Old and broken Pythons.\n def _retry_on_intr(fn, timeout):\n if timeout is None:\n deadline = float(\"inf\")\n else:\n deadline = monotonic() + timeout\n\n while True:\n try:\n return fn(timeout)\n # OSError for 3 <= pyver < 3.5, select.error for pyver <= 2.7\n except (OSError, select.error) as e:\n # 'e.args[0]' incantation works for both OSError and select.error\n if e.args[0] != errno.EINTR:\n raise\n else:\n timeout = deadline - monotonic()\n if timeout < 0:\n timeout = 0\n if timeout == float(\"inf\"):\n timeout = None\n continue\n\n\ndef select_wait_for_socket(sock, read=False, write=False, timeout=None):\n if not read and not write:\n raise RuntimeError(\"must specify at least one of read=True, write=True\")\n rcheck = []\n wcheck = []\n if read:\n rcheck.append(sock)\n if write:\n wcheck.append(sock)\n # When doing a non-blocking connect, most systems signal success by\n # marking the socket writable. Windows, though, signals success by marked\n # it as \"exceptional\". We paper over the difference by checking the write\n # sockets for both conditions. (The stdlib selectors module does the same\n # thing.)\n fn = partial(select.select, rcheck, wcheck, wcheck)\n rready, wready, xready = _retry_on_intr(fn, timeout)\n return bool(rready or wready or xready)\n\n\ndef poll_wait_for_socket(sock, read=False, write=False, timeout=None):\n if not read and not write:\n raise RuntimeError(\"must specify at least one of read=True, write=True\")\n mask = 0\n if read:\n mask |= select.POLLIN\n if write:\n mask |= select.POLLOUT\n poll_obj = select.poll()\n poll_obj.register(sock, mask)\n\n # For some reason, poll() takes timeout in milliseconds\n def do_poll(t):\n if t is not None:\n t *= 1000\n return poll_obj.poll(t)\n\n return bool(_retry_on_intr(do_poll, timeout))\n\n\ndef null_wait_for_socket(*args, **kwargs):\n raise NoWayToWaitForSocketError(\"no select-equivalent available\")\n\n\ndef _have_working_poll():\n # Apparently some systems have a select.poll that fails as soon as you try\n # to use it, either due to strange configuration or broken monkeypatching\n # from libraries like eventlet/greenlet.\n try:\n poll_obj = select.poll()\n _retry_on_intr(poll_obj.poll, 0)\n except (AttributeError, OSError):\n return False\n else:\n return True\n\n\ndef wait_for_socket(*args, **kwargs):\n # We delay choosing which implementation to use until the first time we're\n # called. We could do it at import time, but then we might make the wrong\n # decision if someone goes wild with monkeypatching select.poll after\n # we're imported.\n global wait_for_socket\n if _have_working_poll():\n wait_for_socket = poll_wait_for_socket\n elif hasattr(select, \"select\"):\n wait_for_socket = select_wait_for_socket\n else: # Platform-specific: Appengine.\n wait_for_socket = null_wait_for_socket\n return wait_for_socket(*args, **kwargs)\n\n\ndef wait_for_read(sock, timeout=None):\n \"\"\"Waits for reading to be available on a given socket.\n Returns True if the socket is readable, or False if the timeout expired.\n \"\"\"\n return wait_for_socket(sock, read=True, timeout=timeout)\n\n\ndef wait_for_write(sock, timeout=None):\n \"\"\"Waits for writing to be available on a given socket.\n Returns True if the socket is readable, or False if the timeout expired.\n \"\"\"\n return wait_for_socket(sock, write=True, timeout=timeout)\n",[],[213,919,920,921,1016,1050,1067,1156,1148],"util","0d208286-67fc-11f0-a7d9-0224a6c84d84","url.py","0d208326-67fc-11f0-a7d9-0224a6c84d84",487,["D",1753299269807],"from __future__ import absolute_import\n\nimport re\nfrom collections import namedtuple\n\nfrom ..exceptions import LocationParseError\nfrom ..packages import six\n\nurl_attrs = [\"scheme\", \"auth\", \"host\", \"port\", \"path\", \"query\", \"fragment\"]\n\n# We only want to normalize urls with an HTTP(S) scheme.\n# urllib3 infers URLs without a scheme (None) to be http.\nNORMALIZABLE_SCHEMES = (\"http\", \"https\", None)\n\n# Almost all of these patterns were derived from the\n# 'rfc3986' module: https://github.com/python-hyper/rfc3986\nPERCENT_RE = re.compile(r\"%[a-fA-F0-9]{2}\")\nSCHEME_RE = re.compile(r\"^(?:[a-zA-Z][a-zA-Z0-9+-]*:|/)\")\nURI_RE = re.compile(\n r\"^(?:([a-zA-Z][a-zA-Z0-9+.-]*):)?\"\n r\"(?://([^\\\\/?#]*))?\"\n r\"([^?#]*)\"\n r\"(?:\\?([^#]*))?\"\n r\"(?:#(.*))?$\",\n re.UNICODE | re.DOTALL,\n)\n\nIPV4_PAT = r\"(?:[0-9]{1,3}\\.){3}[0-9]{1,3}\"\nHEX_PAT = \"[0-9A-Fa-f]{1,4}\"\nLS32_PAT = \"(?:{hex}:{hex}|{ipv4})\".format(hex=HEX_PAT, ipv4=IPV4_PAT)\n_subs = {\"hex\": HEX_PAT, \"ls32\": LS32_PAT}\n_variations = [\n # 6( h16 \":\" ) ls32\n \"(?:%(hex)s:){6}%(ls32)s\",\n # \"::\" 5( h16 \":\" ) ls32\n \"::(?:%(hex)s:){5}%(ls32)s\",\n # [ h16 ] \"::\" 4( h16 \":\" ) ls32\n \"(?:%(hex)s)?::(?:%(hex)s:){4}%(ls32)s\",\n # [ *1( h16 \":\" ) h16 ] \"::\" 3( h16 \":\" ) ls32\n \"(?:(?:%(hex)s:)?%(hex)s)?::(?:%(hex)s:){3}%(ls32)s\",\n # [ *2( h16 \":\" ) h16 ] \"::\" 2( h16 \":\" ) ls32\n \"(?:(?:%(hex)s:){0,2}%(hex)s)?::(?:%(hex)s:){2}%(ls32)s\",\n # [ *3( h16 \":\" ) h16 ] \"::\" h16 \":\" ls32\n \"(?:(?:%(hex)s:){0,3}%(hex)s)?::%(hex)s:%(ls32)s\",\n # [ *4( h16 \":\" ) h16 ] \"::\" ls32\n \"(?:(?:%(hex)s:){0,4}%(hex)s)?::%(ls32)s\",\n # [ *5( h16 \":\" ) h16 ] \"::\" h16\n \"(?:(?:%(hex)s:){0,5}%(hex)s)?::%(hex)s\",\n # [ *6( h16 \":\" ) h16 ] \"::\"\n \"(?:(?:%(hex)s:){0,6}%(hex)s)?::\",\n]\n\nUNRESERVED_PAT = r\"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789._\\-~\"\nIPV6_PAT = \"(?:\" + \"|\".join([x % _subs for x in _variations]) + \")\"\nZONE_ID_PAT = \"(?:%25|%)(?:[\" + UNRESERVED_PAT + \"]|%[a-fA-F0-9]{2})+\"\nIPV6_ADDRZ_PAT = r\"\\[\" + IPV6_PAT + r\"(?:\" + ZONE_ID_PAT + r\")?\\]\"\nREG_NAME_PAT = r\"(?:[^\\[\\]%:/?#]|%[a-fA-F0-9]{2})*\"\nTARGET_RE = re.compile(r\"^(/[^?#]*)(?:\\?([^#]*))?(?:#.*)?$\")\n\nIPV4_RE = re.compile(\"^\" + IPV4_PAT + \"$\")\nIPV6_RE = re.compile(\"^\" + IPV6_PAT + \"$\")\nIPV6_ADDRZ_RE = re.compile(\"^\" + IPV6_ADDRZ_PAT + \"$\")\nBRACELESS_IPV6_ADDRZ_RE = re.compile(\"^\" + IPV6_ADDRZ_PAT[2:-2] + \"$\")\nZONE_ID_RE = re.compile(\"(\" + ZONE_ID_PAT + r\")\\]$\")\n\n_HOST_PORT_PAT = (\"^(%s|%s|%s)(?::0*?(|0|[1-9][0-9]{0,4}))?$\") % (\n REG_NAME_PAT,\n IPV4_PAT,\n IPV6_ADDRZ_PAT,\n)\n_HOST_PORT_RE = re.compile(_HOST_PORT_PAT, re.UNICODE | re.DOTALL)\n\nUNRESERVED_CHARS = set(\n \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789._-~\"\n)\nSUB_DELIM_CHARS = set(\"!$&'()*+,;=\")\nUSERINFO_CHARS = UNRESERVED_CHARS | SUB_DELIM_CHARS | {\":\"}\nPATH_CHARS = USERINFO_CHARS | {\"@\", \"/\"}\nQUERY_CHARS = FRAGMENT_CHARS = PATH_CHARS | {\"?\"}\n\n\nclass Url(namedtuple(\"Url\", url_attrs)):\n \"\"\"\n Data structure for representing an HTTP URL. Used as a return value for\n :func:`parse_url`. Both the scheme and host are normalized as they are\n both case-insensitive according to RFC 3986.\n \"\"\"\n\n __slots__ = ()\n\n def __new__(\n cls,\n scheme=None,\n auth=None,\n host=None,\n port=None,\n path=None,\n query=None,\n fragment=None,\n ):\n if path and not path.startswith(\"/\"):\n path = \"/\" + path\n if scheme is not None:\n scheme = scheme.lower()\n return super(Url, cls).__new__(\n cls, scheme, auth, host, port, path, query, fragment\n )\n\n @property\n def hostname(self):\n \"\"\"For backwards-compatibility with urlparse. We're nice like that.\"\"\"\n return self.host\n\n @property\n def request_uri(self):\n \"\"\"Absolute path including the query string.\"\"\"\n uri = self.path or \"/\"\n\n if self.query is not None:\n uri += \"?\" + self.query\n\n return uri\n\n @property\n def netloc(self):\n \"\"\"Network location including host and port\"\"\"\n if self.port:\n return \"%s:%d\" % (self.host, self.port)\n return self.host\n\n @property\n def url(self):\n \"\"\"\n Convert self into a url\n\n This function should more or less round-trip with :func:`.parse_url`. The\n returned url may not be exactly the same as the url inputted to\n :func:`.parse_url`, but it should be equivalent by the RFC (e.g., urls\n with a blank port will have : removed).\n\n Example: ::\n\n >>> U = parse_url('http://google.com/mail/')\n >>> U.url\n 'http://google.com/mail/'\n >>> Url('http', 'username:password', 'host.com', 80,\n ... '/path', 'query', 'fragment').url\n 'http://username:password@host.com:80/path?query#fragment'\n \"\"\"\n scheme, auth, host, port, path, query, fragment = self\n url = u\"\"\n\n # We use \"is not None\" we want things to happen with empty strings (or 0 port)\n if scheme is not None:\n url += scheme + u\"://\"\n if auth is not None:\n url += auth + u\"@\"\n if host is not None:\n url += host\n if port is not None:\n url += u\":\" + str(port)\n if path is not None:\n url += path\n if query is not None:\n url += u\"?\" + query\n if fragment is not None:\n url += u\"#\" + fragment\n\n return url\n\n def __str__(self):\n return self.url\n\n\ndef split_first(s, delims):\n \"\"\"\n .. deprecated:: 1.25\n\n Given a string and an iterable of delimiters, split on the first found\n delimiter. Return two split parts and the matched delimiter.\n\n If not found, then the first part is the full input string.\n\n Example::\n\n >>> split_first('foo/bar?baz', '?/=')\n ('foo', 'bar?baz', '/')\n >>> split_first('foo/bar?baz', '123')\n ('foo/bar?baz', '', None)\n\n Scales linearly with number of delims. Not ideal for large number of delims.\n \"\"\"\n min_idx = None\n min_delim = None\n for d in delims:\n idx = s.find(d)\n if idx < 0:\n continue\n\n if min_idx is None or idx < min_idx:\n min_idx = idx\n min_delim = d\n\n if min_idx is None or min_idx < 0:\n return s, \"\", None\n\n return s[:min_idx], s[min_idx + 1 :], min_delim\n\n\ndef _encode_invalid_chars(component, allowed_chars, encoding=\"utf-8\"):\n \"\"\"Percent-encodes a URI component without reapplying\n onto an already percent-encoded component.\n \"\"\"\n if component is None:\n return component\n\n component = six.ensure_text(component)\n\n # Normalize existing percent-encoded bytes.\n # Try to see if the component we're encoding is already percent-encoded\n # so we can skip all '%' characters but still encode all others.\n component, percent_encodings = PERCENT_RE.subn(\n lambda match: match.group(0).upper(), component\n )\n\n uri_bytes = component.encode(\"utf-8\", \"surrogatepass\")\n is_percent_encoded = percent_encodings == uri_bytes.count(b\"%\")\n encoded_component = bytearray()\n\n for i in range(0, len(uri_bytes)):\n # Will return a single character bytestring on both Python 2 & 3\n byte = uri_bytes[i : i + 1]\n byte_ord = ord(byte)\n if (is_percent_encoded and byte == b\"%\") or (\n byte_ord < 128 and byte.decode() in allowed_chars\n ):\n encoded_component += byte\n continue\n encoded_component.extend(b\"%\" + (hex(byte_ord)[2:].encode().zfill(2).upper()))\n\n return encoded_component.decode(encoding)\n\n\ndef _remove_path_dot_segments(path):\n # See http://tools.ietf.org/html/rfc3986#section-5.2.4 for pseudo-code\n segments = path.split(\"/\") # Turn the path into a list of segments\n output = [] # Initialize the variable to use to store output\n\n for segment in segments:\n # '.' is the current directory, so ignore it, it is superfluous\n if segment == \".\":\n continue\n # Anything other than '..', should be appended to the output\n elif segment != \"..\":\n output.append(segment)\n # In this case segment == '..', if we can, we should pop the last\n # element\n elif output:\n output.pop()\n\n # If the path starts with '/' and the output is empty or the first string\n # is non-empty\n if path.startswith(\"/\") and (not output or output[0]):\n output.insert(0, \"\")\n\n # If the path starts with '/.' or '/..' ensure we add one more empty\n # string to add a trailing '/'\n if path.endswith((\"/.\", \"/..\")):\n output.append(\"\")\n\n return \"/\".join(output)\n\n\ndef _normalize_host(host, scheme):\n if host:\n if isinstance(host, six.binary_type):\n host = six.ensure_str(host)\n\n if scheme in NORMALIZABLE_SCHEMES:\n is_ipv6 = IPV6_ADDRZ_RE.match(host)\n if is_ipv6:\n # IPv6 hosts of the form 'a::b%zone' are encoded in a URL as\n # such per RFC 6874: 'a::b%25zone'. Unquote the ZoneID\n # separator as necessary to return a valid RFC 4007 scoped IP.\n match = ZONE_ID_RE.search(host)\n if match:\n start, end = match.span(1)\n zone_id = host[start:end]\n\n if zone_id.startswith(\"%25\") and zone_id != \"%25\":\n zone_id = zone_id[3:]\n else:\n zone_id = zone_id[1:]\n zone_id = \"%\" + _encode_invalid_chars(zone_id, UNRESERVED_CHARS)\n return host[:start].lower() + zone_id + host[end:]\n else:\n return host.lower()\n elif not IPV4_RE.match(host):\n return six.ensure_str(\n b\".\".join([_idna_encode(label) for label in host.split(\".\")])\n )\n return host\n\n\ndef _idna_encode(name):\n if name and any(ord(x) >= 128 for x in name):\n try:\n from pip._vendor import idna\n except ImportError:\n six.raise_from(\n LocationParseError(\"Unable to parse URL without the 'idna' module\"),\n None,\n )\n try:\n return idna.encode(name.lower(), strict=True, std3_rules=True)\n except idna.IDNAError:\n six.raise_from(\n LocationParseError(u\"Name '%s' is not a valid IDNA label\" % name), None\n )\n return name.lower().encode(\"ascii\")\n\n\ndef _encode_target(target):\n \"\"\"Percent-encodes a request target so that there are no invalid characters\"\"\"\n path, query = TARGET_RE.match(target).groups()\n target = _encode_invalid_chars(path, PATH_CHARS)\n query = _encode_invalid_chars(query, QUERY_CHARS)\n if query is not None:\n target += \"?\" + query\n return target\n\n\ndef parse_url(url):\n \"\"\"\n Given a url, return a parsed :class:`.Url` namedtuple. Best-effort is\n performed to parse incomplete urls. Fields not provided will be None.\n This parser is RFC 3986 and RFC 6874 compliant.\n\n The parser logic and helper functions are based heavily on\n work done in the ``rfc3986`` module.\n\n :param str url: URL to parse into a :class:`.Url` namedtuple.\n\n Partly backwards-compatible with :mod:`urlparse`.\n\n Example::\n\n >>> parse_url('http://google.com/mail/')\n Url(scheme='http', host='google.com', port=None, path='/mail/', ...)\n >>> parse_url('google.com:80')\n Url(scheme=None, host='google.com', port=80, path=None, ...)\n >>> parse_url('/foo?bar')\n Url(scheme=None, host=None, port=None, path='/foo', query='bar', ...)\n \"\"\"\n if not url:\n # Empty\n return Url()\n\n source_url = url\n if not SCHEME_RE.search(url):\n url = \"//\" + url\n\n try:\n scheme, authority, path, query, fragment = URI_RE.match(url).groups()\n normalize_uri = scheme is None or scheme.lower() in NORMALIZABLE_SCHEMES\n\n if scheme:\n scheme = scheme.lower()\n\n if authority:\n auth, _, host_port = authority.rpartition(\"@\")\n auth = auth or None\n host, port = _HOST_PORT_RE.match(host_port).groups()\n if auth and normalize_uri:\n auth = _encode_invalid_chars(auth, USERINFO_CHARS)\n if port == \"\":\n port = None\n else:\n auth, host, port = None, None, None\n\n if port is not None:\n port = int(port)\n if not (0 <= port <= 65535):\n raise LocationParseError(url)\n\n host = _normalize_host(host, scheme)\n\n if normalize_uri and path:\n path = _remove_path_dot_segments(path)\n path = _encode_invalid_chars(path, PATH_CHARS)\n if normalize_uri and query:\n query = _encode_invalid_chars(query, QUERY_CHARS)\n if normalize_uri and fragment:\n fragment = _encode_invalid_chars(fragment, FRAGMENT_CHARS)\n\n except (ValueError, AttributeError):\n return six.raise_from(LocationParseError(source_url), None)\n\n # For the sake of backwards compatibility we put empty\n # string values for path if there are any defined values\n # beyond the path in the URL.\n # TODO: Remove this when we break backwards compatibility.\n if not path:\n if query is not None or fragment is not None:\n path = \"\"\n else:\n path = None\n\n # Ensure that each part of the URL is a `str` for\n # backwards compatibility.\n if isinstance(url, six.text_type):\n ensure_func = six.ensure_text\n else:\n ensure_func = six.ensure_str\n\n def ensure_type(x):\n return x if x is None else ensure_func(x)\n\n return Url(\n scheme=ensure_type(scheme),\n auth=ensure_type(auth),\n host=ensure_type(host),\n port=port,\n path=ensure_type(path),\n query=ensure_type(query),\n fragment=ensure_type(fragment),\n )\n\n\ndef get_host(url):\n \"\"\"\n Deprecated. Use :func:`parse_url` instead.\n \"\"\"\n p = parse_url(url)\n return p.scheme or \"http\", p.hostname, p.port\n",[],[213,919,920,921,1016,1050,1067,1156,1158],"0d04b6f0-67fc-11f0-befa-0224a6c84d84","timeout.py","0d04b7b8-67fc-11f0-befa-0224a6c84d84",482,["D",1753299269626],"from __future__ import absolute_import\n\nimport time\n\n# The default socket timeout, used by httplib to indicate that no timeout was; specified by the user\nfrom socket import _GLOBAL_DEFAULT_TIMEOUT, getdefaulttimeout\n\nfrom ..exceptions import TimeoutStateError\n\n# A sentinel value to indicate that no timeout was specified by the user in\n# urllib3\n_Default = object()\n\n\n# Use time.monotonic if available.\ncurrent_time = getattr(time, \"monotonic\", time.time)\n\n\nclass Timeout(object):\n \"\"\"Timeout configuration.\n\n Timeouts can be defined as a default for a pool:\n\n .. code-block:: python\n\n timeout = Timeout(connect=2.0, read=7.0)\n http = PoolManager(timeout=timeout)\n response = http.request('GET', 'http://example.com/')\n\n Or per-request (which overrides the default for the pool):\n\n .. code-block:: python\n\n response = http.request('GET', 'http://example.com/', timeout=Timeout(10))\n\n Timeouts can be disabled by setting all the parameters to ``None``:\n\n .. code-block:: python\n\n no_timeout = Timeout(connect=None, read=None)\n response = http.request('GET', 'http://example.com/, timeout=no_timeout)\n\n\n :param total:\n This combines the connect and read timeouts into one; the read timeout\n will be set to the time leftover from the connect attempt. In the\n event that both a connect timeout and a total are specified, or a read\n timeout and a total are specified, the shorter timeout will be applied.\n\n Defaults to None.\n\n :type total: int, float, or None\n\n :param connect:\n The maximum amount of time (in seconds) to wait for a connection\n attempt to a server to succeed. Omitting the parameter will default the\n connect timeout to the system default, probably `the global default\n timeout in socket.py\n `_.\n None will set an infinite timeout for connection attempts.\n\n :type connect: int, float, or None\n\n :param read:\n The maximum amount of time (in seconds) to wait between consecutive\n read operations for a response from the server. Omitting the parameter\n will default the read timeout to the system default, probably `the\n global default timeout in socket.py\n `_.\n None will set an infinite timeout.\n\n :type read: int, float, or None\n\n .. note::\n\n Many factors can affect the total amount of time for urllib3 to return\n an HTTP response.\n\n For example, Python's DNS resolver does not obey the timeout specified\n on the socket. Other factors that can affect total request time include\n high CPU load, high swap, the program running at a low priority level,\n or other behaviors.\n\n In addition, the read and total timeouts only measure the time between\n read operations on the socket connecting the client and the server,\n not the total amount of time for the request to return a complete\n response. For most requests, the timeout is raised because the server\n has not sent the first byte in the specified time. This is not always\n the case; if a server streams one byte every fifteen seconds, a timeout\n of 20 seconds will not trigger, even though the request will take\n several minutes to complete.\n\n If your goal is to cut off any request after a set amount of wall clock\n time, consider having a second \"watcher\" thread to cut off a slow\n request.\n \"\"\"\n\n #: A sentinel object representing the default timeout value\n DEFAULT_TIMEOUT = _GLOBAL_DEFAULT_TIMEOUT\n\n def __init__(self, total=None, connect=_Default, read=_Default):\n self._connect = self._validate_timeout(connect, \"connect\")\n self._read = self._validate_timeout(read, \"read\")\n self.total = self._validate_timeout(total, \"total\")\n self._start_connect = None\n\n def __repr__(self):\n return \"%s(connect=%r, read=%r, total=%r)\" % (\n type(self).__name__,\n self._connect,\n self._read,\n self.total,\n )\n\n # __str__ provided for backwards compatibility\n __str__ = __repr__\n\n @classmethod\n def resolve_default_timeout(cls, timeout):\n return getdefaulttimeout() if timeout is cls.DEFAULT_TIMEOUT else timeout\n\n @classmethod\n def _validate_timeout(cls, value, name):\n \"\"\"Check that a timeout attribute is valid.\n\n :param value: The timeout value to validate\n :param name: The name of the timeout attribute to validate. This is\n used to specify in error messages.\n :return: The validated and casted version of the given value.\n :raises ValueError: If it is a numeric value less than or equal to\n zero, or the type is not an integer, float, or None.\n \"\"\"\n if value is _Default:\n return cls.DEFAULT_TIMEOUT\n\n if value is None or value is cls.DEFAULT_TIMEOUT:\n return value\n\n if isinstance(value, bool):\n raise ValueError(\n \"Timeout cannot be a boolean value. It must \"\n \"be an int, float or None.\"\n )\n try:\n float(value)\n except (TypeError, ValueError):\n raise ValueError(\n \"Timeout value %s was %s, but it must be an \"\n \"int, float or None.\" % (name, value)\n )\n\n try:\n if value <= 0:\n raise ValueError(\n \"Attempted to set %s timeout to %s, but the \"\n \"timeout cannot be set to a value less \"\n \"than or equal to 0.\" % (name, value)\n )\n except TypeError:\n # Python 3\n raise ValueError(\n \"Timeout value %s was %s, but it must be an \"\n \"int, float or None.\" % (name, value)\n )\n\n return value\n\n @classmethod\n def from_float(cls, timeout):\n \"\"\"Create a new Timeout from a legacy timeout value.\n\n The timeout value used by httplib.py sets the same timeout on the\n connect(), and recv() socket requests. This creates a :class:`Timeout`\n object that sets the individual timeouts to the ``timeout`` value\n passed to this function.\n\n :param timeout: The legacy timeout value.\n :type timeout: integer, float, sentinel default object, or None\n :return: Timeout object\n :rtype: :class:`Timeout`\n \"\"\"\n return Timeout(read=timeout, connect=timeout)\n\n def clone(self):\n \"\"\"Create a copy of the timeout object\n\n Timeout properties are stored per-pool but each request needs a fresh\n Timeout object to ensure each one has its own start/stop configured.\n\n :return: a copy of the timeout object\n :rtype: :class:`Timeout`\n \"\"\"\n # We can't use copy.deepcopy because that will also create a new object\n # for _GLOBAL_DEFAULT_TIMEOUT, which socket.py uses as a sentinel to\n # detect the user default.\n return Timeout(connect=self._connect, read=self._read, total=self.total)\n\n def start_connect(self):\n \"\"\"Start the timeout clock, used during a connect() attempt\n\n :raises urllib3.exceptions.TimeoutStateError: if you attempt\n to start a timer that has been started already.\n \"\"\"\n if self._start_connect is not None:\n raise TimeoutStateError(\"Timeout timer has already been started.\")\n self._start_connect = current_time()\n return self._start_connect\n\n def get_connect_duration(self):\n \"\"\"Gets the time elapsed since the call to :meth:`start_connect`.\n\n :return: Elapsed time in seconds.\n :rtype: float\n :raises urllib3.exceptions.TimeoutStateError: if you attempt\n to get duration for a timer that hasn't been started.\n \"\"\"\n if self._start_connect is None:\n raise TimeoutStateError(\n \"Can't get connect duration for timer that has not started.\"\n )\n return current_time() - self._start_connect\n\n @property\n def connect_timeout(self):\n \"\"\"Get the value to use when setting a connection timeout.\n\n This will be a positive float or integer, the value None\n (never timeout), or the default system timeout.\n\n :return: Connect timeout.\n :rtype: int, float, :attr:`Timeout.DEFAULT_TIMEOUT` or None\n \"\"\"\n if self.total is None:\n return self._connect\n\n if self._connect is None or self._connect is self.DEFAULT_TIMEOUT:\n return self.total\n\n return min(self._connect, self.total)\n\n @property\n def read_timeout(self):\n \"\"\"Get the value for the read timeout.\n\n This assumes some time has elapsed in the connection timeout and\n computes the read timeout appropriately.\n\n If self.total is set, the read timeout is dependent on the amount of\n time taken by the connect timeout. If the connection time has not been\n established, a :exc:`~urllib3.exceptions.TimeoutStateError` will be\n raised.\n\n :return: Value to use for the read timeout.\n :rtype: int, float, :attr:`Timeout.DEFAULT_TIMEOUT` or None\n :raises urllib3.exceptions.TimeoutStateError: If :meth:`start_connect`\n has not yet been called on this object.\n \"\"\"\n if (\n self.total is not None\n and self.total is not self.DEFAULT_TIMEOUT\n and self._read is not None\n and self._read is not self.DEFAULT_TIMEOUT\n ):\n # In case the connect timeout has not yet been established.\n if self._start_connect is None:\n return self._read\n return max(0, min(self.total - self.get_connect_duration(), self._read))\n elif self.total is not None and self.total is not self.DEFAULT_TIMEOUT:\n return max(0, self.total - self.get_connect_duration())\n else:\n return self._read\n",[],[213,919,920,921,1016,1050,1067,1156,1166],"0ced4448-67fc-11f0-aca6-0224a6c84d84","ssltransport.py","0ced44fc-67fc-11f0-aca6-0224a6c84d84",478,["D",1753299269445],"import io\nimport socket\nimport ssl\n\nfrom ..exceptions import ProxySchemeUnsupported\nfrom ..packages import six\n\nSSL_BLOCKSIZE = 16384\n\n\nclass SSLTransport:\n \"\"\"\n The SSLTransport wraps an existing socket and establishes an SSL connection.\n\n Contrary to Python's implementation of SSLSocket, it allows you to chain\n multiple TLS connections together. It's particularly useful if you need to\n implement TLS within TLS.\n\n The class supports most of the socket API operations.\n \"\"\"\n\n @staticmethod\n def _validate_ssl_context_for_tls_in_tls(ssl_context):\n \"\"\"\n Raises a ProxySchemeUnsupported if the provided ssl_context can't be used\n for TLS in TLS.\n\n The only requirement is that the ssl_context provides the 'wrap_bio'\n methods.\n \"\"\"\n\n if not hasattr(ssl_context, \"wrap_bio\"):\n if six.PY2:\n raise ProxySchemeUnsupported(\n \"TLS in TLS requires SSLContext.wrap_bio() which isn't \"\n \"supported on Python 2\"\n )\n else:\n raise ProxySchemeUnsupported(\n \"TLS in TLS requires SSLContext.wrap_bio() which isn't \"\n \"available on non-native SSLContext\"\n )\n\n def __init__(\n self, socket, ssl_context, server_hostname=None, suppress_ragged_eofs=True\n ):\n \"\"\"\n Create an SSLTransport around socket using the provided ssl_context.\n \"\"\"\n self.incoming = ssl.MemoryBIO()\n self.outgoing = ssl.MemoryBIO()\n\n self.suppress_ragged_eofs = suppress_ragged_eofs\n self.socket = socket\n\n self.sslobj = ssl_context.wrap_bio(\n self.incoming, self.outgoing, server_hostname=server_hostname\n )\n\n # Perform initial handshake.\n self._ssl_io_loop(self.sslobj.do_handshake)\n\n def __enter__(self):\n return self\n\n def __exit__(self, *_):\n self.close()\n\n def fileno(self):\n return self.socket.fileno()\n\n def read(self, len=1024, buffer=None):\n return self._wrap_ssl_read(len, buffer)\n\n def recv(self, len=1024, flags=0):\n if flags != 0:\n raise ValueError(\"non-zero flags not allowed in calls to recv\")\n return self._wrap_ssl_read(len)\n\n def recv_into(self, buffer, nbytes=None, flags=0):\n if flags != 0:\n raise ValueError(\"non-zero flags not allowed in calls to recv_into\")\n if buffer and (nbytes is None):\n nbytes = len(buffer)\n elif nbytes is None:\n nbytes = 1024\n return self.read(nbytes, buffer)\n\n def sendall(self, data, flags=0):\n if flags != 0:\n raise ValueError(\"non-zero flags not allowed in calls to sendall\")\n count = 0\n with memoryview(data) as view, view.cast(\"B\") as byte_view:\n amount = len(byte_view)\n while count < amount:\n v = self.send(byte_view[count:])\n count += v\n\n def send(self, data, flags=0):\n if flags != 0:\n raise ValueError(\"non-zero flags not allowed in calls to send\")\n response = self._ssl_io_loop(self.sslobj.write, data)\n return response\n\n def makefile(\n self, mode=\"r\", buffering=None, encoding=None, errors=None, newline=None\n ):\n \"\"\"\n Python's httpclient uses makefile and buffered io when reading HTTP\n messages and we need to support it.\n\n This is unfortunately a copy and paste of socket.py makefile with small\n changes to point to the socket directly.\n \"\"\"\n if not set(mode) <= {\"r\", \"w\", \"b\"}:\n raise ValueError(\"invalid mode %r (only r, w, b allowed)\" % (mode,))\n\n writing = \"w\" in mode\n reading = \"r\" in mode or not writing\n assert reading or writing\n binary = \"b\" in mode\n rawmode = \"\"\n if reading:\n rawmode += \"r\"\n if writing:\n rawmode += \"w\"\n raw = socket.SocketIO(self, rawmode)\n self.socket._io_refs += 1\n if buffering is None:\n buffering = -1\n if buffering < 0:\n buffering = io.DEFAULT_BUFFER_SIZE\n if buffering == 0:\n if not binary:\n raise ValueError(\"unbuffered streams must be binary\")\n return raw\n if reading and writing:\n buffer = io.BufferedRWPair(raw, raw, buffering)\n elif reading:\n buffer = io.BufferedReader(raw, buffering)\n else:\n assert writing\n buffer = io.BufferedWriter(raw, buffering)\n if binary:\n return buffer\n text = io.TextIOWrapper(buffer, encoding, errors, newline)\n text.mode = mode\n return text\n\n def unwrap(self):\n self._ssl_io_loop(self.sslobj.unwrap)\n\n def close(self):\n self.socket.close()\n\n def getpeercert(self, binary_form=False):\n return self.sslobj.getpeercert(binary_form)\n\n def version(self):\n return self.sslobj.version()\n\n def cipher(self):\n return self.sslobj.cipher()\n\n def selected_alpn_protocol(self):\n return self.sslobj.selected_alpn_protocol()\n\n def selected_npn_protocol(self):\n return self.sslobj.selected_npn_protocol()\n\n def shared_ciphers(self):\n return self.sslobj.shared_ciphers()\n\n def compression(self):\n return self.sslobj.compression()\n\n def settimeout(self, value):\n self.socket.settimeout(value)\n\n def gettimeout(self):\n return self.socket.gettimeout()\n\n def _decref_socketios(self):\n self.socket._decref_socketios()\n\n def _wrap_ssl_read(self, len, buffer=None):\n try:\n return self._ssl_io_loop(self.sslobj.read, len, buffer)\n except ssl.SSLError as e:\n if e.errno == ssl.SSL_ERROR_EOF and self.suppress_ragged_eofs:\n return 0 # eof, return 0.\n else:\n raise\n\n def _ssl_io_loop(self, func, *args):\n \"\"\"Performs an I/O loop between incoming/outgoing and the socket.\"\"\"\n should_loop = True\n ret = None\n\n while should_loop:\n errno = None\n try:\n ret = func(*args)\n except ssl.SSLError as e:\n if e.errno not in (ssl.SSL_ERROR_WANT_READ, ssl.SSL_ERROR_WANT_WRITE):\n # WANT_READ, and WANT_WRITE are expected, others are not.\n raise e\n errno = e.errno\n\n buf = self.outgoing.read()\n self.socket.sendall(buf)\n\n if errno is None:\n should_loop = False\n elif errno == ssl.SSL_ERROR_WANT_READ:\n buf = self.socket.recv(SSL_BLOCKSIZE)\n if buf:\n self.incoming.write(buf)\n else:\n self.incoming.write_eof()\n return ret\n",[],[213,919,920,921,1016,1050,1067,1156,1174],"0d2c67d6-67fc-11f0-b0dc-0224a6c84d84","ssl_match_hostname.py","0d2c6876-67fc-11f0-b0dc-0224a6c84d84",489,["D",1753299269884],"\"\"\"The match_hostname() function from Python 3.3.3, essential when using SSL.\"\"\"\n\n# Note: This file is under the PSF license as the code comes from the python\n# stdlib. http://docs.python.org/3/license.html\n\nimport re\nimport sys\n\n# ipaddress has been backported to 2.6+ in pypi. If it is installed on the\n# system, use it to handle IPAddress ServerAltnames (this was added in\n# python-3.5) otherwise only do DNS matching. This allows\n# util.ssl_match_hostname to continue to be used in Python 2.7.\ntry:\n import ipaddress\nexcept ImportError:\n ipaddress = None\n\n__version__ = \"3.5.0.1\"\n\n\nclass CertificateError(ValueError):\n pass\n\n\ndef _dnsname_match(dn, hostname, max_wildcards=1):\n \"\"\"Matching according to RFC 6125, section 6.4.3\n\n http://tools.ietf.org/html/rfc6125#section-6.4.3\n \"\"\"\n pats = []\n if not dn:\n return False\n\n # Ported from python3-syntax:\n # leftmost, *remainder = dn.split(r'.')\n parts = dn.split(r\".\")\n leftmost = parts[0]\n remainder = parts[1:]\n\n wildcards = leftmost.count(\"*\")\n if wildcards > max_wildcards:\n # Issue #17980: avoid denials of service by refusing more\n # than one wildcard per fragment. A survey of established\n # policy among SSL implementations showed it to be a\n # reasonable choice.\n raise CertificateError(\n \"too many wildcards in certificate DNS name: \" + repr(dn)\n )\n\n # speed up common case w/o wildcards\n if not wildcards:\n return dn.lower() == hostname.lower()\n\n # RFC 6125, section 6.4.3, subitem 1.\n # The client SHOULD NOT attempt to match a presented identifier in which\n # the wildcard character comprises a label other than the left-most label.\n if leftmost == \"*\":\n # When '*' is a fragment by itself, it matches a non-empty dotless\n # fragment.\n pats.append(\"[^.]+\")\n elif leftmost.startswith(\"xn--\") or hostname.startswith(\"xn--\"):\n # RFC 6125, section 6.4.3, subitem 3.\n # The client SHOULD NOT attempt to match a presented identifier\n # where the wildcard character is embedded within an A-label or\n # U-label of an internationalized domain name.\n pats.append(re.escape(leftmost))\n else:\n # Otherwise, '*' matches any dotless string, e.g. www*\n pats.append(re.escape(leftmost).replace(r\"\\*\", \"[^.]*\"))\n\n # add the remaining fragments, ignore any wildcards\n for frag in remainder:\n pats.append(re.escape(frag))\n\n pat = re.compile(r\"\\A\" + r\"\\.\".join(pats) + r\"\\Z\", re.IGNORECASE)\n return pat.match(hostname)\n\n\ndef _to_unicode(obj):\n if isinstance(obj, str) and sys.version_info < (3,):\n # ignored flake8 # F821 to support python 2.7 function\n obj = unicode(obj, encoding=\"ascii\", errors=\"strict\") # noqa: F821\n return obj\n\n\ndef _ipaddress_match(ipname, host_ip):\n \"\"\"Exact matching of IP addresses.\n\n RFC 6125 explicitly doesn't define an algorithm for this\n (section 1.7.2 - \"Out of Scope\").\n \"\"\"\n # OpenSSL may add a trailing newline to a subjectAltName's IP address\n # Divergence from upstream: ipaddress can't handle byte str\n ip = ipaddress.ip_address(_to_unicode(ipname).rstrip())\n return ip == host_ip\n\n\ndef match_hostname(cert, hostname):\n \"\"\"Verify that *cert* (in decoded format as returned by\n SSLSocket.getpeercert()) matches the *hostname*. RFC 2818 and RFC 6125\n rules are followed, but IP addresses are not accepted for *hostname*.\n\n CertificateError is raised on failure. On success, the function\n returns nothing.\n \"\"\"\n if not cert:\n raise ValueError(\n \"empty or no certificate, match_hostname needs a \"\n \"SSL socket or SSL context with either \"\n \"CERT_OPTIONAL or CERT_REQUIRED\"\n )\n try:\n # Divergence from upstream: ipaddress can't handle byte str\n host_ip = ipaddress.ip_address(_to_unicode(hostname))\n except (UnicodeError, ValueError):\n # ValueError: Not an IP address (common case)\n # UnicodeError: Divergence from upstream: Have to deal with ipaddress not taking\n # byte strings. addresses should be all ascii, so we consider it not\n # an ipaddress in this case\n host_ip = None\n except AttributeError:\n # Divergence from upstream: Make ipaddress library optional\n if ipaddress is None:\n host_ip = None\n else: # Defensive\n raise\n dnsnames = []\n san = cert.get(\"subjectAltName\", ())\n for key, value in san:\n if key == \"DNS\":\n if host_ip is None and _dnsname_match(value, hostname):\n return\n dnsnames.append(value)\n elif key == \"IP Address\":\n if host_ip is not None and _ipaddress_match(value, host_ip):\n return\n dnsnames.append(value)\n if not dnsnames:\n # The subject is only checked when there is no dNSName entry\n # in subjectAltName\n for sub in cert.get(\"subject\", ()):\n for key, value in sub:\n # XXX according to RFC 2818, the most specific Common Name\n # must be used.\n if key == \"commonName\":\n if _dnsname_match(value, hostname):\n return\n dnsnames.append(value)\n if len(dnsnames) > 1:\n raise CertificateError(\n \"hostname %r \"\n \"doesn't match either of %s\" % (hostname, \", \".join(map(repr, dnsnames)))\n )\n elif len(dnsnames) == 1:\n raise CertificateError(\"hostname %r doesn't match %r\" % (hostname, dnsnames[0]))\n else:\n raise CertificateError(\n \"no appropriate commonName or subjectAltName fields were found\"\n )\n",[],[213,919,920,921,1016,1050,1067,1156,1182],"0d175ecc-67fc-11f0-9b65-0224a6c84d84","ssl_.py","0d175f94-67fc-11f0-9b65-0224a6c84d84",485,["D",1753299269744],"from __future__ import absolute_import\n\nimport hashlib\nimport hmac\nimport os\nimport sys\nimport warnings\nfrom binascii import hexlify, unhexlify\n\nfrom ..exceptions import (\n InsecurePlatformWarning,\n ProxySchemeUnsupported,\n SNIMissingWarning,\n SSLError,\n)\nfrom ..packages import six\nfrom .url import BRACELESS_IPV6_ADDRZ_RE, IPV4_RE\n\nSSLContext = None\nSSLTransport = None\nHAS_SNI = False\nIS_PYOPENSSL = False\nIS_SECURETRANSPORT = False\nALPN_PROTOCOLS = [\"http/1.1\"]\n\n# Maps the length of a digest to a possible hash function producing this digest\nHASHFUNC_MAP = {\n length: getattr(hashlib, algorithm, None)\n for length, algorithm in ((32, \"md5\"), (40, \"sha1\"), (64, \"sha256\"))\n}\n\n\ndef _const_compare_digest_backport(a, b):\n \"\"\"\n Compare two digests of equal length in constant time.\n\n The digests must be of type str/bytes.\n Returns True if the digests match, and False otherwise.\n \"\"\"\n result = abs(len(a) - len(b))\n for left, right in zip(bytearray(a), bytearray(b)):\n result |= left ^ right\n return result == 0\n\n\n_const_compare_digest = getattr(hmac, \"compare_digest\", _const_compare_digest_backport)\n\ntry: # Test for SSL features\n import ssl\n from ssl import CERT_REQUIRED, wrap_socket\nexcept ImportError:\n pass\n\ntry:\n from ssl import HAS_SNI # Has SNI?\nexcept ImportError:\n pass\n\ntry:\n from .ssltransport import SSLTransport\nexcept ImportError:\n pass\n\n\ntry: # Platform-specific: Python 3.6\n from ssl import PROTOCOL_TLS\n\n PROTOCOL_SSLv23 = PROTOCOL_TLS\nexcept ImportError:\n try:\n from ssl import PROTOCOL_SSLv23 as PROTOCOL_TLS\n\n PROTOCOL_SSLv23 = PROTOCOL_TLS\n except ImportError:\n PROTOCOL_SSLv23 = PROTOCOL_TLS = 2\n\ntry:\n from ssl import PROTOCOL_TLS_CLIENT\nexcept ImportError:\n PROTOCOL_TLS_CLIENT = PROTOCOL_TLS\n\n\ntry:\n from ssl import OP_NO_COMPRESSION, OP_NO_SSLv2, OP_NO_SSLv3\nexcept ImportError:\n OP_NO_SSLv2, OP_NO_SSLv3 = 0x1000000, 0x2000000\n OP_NO_COMPRESSION = 0x20000\n\n\ntry: # OP_NO_TICKET was added in Python 3.6\n from ssl import OP_NO_TICKET\nexcept ImportError:\n OP_NO_TICKET = 0x4000\n\n\n# A secure default.\n# Sources for more information on TLS ciphers:\n#\n# - https://wiki.mozilla.org/Security/Server_Side_TLS\n# - https://www.ssllabs.com/projects/best-practices/index.html\n# - https://hynek.me/articles/hardening-your-web-servers-ssl-ciphers/\n#\n# The general intent is:\n# - prefer cipher suites that offer perfect forward secrecy (DHE/ECDHE),\n# - prefer ECDHE over DHE for better performance,\n# - prefer any AES-GCM and ChaCha20 over any AES-CBC for better performance and\n# security,\n# - prefer AES-GCM over ChaCha20 because hardware-accelerated AES is common,\n# - disable NULL authentication, MD5 MACs, DSS, and other\n# insecure ciphers for security reasons.\n# - NOTE: TLS 1.3 cipher suites are managed through a different interface\n# not exposed by CPython (yet!) and are enabled by default if they're available.\nDEFAULT_CIPHERS = \":\".join(\n [\n \"ECDHE+AESGCM\",\n \"ECDHE+CHACHA20\",\n \"DHE+AESGCM\",\n \"DHE+CHACHA20\",\n \"ECDH+AESGCM\",\n \"DH+AESGCM\",\n \"ECDH+AES\",\n \"DH+AES\",\n \"RSA+AESGCM\",\n \"RSA+AES\",\n \"!aNULL\",\n \"!eNULL\",\n \"!MD5\",\n \"!DSS\",\n ]\n)\n\ntry:\n from ssl import SSLContext # Modern SSL?\nexcept ImportError:\n\n class SSLContext(object): # Platform-specific: Python 2\n def __init__(self, protocol_version):\n self.protocol = protocol_version\n # Use default values from a real SSLContext\n self.check_hostname = False\n self.verify_mode = ssl.CERT_NONE\n self.ca_certs = None\n self.options = 0\n self.certfile = None\n self.keyfile = None\n self.ciphers = None\n\n def load_cert_chain(self, certfile, keyfile):\n self.certfile = certfile\n self.keyfile = keyfile\n\n def load_verify_locations(self, cafile=None, capath=None, cadata=None):\n self.ca_certs = cafile\n\n if capath is not None:\n raise SSLError(\"CA directories not supported in older Pythons\")\n\n if cadata is not None:\n raise SSLError(\"CA data not supported in older Pythons\")\n\n def set_ciphers(self, cipher_suite):\n self.ciphers = cipher_suite\n\n def wrap_socket(self, socket, server_hostname=None, server_side=False):\n warnings.warn(\n \"A true SSLContext object is not available. This prevents \"\n \"urllib3 from configuring SSL appropriately and may cause \"\n \"certain SSL connections to fail. You can upgrade to a newer \"\n \"version of Python to solve this. For more information, see \"\n \"https://urllib3.readthedocs.io/en/1.26.x/advanced-usage.html\"\n \"#ssl-warnings\",\n InsecurePlatformWarning,\n )\n kwargs = {\n \"keyfile\": self.keyfile,\n \"certfile\": self.certfile,\n \"ca_certs\": self.ca_certs,\n \"cert_reqs\": self.verify_mode,\n \"ssl_version\": self.protocol,\n \"server_side\": server_side,\n }\n return wrap_socket(socket, ciphers=self.ciphers, **kwargs)\n\n\ndef assert_fingerprint(cert, fingerprint):\n \"\"\"\n Checks if given fingerprint matches the supplied certificate.\n\n :param cert:\n Certificate as bytes object.\n :param fingerprint:\n Fingerprint as string of hexdigits, can be interspersed by colons.\n \"\"\"\n\n fingerprint = fingerprint.replace(\":\", \"\").lower()\n digest_length = len(fingerprint)\n if digest_length not in HASHFUNC_MAP:\n raise SSLError(\"Fingerprint of invalid length: {0}\".format(fingerprint))\n hashfunc = HASHFUNC_MAP.get(digest_length)\n if hashfunc is None:\n raise SSLError(\n \"Hash function implementation unavailable for fingerprint length: {0}\".format(\n digest_length\n )\n )\n\n # We need encode() here for py32; works on py2 and p33.\n fingerprint_bytes = unhexlify(fingerprint.encode())\n\n cert_digest = hashfunc(cert).digest()\n\n if not _const_compare_digest(cert_digest, fingerprint_bytes):\n raise SSLError(\n 'Fingerprints did not match. Expected \"{0}\", got \"{1}\".'.format(\n fingerprint, hexlify(cert_digest)\n )\n )\n\n\ndef resolve_cert_reqs(candidate):\n \"\"\"\n Resolves the argument to a numeric constant, which can be passed to\n the wrap_socket function/method from the ssl module.\n Defaults to :data:`ssl.CERT_REQUIRED`.\n If given a string it is assumed to be the name of the constant in the\n :mod:`ssl` module or its abbreviation.\n (So you can specify `REQUIRED` instead of `CERT_REQUIRED`.\n If it's neither `None` nor a string we assume it is already the numeric\n constant which can directly be passed to wrap_socket.\n \"\"\"\n if candidate is None:\n return CERT_REQUIRED\n\n if isinstance(candidate, str):\n res = getattr(ssl, candidate, None)\n if res is None:\n res = getattr(ssl, \"CERT_\" + candidate)\n return res\n\n return candidate\n\n\ndef resolve_ssl_version(candidate):\n \"\"\"\n like resolve_cert_reqs\n \"\"\"\n if candidate is None:\n return PROTOCOL_TLS\n\n if isinstance(candidate, str):\n res = getattr(ssl, candidate, None)\n if res is None:\n res = getattr(ssl, \"PROTOCOL_\" + candidate)\n return res\n\n return candidate\n\n\ndef create_urllib3_context(\n ssl_version=None, cert_reqs=None, options=None, ciphers=None\n):\n \"\"\"All arguments have the same meaning as ``ssl_wrap_socket``.\n\n By default, this function does a lot of the same work that\n ``ssl.create_default_context`` does on Python 3.4+. It:\n\n - Disables SSLv2, SSLv3, and compression\n - Sets a restricted set of server ciphers\n\n If you wish to enable SSLv3, you can do::\n\n from pip._vendor.urllib3.util import ssl_\n context = ssl_.create_urllib3_context()\n context.options &= ~ssl_.OP_NO_SSLv3\n\n You can do the same to enable compression (substituting ``COMPRESSION``\n for ``SSLv3`` in the last line above).\n\n :param ssl_version:\n The desired protocol version to use. This will default to\n PROTOCOL_SSLv23 which will negotiate the highest protocol that both\n the server and your installation of OpenSSL support.\n :param cert_reqs:\n Whether to require the certificate verification. This defaults to\n ``ssl.CERT_REQUIRED``.\n :param options:\n Specific OpenSSL options. These default to ``ssl.OP_NO_SSLv2``,\n ``ssl.OP_NO_SSLv3``, ``ssl.OP_NO_COMPRESSION``, and ``ssl.OP_NO_TICKET``.\n :param ciphers:\n Which cipher suites to allow the server to select.\n :returns:\n Constructed SSLContext object with specified options\n :rtype: SSLContext\n \"\"\"\n # PROTOCOL_TLS is deprecated in Python 3.10\n if not ssl_version or ssl_version == PROTOCOL_TLS:\n ssl_version = PROTOCOL_TLS_CLIENT\n\n context = SSLContext(ssl_version)\n\n context.set_ciphers(ciphers or DEFAULT_CIPHERS)\n\n # Setting the default here, as we may have no ssl module on import\n cert_reqs = ssl.CERT_REQUIRED if cert_reqs is None else cert_reqs\n\n if options is None:\n options = 0\n # SSLv2 is easily broken and is considered harmful and dangerous\n options |= OP_NO_SSLv2\n # SSLv3 has several problems and is now dangerous\n options |= OP_NO_SSLv3\n # Disable compression to prevent CRIME attacks for OpenSSL 1.0+\n # (issue #309)\n options |= OP_NO_COMPRESSION\n # TLSv1.2 only. Unless set explicitly, do not request tickets.\n # This may save some bandwidth on wire, and although the ticket is encrypted,\n # there is a risk associated with it being on wire,\n # if the server is not rotating its ticketing keys properly.\n options |= OP_NO_TICKET\n\n context.options |= options\n\n # Enable post-handshake authentication for TLS 1.3, see GH #1634. PHA is\n # necessary for conditional client cert authentication with TLS 1.3.\n # The attribute is None for OpenSSL <= 1.1.0 or does not exist in older\n # versions of Python. We only enable on Python 3.7.4+ or if certificate\n # verification is enabled to work around Python issue #37428\n # See: https://bugs.python.org/issue37428\n if (cert_reqs == ssl.CERT_REQUIRED or sys.version_info >= (3, 7, 4)) and getattr(\n context, \"post_handshake_auth\", None\n ) is not None:\n context.post_handshake_auth = True\n\n def disable_check_hostname():\n if (\n getattr(context, \"check_hostname\", None) is not None\n ): # Platform-specific: Python 3.2\n # We do our own verification, including fingerprints and alternative\n # hostnames. So disable it here\n context.check_hostname = False\n\n # The order of the below lines setting verify_mode and check_hostname\n # matter due to safe-guards SSLContext has to prevent an SSLContext with\n # check_hostname=True, verify_mode=NONE/OPTIONAL. This is made even more\n # complex because we don't know whether PROTOCOL_TLS_CLIENT will be used\n # or not so we don't know the initial state of the freshly created SSLContext.\n if cert_reqs == ssl.CERT_REQUIRED:\n context.verify_mode = cert_reqs\n disable_check_hostname()\n else:\n disable_check_hostname()\n context.verify_mode = cert_reqs\n\n # Enable logging of TLS session keys via defacto standard environment variable\n # 'SSLKEYLOGFILE', if the feature is available (Python 3.8+). Skip empty values.\n if hasattr(context, \"keylog_filename\"):\n sslkeylogfile = os.environ.get(\"SSLKEYLOGFILE\")\n if sslkeylogfile:\n context.keylog_filename = sslkeylogfile\n\n return context\n\n\ndef ssl_wrap_socket(\n sock,\n keyfile=None,\n certfile=None,\n cert_reqs=None,\n ca_certs=None,\n server_hostname=None,\n ssl_version=None,\n ciphers=None,\n ssl_context=None,\n ca_cert_dir=None,\n key_password=None,\n ca_cert_data=None,\n tls_in_tls=False,\n):\n \"\"\"\n All arguments except for server_hostname, ssl_context, and ca_cert_dir have\n the same meaning as they do when using :func:`ssl.wrap_socket`.\n\n :param server_hostname:\n When SNI is supported, the expected hostname of the certificate\n :param ssl_context:\n A pre-made :class:`SSLContext` object. If none is provided, one will\n be created using :func:`create_urllib3_context`.\n :param ciphers:\n A string of ciphers we wish the client to support.\n :param ca_cert_dir:\n A directory containing CA certificates in multiple separate files, as\n supported by OpenSSL's -CApath flag or the capath argument to\n SSLContext.load_verify_locations().\n :param key_password:\n Optional password if the keyfile is encrypted.\n :param ca_cert_data:\n Optional string containing CA certificates in PEM format suitable for\n passing as the cadata parameter to SSLContext.load_verify_locations()\n :param tls_in_tls:\n Use SSLTransport to wrap the existing socket.\n \"\"\"\n context = ssl_context\n if context is None:\n # Note: This branch of code and all the variables in it are no longer\n # used by urllib3 itself. We should consider deprecating and removing\n # this code.\n context = create_urllib3_context(ssl_version, cert_reqs, ciphers=ciphers)\n\n if ca_certs or ca_cert_dir or ca_cert_data:\n try:\n context.load_verify_locations(ca_certs, ca_cert_dir, ca_cert_data)\n except (IOError, OSError) as e:\n raise SSLError(e)\n\n elif ssl_context is None and hasattr(context, \"load_default_certs\"):\n # try to load OS default certs; works well on Windows (require Python3.4+)\n context.load_default_certs()\n\n # Attempt to detect if we get the goofy behavior of the\n # keyfile being encrypted and OpenSSL asking for the\n # passphrase via the terminal and instead error out.\n if keyfile and key_password is None and _is_key_file_encrypted(keyfile):\n raise SSLError(\"Client private key is encrypted, password is required\")\n\n if certfile:\n if key_password is None:\n context.load_cert_chain(certfile, keyfile)\n else:\n context.load_cert_chain(certfile, keyfile, key_password)\n\n try:\n if hasattr(context, \"set_alpn_protocols\"):\n context.set_alpn_protocols(ALPN_PROTOCOLS)\n except NotImplementedError: # Defensive: in CI, we always have set_alpn_protocols\n pass\n\n # If we detect server_hostname is an IP address then the SNI\n # extension should not be used according to RFC3546 Section 3.1\n use_sni_hostname = server_hostname and not is_ipaddress(server_hostname)\n # SecureTransport uses server_hostname in certificate verification.\n send_sni = (use_sni_hostname and HAS_SNI) or (\n IS_SECURETRANSPORT and server_hostname\n )\n # Do not warn the user if server_hostname is an invalid SNI hostname.\n if not HAS_SNI and use_sni_hostname:\n warnings.warn(\n \"An HTTPS request has been made, but the SNI (Server Name \"\n \"Indication) extension to TLS is not available on this platform. \"\n \"This may cause the server to present an incorrect TLS \"\n \"certificate, which can cause validation failures. You can upgrade to \"\n \"a newer version of Python to solve this. For more information, see \"\n \"https://urllib3.readthedocs.io/en/1.26.x/advanced-usage.html\"\n \"#ssl-warnings\",\n SNIMissingWarning,\n )\n\n if send_sni:\n ssl_sock = _ssl_wrap_socket_impl(\n sock, context, tls_in_tls, server_hostname=server_hostname\n )\n else:\n ssl_sock = _ssl_wrap_socket_impl(sock, context, tls_in_tls)\n return ssl_sock\n\n\ndef is_ipaddress(hostname):\n \"\"\"Detects whether the hostname given is an IPv4 or IPv6 address.\n Also detects IPv6 addresses with Zone IDs.\n\n :param str hostname: Hostname to examine.\n :return: True if the hostname is an IP address, False otherwise.\n \"\"\"\n if not six.PY2 and isinstance(hostname, bytes):\n # IDN A-label bytes are ASCII compatible.\n hostname = hostname.decode(\"ascii\")\n return bool(IPV4_RE.match(hostname) or BRACELESS_IPV6_ADDRZ_RE.match(hostname))\n\n\ndef _is_key_file_encrypted(key_file):\n \"\"\"Detects if a key file is encrypted or not.\"\"\"\n with open(key_file, \"r\") as f:\n for line in f:\n # Look for Proc-Type: 4,ENCRYPTED\n if \"ENCRYPTED\" in line:\n return True\n\n return False\n\n\ndef _ssl_wrap_socket_impl(sock, ssl_context, tls_in_tls, server_hostname=None):\n if tls_in_tls:\n if not SSLTransport:\n # Import error, ssl is not available.\n raise ProxySchemeUnsupported(\n \"TLS in TLS requires support for the 'ssl' module\"\n )\n\n SSLTransport._validate_ssl_context_for_tls_in_tls(ssl_context)\n return SSLTransport(sock, ssl_context, server_hostname)\n\n if server_hostname:\n return ssl_context.wrap_socket(sock, server_hostname=server_hostname)\n else:\n return ssl_context.wrap_socket(sock)\n",[],[213,919,920,921,1016,1050,1067,1156,1190],"0d1d83f6-67fc-11f0-9ad5-0224a6c84d84","retry.py","0d1d848c-67fc-11f0-9ad5-0224a6c84d84",486,["D",1753299269752],"from __future__ import absolute_import\n\nimport email\nimport logging\nimport re\nimport time\nimport warnings\nfrom collections import namedtuple\nfrom itertools import takewhile\n\nfrom ..exceptions import (\n ConnectTimeoutError,\n InvalidHeader,\n MaxRetryError,\n ProtocolError,\n ProxyError,\n ReadTimeoutError,\n ResponseError,\n)\nfrom ..packages import six\n\nlog = logging.getLogger(__name__)\n\n\n# Data structure for representing the metadata of requests that result in a retry.\nRequestHistory = namedtuple(\n \"RequestHistory\", [\"method\", \"url\", \"error\", \"status\", \"redirect_location\"]\n)\n\n\n# TODO: In v2 we can remove this sentinel and metaclass with deprecated options.\n_Default = object()\n\n\nclass _RetryMeta(type):\n @property\n def DEFAULT_METHOD_WHITELIST(cls):\n warnings.warn(\n \"Using 'Retry.DEFAULT_METHOD_WHITELIST' is deprecated and \"\n \"will be removed in v2.0. Use 'Retry.DEFAULT_ALLOWED_METHODS' instead\",\n DeprecationWarning,\n )\n return cls.DEFAULT_ALLOWED_METHODS\n\n @DEFAULT_METHOD_WHITELIST.setter\n def DEFAULT_METHOD_WHITELIST(cls, value):\n warnings.warn(\n \"Using 'Retry.DEFAULT_METHOD_WHITELIST' is deprecated and \"\n \"will be removed in v2.0. Use 'Retry.DEFAULT_ALLOWED_METHODS' instead\",\n DeprecationWarning,\n )\n cls.DEFAULT_ALLOWED_METHODS = value\n\n @property\n def DEFAULT_REDIRECT_HEADERS_BLACKLIST(cls):\n warnings.warn(\n \"Using 'Retry.DEFAULT_REDIRECT_HEADERS_BLACKLIST' is deprecated and \"\n \"will be removed in v2.0. Use 'Retry.DEFAULT_REMOVE_HEADERS_ON_REDIRECT' instead\",\n DeprecationWarning,\n )\n return cls.DEFAULT_REMOVE_HEADERS_ON_REDIRECT\n\n @DEFAULT_REDIRECT_HEADERS_BLACKLIST.setter\n def DEFAULT_REDIRECT_HEADERS_BLACKLIST(cls, value):\n warnings.warn(\n \"Using 'Retry.DEFAULT_REDIRECT_HEADERS_BLACKLIST' is deprecated and \"\n \"will be removed in v2.0. Use 'Retry.DEFAULT_REMOVE_HEADERS_ON_REDIRECT' instead\",\n DeprecationWarning,\n )\n cls.DEFAULT_REMOVE_HEADERS_ON_REDIRECT = value\n\n @property\n def BACKOFF_MAX(cls):\n warnings.warn(\n \"Using 'Retry.BACKOFF_MAX' is deprecated and \"\n \"will be removed in v2.0. Use 'Retry.DEFAULT_BACKOFF_MAX' instead\",\n DeprecationWarning,\n )\n return cls.DEFAULT_BACKOFF_MAX\n\n @BACKOFF_MAX.setter\n def BACKOFF_MAX(cls, value):\n warnings.warn(\n \"Using 'Retry.BACKOFF_MAX' is deprecated and \"\n \"will be removed in v2.0. Use 'Retry.DEFAULT_BACKOFF_MAX' instead\",\n DeprecationWarning,\n )\n cls.DEFAULT_BACKOFF_MAX = value\n\n\n@six.add_metaclass(_RetryMeta)\nclass Retry(object):\n \"\"\"Retry configuration.\n\n Each retry attempt will create a new Retry object with updated values, so\n they can be safely reused.\n\n Retries can be defined as a default for a pool::\n\n retries = Retry(connect=5, read=2, redirect=5)\n http = PoolManager(retries=retries)\n response = http.request('GET', 'http://example.com/')\n\n Or per-request (which overrides the default for the pool)::\n\n response = http.request('GET', 'http://example.com/', retries=Retry(10))\n\n Retries can be disabled by passing ``False``::\n\n response = http.request('GET', 'http://example.com/', retries=False)\n\n Errors will be wrapped in :class:`~urllib3.exceptions.MaxRetryError` unless\n retries are disabled, in which case the causing exception will be raised.\n\n :param int total:\n Total number of retries to allow. Takes precedence over other counts.\n\n Set to ``None`` to remove this constraint and fall back on other\n counts.\n\n Set to ``0`` to fail on the first retry.\n\n Set to ``False`` to disable and imply ``raise_on_redirect=False``.\n\n :param int connect:\n How many connection-related errors to retry on.\n\n These are errors raised before the request is sent to the remote server,\n which we assume has not triggered the server to process the request.\n\n Set to ``0`` to fail on the first retry of this type.\n\n :param int read:\n How many times to retry on read errors.\n\n These errors are raised after the request was sent to the server, so the\n request may have side-effects.\n\n Set to ``0`` to fail on the first retry of this type.\n\n :param int redirect:\n How many redirects to perform. Limit this to avoid infinite redirect\n loops.\n\n A redirect is a HTTP response with a status code 301, 302, 303, 307 or\n 308.\n\n Set to ``0`` to fail on the first retry of this type.\n\n Set to ``False`` to disable and imply ``raise_on_redirect=False``.\n\n :param int status:\n How many times to retry on bad status codes.\n\n These are retries made on responses, where status code matches\n ``status_forcelist``.\n\n Set to ``0`` to fail on the first retry of this type.\n\n :param int other:\n How many times to retry on other errors.\n\n Other errors are errors that are not connect, read, redirect or status errors.\n These errors might be raised after the request was sent to the server, so the\n request might have side-effects.\n\n Set to ``0`` to fail on the first retry of this type.\n\n If ``total`` is not set, it's a good idea to set this to 0 to account\n for unexpected edge cases and avoid infinite retry loops.\n\n :param iterable allowed_methods:\n Set of uppercased HTTP method verbs that we should retry on.\n\n By default, we only retry on methods which are considered to be\n idempotent (multiple requests with the same parameters end with the\n same state). See :attr:`Retry.DEFAULT_ALLOWED_METHODS`.\n\n Set to a ``False`` value to retry on any verb.\n\n .. warning::\n\n Previously this parameter was named ``method_whitelist``, that\n usage is deprecated in v1.26.0 and will be removed in v2.0.\n\n :param iterable status_forcelist:\n A set of integer HTTP status codes that we should force a retry on.\n A retry is initiated if the request method is in ``allowed_methods``\n and the response status code is in ``status_forcelist``.\n\n By default, this is disabled with ``None``.\n\n :param float backoff_factor:\n A backoff factor to apply between attempts after the second try\n (most errors are resolved immediately by a second try without a\n delay). urllib3 will sleep for::\n\n {backoff factor} * (2 ** ({number of total retries} - 1))\n\n seconds. If the backoff_factor is 0.1, then :func:`.sleep` will sleep\n for [0.0s, 0.2s, 0.4s, ...] between retries. It will never be longer\n than :attr:`Retry.DEFAULT_BACKOFF_MAX`.\n\n By default, backoff is disabled (set to 0).\n\n :param bool raise_on_redirect: Whether, if the number of redirects is\n exhausted, to raise a MaxRetryError, or to return a response with a\n response code in the 3xx range.\n\n :param bool raise_on_status: Similar meaning to ``raise_on_redirect``:\n whether we should raise an exception, or return a response,\n if status falls in ``status_forcelist`` range and retries have\n been exhausted.\n\n :param tuple history: The history of the request encountered during\n each call to :meth:`~Retry.increment`. The list is in the order\n the requests occurred. Each list item is of class :class:`RequestHistory`.\n\n :param bool respect_retry_after_header:\n Whether to respect Retry-After header on status codes defined as\n :attr:`Retry.RETRY_AFTER_STATUS_CODES` or not.\n\n :param iterable remove_headers_on_redirect:\n Sequence of headers to remove from the request when a response\n indicating a redirect is returned before firing off the redirected\n request.\n \"\"\"\n\n #: Default methods to be used for ``allowed_methods``\n DEFAULT_ALLOWED_METHODS = frozenset(\n [\"HEAD\", \"GET\", \"PUT\", \"DELETE\", \"OPTIONS\", \"TRACE\"]\n )\n\n #: Default status codes to be used for ``status_forcelist``\n RETRY_AFTER_STATUS_CODES = frozenset([413, 429, 503])\n\n #: Default headers to be used for ``remove_headers_on_redirect``\n DEFAULT_REMOVE_HEADERS_ON_REDIRECT = frozenset(\n [\"Cookie\", \"Authorization\", \"Proxy-Authorization\"]\n )\n\n #: Maximum backoff time.\n DEFAULT_BACKOFF_MAX = 120\n\n def __init__(\n self,\n total=10,\n connect=None,\n read=None,\n redirect=None,\n status=None,\n other=None,\n allowed_methods=_Default,\n status_forcelist=None,\n backoff_factor=0,\n raise_on_redirect=True,\n raise_on_status=True,\n history=None,\n respect_retry_after_header=True,\n remove_headers_on_redirect=_Default,\n # TODO: Deprecated, remove in v2.0\n method_whitelist=_Default,\n ):\n\n if method_whitelist is not _Default:\n if allowed_methods is not _Default:\n raise ValueError(\n \"Using both 'allowed_methods' and \"\n \"'method_whitelist' together is not allowed. \"\n \"Instead only use 'allowed_methods'\"\n )\n warnings.warn(\n \"Using 'method_whitelist' with Retry is deprecated and \"\n \"will be removed in v2.0. Use 'allowed_methods' instead\",\n DeprecationWarning,\n stacklevel=2,\n )\n allowed_methods = method_whitelist\n if allowed_methods is _Default:\n allowed_methods = self.DEFAULT_ALLOWED_METHODS\n if remove_headers_on_redirect is _Default:\n remove_headers_on_redirect = self.DEFAULT_REMOVE_HEADERS_ON_REDIRECT\n\n self.total = total\n self.connect = connect\n self.read = read\n self.status = status\n self.other = other\n\n if redirect is False or total is False:\n redirect = 0\n raise_on_redirect = False\n\n self.redirect = redirect\n self.status_forcelist = status_forcelist or set()\n self.allowed_methods = allowed_methods\n self.backoff_factor = backoff_factor\n self.raise_on_redirect = raise_on_redirect\n self.raise_on_status = raise_on_status\n self.history = history or tuple()\n self.respect_retry_after_header = respect_retry_after_header\n self.remove_headers_on_redirect = frozenset(\n [h.lower() for h in remove_headers_on_redirect]\n )\n\n def new(self, **kw):\n params = dict(\n total=self.total,\n connect=self.connect,\n read=self.read,\n redirect=self.redirect,\n status=self.status,\n other=self.other,\n status_forcelist=self.status_forcelist,\n backoff_factor=self.backoff_factor,\n raise_on_redirect=self.raise_on_redirect,\n raise_on_status=self.raise_on_status,\n history=self.history,\n remove_headers_on_redirect=self.remove_headers_on_redirect,\n respect_retry_after_header=self.respect_retry_after_header,\n )\n\n # TODO: If already given in **kw we use what's given to us\n # If not given we need to figure out what to pass. We decide\n # based on whether our class has the 'method_whitelist' property\n # and if so we pass the deprecated 'method_whitelist' otherwise\n # we use 'allowed_methods'. Remove in v2.0\n if \"method_whitelist\" not in kw and \"allowed_methods\" not in kw:\n if \"method_whitelist\" in self.__dict__:\n warnings.warn(\n \"Using 'method_whitelist' with Retry is deprecated and \"\n \"will be removed in v2.0. Use 'allowed_methods' instead\",\n DeprecationWarning,\n )\n params[\"method_whitelist\"] = self.allowed_methods\n else:\n params[\"allowed_methods\"] = self.allowed_methods\n\n params.update(kw)\n return type(self)(**params)\n\n @classmethod\n def from_int(cls, retries, redirect=True, default=None):\n \"\"\"Backwards-compatibility for the old retries format.\"\"\"\n if retries is None:\n retries = default if default is not None else cls.DEFAULT\n\n if isinstance(retries, Retry):\n return retries\n\n redirect = bool(redirect) and None\n new_retries = cls(retries, redirect=redirect)\n log.debug(\"Converted retries value: %r -> %r\", retries, new_retries)\n return new_retries\n\n def get_backoff_time(self):\n \"\"\"Formula for computing the current backoff\n\n :rtype: float\n \"\"\"\n # We want to consider only the last consecutive errors sequence (Ignore redirects).\n consecutive_errors_len = len(\n list(\n takewhile(lambda x: x.redirect_location is None, reversed(self.history))\n )\n )\n if consecutive_errors_len <= 1:\n return 0\n\n backoff_value = self.backoff_factor * (2 ** (consecutive_errors_len - 1))\n return min(self.DEFAULT_BACKOFF_MAX, backoff_value)\n\n def parse_retry_after(self, retry_after):\n # Whitespace: https://tools.ietf.org/html/rfc7230#section-3.2.4\n if re.match(r\"^\\s*[0-9]+\\s*$\", retry_after):\n seconds = int(retry_after)\n else:\n retry_date_tuple = email.utils.parsedate_tz(retry_after)\n if retry_date_tuple is None:\n raise InvalidHeader(\"Invalid Retry-After header: %s\" % retry_after)\n if retry_date_tuple[9] is None: # Python 2\n # Assume UTC if no timezone was specified\n # On Python2.7, parsedate_tz returns None for a timezone offset\n # instead of 0 if no timezone is given, where mktime_tz treats\n # a None timezone offset as local time.\n retry_date_tuple = retry_date_tuple[:9] + (0,) + retry_date_tuple[10:]\n\n retry_date = email.utils.mktime_tz(retry_date_tuple)\n seconds = retry_date - time.time()\n\n if seconds < 0:\n seconds = 0\n\n return seconds\n\n def get_retry_after(self, response):\n \"\"\"Get the value of Retry-After in seconds.\"\"\"\n\n retry_after = response.headers.get(\"Retry-After\")\n\n if retry_after is None:\n return None\n\n return self.parse_retry_after(retry_after)\n\n def sleep_for_retry(self, response=None):\n retry_after = self.get_retry_after(response)\n if retry_after:\n time.sleep(retry_after)\n return True\n\n return False\n\n def _sleep_backoff(self):\n backoff = self.get_backoff_time()\n if backoff <= 0:\n return\n time.sleep(backoff)\n\n def sleep(self, response=None):\n \"\"\"Sleep between retry attempts.\n\n This method will respect a server's ``Retry-After`` response header\n and sleep the duration of the time requested. If that is not present, it\n will use an exponential backoff. By default, the backoff factor is 0 and\n this method will return immediately.\n \"\"\"\n\n if self.respect_retry_after_header and response:\n slept = self.sleep_for_retry(response)\n if slept:\n return\n\n self._sleep_backoff()\n\n def _is_connection_error(self, err):\n \"\"\"Errors when we're fairly sure that the server did not receive the\n request, so it should be safe to retry.\n \"\"\"\n if isinstance(err, ProxyError):\n err = err.original_error\n return isinstance(err, ConnectTimeoutError)\n\n def _is_read_error(self, err):\n \"\"\"Errors that occur after the request has been started, so we should\n assume that the server began processing it.\n \"\"\"\n return isinstance(err, (ReadTimeoutError, ProtocolError))\n\n def _is_method_retryable(self, method):\n \"\"\"Checks if a given HTTP method should be retried upon, depending if\n it is included in the allowed_methods\n \"\"\"\n # TODO: For now favor if the Retry implementation sets its own method_whitelist\n # property outside of our constructor to avoid breaking custom implementations.\n if \"method_whitelist\" in self.__dict__:\n warnings.warn(\n \"Using 'method_whitelist' with Retry is deprecated and \"\n \"will be removed in v2.0. Use 'allowed_methods' instead\",\n DeprecationWarning,\n )\n allowed_methods = self.method_whitelist\n else:\n allowed_methods = self.allowed_methods\n\n if allowed_methods and method.upper() not in allowed_methods:\n return False\n return True\n\n def is_retry(self, method, status_code, has_retry_after=False):\n \"\"\"Is this method/status code retryable? (Based on allowlists and control\n variables such as the number of total retries to allow, whether to\n respect the Retry-After header, whether this header is present, and\n whether the returned status code is on the list of status codes to\n be retried upon on the presence of the aforementioned header)\n \"\"\"\n if not self._is_method_retryable(method):\n return False\n\n if self.status_forcelist and status_code in self.status_forcelist:\n return True\n\n return (\n self.total\n and self.respect_retry_after_header\n and has_retry_after\n and (status_code in self.RETRY_AFTER_STATUS_CODES)\n )\n\n def is_exhausted(self):\n \"\"\"Are we out of retries?\"\"\"\n retry_counts = (\n self.total,\n self.connect,\n self.read,\n self.redirect,\n self.status,\n self.other,\n )\n retry_counts = list(filter(None, retry_counts))\n if not retry_counts:\n return False\n\n return min(retry_counts) < 0\n\n def increment(\n self,\n method=None,\n url=None,\n response=None,\n error=None,\n _pool=None,\n _stacktrace=None,\n ):\n \"\"\"Return a new Retry object with incremented retry counters.\n\n :param response: A response object, or None, if the server did not\n return a response.\n :type response: :class:`~urllib3.response.HTTPResponse`\n :param Exception error: An error encountered during the request, or\n None if the response was received successfully.\n\n :return: A new ``Retry`` object.\n \"\"\"\n if self.total is False and error:\n # Disabled, indicate to re-raise the error.\n raise six.reraise(type(error), error, _stacktrace)\n\n total = self.total\n if total is not None:\n total -= 1\n\n connect = self.connect\n read = self.read\n redirect = self.redirect\n status_count = self.status\n other = self.other\n cause = \"unknown\"\n status = None\n redirect_location = None\n\n if error and self._is_connection_error(error):\n # Connect retry?\n if connect is False:\n raise six.reraise(type(error), error, _stacktrace)\n elif connect is not None:\n connect -= 1\n\n elif error and self._is_read_error(error):\n # Read retry?\n if read is False or not self._is_method_retryable(method):\n raise six.reraise(type(error), error, _stacktrace)\n elif read is not None:\n read -= 1\n\n elif error:\n # Other retry?\n if other is not None:\n other -= 1\n\n elif response and response.get_redirect_location():\n # Redirect retry?\n if redirect is not None:\n redirect -= 1\n cause = \"too many redirects\"\n redirect_location = response.get_redirect_location()\n status = response.status\n\n else:\n # Incrementing because of a server error like a 500 in\n # status_forcelist and the given method is in the allowed_methods\n cause = ResponseError.GENERIC_ERROR\n if response and response.status:\n if status_count is not None:\n status_count -= 1\n cause = ResponseError.SPECIFIC_ERROR.format(status_code=response.status)\n status = response.status\n\n history = self.history + (\n RequestHistory(method, url, error, status, redirect_location),\n )\n\n new_retry = self.new(\n total=total,\n connect=connect,\n read=read,\n redirect=redirect,\n status=status_count,\n other=other,\n history=history,\n )\n\n if new_retry.is_exhausted():\n raise MaxRetryError(_pool, url, error or ResponseError(cause))\n\n log.debug(\"Incremented Retry for (url='%s'): %r\", url, new_retry)\n\n return new_retry\n\n def __repr__(self):\n return (\n \"{cls.__name__}(total={self.total}, connect={self.connect}, \"\n \"read={self.read}, redirect={self.redirect}, status={self.status})\"\n ).format(cls=type(self), self=self)\n\n def __getattr__(self, item):\n if item == \"method_whitelist\":\n # TODO: Remove this deprecated alias in v2.0\n warnings.warn(\n \"Using 'method_whitelist' with Retry is deprecated and \"\n \"will be removed in v2.0. Use 'allowed_methods' instead\",\n DeprecationWarning,\n )\n return self.allowed_methods\n try:\n return getattr(super(Retry, self), item)\n except AttributeError:\n return getattr(Retry, item)\n\n\n# For backwards compatibility (equivalent to pre-v1.9):\nRetry.DEFAULT = Retry(3)\n",[],[213,919,920,921,1016,1050,1067,1156,1198],"0d10e7e0-67fc-11f0-aedf-0224a6c84d84","0d10e88a-67fc-11f0-aedf-0224a6c84d84",484,["D",1753299269705],"from __future__ import absolute_import\n\nfrom email.errors import MultipartInvariantViolationDefect, StartBoundaryNotFoundDefect\n\nfrom ..exceptions import HeaderParsingError\nfrom ..packages.six.moves import http_client as httplib\n\n\ndef is_fp_closed(obj):\n \"\"\"\n Checks whether a given file-like object is closed.\n\n :param obj:\n The file-like object to check.\n \"\"\"\n\n try:\n # Check `isclosed()` first, in case Python3 doesn't set `closed`.\n # GH Issue #928\n return obj.isclosed()\n except AttributeError:\n pass\n\n try:\n # Check via the official file-like-object way.\n return obj.closed\n except AttributeError:\n pass\n\n try:\n # Check if the object is a container for another file-like object that\n # gets released on exhaustion (e.g. HTTPResponse).\n return obj.fp is None\n except AttributeError:\n pass\n\n raise ValueError(\"Unable to determine whether fp is closed.\")\n\n\ndef assert_header_parsing(headers):\n \"\"\"\n Asserts whether all headers have been successfully parsed.\n Extracts encountered errors from the result of parsing headers.\n\n Only works on Python 3.\n\n :param http.client.HTTPMessage headers: Headers to verify.\n\n :raises urllib3.exceptions.HeaderParsingError:\n If parsing errors are found.\n \"\"\"\n\n # This will fail silently if we pass in the wrong kind of parameter.\n # To make debugging easier add an explicit check.\n if not isinstance(headers, httplib.HTTPMessage):\n raise TypeError(\"expected httplib.Message, got {0}.\".format(type(headers)))\n\n defects = getattr(headers, \"defects\", None)\n get_payload = getattr(headers, \"get_payload\", None)\n\n unparsed_data = None\n if get_payload:\n # get_payload is actually email.message.Message.get_payload;\n # we're only interested in the result if it's not a multipart message\n if not headers.is_multipart():\n payload = get_payload()\n\n if isinstance(payload, (bytes, str)):\n unparsed_data = payload\n if defects:\n # httplib is assuming a response body is available\n # when parsing headers even when httplib only sends\n # header data to parse_headers() This results in\n # defects on multipart responses in particular.\n # See: https://github.com/urllib3/urllib3/issues/800\n\n # So we ignore the following defects:\n # - StartBoundaryNotFoundDefect:\n # The claimed start boundary was never found.\n # - MultipartInvariantViolationDefect:\n # A message claimed to be a multipart but no subparts were found.\n defects = [\n defect\n for defect in defects\n if not isinstance(\n defect, (StartBoundaryNotFoundDefect, MultipartInvariantViolationDefect)\n )\n ]\n\n if defects or unparsed_data:\n raise HeaderParsingError(defects=defects, unparsed_data=unparsed_data)\n\n\ndef is_response_to_head(response):\n \"\"\"\n Checks whether the request of a response has been a HEAD-request.\n Handles the quirks of AppEngine.\n\n :param http.client.HTTPResponse response:\n Response to check if the originating request\n used 'HEAD' as a method.\n \"\"\"\n # FIXME: Can we do this somehow without accessing private httplib _method?\n method = response._method\n if isinstance(method, int): # Platform-specific: Appengine\n return method == 3\n return method.upper() == \"HEAD\"\n",[],[213,919,920,921,1016,1050,1067,1156,1059],"0cfd7c00-67fc-11f0-a7d9-0224a6c84d84","0cfd7cb4-67fc-11f0-a7d9-0224a6c84d84",481,["D",1753299269577],"from __future__ import absolute_import\n\nfrom base64 import b64encode\n\nfrom ..exceptions import UnrewindableBodyError\nfrom ..packages.six import b, integer_types\n\n# Pass as a value within ``headers`` to skip\n# emitting some HTTP headers that are added automatically.\n# The only headers that are supported are ``Accept-Encoding``,\n# ``Host``, and ``User-Agent``.\nSKIP_HEADER = \"@@@SKIP_HEADER@@@\"\nSKIPPABLE_HEADERS = frozenset([\"accept-encoding\", \"host\", \"user-agent\"])\n\nACCEPT_ENCODING = \"gzip,deflate\"\n\n_FAILEDTELL = object()\n\n\ndef make_headers(\n keep_alive=None,\n accept_encoding=None,\n user_agent=None,\n basic_auth=None,\n proxy_basic_auth=None,\n disable_cache=None,\n):\n \"\"\"\n Shortcuts for generating request headers.\n\n :param keep_alive:\n If ``True``, adds 'connection: keep-alive' header.\n\n :param accept_encoding:\n Can be a boolean, list, or string.\n ``True`` translates to 'gzip,deflate'.\n List will get joined by comma.\n String will be used as provided.\n\n :param user_agent:\n String representing the user-agent you want, such as\n \"python-urllib3/0.6\"\n\n :param basic_auth:\n Colon-separated username:password string for 'authorization: basic ...'\n auth header.\n\n :param proxy_basic_auth:\n Colon-separated username:password string for 'proxy-authorization: basic ...'\n auth header.\n\n :param disable_cache:\n If ``True``, adds 'cache-control: no-cache' header.\n\n Example::\n\n >>> make_headers(keep_alive=True, user_agent=\"Batman/1.0\")\n {'connection': 'keep-alive', 'user-agent': 'Batman/1.0'}\n >>> make_headers(accept_encoding=True)\n {'accept-encoding': 'gzip,deflate'}\n \"\"\"\n headers = {}\n if accept_encoding:\n if isinstance(accept_encoding, str):\n pass\n elif isinstance(accept_encoding, list):\n accept_encoding = \",\".join(accept_encoding)\n else:\n accept_encoding = ACCEPT_ENCODING\n headers[\"accept-encoding\"] = accept_encoding\n\n if user_agent:\n headers[\"user-agent\"] = user_agent\n\n if keep_alive:\n headers[\"connection\"] = \"keep-alive\"\n\n if basic_auth:\n headers[\"authorization\"] = \"Basic \" + b64encode(b(basic_auth)).decode(\"utf-8\")\n\n if proxy_basic_auth:\n headers[\"proxy-authorization\"] = \"Basic \" + b64encode(\n b(proxy_basic_auth)\n ).decode(\"utf-8\")\n\n if disable_cache:\n headers[\"cache-control\"] = \"no-cache\"\n\n return headers\n\n\ndef set_file_position(body, pos):\n \"\"\"\n If a position is provided, move file to that point.\n Otherwise, we'll attempt to record a position for future use.\n \"\"\"\n if pos is not None:\n rewind_body(body, pos)\n elif getattr(body, \"tell\", None) is not None:\n try:\n pos = body.tell()\n except (IOError, OSError):\n # This differentiates from None, allowing us to catch\n # a failed `tell()` later when trying to rewind the body.\n pos = _FAILEDTELL\n\n return pos\n\n\ndef rewind_body(body, body_pos):\n \"\"\"\n Attempt to rewind body to a certain position.\n Primarily used for request redirects and retries.\n\n :param body:\n File-like object that supports seek.\n\n :param int pos:\n Position to seek to in file.\n \"\"\"\n body_seek = getattr(body, \"seek\", None)\n if body_seek is not None and isinstance(body_pos, integer_types):\n try:\n body_seek(body_pos)\n except (IOError, OSError):\n raise UnrewindableBodyError(\n \"An error occurred when rewinding request body for redirect/retry.\"\n )\n elif body_pos is _FAILEDTELL:\n raise UnrewindableBodyError(\n \"Unable to record file position for rewinding \"\n \"request body during a redirect/retry.\"\n )\n else:\n raise ValueError(\n \"body_pos must be of type integer, instead it was %s.\" % type(body_pos)\n )\n",[],[213,919,920,921,1016,1050,1067,1156,1069],"0ce963d2-67fc-11f0-8a1c-0224a6c84d84","queue.py","0ce96486-67fc-11f0-8a1c-0224a6c84d84",477,["D",1753299269444],"import collections\n\nfrom ..packages import six\nfrom ..packages.six.moves import queue\n\nif six.PY2:\n # Queue is imported for side effects on MS Windows. See issue #229.\n import Queue as _unused_module_Queue # noqa: F401\n\n\nclass LifoQueue(queue.Queue):\n def _init(self, _):\n self.queue = collections.deque()\n\n def _qsize(self, len=len):\n return len(self.queue)\n\n def _put(self, item):\n self.queue.append(item)\n\n def _get(self):\n return self.queue.pop()\n",[],[213,919,920,921,1016,1050,1067,1156,1220],"0cf2889a-67fc-11f0-a29b-0224a6c84d84","proxy.py","0cf2894e-67fc-11f0-a29b-0224a6c84d84",479,["D",1753299269503],"from .ssl_ import create_urllib3_context, resolve_cert_reqs, resolve_ssl_version\n\n\ndef connection_requires_http_tunnel(\n proxy_url=None, proxy_config=None, destination_scheme=None\n):\n \"\"\"\n Returns True if the connection requires an HTTP CONNECT through the proxy.\n\n :param URL proxy_url:\n URL of the proxy.\n :param ProxyConfig proxy_config:\n Proxy configuration from poolmanager.py\n :param str destination_scheme:\n The scheme of the destination. (i.e https, http, etc)\n \"\"\"\n # If we're not using a proxy, no way to use a tunnel.\n if proxy_url is None:\n return False\n\n # HTTP destinations never require tunneling, we always forward.\n if destination_scheme == \"http\":\n return False\n\n # Support for forwarding with HTTPS proxies and HTTPS destinations.\n if (\n proxy_url.scheme == \"https\"\n and proxy_config\n and proxy_config.use_forwarding_for_https\n ):\n return False\n\n # Otherwise always use a tunnel.\n return True\n\n\ndef create_proxy_ssl_context(\n ssl_version, cert_reqs, ca_certs=None, ca_cert_dir=None, ca_cert_data=None\n):\n \"\"\"\n Generates a default proxy ssl context if one hasn't been provided by the\n user.\n \"\"\"\n ssl_context = create_urllib3_context(\n ssl_version=resolve_ssl_version(ssl_version),\n cert_reqs=resolve_cert_reqs(cert_reqs),\n )\n\n if (\n not ca_certs\n and not ca_cert_dir\n and not ca_cert_data\n and hasattr(ssl_context, \"load_default_certs\")\n ):\n ssl_context.load_default_certs()\n\n return ssl_context\n",[],[213,919,920,921,1016,1050,1067,1156,1228],"0d261458-67fc-11f0-a29b-0224a6c84d84","0d261520-67fc-11f0-a29b-0224a6c84d84",488,["D",1753299269842],"from __future__ import absolute_import\n\nimport socket\n\nfrom ..contrib import _appengine_environ\nfrom ..exceptions import LocationParseError\nfrom ..packages import six\nfrom .wait import NoWayToWaitForSocketError, wait_for_read\n\n\ndef is_connection_dropped(conn): # Platform-specific\n \"\"\"\n Returns True if the connection is dropped and should be closed.\n\n :param conn:\n :class:`http.client.HTTPConnection` object.\n\n Note: For platforms like AppEngine, this will always return ``False`` to\n let the platform handle connection recycling transparently for us.\n \"\"\"\n sock = getattr(conn, \"sock\", False)\n if sock is False: # Platform-specific: AppEngine\n return False\n if sock is None: # Connection already closed (such as by httplib).\n return True\n try:\n # Returns True if readable, which here means it's been dropped\n return wait_for_read(sock, timeout=0.0)\n except NoWayToWaitForSocketError: # Platform-specific: AppEngine\n return False\n\n\n# This function is copied from socket.py in the Python 2.7 standard\n# library test suite. Added to its signature is only `socket_options`.\n# One additional modification is that we avoid binding to IPv6 servers\n# discovered in DNS if the system doesn't have IPv6 functionality.\ndef create_connection(\n address,\n timeout=socket._GLOBAL_DEFAULT_TIMEOUT,\n source_address=None,\n socket_options=None,\n):\n \"\"\"Connect to *address* and return the socket object.\n\n Convenience function. Connect to *address* (a 2-tuple ``(host,\n port)``) and return the socket object. Passing the optional\n *timeout* parameter will set the timeout on the socket instance\n before attempting to connect. If no *timeout* is supplied, the\n global default timeout setting returned by :func:`socket.getdefaulttimeout`\n is used. If *source_address* is set it must be a tuple of (host, port)\n for the socket to bind as a source address before making the connection.\n An host of '' or port 0 tells the OS to use the default.\n \"\"\"\n\n host, port = address\n if host.startswith(\"[\"):\n host = host.strip(\"[]\")\n err = None\n\n # Using the value from allowed_gai_family() in the context of getaddrinfo lets\n # us select whether to work with IPv4 DNS records, IPv6 records, or both.\n # The original create_connection function always returns all records.\n family = allowed_gai_family()\n\n try:\n host.encode(\"idna\")\n except UnicodeError:\n return six.raise_from(\n LocationParseError(u\"'%s', label empty or too long\" % host), None\n )\n\n for res in socket.getaddrinfo(host, port, family, socket.SOCK_STREAM):\n af, socktype, proto, canonname, sa = res\n sock = None\n try:\n sock = socket.socket(af, socktype, proto)\n\n # If provided, set socket level options before connecting.\n _set_socket_options(sock, socket_options)\n\n if timeout is not socket._GLOBAL_DEFAULT_TIMEOUT:\n sock.settimeout(timeout)\n if source_address:\n sock.bind(source_address)\n sock.connect(sa)\n return sock\n\n except socket.error as e:\n err = e\n if sock is not None:\n sock.close()\n sock = None\n\n if err is not None:\n raise err\n\n raise socket.error(\"getaddrinfo returns an empty list\")\n\n\ndef _set_socket_options(sock, options):\n if options is None:\n return\n\n for opt in options:\n sock.setsockopt(*opt)\n\n\ndef allowed_gai_family():\n \"\"\"This function is designed to work in the context of\n getaddrinfo, where family=socket.AF_UNSPEC is the default and\n will perform a DNS search for both IPv6 and IPv4 records.\"\"\"\n\n family = socket.AF_INET\n if HAS_IPV6:\n family = socket.AF_UNSPEC\n return family\n\n\ndef _has_ipv6(host):\n \"\"\"Returns True if the system can bind an IPv6 address.\"\"\"\n sock = None\n has_ipv6 = False\n\n # App Engine doesn't support IPV6 sockets and actually has a quota on the\n # number of sockets that can be used, so just early out here instead of\n # creating a socket needlessly.\n # See https://github.com/urllib3/urllib3/issues/1446\n if _appengine_environ.is_appengine_sandbox():\n return False\n\n if socket.has_ipv6:\n # has_ipv6 returns true if cPython was compiled with IPv6 support.\n # It does not tell us if the system has IPv6 support enabled. To\n # determine that we must bind to an IPv6 address.\n # https://github.com/urllib3/urllib3/pull/611\n # https://bugs.python.org/issue658327\n try:\n sock = socket.socket(socket.AF_INET6)\n sock.bind((host, 0))\n has_ipv6 = True\n except Exception:\n pass\n\n if sock:\n sock.close()\n return has_ipv6\n\n\nHAS_IPV6 = _has_ipv6(\"::1\")\n",[],[213,919,920,921,1016,1050,1067,1156,1117],"0d09a0ca-67fc-11f0-9454-0224a6c84d84","0d09a19c-67fc-11f0-9454-0224a6c84d84",483,["D",1753299269654],"from __future__ import absolute_import\n\n# For backwards compatibility, provide imports that used to be here.\nfrom .connection import is_connection_dropped\nfrom .request import SKIP_HEADER, SKIPPABLE_HEADERS, make_headers\nfrom .response import is_fp_closed\nfrom .retry import Retry\nfrom .ssl_ import (\n ALPN_PROTOCOLS,\n HAS_SNI,\n IS_PYOPENSSL,\n IS_SECURETRANSPORT,\n PROTOCOL_TLS,\n SSLContext,\n assert_fingerprint,\n resolve_cert_reqs,\n resolve_ssl_version,\n ssl_wrap_socket,\n)\nfrom .timeout import Timeout, current_time\nfrom .url import Url, get_host, parse_url, split_first\nfrom .wait import wait_for_read, wait_for_write\n\n__all__ = (\n \"HAS_SNI\",\n \"IS_PYOPENSSL\",\n \"IS_SECURETRANSPORT\",\n \"SSLContext\",\n \"PROTOCOL_TLS\",\n \"ALPN_PROTOCOLS\",\n \"Retry\",\n \"Timeout\",\n \"Url\",\n \"assert_fingerprint\",\n \"current_time\",\n \"is_connection_dropped\",\n \"is_fp_closed\",\n \"get_host\",\n \"parse_url\",\n \"make_headers\",\n \"resolve_cert_reqs\",\n \"resolve_ssl_version\",\n \"split_first\",\n \"ssl_wrap_socket\",\n \"wait_for_read\",\n \"wait_for_write\",\n \"SKIP_HEADER\",\n \"SKIPPABLE_HEADERS\",\n)\n",[],[213,919,920,921,1016,1050,1067,1156,1034],"031d8c02-67fc-11f0-b800-0224a6c84d84",101,["D",1753299253008],[702,703,704,705,706,707,708,709,710,711,712,713,714],[213,919,920,921,1016,1050,1067,1156],"0dac43d4-67fc-11f0-9454-0224a6c84d84","six.py","0dac447e-67fc-11f0-9454-0224a6c84d84","0353664c-67fc-11f0-b654-0224a6c84d84",507,["D",1753299270647],"# Copyright (c) 2010-2020 Benjamin Peterson\n#\n# Permission is hereby granted, free of charge, to any person obtaining a copy\n# of this software and associated documentation files (the \"Software\"), to deal\n# in the Software without restriction, including without limitation the rights\n# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n# copies of the Software, and to permit persons to whom the Software is\n# furnished to do so, subject to the following conditions:\n#\n# The above copyright notice and this permission notice shall be included in all\n# copies or substantial portions of the Software.\n#\n# THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n# SOFTWARE.\n\n\"\"\"Utilities for writing code that runs on Python 2 and 3\"\"\"\n\nfrom __future__ import absolute_import\n\nimport functools\nimport itertools\nimport operator\nimport sys\nimport types\n\n__author__ = \"Benjamin Peterson \"\n__version__ = \"1.16.0\"\n\n\n# Useful for very coarse version differentiation.\nPY2 = sys.version_info[0] == 2\nPY3 = sys.version_info[0] == 3\nPY34 = sys.version_info[0:2] >= (3, 4)\n\nif PY3:\n string_types = (str,)\n integer_types = (int,)\n class_types = (type,)\n text_type = str\n binary_type = bytes\n\n MAXSIZE = sys.maxsize\nelse:\n string_types = (basestring,)\n integer_types = (int, long)\n class_types = (type, types.ClassType)\n text_type = unicode\n binary_type = str\n\n if sys.platform.startswith(\"java\"):\n # Jython always uses 32 bits.\n MAXSIZE = int((1 << 31) - 1)\n else:\n # It's possible to have sizeof(long) != sizeof(Py_ssize_t).\n class X(object):\n def __len__(self):\n return 1 << 31\n\n try:\n len(X())\n except OverflowError:\n # 32-bit\n MAXSIZE = int((1 << 31) - 1)\n else:\n # 64-bit\n MAXSIZE = int((1 << 63) - 1)\n del X\n\nif PY34:\n from importlib.util import spec_from_loader\nelse:\n spec_from_loader = None\n\n\ndef _add_doc(func, doc):\n \"\"\"Add documentation to a function.\"\"\"\n func.__doc__ = doc\n\n\ndef _import_module(name):\n \"\"\"Import module, returning the module after the last dot.\"\"\"\n __import__(name)\n return sys.modules[name]\n\n\nclass _LazyDescr(object):\n def __init__(self, name):\n self.name = name\n\n def __get__(self, obj, tp):\n result = self._resolve()\n setattr(obj, self.name, result) # Invokes __set__.\n try:\n # This is a bit ugly, but it avoids running this again by\n # removing this descriptor.\n delattr(obj.__class__, self.name)\n except AttributeError:\n pass\n return result\n\n\nclass MovedModule(_LazyDescr):\n def __init__(self, name, old, new=None):\n super(MovedModule, self).__init__(name)\n if PY3:\n if new is None:\n new = name\n self.mod = new\n else:\n self.mod = old\n\n def _resolve(self):\n return _import_module(self.mod)\n\n def __getattr__(self, attr):\n _module = self._resolve()\n value = getattr(_module, attr)\n setattr(self, attr, value)\n return value\n\n\nclass _LazyModule(types.ModuleType):\n def __init__(self, name):\n super(_LazyModule, self).__init__(name)\n self.__doc__ = self.__class__.__doc__\n\n def __dir__(self):\n attrs = [\"__doc__\", \"__name__\"]\n attrs += [attr.name for attr in self._moved_attributes]\n return attrs\n\n # Subclasses should override this\n _moved_attributes = []\n\n\nclass MovedAttribute(_LazyDescr):\n def __init__(self, name, old_mod, new_mod, old_attr=None, new_attr=None):\n super(MovedAttribute, self).__init__(name)\n if PY3:\n if new_mod is None:\n new_mod = name\n self.mod = new_mod\n if new_attr is None:\n if old_attr is None:\n new_attr = name\n else:\n new_attr = old_attr\n self.attr = new_attr\n else:\n self.mod = old_mod\n if old_attr is None:\n old_attr = name\n self.attr = old_attr\n\n def _resolve(self):\n module = _import_module(self.mod)\n return getattr(module, self.attr)\n\n\nclass _SixMetaPathImporter(object):\n\n \"\"\"\n A meta path importer to import six.moves and its submodules.\n\n This class implements a PEP302 finder and loader. It should be compatible\n with Python 2.5 and all existing versions of Python3\n \"\"\"\n\n def __init__(self, six_module_name):\n self.name = six_module_name\n self.known_modules = {}\n\n def _add_module(self, mod, *fullnames):\n for fullname in fullnames:\n self.known_modules[self.name + \".\" + fullname] = mod\n\n def _get_module(self, fullname):\n return self.known_modules[self.name + \".\" + fullname]\n\n def find_module(self, fullname, path=None):\n if fullname in self.known_modules:\n return self\n return None\n\n def find_spec(self, fullname, path, target=None):\n if fullname in self.known_modules:\n return spec_from_loader(fullname, self)\n return None\n\n def __get_module(self, fullname):\n try:\n return self.known_modules[fullname]\n except KeyError:\n raise ImportError(\"This loader does not know module \" + fullname)\n\n def load_module(self, fullname):\n try:\n # in case of a reload\n return sys.modules[fullname]\n except KeyError:\n pass\n mod = self.__get_module(fullname)\n if isinstance(mod, MovedModule):\n mod = mod._resolve()\n else:\n mod.__loader__ = self\n sys.modules[fullname] = mod\n return mod\n\n def is_package(self, fullname):\n \"\"\"\n Return true, if the named module is a package.\n\n We need this method to get correct spec objects with\n Python 3.4 (see PEP451)\n \"\"\"\n return hasattr(self.__get_module(fullname), \"__path__\")\n\n def get_code(self, fullname):\n \"\"\"Return None\n\n Required, if is_package is implemented\"\"\"\n self.__get_module(fullname) # eventually raises ImportError\n return None\n\n get_source = get_code # same as get_code\n\n def create_module(self, spec):\n return self.load_module(spec.name)\n\n def exec_module(self, module):\n pass\n\n\n_importer = _SixMetaPathImporter(__name__)\n\n\nclass _MovedItems(_LazyModule):\n\n \"\"\"Lazy loading of moved objects\"\"\"\n\n __path__ = [] # mark as package\n\n\n_moved_attributes = [\n MovedAttribute(\"cStringIO\", \"cStringIO\", \"io\", \"StringIO\"),\n MovedAttribute(\"filter\", \"itertools\", \"builtins\", \"ifilter\", \"filter\"),\n MovedAttribute(\n \"filterfalse\", \"itertools\", \"itertools\", \"ifilterfalse\", \"filterfalse\"\n ),\n MovedAttribute(\"input\", \"__builtin__\", \"builtins\", \"raw_input\", \"input\"),\n MovedAttribute(\"intern\", \"__builtin__\", \"sys\"),\n MovedAttribute(\"map\", \"itertools\", \"builtins\", \"imap\", \"map\"),\n MovedAttribute(\"getcwd\", \"os\", \"os\", \"getcwdu\", \"getcwd\"),\n MovedAttribute(\"getcwdb\", \"os\", \"os\", \"getcwd\", \"getcwdb\"),\n MovedAttribute(\"getoutput\", \"commands\", \"subprocess\"),\n MovedAttribute(\"range\", \"__builtin__\", \"builtins\", \"xrange\", \"range\"),\n MovedAttribute(\n \"reload_module\", \"__builtin__\", \"importlib\" if PY34 else \"imp\", \"reload\"\n ),\n MovedAttribute(\"reduce\", \"__builtin__\", \"functools\"),\n MovedAttribute(\"shlex_quote\", \"pipes\", \"shlex\", \"quote\"),\n MovedAttribute(\"StringIO\", \"StringIO\", \"io\"),\n MovedAttribute(\"UserDict\", \"UserDict\", \"collections\"),\n MovedAttribute(\"UserList\", \"UserList\", \"collections\"),\n MovedAttribute(\"UserString\", \"UserString\", \"collections\"),\n MovedAttribute(\"xrange\", \"__builtin__\", \"builtins\", \"xrange\", \"range\"),\n MovedAttribute(\"zip\", \"itertools\", \"builtins\", \"izip\", \"zip\"),\n MovedAttribute(\n \"zip_longest\", \"itertools\", \"itertools\", \"izip_longest\", \"zip_longest\"\n ),\n MovedModule(\"builtins\", \"__builtin__\"),\n MovedModule(\"configparser\", \"ConfigParser\"),\n MovedModule(\n \"collections_abc\",\n \"collections\",\n \"collections.abc\" if sys.version_info >= (3, 3) else \"collections\",\n ),\n MovedModule(\"copyreg\", \"copy_reg\"),\n MovedModule(\"dbm_gnu\", \"gdbm\", \"dbm.gnu\"),\n MovedModule(\"dbm_ndbm\", \"dbm\", \"dbm.ndbm\"),\n MovedModule(\n \"_dummy_thread\",\n \"dummy_thread\",\n \"_dummy_thread\" if sys.version_info < (3, 9) else \"_thread\",\n ),\n MovedModule(\"http_cookiejar\", \"cookielib\", \"http.cookiejar\"),\n MovedModule(\"http_cookies\", \"Cookie\", \"http.cookies\"),\n MovedModule(\"html_entities\", \"htmlentitydefs\", \"html.entities\"),\n MovedModule(\"html_parser\", \"HTMLParser\", \"html.parser\"),\n MovedModule(\"http_client\", \"httplib\", \"http.client\"),\n MovedModule(\"email_mime_base\", \"email.MIMEBase\", \"email.mime.base\"),\n MovedModule(\"email_mime_image\", \"email.MIMEImage\", \"email.mime.image\"),\n MovedModule(\"email_mime_multipart\", \"email.MIMEMultipart\", \"email.mime.multipart\"),\n MovedModule(\n \"email_mime_nonmultipart\", \"email.MIMENonMultipart\", \"email.mime.nonmultipart\"\n ),\n MovedModule(\"email_mime_text\", \"email.MIMEText\", \"email.mime.text\"),\n MovedModule(\"BaseHTTPServer\", \"BaseHTTPServer\", \"http.server\"),\n MovedModule(\"CGIHTTPServer\", \"CGIHTTPServer\", \"http.server\"),\n MovedModule(\"SimpleHTTPServer\", \"SimpleHTTPServer\", \"http.server\"),\n MovedModule(\"cPickle\", \"cPickle\", \"pickle\"),\n MovedModule(\"queue\", \"Queue\"),\n MovedModule(\"reprlib\", \"repr\"),\n MovedModule(\"socketserver\", \"SocketServer\"),\n MovedModule(\"_thread\", \"thread\", \"_thread\"),\n MovedModule(\"tkinter\", \"Tkinter\"),\n MovedModule(\"tkinter_dialog\", \"Dialog\", \"tkinter.dialog\"),\n MovedModule(\"tkinter_filedialog\", \"FileDialog\", \"tkinter.filedialog\"),\n MovedModule(\"tkinter_scrolledtext\", \"ScrolledText\", \"tkinter.scrolledtext\"),\n MovedModule(\"tkinter_simpledialog\", \"SimpleDialog\", \"tkinter.simpledialog\"),\n MovedModule(\"tkinter_tix\", \"Tix\", \"tkinter.tix\"),\n MovedModule(\"tkinter_ttk\", \"ttk\", \"tkinter.ttk\"),\n MovedModule(\"tkinter_constants\", \"Tkconstants\", \"tkinter.constants\"),\n MovedModule(\"tkinter_dnd\", \"Tkdnd\", \"tkinter.dnd\"),\n MovedModule(\"tkinter_colorchooser\", \"tkColorChooser\", \"tkinter.colorchooser\"),\n MovedModule(\"tkinter_commondialog\", \"tkCommonDialog\", \"tkinter.commondialog\"),\n MovedModule(\"tkinter_tkfiledialog\", \"tkFileDialog\", \"tkinter.filedialog\"),\n MovedModule(\"tkinter_font\", \"tkFont\", \"tkinter.font\"),\n MovedModule(\"tkinter_messagebox\", \"tkMessageBox\", \"tkinter.messagebox\"),\n MovedModule(\"tkinter_tksimpledialog\", \"tkSimpleDialog\", \"tkinter.simpledialog\"),\n MovedModule(\"urllib_parse\", __name__ + \".moves.urllib_parse\", \"urllib.parse\"),\n MovedModule(\"urllib_error\", __name__ + \".moves.urllib_error\", \"urllib.error\"),\n MovedModule(\"urllib\", __name__ + \".moves.urllib\", __name__ + \".moves.urllib\"),\n MovedModule(\"urllib_robotparser\", \"robotparser\", \"urllib.robotparser\"),\n MovedModule(\"xmlrpc_client\", \"xmlrpclib\", \"xmlrpc.client\"),\n MovedModule(\"xmlrpc_server\", \"SimpleXMLRPCServer\", \"xmlrpc.server\"),\n]\n# Add windows specific modules.\nif sys.platform == \"win32\":\n _moved_attributes += [\n MovedModule(\"winreg\", \"_winreg\"),\n ]\n\nfor attr in _moved_attributes:\n setattr(_MovedItems, attr.name, attr)\n if isinstance(attr, MovedModule):\n _importer._add_module(attr, \"moves.\" + attr.name)\ndel attr\n\n_MovedItems._moved_attributes = _moved_attributes\n\nmoves = _MovedItems(__name__ + \".moves\")\n_importer._add_module(moves, \"moves\")\n\n\nclass Module_six_moves_urllib_parse(_LazyModule):\n\n \"\"\"Lazy loading of moved objects in six.moves.urllib_parse\"\"\"\n\n\n_urllib_parse_moved_attributes = [\n MovedAttribute(\"ParseResult\", \"urlparse\", \"urllib.parse\"),\n MovedAttribute(\"SplitResult\", \"urlparse\", \"urllib.parse\"),\n MovedAttribute(\"parse_qs\", \"urlparse\", \"urllib.parse\"),\n MovedAttribute(\"parse_qsl\", \"urlparse\", \"urllib.parse\"),\n MovedAttribute(\"urldefrag\", \"urlparse\", \"urllib.parse\"),\n MovedAttribute(\"urljoin\", \"urlparse\", \"urllib.parse\"),\n MovedAttribute(\"urlparse\", \"urlparse\", \"urllib.parse\"),\n MovedAttribute(\"urlsplit\", \"urlparse\", \"urllib.parse\"),\n MovedAttribute(\"urlunparse\", \"urlparse\", \"urllib.parse\"),\n MovedAttribute(\"urlunsplit\", \"urlparse\", \"urllib.parse\"),\n MovedAttribute(\"quote\", \"urllib\", \"urllib.parse\"),\n MovedAttribute(\"quote_plus\", \"urllib\", \"urllib.parse\"),\n MovedAttribute(\"unquote\", \"urllib\", \"urllib.parse\"),\n MovedAttribute(\"unquote_plus\", \"urllib\", \"urllib.parse\"),\n MovedAttribute(\n \"unquote_to_bytes\", \"urllib\", \"urllib.parse\", \"unquote\", \"unquote_to_bytes\"\n ),\n MovedAttribute(\"urlencode\", \"urllib\", \"urllib.parse\"),\n MovedAttribute(\"splitquery\", \"urllib\", \"urllib.parse\"),\n MovedAttribute(\"splittag\", \"urllib\", \"urllib.parse\"),\n MovedAttribute(\"splituser\", \"urllib\", \"urllib.parse\"),\n MovedAttribute(\"splitvalue\", \"urllib\", \"urllib.parse\"),\n MovedAttribute(\"uses_fragment\", \"urlparse\", \"urllib.parse\"),\n MovedAttribute(\"uses_netloc\", \"urlparse\", \"urllib.parse\"),\n MovedAttribute(\"uses_params\", \"urlparse\", \"urllib.parse\"),\n MovedAttribute(\"uses_query\", \"urlparse\", \"urllib.parse\"),\n MovedAttribute(\"uses_relative\", \"urlparse\", \"urllib.parse\"),\n]\nfor attr in _urllib_parse_moved_attributes:\n setattr(Module_six_moves_urllib_parse, attr.name, attr)\ndel attr\n\nModule_six_moves_urllib_parse._moved_attributes = _urllib_parse_moved_attributes\n\n_importer._add_module(\n Module_six_moves_urllib_parse(__name__ + \".moves.urllib_parse\"),\n \"moves.urllib_parse\",\n \"moves.urllib.parse\",\n)\n\n\nclass Module_six_moves_urllib_error(_LazyModule):\n\n \"\"\"Lazy loading of moved objects in six.moves.urllib_error\"\"\"\n\n\n_urllib_error_moved_attributes = [\n MovedAttribute(\"URLError\", \"urllib2\", \"urllib.error\"),\n MovedAttribute(\"HTTPError\", \"urllib2\", \"urllib.error\"),\n MovedAttribute(\"ContentTooShortError\", \"urllib\", \"urllib.error\"),\n]\nfor attr in _urllib_error_moved_attributes:\n setattr(Module_six_moves_urllib_error, attr.name, attr)\ndel attr\n\nModule_six_moves_urllib_error._moved_attributes = _urllib_error_moved_attributes\n\n_importer._add_module(\n Module_six_moves_urllib_error(__name__ + \".moves.urllib.error\"),\n \"moves.urllib_error\",\n \"moves.urllib.error\",\n)\n\n\nclass Module_six_moves_urllib_request(_LazyModule):\n\n \"\"\"Lazy loading of moved objects in six.moves.urllib_request\"\"\"\n\n\n_urllib_request_moved_attributes = [\n MovedAttribute(\"urlopen\", \"urllib2\", \"urllib.request\"),\n MovedAttribute(\"install_opener\", \"urllib2\", \"urllib.request\"),\n MovedAttribute(\"build_opener\", \"urllib2\", \"urllib.request\"),\n MovedAttribute(\"pathname2url\", \"urllib\", \"urllib.request\"),\n MovedAttribute(\"url2pathname\", \"urllib\", \"urllib.request\"),\n MovedAttribute(\"getproxies\", \"urllib\", \"urllib.request\"),\n MovedAttribute(\"Request\", \"urllib2\", \"urllib.request\"),\n MovedAttribute(\"OpenerDirector\", \"urllib2\", \"urllib.request\"),\n MovedAttribute(\"HTTPDefaultErrorHandler\", \"urllib2\", \"urllib.request\"),\n MovedAttribute(\"HTTPRedirectHandler\", \"urllib2\", \"urllib.request\"),\n MovedAttribute(\"HTTPCookieProcessor\", \"urllib2\", \"urllib.request\"),\n MovedAttribute(\"ProxyHandler\", \"urllib2\", \"urllib.request\"),\n MovedAttribute(\"BaseHandler\", \"urllib2\", \"urllib.request\"),\n MovedAttribute(\"HTTPPasswordMgr\", \"urllib2\", \"urllib.request\"),\n MovedAttribute(\"HTTPPasswordMgrWithDefaultRealm\", \"urllib2\", \"urllib.request\"),\n MovedAttribute(\"AbstractBasicAuthHandler\", \"urllib2\", \"urllib.request\"),\n MovedAttribute(\"HTTPBasicAuthHandler\", \"urllib2\", \"urllib.request\"),\n MovedAttribute(\"ProxyBasicAuthHandler\", \"urllib2\", \"urllib.request\"),\n MovedAttribute(\"AbstractDigestAuthHandler\", \"urllib2\", \"urllib.request\"),\n MovedAttribute(\"HTTPDigestAuthHandler\", \"urllib2\", \"urllib.request\"),\n MovedAttribute(\"ProxyDigestAuthHandler\", \"urllib2\", \"urllib.request\"),\n MovedAttribute(\"HTTPHandler\", \"urllib2\", \"urllib.request\"),\n MovedAttribute(\"HTTPSHandler\", \"urllib2\", \"urllib.request\"),\n MovedAttribute(\"FileHandler\", \"urllib2\", \"urllib.request\"),\n MovedAttribute(\"FTPHandler\", \"urllib2\", \"urllib.request\"),\n MovedAttribute(\"CacheFTPHandler\", \"urllib2\", \"urllib.request\"),\n MovedAttribute(\"UnknownHandler\", \"urllib2\", \"urllib.request\"),\n MovedAttribute(\"HTTPErrorProcessor\", \"urllib2\", \"urllib.request\"),\n MovedAttribute(\"urlretrieve\", \"urllib\", \"urllib.request\"),\n MovedAttribute(\"urlcleanup\", \"urllib\", \"urllib.request\"),\n MovedAttribute(\"URLopener\", \"urllib\", \"urllib.request\"),\n MovedAttribute(\"FancyURLopener\", \"urllib\", \"urllib.request\"),\n MovedAttribute(\"proxy_bypass\", \"urllib\", \"urllib.request\"),\n MovedAttribute(\"parse_http_list\", \"urllib2\", \"urllib.request\"),\n MovedAttribute(\"parse_keqv_list\", \"urllib2\", \"urllib.request\"),\n]\nfor attr in _urllib_request_moved_attributes:\n setattr(Module_six_moves_urllib_request, attr.name, attr)\ndel attr\n\nModule_six_moves_urllib_request._moved_attributes = _urllib_request_moved_attributes\n\n_importer._add_module(\n Module_six_moves_urllib_request(__name__ + \".moves.urllib.request\"),\n \"moves.urllib_request\",\n \"moves.urllib.request\",\n)\n\n\nclass Module_six_moves_urllib_response(_LazyModule):\n\n \"\"\"Lazy loading of moved objects in six.moves.urllib_response\"\"\"\n\n\n_urllib_response_moved_attributes = [\n MovedAttribute(\"addbase\", \"urllib\", \"urllib.response\"),\n MovedAttribute(\"addclosehook\", \"urllib\", \"urllib.response\"),\n MovedAttribute(\"addinfo\", \"urllib\", \"urllib.response\"),\n MovedAttribute(\"addinfourl\", \"urllib\", \"urllib.response\"),\n]\nfor attr in _urllib_response_moved_attributes:\n setattr(Module_six_moves_urllib_response, attr.name, attr)\ndel attr\n\nModule_six_moves_urllib_response._moved_attributes = _urllib_response_moved_attributes\n\n_importer._add_module(\n Module_six_moves_urllib_response(__name__ + \".moves.urllib.response\"),\n \"moves.urllib_response\",\n \"moves.urllib.response\",\n)\n\n\nclass Module_six_moves_urllib_robotparser(_LazyModule):\n\n \"\"\"Lazy loading of moved objects in six.moves.urllib_robotparser\"\"\"\n\n\n_urllib_robotparser_moved_attributes = [\n MovedAttribute(\"RobotFileParser\", \"robotparser\", \"urllib.robotparser\"),\n]\nfor attr in _urllib_robotparser_moved_attributes:\n setattr(Module_six_moves_urllib_robotparser, attr.name, attr)\ndel attr\n\nModule_six_moves_urllib_robotparser._moved_attributes = (\n _urllib_robotparser_moved_attributes\n)\n\n_importer._add_module(\n Module_six_moves_urllib_robotparser(__name__ + \".moves.urllib.robotparser\"),\n \"moves.urllib_robotparser\",\n \"moves.urllib.robotparser\",\n)\n\n\nclass Module_six_moves_urllib(types.ModuleType):\n\n \"\"\"Create a six.moves.urllib namespace that resembles the Python 3 namespace\"\"\"\n\n __path__ = [] # mark as package\n parse = _importer._get_module(\"moves.urllib_parse\")\n error = _importer._get_module(\"moves.urllib_error\")\n request = _importer._get_module(\"moves.urllib_request\")\n response = _importer._get_module(\"moves.urllib_response\")\n robotparser = _importer._get_module(\"moves.urllib_robotparser\")\n\n def __dir__(self):\n return [\"parse\", \"error\", \"request\", \"response\", \"robotparser\"]\n\n\n_importer._add_module(\n Module_six_moves_urllib(__name__ + \".moves.urllib\"), \"moves.urllib\"\n)\n\n\ndef add_move(move):\n \"\"\"Add an item to six.moves.\"\"\"\n setattr(_MovedItems, move.name, move)\n\n\ndef remove_move(name):\n \"\"\"Remove item from six.moves.\"\"\"\n try:\n delattr(_MovedItems, name)\n except AttributeError:\n try:\n del moves.__dict__[name]\n except KeyError:\n raise AttributeError(\"no such move, %r\" % (name,))\n\n\nif PY3:\n _meth_func = \"__func__\"\n _meth_self = \"__self__\"\n\n _func_closure = \"__closure__\"\n _func_code = \"__code__\"\n _func_defaults = \"__defaults__\"\n _func_globals = \"__globals__\"\nelse:\n _meth_func = \"im_func\"\n _meth_self = \"im_self\"\n\n _func_closure = \"func_closure\"\n _func_code = \"func_code\"\n _func_defaults = \"func_defaults\"\n _func_globals = \"func_globals\"\n\n\ntry:\n advance_iterator = next\nexcept NameError:\n\n def advance_iterator(it):\n return it.next()\n\n\nnext = advance_iterator\n\n\ntry:\n callable = callable\nexcept NameError:\n\n def callable(obj):\n return any(\"__call__\" in klass.__dict__ for klass in type(obj).__mro__)\n\n\nif PY3:\n\n def get_unbound_function(unbound):\n return unbound\n\n create_bound_method = types.MethodType\n\n def create_unbound_method(func, cls):\n return func\n\n Iterator = object\nelse:\n\n def get_unbound_function(unbound):\n return unbound.im_func\n\n def create_bound_method(func, obj):\n return types.MethodType(func, obj, obj.__class__)\n\n def create_unbound_method(func, cls):\n return types.MethodType(func, None, cls)\n\n class Iterator(object):\n def next(self):\n return type(self).__next__(self)\n\n callable = callable\n_add_doc(\n get_unbound_function, \"\"\"Get the function out of a possibly unbound function\"\"\"\n)\n\n\nget_method_function = operator.attrgetter(_meth_func)\nget_method_self = operator.attrgetter(_meth_self)\nget_function_closure = operator.attrgetter(_func_closure)\nget_function_code = operator.attrgetter(_func_code)\nget_function_defaults = operator.attrgetter(_func_defaults)\nget_function_globals = operator.attrgetter(_func_globals)\n\n\nif PY3:\n\n def iterkeys(d, **kw):\n return iter(d.keys(**kw))\n\n def itervalues(d, **kw):\n return iter(d.values(**kw))\n\n def iteritems(d, **kw):\n return iter(d.items(**kw))\n\n def iterlists(d, **kw):\n return iter(d.lists(**kw))\n\n viewkeys = operator.methodcaller(\"keys\")\n\n viewvalues = operator.methodcaller(\"values\")\n\n viewitems = operator.methodcaller(\"items\")\nelse:\n\n def iterkeys(d, **kw):\n return d.iterkeys(**kw)\n\n def itervalues(d, **kw):\n return d.itervalues(**kw)\n\n def iteritems(d, **kw):\n return d.iteritems(**kw)\n\n def iterlists(d, **kw):\n return d.iterlists(**kw)\n\n viewkeys = operator.methodcaller(\"viewkeys\")\n\n viewvalues = operator.methodcaller(\"viewvalues\")\n\n viewitems = operator.methodcaller(\"viewitems\")\n\n_add_doc(iterkeys, \"Return an iterator over the keys of a dictionary.\")\n_add_doc(itervalues, \"Return an iterator over the values of a dictionary.\")\n_add_doc(iteritems, \"Return an iterator over the (key, value) pairs of a dictionary.\")\n_add_doc(\n iterlists, \"Return an iterator over the (key, [values]) pairs of a dictionary.\"\n)\n\n\nif PY3:\n\n def b(s):\n return s.encode(\"latin-1\")\n\n def u(s):\n return s\n\n unichr = chr\n import struct\n\n int2byte = struct.Struct(\">B\").pack\n del struct\n byte2int = operator.itemgetter(0)\n indexbytes = operator.getitem\n iterbytes = iter\n import io\n\n StringIO = io.StringIO\n BytesIO = io.BytesIO\n del io\n _assertCountEqual = \"assertCountEqual\"\n if sys.version_info[1] <= 1:\n _assertRaisesRegex = \"assertRaisesRegexp\"\n _assertRegex = \"assertRegexpMatches\"\n _assertNotRegex = \"assertNotRegexpMatches\"\n else:\n _assertRaisesRegex = \"assertRaisesRegex\"\n _assertRegex = \"assertRegex\"\n _assertNotRegex = \"assertNotRegex\"\nelse:\n\n def b(s):\n return s\n\n # Workaround for standalone backslash\n\n def u(s):\n return unicode(s.replace(r\"\\\\\", r\"\\\\\\\\\"), \"unicode_escape\")\n\n unichr = unichr\n int2byte = chr\n\n def byte2int(bs):\n return ord(bs[0])\n\n def indexbytes(buf, i):\n return ord(buf[i])\n\n iterbytes = functools.partial(itertools.imap, ord)\n import StringIO\n\n StringIO = BytesIO = StringIO.StringIO\n _assertCountEqual = \"assertItemsEqual\"\n _assertRaisesRegex = \"assertRaisesRegexp\"\n _assertRegex = \"assertRegexpMatches\"\n _assertNotRegex = \"assertNotRegexpMatches\"\n_add_doc(b, \"\"\"Byte literal\"\"\")\n_add_doc(u, \"\"\"Text literal\"\"\")\n\n\ndef assertCountEqual(self, *args, **kwargs):\n return getattr(self, _assertCountEqual)(*args, **kwargs)\n\n\ndef assertRaisesRegex(self, *args, **kwargs):\n return getattr(self, _assertRaisesRegex)(*args, **kwargs)\n\n\ndef assertRegex(self, *args, **kwargs):\n return getattr(self, _assertRegex)(*args, **kwargs)\n\n\ndef assertNotRegex(self, *args, **kwargs):\n return getattr(self, _assertNotRegex)(*args, **kwargs)\n\n\nif PY3:\n exec_ = getattr(moves.builtins, \"exec\")\n\n def reraise(tp, value, tb=None):\n try:\n if value is None:\n value = tp()\n if value.__traceback__ is not tb:\n raise value.with_traceback(tb)\n raise value\n finally:\n value = None\n tb = None\n\nelse:\n\n def exec_(_code_, _globs_=None, _locs_=None):\n \"\"\"Execute code in a namespace.\"\"\"\n if _globs_ is None:\n frame = sys._getframe(1)\n _globs_ = frame.f_globals\n if _locs_ is None:\n _locs_ = frame.f_locals\n del frame\n elif _locs_ is None:\n _locs_ = _globs_\n exec (\"\"\"exec _code_ in _globs_, _locs_\"\"\")\n\n exec_(\n \"\"\"def reraise(tp, value, tb=None):\n try:\n raise tp, value, tb\n finally:\n tb = None\n\"\"\"\n )\n\n\nif sys.version_info[:2] > (3,):\n exec_(\n \"\"\"def raise_from(value, from_value):\n try:\n raise value from from_value\n finally:\n value = None\n\"\"\"\n )\nelse:\n\n def raise_from(value, from_value):\n raise value\n\n\nprint_ = getattr(moves.builtins, \"print\", None)\nif print_ is None:\n\n def print_(*args, **kwargs):\n \"\"\"The new-style print function for Python 2.4 and 2.5.\"\"\"\n fp = kwargs.pop(\"file\", sys.stdout)\n if fp is None:\n return\n\n def write(data):\n if not isinstance(data, basestring):\n data = str(data)\n # If the file has an encoding, encode unicode with it.\n if (\n isinstance(fp, file)\n and isinstance(data, unicode)\n and fp.encoding is not None\n ):\n errors = getattr(fp, \"errors\", None)\n if errors is None:\n errors = \"strict\"\n data = data.encode(fp.encoding, errors)\n fp.write(data)\n\n want_unicode = False\n sep = kwargs.pop(\"sep\", None)\n if sep is not None:\n if isinstance(sep, unicode):\n want_unicode = True\n elif not isinstance(sep, str):\n raise TypeError(\"sep must be None or a string\")\n end = kwargs.pop(\"end\", None)\n if end is not None:\n if isinstance(end, unicode):\n want_unicode = True\n elif not isinstance(end, str):\n raise TypeError(\"end must be None or a string\")\n if kwargs:\n raise TypeError(\"invalid keyword arguments to print()\")\n if not want_unicode:\n for arg in args:\n if isinstance(arg, unicode):\n want_unicode = True\n break\n if want_unicode:\n newline = unicode(\"\\n\")\n space = unicode(\" \")\n else:\n newline = \"\\n\"\n space = \" \"\n if sep is None:\n sep = space\n if end is None:\n end = newline\n for i, arg in enumerate(args):\n if i:\n write(sep)\n write(arg)\n write(end)\n\n\nif sys.version_info[:2] < (3, 3):\n _print = print_\n\n def print_(*args, **kwargs):\n fp = kwargs.get(\"file\", sys.stdout)\n flush = kwargs.pop(\"flush\", False)\n _print(*args, **kwargs)\n if flush and fp is not None:\n fp.flush()\n\n\n_add_doc(reraise, \"\"\"Reraise an exception.\"\"\")\n\nif sys.version_info[0:2] < (3, 4):\n # This does exactly the same what the :func:`py3:functools.update_wrapper`\n # function does on Python versions after 3.2. It sets the ``__wrapped__``\n # attribute on ``wrapper`` object and it doesn't raise an error if any of\n # the attributes mentioned in ``assigned`` and ``updated`` are missing on\n # ``wrapped`` object.\n def _update_wrapper(\n wrapper,\n wrapped,\n assigned=functools.WRAPPER_ASSIGNMENTS,\n updated=functools.WRAPPER_UPDATES,\n ):\n for attr in assigned:\n try:\n value = getattr(wrapped, attr)\n except AttributeError:\n continue\n else:\n setattr(wrapper, attr, value)\n for attr in updated:\n getattr(wrapper, attr).update(getattr(wrapped, attr, {}))\n wrapper.__wrapped__ = wrapped\n return wrapper\n\n _update_wrapper.__doc__ = functools.update_wrapper.__doc__\n\n def wraps(\n wrapped,\n assigned=functools.WRAPPER_ASSIGNMENTS,\n updated=functools.WRAPPER_UPDATES,\n ):\n return functools.partial(\n _update_wrapper, wrapped=wrapped, assigned=assigned, updated=updated\n )\n\n wraps.__doc__ = functools.wraps.__doc__\n\nelse:\n wraps = functools.wraps\n\n\ndef with_metaclass(meta, *bases):\n \"\"\"Create a base class with a metaclass.\"\"\"\n # This requires a bit of explanation: the basic idea is to make a dummy\n # metaclass for one level of class instantiation that replaces itself with\n # the actual metaclass.\n class metaclass(type):\n def __new__(cls, name, this_bases, d):\n if sys.version_info[:2] >= (3, 7):\n # This version introduced PEP 560 that requires a bit\n # of extra care (we mimic what is done by __build_class__).\n resolved_bases = types.resolve_bases(bases)\n if resolved_bases is not bases:\n d[\"__orig_bases__\"] = bases\n else:\n resolved_bases = bases\n return meta(name, resolved_bases, d)\n\n @classmethod\n def __prepare__(cls, name, this_bases):\n return meta.__prepare__(name, bases)\n\n return type.__new__(metaclass, \"temporary_class\", (), {})\n\n\ndef add_metaclass(metaclass):\n \"\"\"Class decorator for creating a class with a metaclass.\"\"\"\n\n def wrapper(cls):\n orig_vars = cls.__dict__.copy()\n slots = orig_vars.get(\"__slots__\")\n if slots is not None:\n if isinstance(slots, str):\n slots = [slots]\n for slots_var in slots:\n orig_vars.pop(slots_var)\n orig_vars.pop(\"__dict__\", None)\n orig_vars.pop(\"__weakref__\", None)\n if hasattr(cls, \"__qualname__\"):\n orig_vars[\"__qualname__\"] = cls.__qualname__\n return metaclass(cls.__name__, cls.__bases__, orig_vars)\n\n return wrapper\n\n\ndef ensure_binary(s, encoding=\"utf-8\", errors=\"strict\"):\n \"\"\"Coerce **s** to six.binary_type.\n\n For Python 2:\n - `unicode` -> encoded to `str`\n - `str` -> `str`\n\n For Python 3:\n - `str` -> encoded to `bytes`\n - `bytes` -> `bytes`\n \"\"\"\n if isinstance(s, binary_type):\n return s\n if isinstance(s, text_type):\n return s.encode(encoding, errors)\n raise TypeError(\"not expecting type '%s'\" % type(s))\n\n\ndef ensure_str(s, encoding=\"utf-8\", errors=\"strict\"):\n \"\"\"Coerce *s* to `str`.\n\n For Python 2:\n - `unicode` -> encoded to `str`\n - `str` -> `str`\n\n For Python 3:\n - `str` -> `str`\n - `bytes` -> decoded to `str`\n \"\"\"\n # Optimization: Fast return for the common case.\n if type(s) is str:\n return s\n if PY2 and isinstance(s, text_type):\n return s.encode(encoding, errors)\n elif PY3 and isinstance(s, binary_type):\n return s.decode(encoding, errors)\n elif not isinstance(s, (text_type, binary_type)):\n raise TypeError(\"not expecting type '%s'\" % type(s))\n return s\n\n\ndef ensure_text(s, encoding=\"utf-8\", errors=\"strict\"):\n \"\"\"Coerce *s* to six.text_type.\n\n For Python 2:\n - `unicode` -> `unicode`\n - `str` -> `unicode`\n\n For Python 3:\n - `str` -> `str`\n - `bytes` -> decoded to `str`\n \"\"\"\n if isinstance(s, binary_type):\n return s.decode(encoding, errors)\n elif isinstance(s, text_type):\n return s\n else:\n raise TypeError(\"not expecting type '%s'\" % type(s))\n\n\ndef python_2_unicode_compatible(klass):\n \"\"\"\n A class decorator that defines __unicode__ and __str__ methods under Python 2.\n Under Python 3 it does nothing.\n\n To support Python 2 and 3 with a single code base, define a __str__ method\n returning text and apply this decorator to the class.\n \"\"\"\n if PY2:\n if \"__str__\" not in klass.__dict__:\n raise ValueError(\n \"@python_2_unicode_compatible cannot be applied \"\n \"to %s because it doesn't define __str__().\" % klass.__name__\n )\n klass.__unicode__ = klass.__str__\n klass.__str__ = lambda self: self.__unicode__().encode(\"utf-8\")\n return klass\n\n\n# Complete the moves implementation.\n# This code is at the end of this module to speed up module loading.\n# Turn this module into a package.\n__path__ = [] # required for PEP 302 and PEP 451\n__package__ = __name__ # see PEP 366 @ReservedAssignment\nif globals().get(\"__spec__\") is not None:\n __spec__.submodule_search_locations = [] # PEP 451 @UndefinedVariable\n# Remove other six meta path importers, since they cause problems. This can\n# happen if six is removed from sys.modules and then reloaded. (Setuptools does\n# this for some reason.)\nif sys.meta_path:\n for i, importer in enumerate(sys.meta_path):\n # Here's some real nastiness: Another \"instance\" of the six module might\n # be floating around. Therefore, we can't use isinstance() to check for\n # the six meta path importer, since the other six instance will have\n # inserted an importer with different class.\n if (\n type(importer).__name__ == \"_SixMetaPathImporter\"\n and importer.name == __name__\n ):\n del sys.meta_path[i]\n break\n del i, importer\n# Finally, add the importer to the meta path import hook.\nsys.meta_path.append(_importer)\n",[],[213,919,920,921,1016,1050,1067,1263,1255],"packages","0d969e94-67fc-11f0-9f6f-0224a6c84d84","weakref_finalize.py","0d969f84-67fc-11f0-9f6f-0224a6c84d84","03a1c1c0-67fc-11f0-bfb3-0224a6c84d84",505,["D",1753299270567],"# -*- coding: utf-8 -*-\n\"\"\"\nbackports.weakref_finalize\n~~~~~~~~~~~~~~~~~~\n\nBackports the Python 3 ``weakref.finalize`` method.\n\"\"\"\nfrom __future__ import absolute_import\n\nimport itertools\nimport sys\nfrom weakref import ref\n\n__all__ = [\"weakref_finalize\"]\n\n\nclass weakref_finalize(object):\n \"\"\"Class for finalization of weakrefable objects\n finalize(obj, func, *args, **kwargs) returns a callable finalizer\n object which will be called when obj is garbage collected. The\n first time the finalizer is called it evaluates func(*arg, **kwargs)\n and returns the result. After this the finalizer is dead, and\n calling it just returns None.\n When the program exits any remaining finalizers for which the\n atexit attribute is true will be run in reverse order of creation.\n By default atexit is true.\n \"\"\"\n\n # Finalizer objects don't have any state of their own. They are\n # just used as keys to lookup _Info objects in the registry. This\n # ensures that they cannot be part of a ref-cycle.\n\n __slots__ = ()\n _registry = {}\n _shutdown = False\n _index_iter = itertools.count()\n _dirty = False\n _registered_with_atexit = False\n\n class _Info(object):\n __slots__ = (\"weakref\", \"func\", \"args\", \"kwargs\", \"atexit\", \"index\")\n\n def __init__(self, obj, func, *args, **kwargs):\n if not self._registered_with_atexit:\n # We may register the exit function more than once because\n # of a thread race, but that is harmless\n import atexit\n\n atexit.register(self._exitfunc)\n weakref_finalize._registered_with_atexit = True\n info = self._Info()\n info.weakref = ref(obj, self)\n info.func = func\n info.args = args\n info.kwargs = kwargs or None\n info.atexit = True\n info.index = next(self._index_iter)\n self._registry[self] = info\n weakref_finalize._dirty = True\n\n def __call__(self, _=None):\n \"\"\"If alive then mark as dead and return func(*args, **kwargs);\n otherwise return None\"\"\"\n info = self._registry.pop(self, None)\n if info and not self._shutdown:\n return info.func(*info.args, **(info.kwargs or {}))\n\n def detach(self):\n \"\"\"If alive then mark as dead and return (obj, func, args, kwargs);\n otherwise return None\"\"\"\n info = self._registry.get(self)\n obj = info and info.weakref()\n if obj is not None and self._registry.pop(self, None):\n return (obj, info.func, info.args, info.kwargs or {})\n\n def peek(self):\n \"\"\"If alive then return (obj, func, args, kwargs);\n otherwise return None\"\"\"\n info = self._registry.get(self)\n obj = info and info.weakref()\n if obj is not None:\n return (obj, info.func, info.args, info.kwargs or {})\n\n @property\n def alive(self):\n \"\"\"Whether finalizer is alive\"\"\"\n return self in self._registry\n\n @property\n def atexit(self):\n \"\"\"Whether finalizer should be called at exit\"\"\"\n info = self._registry.get(self)\n return bool(info) and info.atexit\n\n @atexit.setter\n def atexit(self, value):\n info = self._registry.get(self)\n if info:\n info.atexit = bool(value)\n\n def __repr__(self):\n info = self._registry.get(self)\n obj = info and info.weakref()\n if obj is None:\n return \"<%s object at %#x; dead>\" % (type(self).__name__, id(self))\n else:\n return \"<%s object at %#x; for %r at %#x>\" % (\n type(self).__name__,\n id(self),\n type(obj).__name__,\n id(obj),\n )\n\n @classmethod\n def _select_for_exit(cls):\n # Return live finalizers marked for exit, oldest first\n L = [(f, i) for (f, i) in cls._registry.items() if i.atexit]\n L.sort(key=lambda item: item[1].index)\n return [f for (f, i) in L]\n\n @classmethod\n def _exitfunc(cls):\n # At shutdown invoke finalizers for which atexit is true.\n # This is called once all other non-daemonic threads have been\n # joined.\n reenable_gc = False\n try:\n if cls._registry:\n import gc\n\n if gc.isenabled():\n reenable_gc = True\n gc.disable()\n pending = None\n while True:\n if pending is None or weakref_finalize._dirty:\n pending = cls._select_for_exit()\n weakref_finalize._dirty = False\n if not pending:\n break\n f = pending.pop()\n try:\n # gc is disabled, so (assuming no daemonic\n # threads) the following is the only line in\n # this function which might trigger creation\n # of a new finalizer\n f()\n except Exception:\n sys.excepthook(*sys.exc_info())\n assert f not in cls._registry\n finally:\n # prevent any more finalizers from executing during shutdown\n weakref_finalize._shutdown = True\n if reenable_gc:\n gc.enable()\n",[],[213,919,920,921,1016,1050,1067,1263,1273,1265],"backports","0d9ecf38-67fc-11f0-a319-0224a6c84d84","makefile.py","0d9ed00a-67fc-11f0-a319-0224a6c84d84",506,["D",1753299270557],"# -*- coding: utf-8 -*-\n\"\"\"\nbackports.makefile\n~~~~~~~~~~~~~~~~~~\n\nBackports the Python 3 ``socket.makefile`` method for use with anything that\nwants to create a \"fake\" socket object.\n\"\"\"\nimport io\nfrom socket import SocketIO\n\n\ndef backport_makefile(\n self, mode=\"r\", buffering=None, encoding=None, errors=None, newline=None\n):\n \"\"\"\n Backport of ``socket.makefile`` from Python 3.5.\n \"\"\"\n if not set(mode) <= {\"r\", \"w\", \"b\"}:\n raise ValueError(\"invalid mode %r (only r, w, b allowed)\" % (mode,))\n writing = \"w\" in mode\n reading = \"r\" in mode or not writing\n assert reading or writing\n binary = \"b\" in mode\n rawmode = \"\"\n if reading:\n rawmode += \"r\"\n if writing:\n rawmode += \"w\"\n raw = SocketIO(self, rawmode)\n self._makefile_refs += 1\n if buffering is None:\n buffering = -1\n if buffering < 0:\n buffering = io.DEFAULT_BUFFER_SIZE\n if buffering == 0:\n if not binary:\n raise ValueError(\"unbuffered streams must be binary\")\n return raw\n if reading and writing:\n buffer = io.BufferedRWPair(raw, raw, buffering)\n elif reading:\n buffer = io.BufferedReader(raw, buffering)\n else:\n assert writing\n buffer = io.BufferedWriter(raw, buffering)\n if binary:\n return buffer\n text = io.TextIOWrapper(buffer, encoding, errors, newline)\n text.mode = mode\n return text\n",[],[213,919,920,921,1016,1050,1067,1263,1273,1275],"03a1c10c-67fc-11f0-bfb3-0224a6c84d84",106,["D",1753299253876],[698,699],[213,919,920,921,1016,1050,1067,1263,1273],"03536584-67fc-11f0-b654-0224a6c84d84",103,["D",1753299253364],[697,700],[213,919,920,921,1016,1050,1067,1263],"0d5d8faa-67fc-11f0-9454-0224a6c84d84","socks.py","0d5d9068-67fc-11f0-9454-0224a6c84d84","033a883e-67fc-11f0-b800-0224a6c84d84",496,["D",1753299270206],"# -*- coding: utf-8 -*-\n\"\"\"\nThis module contains provisional support for SOCKS proxies from within\nurllib3. This module supports SOCKS4, SOCKS4A (an extension of SOCKS4), and\nSOCKS5. To enable its functionality, either install PySocks or install this\nmodule with the ``socks`` extra.\n\nThe SOCKS implementation supports the full range of urllib3 features. It also\nsupports the following SOCKS features:\n\n- SOCKS4A (``proxy_url='socks4a://...``)\n- SOCKS4 (``proxy_url='socks4://...``)\n- SOCKS5 with remote DNS (``proxy_url='socks5h://...``)\n- SOCKS5 with local DNS (``proxy_url='socks5://...``)\n- Usernames and passwords for the SOCKS proxy\n\n.. note::\n It is recommended to use ``socks5h://`` or ``socks4a://`` schemes in\n your ``proxy_url`` to ensure that DNS resolution is done from the remote\n server instead of client-side when connecting to a domain name.\n\nSOCKS4 supports IPv4 and domain names with the SOCKS4A extension. SOCKS5\nsupports IPv4, IPv6, and domain names.\n\nWhen connecting to a SOCKS4 proxy the ``username`` portion of the ``proxy_url``\nwill be sent as the ``userid`` section of the SOCKS request:\n\n.. code-block:: python\n\n proxy_url=\"socks4a://@proxy-host\"\n\nWhen connecting to a SOCKS5 proxy the ``username`` and ``password`` portion\nof the ``proxy_url`` will be sent as the username/password to authenticate\nwith the proxy:\n\n.. code-block:: python\n\n proxy_url=\"socks5h://:@proxy-host\"\n\n\"\"\"\nfrom __future__ import absolute_import\n\ntry:\n import socks\nexcept ImportError:\n import warnings\n\n from ..exceptions import DependencyWarning\n\n warnings.warn(\n (\n \"SOCKS support in urllib3 requires the installation of optional \"\n \"dependencies: specifically, PySocks. For more information, see \"\n \"https://urllib3.readthedocs.io/en/1.26.x/contrib.html#socks-proxies\"\n ),\n DependencyWarning,\n )\n raise\n\nfrom socket import error as SocketError\nfrom socket import timeout as SocketTimeout\n\nfrom ..connection import HTTPConnection, HTTPSConnection\nfrom ..connectionpool import HTTPConnectionPool, HTTPSConnectionPool\nfrom ..exceptions import ConnectTimeoutError, NewConnectionError\nfrom ..poolmanager import PoolManager\nfrom ..util.url import parse_url\n\ntry:\n import ssl\nexcept ImportError:\n ssl = None\n\n\nclass SOCKSConnection(HTTPConnection):\n \"\"\"\n A plain-text HTTP connection that connects via a SOCKS proxy.\n \"\"\"\n\n def __init__(self, *args, **kwargs):\n self._socks_options = kwargs.pop(\"_socks_options\")\n super(SOCKSConnection, self).__init__(*args, **kwargs)\n\n def _new_conn(self):\n \"\"\"\n Establish a new connection via the SOCKS proxy.\n \"\"\"\n extra_kw = {}\n if self.source_address:\n extra_kw[\"source_address\"] = self.source_address\n\n if self.socket_options:\n extra_kw[\"socket_options\"] = self.socket_options\n\n try:\n conn = socks.create_connection(\n (self.host, self.port),\n proxy_type=self._socks_options[\"socks_version\"],\n proxy_addr=self._socks_options[\"proxy_host\"],\n proxy_port=self._socks_options[\"proxy_port\"],\n proxy_username=self._socks_options[\"username\"],\n proxy_password=self._socks_options[\"password\"],\n proxy_rdns=self._socks_options[\"rdns\"],\n timeout=self.timeout,\n **extra_kw\n )\n\n except SocketTimeout:\n raise ConnectTimeoutError(\n self,\n \"Connection to %s timed out. (connect timeout=%s)\"\n % (self.host, self.timeout),\n )\n\n except socks.ProxyError as e:\n # This is fragile as hell, but it seems to be the only way to raise\n # useful errors here.\n if e.socket_err:\n error = e.socket_err\n if isinstance(error, SocketTimeout):\n raise ConnectTimeoutError(\n self,\n \"Connection to %s timed out. (connect timeout=%s)\"\n % (self.host, self.timeout),\n )\n else:\n raise NewConnectionError(\n self, \"Failed to establish a new connection: %s\" % error\n )\n else:\n raise NewConnectionError(\n self, \"Failed to establish a new connection: %s\" % e\n )\n\n except SocketError as e: # Defensive: PySocks should catch all these.\n raise NewConnectionError(\n self, \"Failed to establish a new connection: %s\" % e\n )\n\n return conn\n\n\n# We don't need to duplicate the Verified/Unverified distinction from\n# urllib3/connection.py here because the HTTPSConnection will already have been\n# correctly set to either the Verified or Unverified form by that module. This\n# means the SOCKSHTTPSConnection will automatically be the correct type.\nclass SOCKSHTTPSConnection(SOCKSConnection, HTTPSConnection):\n pass\n\n\nclass SOCKSHTTPConnectionPool(HTTPConnectionPool):\n ConnectionCls = SOCKSConnection\n\n\nclass SOCKSHTTPSConnectionPool(HTTPSConnectionPool):\n ConnectionCls = SOCKSHTTPSConnection\n\n\nclass SOCKSProxyManager(PoolManager):\n \"\"\"\n A version of the urllib3 ProxyManager that routes connections via the\n defined SOCKS proxy.\n \"\"\"\n\n pool_classes_by_scheme = {\n \"http\": SOCKSHTTPConnectionPool,\n \"https\": SOCKSHTTPSConnectionPool,\n }\n\n def __init__(\n self,\n proxy_url,\n username=None,\n password=None,\n num_pools=10,\n headers=None,\n **connection_pool_kw\n ):\n parsed = parse_url(proxy_url)\n\n if username is None and password is None and parsed.auth is not None:\n split = parsed.auth.split(\":\")\n if len(split) == 2:\n username, password = split\n if parsed.scheme == \"socks5\":\n socks_version = socks.PROXY_TYPE_SOCKS5\n rdns = False\n elif parsed.scheme == \"socks5h\":\n socks_version = socks.PROXY_TYPE_SOCKS5\n rdns = True\n elif parsed.scheme == \"socks4\":\n socks_version = socks.PROXY_TYPE_SOCKS4\n rdns = False\n elif parsed.scheme == \"socks4a\":\n socks_version = socks.PROXY_TYPE_SOCKS4\n rdns = True\n else:\n raise ValueError(\"Unable to determine SOCKS version from %s\" % proxy_url)\n\n self.proxy_url = proxy_url\n\n socks_options = {\n \"socks_version\": socks_version,\n \"proxy_host\": parsed.host,\n \"proxy_port\": parsed.port,\n \"username\": username,\n \"password\": password,\n \"rdns\": rdns,\n }\n connection_pool_kw[\"_socks_options\"] = socks_options\n\n super(SOCKSProxyManager, self).__init__(\n num_pools, headers, **connection_pool_kw\n )\n\n self.pool_classes_by_scheme = SOCKSProxyManager.pool_classes_by_scheme\n",[],[213,919,920,921,1016,1050,1067,1301,1293],"contrib","0d58ab5c-67fc-11f0-8d4e-0224a6c84d84","securetransport.py","0d58ac10-67fc-11f0-8d4e-0224a6c84d84",495,["D",1753299270174],"\"\"\"\nSecureTranport support for urllib3 via ctypes.\n\nThis makes platform-native TLS available to urllib3 users on macOS without the\nuse of a compiler. This is an important feature because the Python Package\nIndex is moving to become a TLSv1.2-or-higher server, and the default OpenSSL\nthat ships with macOS is not capable of doing TLSv1.2. The only way to resolve\nthis is to give macOS users an alternative solution to the problem, and that\nsolution is to use SecureTransport.\n\nWe use ctypes here because this solution must not require a compiler. That's\nbecause pip is not allowed to require a compiler either.\n\nThis is not intended to be a seriously long-term solution to this problem.\nThe hope is that PEP 543 will eventually solve this issue for us, at which\npoint we can retire this contrib module. But in the short term, we need to\nsolve the impending tire fire that is Python on Mac without this kind of\ncontrib module. So...here we are.\n\nTo use this module, simply import and inject it::\n\n import pip._vendor.urllib3.contrib.securetransport as securetransport\n securetransport.inject_into_urllib3()\n\nHappy TLSing!\n\nThis code is a bastardised version of the code found in Will Bond's oscrypto\nlibrary. An enormous debt is owed to him for blazing this trail for us. For\nthat reason, this code should be considered to be covered both by urllib3's\nlicense and by oscrypto's:\n\n.. code-block::\n\n Copyright (c) 2015-2016 Will Bond \n\n Permission is hereby granted, free of charge, to any person obtaining a\n copy of this software and associated documentation files (the \"Software\"),\n to deal in the Software without restriction, including without limitation\n the rights to use, copy, modify, merge, publish, distribute, sublicense,\n and/or sell copies of the Software, and to permit persons to whom the\n Software is furnished to do so, subject to the following conditions:\n\n The above copyright notice and this permission notice shall be included in\n all copies or substantial portions of the Software.\n\n THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\n DEALINGS IN THE SOFTWARE.\n\"\"\"\nfrom __future__ import absolute_import\n\nimport contextlib\nimport ctypes\nimport errno\nimport os.path\nimport shutil\nimport socket\nimport ssl\nimport struct\nimport threading\nimport weakref\n\nfrom .. import util\nfrom ..packages import six\nfrom ..util.ssl_ import PROTOCOL_TLS_CLIENT\nfrom ._securetransport.bindings import CoreFoundation, Security, SecurityConst\nfrom ._securetransport.low_level import (\n _assert_no_error,\n _build_tls_unknown_ca_alert,\n _cert_array_from_pem,\n _create_cfstring_array,\n _load_client_cert_chain,\n _temporary_keychain,\n)\n\ntry: # Platform-specific: Python 2\n from socket import _fileobject\nexcept ImportError: # Platform-specific: Python 3\n _fileobject = None\n from ..packages.backports.makefile import backport_makefile\n\n__all__ = [\"inject_into_urllib3\", \"extract_from_urllib3\"]\n\n# SNI always works\nHAS_SNI = True\n\norig_util_HAS_SNI = util.HAS_SNI\norig_util_SSLContext = util.ssl_.SSLContext\n\n# This dictionary is used by the read callback to obtain a handle to the\n# calling wrapped socket. This is a pretty silly approach, but for now it'll\n# do. I feel like I should be able to smuggle a handle to the wrapped socket\n# directly in the SSLConnectionRef, but for now this approach will work I\n# guess.\n#\n# We need to lock around this structure for inserts, but we don't do it for\n# reads/writes in the callbacks. The reasoning here goes as follows:\n#\n# 1. It is not possible to call into the callbacks before the dictionary is\n# populated, so once in the callback the id must be in the dictionary.\n# 2. The callbacks don't mutate the dictionary, they only read from it, and\n# so cannot conflict with any of the insertions.\n#\n# This is good: if we had to lock in the callbacks we'd drastically slow down\n# the performance of this code.\n_connection_refs = weakref.WeakValueDictionary()\n_connection_ref_lock = threading.Lock()\n\n# Limit writes to 16kB. This is OpenSSL's limit, but we'll cargo-cult it over\n# for no better reason than we need *a* limit, and this one is right there.\nSSL_WRITE_BLOCKSIZE = 16384\n\n# This is our equivalent of util.ssl_.DEFAULT_CIPHERS, but expanded out to\n# individual cipher suites. We need to do this because this is how\n# SecureTransport wants them.\nCIPHER_SUITES = [\n SecurityConst.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,\n SecurityConst.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,\n SecurityConst.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,\n SecurityConst.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,\n SecurityConst.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256,\n SecurityConst.TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256,\n SecurityConst.TLS_DHE_RSA_WITH_AES_256_GCM_SHA384,\n SecurityConst.TLS_DHE_RSA_WITH_AES_128_GCM_SHA256,\n SecurityConst.TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384,\n SecurityConst.TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA,\n SecurityConst.TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256,\n SecurityConst.TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA,\n SecurityConst.TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384,\n SecurityConst.TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA,\n SecurityConst.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256,\n SecurityConst.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA,\n SecurityConst.TLS_DHE_RSA_WITH_AES_256_CBC_SHA256,\n SecurityConst.TLS_DHE_RSA_WITH_AES_256_CBC_SHA,\n SecurityConst.TLS_DHE_RSA_WITH_AES_128_CBC_SHA256,\n SecurityConst.TLS_DHE_RSA_WITH_AES_128_CBC_SHA,\n SecurityConst.TLS_AES_256_GCM_SHA384,\n SecurityConst.TLS_AES_128_GCM_SHA256,\n SecurityConst.TLS_RSA_WITH_AES_256_GCM_SHA384,\n SecurityConst.TLS_RSA_WITH_AES_128_GCM_SHA256,\n SecurityConst.TLS_AES_128_CCM_8_SHA256,\n SecurityConst.TLS_AES_128_CCM_SHA256,\n SecurityConst.TLS_RSA_WITH_AES_256_CBC_SHA256,\n SecurityConst.TLS_RSA_WITH_AES_128_CBC_SHA256,\n SecurityConst.TLS_RSA_WITH_AES_256_CBC_SHA,\n SecurityConst.TLS_RSA_WITH_AES_128_CBC_SHA,\n]\n\n# Basically this is simple: for PROTOCOL_SSLv23 we turn it into a low of\n# TLSv1 and a high of TLSv1.2. For everything else, we pin to that version.\n# TLSv1 to 1.2 are supported on macOS 10.8+\n_protocol_to_min_max = {\n util.PROTOCOL_TLS: (SecurityConst.kTLSProtocol1, SecurityConst.kTLSProtocol12),\n PROTOCOL_TLS_CLIENT: (SecurityConst.kTLSProtocol1, SecurityConst.kTLSProtocol12),\n}\n\nif hasattr(ssl, \"PROTOCOL_SSLv2\"):\n _protocol_to_min_max[ssl.PROTOCOL_SSLv2] = (\n SecurityConst.kSSLProtocol2,\n SecurityConst.kSSLProtocol2,\n )\nif hasattr(ssl, \"PROTOCOL_SSLv3\"):\n _protocol_to_min_max[ssl.PROTOCOL_SSLv3] = (\n SecurityConst.kSSLProtocol3,\n SecurityConst.kSSLProtocol3,\n )\nif hasattr(ssl, \"PROTOCOL_TLSv1\"):\n _protocol_to_min_max[ssl.PROTOCOL_TLSv1] = (\n SecurityConst.kTLSProtocol1,\n SecurityConst.kTLSProtocol1,\n )\nif hasattr(ssl, \"PROTOCOL_TLSv1_1\"):\n _protocol_to_min_max[ssl.PROTOCOL_TLSv1_1] = (\n SecurityConst.kTLSProtocol11,\n SecurityConst.kTLSProtocol11,\n )\nif hasattr(ssl, \"PROTOCOL_TLSv1_2\"):\n _protocol_to_min_max[ssl.PROTOCOL_TLSv1_2] = (\n SecurityConst.kTLSProtocol12,\n SecurityConst.kTLSProtocol12,\n )\n\n\ndef inject_into_urllib3():\n \"\"\"\n Monkey-patch urllib3 with SecureTransport-backed SSL-support.\n \"\"\"\n util.SSLContext = SecureTransportContext\n util.ssl_.SSLContext = SecureTransportContext\n util.HAS_SNI = HAS_SNI\n util.ssl_.HAS_SNI = HAS_SNI\n util.IS_SECURETRANSPORT = True\n util.ssl_.IS_SECURETRANSPORT = True\n\n\ndef extract_from_urllib3():\n \"\"\"\n Undo monkey-patching by :func:`inject_into_urllib3`.\n \"\"\"\n util.SSLContext = orig_util_SSLContext\n util.ssl_.SSLContext = orig_util_SSLContext\n util.HAS_SNI = orig_util_HAS_SNI\n util.ssl_.HAS_SNI = orig_util_HAS_SNI\n util.IS_SECURETRANSPORT = False\n util.ssl_.IS_SECURETRANSPORT = False\n\n\ndef _read_callback(connection_id, data_buffer, data_length_pointer):\n \"\"\"\n SecureTransport read callback. This is called by ST to request that data\n be returned from the socket.\n \"\"\"\n wrapped_socket = None\n try:\n wrapped_socket = _connection_refs.get(connection_id)\n if wrapped_socket is None:\n return SecurityConst.errSSLInternal\n base_socket = wrapped_socket.socket\n\n requested_length = data_length_pointer[0]\n\n timeout = wrapped_socket.gettimeout()\n error = None\n read_count = 0\n\n try:\n while read_count < requested_length:\n if timeout is None or timeout >= 0:\n if not util.wait_for_read(base_socket, timeout):\n raise socket.error(errno.EAGAIN, \"timed out\")\n\n remaining = requested_length - read_count\n buffer = (ctypes.c_char * remaining).from_address(\n data_buffer + read_count\n )\n chunk_size = base_socket.recv_into(buffer, remaining)\n read_count += chunk_size\n if not chunk_size:\n if not read_count:\n return SecurityConst.errSSLClosedGraceful\n break\n except (socket.error) as e:\n error = e.errno\n\n if error is not None and error != errno.EAGAIN:\n data_length_pointer[0] = read_count\n if error == errno.ECONNRESET or error == errno.EPIPE:\n return SecurityConst.errSSLClosedAbort\n raise\n\n data_length_pointer[0] = read_count\n\n if read_count != requested_length:\n return SecurityConst.errSSLWouldBlock\n\n return 0\n except Exception as e:\n if wrapped_socket is not None:\n wrapped_socket._exception = e\n return SecurityConst.errSSLInternal\n\n\ndef _write_callback(connection_id, data_buffer, data_length_pointer):\n \"\"\"\n SecureTransport write callback. This is called by ST to request that data\n actually be sent on the network.\n \"\"\"\n wrapped_socket = None\n try:\n wrapped_socket = _connection_refs.get(connection_id)\n if wrapped_socket is None:\n return SecurityConst.errSSLInternal\n base_socket = wrapped_socket.socket\n\n bytes_to_write = data_length_pointer[0]\n data = ctypes.string_at(data_buffer, bytes_to_write)\n\n timeout = wrapped_socket.gettimeout()\n error = None\n sent = 0\n\n try:\n while sent < bytes_to_write:\n if timeout is None or timeout >= 0:\n if not util.wait_for_write(base_socket, timeout):\n raise socket.error(errno.EAGAIN, \"timed out\")\n chunk_sent = base_socket.send(data)\n sent += chunk_sent\n\n # This has some needless copying here, but I'm not sure there's\n # much value in optimising this data path.\n data = data[chunk_sent:]\n except (socket.error) as e:\n error = e.errno\n\n if error is not None and error != errno.EAGAIN:\n data_length_pointer[0] = sent\n if error == errno.ECONNRESET or error == errno.EPIPE:\n return SecurityConst.errSSLClosedAbort\n raise\n\n data_length_pointer[0] = sent\n\n if sent != bytes_to_write:\n return SecurityConst.errSSLWouldBlock\n\n return 0\n except Exception as e:\n if wrapped_socket is not None:\n wrapped_socket._exception = e\n return SecurityConst.errSSLInternal\n\n\n# We need to keep these two objects references alive: if they get GC'd while\n# in use then SecureTransport could attempt to call a function that is in freed\n# memory. That would be...uh...bad. Yeah, that's the word. Bad.\n_read_callback_pointer = Security.SSLReadFunc(_read_callback)\n_write_callback_pointer = Security.SSLWriteFunc(_write_callback)\n\n\nclass WrappedSocket(object):\n \"\"\"\n API-compatibility wrapper for Python's OpenSSL wrapped socket object.\n\n Note: _makefile_refs, _drop(), and _reuse() are needed for the garbage\n collector of PyPy.\n \"\"\"\n\n def __init__(self, socket):\n self.socket = socket\n self.context = None\n self._makefile_refs = 0\n self._closed = False\n self._exception = None\n self._keychain = None\n self._keychain_dir = None\n self._client_cert_chain = None\n\n # We save off the previously-configured timeout and then set it to\n # zero. This is done because we use select and friends to handle the\n # timeouts, but if we leave the timeout set on the lower socket then\n # Python will \"kindly\" call select on that socket again for us. Avoid\n # that by forcing the timeout to zero.\n self._timeout = self.socket.gettimeout()\n self.socket.settimeout(0)\n\n @contextlib.contextmanager\n def _raise_on_error(self):\n \"\"\"\n A context manager that can be used to wrap calls that do I/O from\n SecureTransport. If any of the I/O callbacks hit an exception, this\n context manager will correctly propagate the exception after the fact.\n This avoids silently swallowing those exceptions.\n\n It also correctly forces the socket closed.\n \"\"\"\n self._exception = None\n\n # We explicitly don't catch around this yield because in the unlikely\n # event that an exception was hit in the block we don't want to swallow\n # it.\n yield\n if self._exception is not None:\n exception, self._exception = self._exception, None\n self.close()\n raise exception\n\n def _set_ciphers(self):\n \"\"\"\n Sets up the allowed ciphers. By default this matches the set in\n util.ssl_.DEFAULT_CIPHERS, at least as supported by macOS. This is done\n custom and doesn't allow changing at this time, mostly because parsing\n OpenSSL cipher strings is going to be a freaking nightmare.\n \"\"\"\n ciphers = (Security.SSLCipherSuite * len(CIPHER_SUITES))(*CIPHER_SUITES)\n result = Security.SSLSetEnabledCiphers(\n self.context, ciphers, len(CIPHER_SUITES)\n )\n _assert_no_error(result)\n\n def _set_alpn_protocols(self, protocols):\n \"\"\"\n Sets up the ALPN protocols on the context.\n \"\"\"\n if not protocols:\n return\n protocols_arr = _create_cfstring_array(protocols)\n try:\n result = Security.SSLSetALPNProtocols(self.context, protocols_arr)\n _assert_no_error(result)\n finally:\n CoreFoundation.CFRelease(protocols_arr)\n\n def _custom_validate(self, verify, trust_bundle):\n \"\"\"\n Called when we have set custom validation. We do this in two cases:\n first, when cert validation is entirely disabled; and second, when\n using a custom trust DB.\n Raises an SSLError if the connection is not trusted.\n \"\"\"\n # If we disabled cert validation, just say: cool.\n if not verify:\n return\n\n successes = (\n SecurityConst.kSecTrustResultUnspecified,\n SecurityConst.kSecTrustResultProceed,\n )\n try:\n trust_result = self._evaluate_trust(trust_bundle)\n if trust_result in successes:\n return\n reason = \"error code: %d\" % (trust_result,)\n except Exception as e:\n # Do not trust on error\n reason = \"exception: %r\" % (e,)\n\n # SecureTransport does not send an alert nor shuts down the connection.\n rec = _build_tls_unknown_ca_alert(self.version())\n self.socket.sendall(rec)\n # close the connection immediately\n # l_onoff = 1, activate linger\n # l_linger = 0, linger for 0 seoncds\n opts = struct.pack(\"ii\", 1, 0)\n self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_LINGER, opts)\n self.close()\n raise ssl.SSLError(\"certificate verify failed, %s\" % reason)\n\n def _evaluate_trust(self, trust_bundle):\n # We want data in memory, so load it up.\n if os.path.isfile(trust_bundle):\n with open(trust_bundle, \"rb\") as f:\n trust_bundle = f.read()\n\n cert_array = None\n trust = Security.SecTrustRef()\n\n try:\n # Get a CFArray that contains the certs we want.\n cert_array = _cert_array_from_pem(trust_bundle)\n\n # Ok, now the hard part. We want to get the SecTrustRef that ST has\n # created for this connection, shove our CAs into it, tell ST to\n # ignore everything else it knows, and then ask if it can build a\n # chain. This is a buuuunch of code.\n result = Security.SSLCopyPeerTrust(self.context, ctypes.byref(trust))\n _assert_no_error(result)\n if not trust:\n raise ssl.SSLError(\"Failed to copy trust reference\")\n\n result = Security.SecTrustSetAnchorCertificates(trust, cert_array)\n _assert_no_error(result)\n\n result = Security.SecTrustSetAnchorCertificatesOnly(trust, True)\n _assert_no_error(result)\n\n trust_result = Security.SecTrustResultType()\n result = Security.SecTrustEvaluate(trust, ctypes.byref(trust_result))\n _assert_no_error(result)\n finally:\n if trust:\n CoreFoundation.CFRelease(trust)\n\n if cert_array is not None:\n CoreFoundation.CFRelease(cert_array)\n\n return trust_result.value\n\n def handshake(\n self,\n server_hostname,\n verify,\n trust_bundle,\n min_version,\n max_version,\n client_cert,\n client_key,\n client_key_passphrase,\n alpn_protocols,\n ):\n \"\"\"\n Actually performs the TLS handshake. This is run automatically by\n wrapped socket, and shouldn't be needed in user code.\n \"\"\"\n # First, we do the initial bits of connection setup. We need to create\n # a context, set its I/O funcs, and set the connection reference.\n self.context = Security.SSLCreateContext(\n None, SecurityConst.kSSLClientSide, SecurityConst.kSSLStreamType\n )\n result = Security.SSLSetIOFuncs(\n self.context, _read_callback_pointer, _write_callback_pointer\n )\n _assert_no_error(result)\n\n # Here we need to compute the handle to use. We do this by taking the\n # id of self modulo 2**31 - 1. If this is already in the dictionary, we\n # just keep incrementing by one until we find a free space.\n with _connection_ref_lock:\n handle = id(self) % 2147483647\n while handle in _connection_refs:\n handle = (handle + 1) % 2147483647\n _connection_refs[handle] = self\n\n result = Security.SSLSetConnection(self.context, handle)\n _assert_no_error(result)\n\n # If we have a server hostname, we should set that too.\n if server_hostname:\n if not isinstance(server_hostname, bytes):\n server_hostname = server_hostname.encode(\"utf-8\")\n\n result = Security.SSLSetPeerDomainName(\n self.context, server_hostname, len(server_hostname)\n )\n _assert_no_error(result)\n\n # Setup the ciphers.\n self._set_ciphers()\n\n # Setup the ALPN protocols.\n self._set_alpn_protocols(alpn_protocols)\n\n # Set the minimum and maximum TLS versions.\n result = Security.SSLSetProtocolVersionMin(self.context, min_version)\n _assert_no_error(result)\n\n result = Security.SSLSetProtocolVersionMax(self.context, max_version)\n _assert_no_error(result)\n\n # If there's a trust DB, we need to use it. We do that by telling\n # SecureTransport to break on server auth. We also do that if we don't\n # want to validate the certs at all: we just won't actually do any\n # authing in that case.\n if not verify or trust_bundle is not None:\n result = Security.SSLSetSessionOption(\n self.context, SecurityConst.kSSLSessionOptionBreakOnServerAuth, True\n )\n _assert_no_error(result)\n\n # If there's a client cert, we need to use it.\n if client_cert:\n self._keychain, self._keychain_dir = _temporary_keychain()\n self._client_cert_chain = _load_client_cert_chain(\n self._keychain, client_cert, client_key\n )\n result = Security.SSLSetCertificate(self.context, self._client_cert_chain)\n _assert_no_error(result)\n\n while True:\n with self._raise_on_error():\n result = Security.SSLHandshake(self.context)\n\n if result == SecurityConst.errSSLWouldBlock:\n raise socket.timeout(\"handshake timed out\")\n elif result == SecurityConst.errSSLServerAuthCompleted:\n self._custom_validate(verify, trust_bundle)\n continue\n else:\n _assert_no_error(result)\n break\n\n def fileno(self):\n return self.socket.fileno()\n\n # Copy-pasted from Python 3.5 source code\n def _decref_socketios(self):\n if self._makefile_refs > 0:\n self._makefile_refs -= 1\n if self._closed:\n self.close()\n\n def recv(self, bufsiz):\n buffer = ctypes.create_string_buffer(bufsiz)\n bytes_read = self.recv_into(buffer, bufsiz)\n data = buffer[:bytes_read]\n return data\n\n def recv_into(self, buffer, nbytes=None):\n # Read short on EOF.\n if self._closed:\n return 0\n\n if nbytes is None:\n nbytes = len(buffer)\n\n buffer = (ctypes.c_char * nbytes).from_buffer(buffer)\n processed_bytes = ctypes.c_size_t(0)\n\n with self._raise_on_error():\n result = Security.SSLRead(\n self.context, buffer, nbytes, ctypes.byref(processed_bytes)\n )\n\n # There are some result codes that we want to treat as \"not always\n # errors\". Specifically, those are errSSLWouldBlock,\n # errSSLClosedGraceful, and errSSLClosedNoNotify.\n if result == SecurityConst.errSSLWouldBlock:\n # If we didn't process any bytes, then this was just a time out.\n # However, we can get errSSLWouldBlock in situations when we *did*\n # read some data, and in those cases we should just read \"short\"\n # and return.\n if processed_bytes.value == 0:\n # Timed out, no data read.\n raise socket.timeout(\"recv timed out\")\n elif result in (\n SecurityConst.errSSLClosedGraceful,\n SecurityConst.errSSLClosedNoNotify,\n ):\n # The remote peer has closed this connection. We should do so as\n # well. Note that we don't actually return here because in\n # principle this could actually be fired along with return data.\n # It's unlikely though.\n self.close()\n else:\n _assert_no_error(result)\n\n # Ok, we read and probably succeeded. We should return whatever data\n # was actually read.\n return processed_bytes.value\n\n def settimeout(self, timeout):\n self._timeout = timeout\n\n def gettimeout(self):\n return self._timeout\n\n def send(self, data):\n processed_bytes = ctypes.c_size_t(0)\n\n with self._raise_on_error():\n result = Security.SSLWrite(\n self.context, data, len(data), ctypes.byref(processed_bytes)\n )\n\n if result == SecurityConst.errSSLWouldBlock and processed_bytes.value == 0:\n # Timed out\n raise socket.timeout(\"send timed out\")\n else:\n _assert_no_error(result)\n\n # We sent, and probably succeeded. Tell them how much we sent.\n return processed_bytes.value\n\n def sendall(self, data):\n total_sent = 0\n while total_sent < len(data):\n sent = self.send(data[total_sent : total_sent + SSL_WRITE_BLOCKSIZE])\n total_sent += sent\n\n def shutdown(self):\n with self._raise_on_error():\n Security.SSLClose(self.context)\n\n def close(self):\n # TODO: should I do clean shutdown here? Do I have to?\n if self._makefile_refs < 1:\n self._closed = True\n if self.context:\n CoreFoundation.CFRelease(self.context)\n self.context = None\n if self._client_cert_chain:\n CoreFoundation.CFRelease(self._client_cert_chain)\n self._client_cert_chain = None\n if self._keychain:\n Security.SecKeychainDelete(self._keychain)\n CoreFoundation.CFRelease(self._keychain)\n shutil.rmtree(self._keychain_dir)\n self._keychain = self._keychain_dir = None\n return self.socket.close()\n else:\n self._makefile_refs -= 1\n\n def getpeercert(self, binary_form=False):\n # Urgh, annoying.\n #\n # Here's how we do this:\n #\n # 1. Call SSLCopyPeerTrust to get hold of the trust object for this\n # connection.\n # 2. Call SecTrustGetCertificateAtIndex for index 0 to get the leaf.\n # 3. To get the CN, call SecCertificateCopyCommonName and process that\n # string so that it's of the appropriate type.\n # 4. To get the SAN, we need to do something a bit more complex:\n # a. Call SecCertificateCopyValues to get the data, requesting\n # kSecOIDSubjectAltName.\n # b. Mess about with this dictionary to try to get the SANs out.\n #\n # This is gross. Really gross. It's going to be a few hundred LoC extra\n # just to repeat something that SecureTransport can *already do*. So my\n # operating assumption at this time is that what we want to do is\n # instead to just flag to urllib3 that it shouldn't do its own hostname\n # validation when using SecureTransport.\n if not binary_form:\n raise ValueError(\"SecureTransport only supports dumping binary certs\")\n trust = Security.SecTrustRef()\n certdata = None\n der_bytes = None\n\n try:\n # Grab the trust store.\n result = Security.SSLCopyPeerTrust(self.context, ctypes.byref(trust))\n _assert_no_error(result)\n if not trust:\n # Probably we haven't done the handshake yet. No biggie.\n return None\n\n cert_count = Security.SecTrustGetCertificateCount(trust)\n if not cert_count:\n # Also a case that might happen if we haven't handshaked.\n # Handshook? Handshaken?\n return None\n\n leaf = Security.SecTrustGetCertificateAtIndex(trust, 0)\n assert leaf\n\n # Ok, now we want the DER bytes.\n certdata = Security.SecCertificateCopyData(leaf)\n assert certdata\n\n data_length = CoreFoundation.CFDataGetLength(certdata)\n data_buffer = CoreFoundation.CFDataGetBytePtr(certdata)\n der_bytes = ctypes.string_at(data_buffer, data_length)\n finally:\n if certdata:\n CoreFoundation.CFRelease(certdata)\n if trust:\n CoreFoundation.CFRelease(trust)\n\n return der_bytes\n\n def version(self):\n protocol = Security.SSLProtocol()\n result = Security.SSLGetNegotiatedProtocolVersion(\n self.context, ctypes.byref(protocol)\n )\n _assert_no_error(result)\n if protocol.value == SecurityConst.kTLSProtocol13:\n raise ssl.SSLError(\"SecureTransport does not support TLS 1.3\")\n elif protocol.value == SecurityConst.kTLSProtocol12:\n return \"TLSv1.2\"\n elif protocol.value == SecurityConst.kTLSProtocol11:\n return \"TLSv1.1\"\n elif protocol.value == SecurityConst.kTLSProtocol1:\n return \"TLSv1\"\n elif protocol.value == SecurityConst.kSSLProtocol3:\n return \"SSLv3\"\n elif protocol.value == SecurityConst.kSSLProtocol2:\n return \"SSLv2\"\n else:\n raise ssl.SSLError(\"Unknown TLS version: %r\" % protocol)\n\n def _reuse(self):\n self._makefile_refs += 1\n\n def _drop(self):\n if self._makefile_refs < 1:\n self.close()\n else:\n self._makefile_refs -= 1\n\n\nif _fileobject: # Platform-specific: Python 2\n\n def makefile(self, mode, bufsize=-1):\n self._makefile_refs += 1\n return _fileobject(self, mode, bufsize, close=True)\n\nelse: # Platform-specific: Python 3\n\n def makefile(self, mode=\"r\", buffering=None, *args, **kwargs):\n # We disable buffering with SecureTransport because it conflicts with\n # the buffering that ST does internally (see issue #1153 for more).\n buffering = 0\n return backport_makefile(self, mode, buffering, *args, **kwargs)\n\n\nWrappedSocket.makefile = makefile\n\n\nclass SecureTransportContext(object):\n \"\"\"\n I am a wrapper class for the SecureTransport library, to translate the\n interface of the standard library ``SSLContext`` object to calls into\n SecureTransport.\n \"\"\"\n\n def __init__(self, protocol):\n self._min_version, self._max_version = _protocol_to_min_max[protocol]\n self._options = 0\n self._verify = False\n self._trust_bundle = None\n self._client_cert = None\n self._client_key = None\n self._client_key_passphrase = None\n self._alpn_protocols = None\n\n @property\n def check_hostname(self):\n \"\"\"\n SecureTransport cannot have its hostname checking disabled. For more,\n see the comment on getpeercert() in this file.\n \"\"\"\n return True\n\n @check_hostname.setter\n def check_hostname(self, value):\n \"\"\"\n SecureTransport cannot have its hostname checking disabled. For more,\n see the comment on getpeercert() in this file.\n \"\"\"\n pass\n\n @property\n def options(self):\n # TODO: Well, crap.\n #\n # So this is the bit of the code that is the most likely to cause us\n # trouble. Essentially we need to enumerate all of the SSL options that\n # users might want to use and try to see if we can sensibly translate\n # them, or whether we should just ignore them.\n return self._options\n\n @options.setter\n def options(self, value):\n # TODO: Update in line with above.\n self._options = value\n\n @property\n def verify_mode(self):\n return ssl.CERT_REQUIRED if self._verify else ssl.CERT_NONE\n\n @verify_mode.setter\n def verify_mode(self, value):\n self._verify = True if value == ssl.CERT_REQUIRED else False\n\n def set_default_verify_paths(self):\n # So, this has to do something a bit weird. Specifically, what it does\n # is nothing.\n #\n # This means that, if we had previously had load_verify_locations\n # called, this does not undo that. We need to do that because it turns\n # out that the rest of the urllib3 code will attempt to load the\n # default verify paths if it hasn't been told about any paths, even if\n # the context itself was sometime earlier. We resolve that by just\n # ignoring it.\n pass\n\n def load_default_certs(self):\n return self.set_default_verify_paths()\n\n def set_ciphers(self, ciphers):\n # For now, we just require the default cipher string.\n if ciphers != util.ssl_.DEFAULT_CIPHERS:\n raise ValueError(\"SecureTransport doesn't support custom cipher strings\")\n\n def load_verify_locations(self, cafile=None, capath=None, cadata=None):\n # OK, we only really support cadata and cafile.\n if capath is not None:\n raise ValueError(\"SecureTransport does not support cert directories\")\n\n # Raise if cafile does not exist.\n if cafile is not None:\n with open(cafile):\n pass\n\n self._trust_bundle = cafile or cadata\n\n def load_cert_chain(self, certfile, keyfile=None, password=None):\n self._client_cert = certfile\n self._client_key = keyfile\n self._client_cert_passphrase = password\n\n def set_alpn_protocols(self, protocols):\n \"\"\"\n Sets the ALPN protocols that will later be set on the context.\n\n Raises a NotImplementedError if ALPN is not supported.\n \"\"\"\n if not hasattr(Security, \"SSLSetALPNProtocols\"):\n raise NotImplementedError(\n \"SecureTransport supports ALPN only in macOS 10.12+\"\n )\n self._alpn_protocols = [six.ensure_binary(p) for p in protocols]\n\n def wrap_socket(\n self,\n sock,\n server_side=False,\n do_handshake_on_connect=True,\n suppress_ragged_eofs=True,\n server_hostname=None,\n ):\n # So, what do we do here? Firstly, we assert some properties. This is a\n # stripped down shim, so there is some functionality we don't support.\n # See PEP 543 for the real deal.\n assert not server_side\n assert do_handshake_on_connect\n assert suppress_ragged_eofs\n\n # Ok, we're good to go. Now we want to create the wrapped socket object\n # and store it in the appropriate place.\n wrapped_socket = WrappedSocket(sock)\n\n # Now we can handshake\n wrapped_socket.handshake(\n server_hostname,\n self._verify,\n self._trust_bundle,\n self._min_version,\n self._max_version,\n self._client_cert,\n self._client_key,\n self._client_key_passphrase,\n self._alpn_protocols,\n )\n return wrapped_socket\n",[],[213,919,920,921,1016,1050,1067,1301,1303],"0d67ef0e-67fc-11f0-9f6f-0224a6c84d84","pyopenssl.py","0d67efae-67fc-11f0-9f6f-0224a6c84d84",498,["D",1753299270264],"\"\"\"\nTLS with SNI_-support for Python 2. Follow these instructions if you would\nlike to verify TLS certificates in Python 2. Note, the default libraries do\n*not* do certificate checking; you need to do additional work to validate\ncertificates yourself.\n\nThis needs the following packages installed:\n\n* `pyOpenSSL`_ (tested with 16.0.0)\n* `cryptography`_ (minimum 1.3.4, from pyopenssl)\n* `idna`_ (minimum 2.0, from cryptography)\n\nHowever, pyopenssl depends on cryptography, which depends on idna, so while we\nuse all three directly here we end up having relatively few packages required.\n\nYou can install them with the following command:\n\n.. code-block:: bash\n\n $ python -m pip install pyopenssl cryptography idna\n\nTo activate certificate checking, call\n:func:`~urllib3.contrib.pyopenssl.inject_into_urllib3` from your Python code\nbefore you begin making HTTP requests. This can be done in a ``sitecustomize``\nmodule, or at any other time before your application begins using ``urllib3``,\nlike this:\n\n.. code-block:: python\n\n try:\n import pip._vendor.urllib3.contrib.pyopenssl as pyopenssl\n pyopenssl.inject_into_urllib3()\n except ImportError:\n pass\n\nNow you can use :mod:`urllib3` as you normally would, and it will support SNI\nwhen the required modules are installed.\n\nActivating this module also has the positive side effect of disabling SSL/TLS\ncompression in Python 2 (see `CRIME attack`_).\n\n.. _sni: https://en.wikipedia.org/wiki/Server_Name_Indication\n.. _crime attack: https://en.wikipedia.org/wiki/CRIME_(security_exploit)\n.. _pyopenssl: https://www.pyopenssl.org\n.. _cryptography: https://cryptography.io\n.. _idna: https://github.com/kjd/idna\n\"\"\"\nfrom __future__ import absolute_import\n\nimport OpenSSL.crypto\nimport OpenSSL.SSL\nfrom cryptography import x509\nfrom cryptography.hazmat.backends.openssl import backend as openssl_backend\n\ntry:\n from cryptography.x509 import UnsupportedExtension\nexcept ImportError:\n # UnsupportedExtension is gone in cryptography >= 2.1.0\n class UnsupportedExtension(Exception):\n pass\n\n\nfrom io import BytesIO\nfrom socket import error as SocketError\nfrom socket import timeout\n\ntry: # Platform-specific: Python 2\n from socket import _fileobject\nexcept ImportError: # Platform-specific: Python 3\n _fileobject = None\n from ..packages.backports.makefile import backport_makefile\n\nimport logging\nimport ssl\nimport sys\nimport warnings\n\nfrom .. import util\nfrom ..packages import six\nfrom ..util.ssl_ import PROTOCOL_TLS_CLIENT\n\nwarnings.warn(\n \"'urllib3.contrib.pyopenssl' module is deprecated and will be removed \"\n \"in a future release of urllib3 2.x. Read more in this issue: \"\n \"https://github.com/urllib3/urllib3/issues/2680\",\n category=DeprecationWarning,\n stacklevel=2,\n)\n\n__all__ = [\"inject_into_urllib3\", \"extract_from_urllib3\"]\n\n# SNI always works.\nHAS_SNI = True\n\n# Map from urllib3 to PyOpenSSL compatible parameter-values.\n_openssl_versions = {\n util.PROTOCOL_TLS: OpenSSL.SSL.SSLv23_METHOD,\n PROTOCOL_TLS_CLIENT: OpenSSL.SSL.SSLv23_METHOD,\n ssl.PROTOCOL_TLSv1: OpenSSL.SSL.TLSv1_METHOD,\n}\n\nif hasattr(ssl, \"PROTOCOL_SSLv3\") and hasattr(OpenSSL.SSL, \"SSLv3_METHOD\"):\n _openssl_versions[ssl.PROTOCOL_SSLv3] = OpenSSL.SSL.SSLv3_METHOD\n\nif hasattr(ssl, \"PROTOCOL_TLSv1_1\") and hasattr(OpenSSL.SSL, \"TLSv1_1_METHOD\"):\n _openssl_versions[ssl.PROTOCOL_TLSv1_1] = OpenSSL.SSL.TLSv1_1_METHOD\n\nif hasattr(ssl, \"PROTOCOL_TLSv1_2\") and hasattr(OpenSSL.SSL, \"TLSv1_2_METHOD\"):\n _openssl_versions[ssl.PROTOCOL_TLSv1_2] = OpenSSL.SSL.TLSv1_2_METHOD\n\n\n_stdlib_to_openssl_verify = {\n ssl.CERT_NONE: OpenSSL.SSL.VERIFY_NONE,\n ssl.CERT_OPTIONAL: OpenSSL.SSL.VERIFY_PEER,\n ssl.CERT_REQUIRED: OpenSSL.SSL.VERIFY_PEER\n + OpenSSL.SSL.VERIFY_FAIL_IF_NO_PEER_CERT,\n}\n_openssl_to_stdlib_verify = dict((v, k) for k, v in _stdlib_to_openssl_verify.items())\n\n# OpenSSL will only write 16K at a time\nSSL_WRITE_BLOCKSIZE = 16384\n\norig_util_HAS_SNI = util.HAS_SNI\norig_util_SSLContext = util.ssl_.SSLContext\n\n\nlog = logging.getLogger(__name__)\n\n\ndef inject_into_urllib3():\n \"Monkey-patch urllib3 with PyOpenSSL-backed SSL-support.\"\n\n _validate_dependencies_met()\n\n util.SSLContext = PyOpenSSLContext\n util.ssl_.SSLContext = PyOpenSSLContext\n util.HAS_SNI = HAS_SNI\n util.ssl_.HAS_SNI = HAS_SNI\n util.IS_PYOPENSSL = True\n util.ssl_.IS_PYOPENSSL = True\n\n\ndef extract_from_urllib3():\n \"Undo monkey-patching by :func:`inject_into_urllib3`.\"\n\n util.SSLContext = orig_util_SSLContext\n util.ssl_.SSLContext = orig_util_SSLContext\n util.HAS_SNI = orig_util_HAS_SNI\n util.ssl_.HAS_SNI = orig_util_HAS_SNI\n util.IS_PYOPENSSL = False\n util.ssl_.IS_PYOPENSSL = False\n\n\ndef _validate_dependencies_met():\n \"\"\"\n Verifies that PyOpenSSL's package-level dependencies have been met.\n Throws `ImportError` if they are not met.\n \"\"\"\n # Method added in `cryptography==1.1`; not available in older versions\n from cryptography.x509.extensions import Extensions\n\n if getattr(Extensions, \"get_extension_for_class\", None) is None:\n raise ImportError(\n \"'cryptography' module missing required functionality. \"\n \"Try upgrading to v1.3.4 or newer.\"\n )\n\n # pyOpenSSL 0.14 and above use cryptography for OpenSSL bindings. The _x509\n # attribute is only present on those versions.\n from OpenSSL.crypto import X509\n\n x509 = X509()\n if getattr(x509, \"_x509\", None) is None:\n raise ImportError(\n \"'pyOpenSSL' module missing required functionality. \"\n \"Try upgrading to v0.14 or newer.\"\n )\n\n\ndef _dnsname_to_stdlib(name):\n \"\"\"\n Converts a dNSName SubjectAlternativeName field to the form used by the\n standard library on the given Python version.\n\n Cryptography produces a dNSName as a unicode string that was idna-decoded\n from ASCII bytes. We need to idna-encode that string to get it back, and\n then on Python 3 we also need to convert to unicode via UTF-8 (the stdlib\n uses PyUnicode_FromStringAndSize on it, which decodes via UTF-8).\n\n If the name cannot be idna-encoded then we return None signalling that\n the name given should be skipped.\n \"\"\"\n\n def idna_encode(name):\n \"\"\"\n Borrowed wholesale from the Python Cryptography Project. It turns out\n that we can't just safely call `idna.encode`: it can explode for\n wildcard names. This avoids that problem.\n \"\"\"\n from pip._vendor import idna\n\n try:\n for prefix in [u\"*.\", u\".\"]:\n if name.startswith(prefix):\n name = name[len(prefix) :]\n return prefix.encode(\"ascii\") + idna.encode(name)\n return idna.encode(name)\n except idna.core.IDNAError:\n return None\n\n # Don't send IPv6 addresses through the IDNA encoder.\n if \":\" in name:\n return name\n\n name = idna_encode(name)\n if name is None:\n return None\n elif sys.version_info >= (3, 0):\n name = name.decode(\"utf-8\")\n return name\n\n\ndef get_subj_alt_name(peer_cert):\n \"\"\"\n Given an PyOpenSSL certificate, provides all the subject alternative names.\n \"\"\"\n # Pass the cert to cryptography, which has much better APIs for this.\n if hasattr(peer_cert, \"to_cryptography\"):\n cert = peer_cert.to_cryptography()\n else:\n der = OpenSSL.crypto.dump_certificate(OpenSSL.crypto.FILETYPE_ASN1, peer_cert)\n cert = x509.load_der_x509_certificate(der, openssl_backend)\n\n # We want to find the SAN extension. Ask Cryptography to locate it (it's\n # faster than looping in Python)\n try:\n ext = cert.extensions.get_extension_for_class(x509.SubjectAlternativeName).value\n except x509.ExtensionNotFound:\n # No such extension, return the empty list.\n return []\n except (\n x509.DuplicateExtension,\n UnsupportedExtension,\n x509.UnsupportedGeneralNameType,\n UnicodeError,\n ) as e:\n # A problem has been found with the quality of the certificate. Assume\n # no SAN field is present.\n log.warning(\n \"A problem was encountered with the certificate that prevented \"\n \"urllib3 from finding the SubjectAlternativeName field. This can \"\n \"affect certificate validation. The error was %s\",\n e,\n )\n return []\n\n # We want to return dNSName and iPAddress fields. We need to cast the IPs\n # back to strings because the match_hostname function wants them as\n # strings.\n # Sadly the DNS names need to be idna encoded and then, on Python 3, UTF-8\n # decoded. This is pretty frustrating, but that's what the standard library\n # does with certificates, and so we need to attempt to do the same.\n # We also want to skip over names which cannot be idna encoded.\n names = [\n (\"DNS\", name)\n for name in map(_dnsname_to_stdlib, ext.get_values_for_type(x509.DNSName))\n if name is not None\n ]\n names.extend(\n (\"IP Address\", str(name)) for name in ext.get_values_for_type(x509.IPAddress)\n )\n\n return names\n\n\nclass WrappedSocket(object):\n \"\"\"API-compatibility wrapper for Python OpenSSL's Connection-class.\n\n Note: _makefile_refs, _drop() and _reuse() are needed for the garbage\n collector of pypy.\n \"\"\"\n\n def __init__(self, connection, socket, suppress_ragged_eofs=True):\n self.connection = connection\n self.socket = socket\n self.suppress_ragged_eofs = suppress_ragged_eofs\n self._makefile_refs = 0\n self._closed = False\n\n def fileno(self):\n return self.socket.fileno()\n\n # Copy-pasted from Python 3.5 source code\n def _decref_socketios(self):\n if self._makefile_refs > 0:\n self._makefile_refs -= 1\n if self._closed:\n self.close()\n\n def recv(self, *args, **kwargs):\n try:\n data = self.connection.recv(*args, **kwargs)\n except OpenSSL.SSL.SysCallError as e:\n if self.suppress_ragged_eofs and e.args == (-1, \"Unexpected EOF\"):\n return b\"\"\n else:\n raise SocketError(str(e))\n except OpenSSL.SSL.ZeroReturnError:\n if self.connection.get_shutdown() == OpenSSL.SSL.RECEIVED_SHUTDOWN:\n return b\"\"\n else:\n raise\n except OpenSSL.SSL.WantReadError:\n if not util.wait_for_read(self.socket, self.socket.gettimeout()):\n raise timeout(\"The read operation timed out\")\n else:\n return self.recv(*args, **kwargs)\n\n # TLS 1.3 post-handshake authentication\n except OpenSSL.SSL.Error as e:\n raise ssl.SSLError(\"read error: %r\" % e)\n else:\n return data\n\n def recv_into(self, *args, **kwargs):\n try:\n return self.connection.recv_into(*args, **kwargs)\n except OpenSSL.SSL.SysCallError as e:\n if self.suppress_ragged_eofs and e.args == (-1, \"Unexpected EOF\"):\n return 0\n else:\n raise SocketError(str(e))\n except OpenSSL.SSL.ZeroReturnError:\n if self.connection.get_shutdown() == OpenSSL.SSL.RECEIVED_SHUTDOWN:\n return 0\n else:\n raise\n except OpenSSL.SSL.WantReadError:\n if not util.wait_for_read(self.socket, self.socket.gettimeout()):\n raise timeout(\"The read operation timed out\")\n else:\n return self.recv_into(*args, **kwargs)\n\n # TLS 1.3 post-handshake authentication\n except OpenSSL.SSL.Error as e:\n raise ssl.SSLError(\"read error: %r\" % e)\n\n def settimeout(self, timeout):\n return self.socket.settimeout(timeout)\n\n def _send_until_done(self, data):\n while True:\n try:\n return self.connection.send(data)\n except OpenSSL.SSL.WantWriteError:\n if not util.wait_for_write(self.socket, self.socket.gettimeout()):\n raise timeout()\n continue\n except OpenSSL.SSL.SysCallError as e:\n raise SocketError(str(e))\n\n def sendall(self, data):\n total_sent = 0\n while total_sent < len(data):\n sent = self._send_until_done(\n data[total_sent : total_sent + SSL_WRITE_BLOCKSIZE]\n )\n total_sent += sent\n\n def shutdown(self):\n # FIXME rethrow compatible exceptions should we ever use this\n self.connection.shutdown()\n\n def close(self):\n if self._makefile_refs < 1:\n try:\n self._closed = True\n return self.connection.close()\n except OpenSSL.SSL.Error:\n return\n else:\n self._makefile_refs -= 1\n\n def getpeercert(self, binary_form=False):\n x509 = self.connection.get_peer_certificate()\n\n if not x509:\n return x509\n\n if binary_form:\n return OpenSSL.crypto.dump_certificate(OpenSSL.crypto.FILETYPE_ASN1, x509)\n\n return {\n \"subject\": (((\"commonName\", x509.get_subject().CN),),),\n \"subjectAltName\": get_subj_alt_name(x509),\n }\n\n def version(self):\n return self.connection.get_protocol_version_name()\n\n def _reuse(self):\n self._makefile_refs += 1\n\n def _drop(self):\n if self._makefile_refs < 1:\n self.close()\n else:\n self._makefile_refs -= 1\n\n\nif _fileobject: # Platform-specific: Python 2\n\n def makefile(self, mode, bufsize=-1):\n self._makefile_refs += 1\n return _fileobject(self, mode, bufsize, close=True)\n\nelse: # Platform-specific: Python 3\n makefile = backport_makefile\n\nWrappedSocket.makefile = makefile\n\n\nclass PyOpenSSLContext(object):\n \"\"\"\n I am a wrapper class for the PyOpenSSL ``Context`` object. I am responsible\n for translating the interface of the standard library ``SSLContext`` object\n to calls into PyOpenSSL.\n \"\"\"\n\n def __init__(self, protocol):\n self.protocol = _openssl_versions[protocol]\n self._ctx = OpenSSL.SSL.Context(self.protocol)\n self._options = 0\n self.check_hostname = False\n\n @property\n def options(self):\n return self._options\n\n @options.setter\n def options(self, value):\n self._options = value\n self._ctx.set_options(value)\n\n @property\n def verify_mode(self):\n return _openssl_to_stdlib_verify[self._ctx.get_verify_mode()]\n\n @verify_mode.setter\n def verify_mode(self, value):\n self._ctx.set_verify(_stdlib_to_openssl_verify[value], _verify_callback)\n\n def set_default_verify_paths(self):\n self._ctx.set_default_verify_paths()\n\n def set_ciphers(self, ciphers):\n if isinstance(ciphers, six.text_type):\n ciphers = ciphers.encode(\"utf-8\")\n self._ctx.set_cipher_list(ciphers)\n\n def load_verify_locations(self, cafile=None, capath=None, cadata=None):\n if cafile is not None:\n cafile = cafile.encode(\"utf-8\")\n if capath is not None:\n capath = capath.encode(\"utf-8\")\n try:\n self._ctx.load_verify_locations(cafile, capath)\n if cadata is not None:\n self._ctx.load_verify_locations(BytesIO(cadata))\n except OpenSSL.SSL.Error as e:\n raise ssl.SSLError(\"unable to load trusted certificates: %r\" % e)\n\n def load_cert_chain(self, certfile, keyfile=None, password=None):\n self._ctx.use_certificate_chain_file(certfile)\n if password is not None:\n if not isinstance(password, six.binary_type):\n password = password.encode(\"utf-8\")\n self._ctx.set_passwd_cb(lambda *_: password)\n self._ctx.use_privatekey_file(keyfile or certfile)\n\n def set_alpn_protocols(self, protocols):\n protocols = [six.ensure_binary(p) for p in protocols]\n return self._ctx.set_alpn_protos(protocols)\n\n def wrap_socket(\n self,\n sock,\n server_side=False,\n do_handshake_on_connect=True,\n suppress_ragged_eofs=True,\n server_hostname=None,\n ):\n cnx = OpenSSL.SSL.Connection(self._ctx, sock)\n\n if isinstance(server_hostname, six.text_type): # Platform-specific: Python 3\n server_hostname = server_hostname.encode(\"utf-8\")\n\n if server_hostname is not None:\n cnx.set_tlsext_host_name(server_hostname)\n\n cnx.set_connect_state()\n\n while True:\n try:\n cnx.do_handshake()\n except OpenSSL.SSL.WantReadError:\n if not util.wait_for_read(sock, sock.gettimeout()):\n raise timeout(\"select timed out\")\n continue\n except OpenSSL.SSL.Error as e:\n raise ssl.SSLError(\"bad handshake: %r\" % e)\n break\n\n return WrappedSocket(cnx, sock)\n\n\ndef _verify_callback(cnx, x509, err_no, err_depth, return_code):\n return err_no == 0\n",[],[213,919,920,921,1016,1050,1067,1301,1311],"0d8bd73e-67fc-11f0-847e-0224a6c84d84","ntlmpool.py","0d8bd7f2-67fc-11f0-847e-0224a6c84d84",503,["D",1753299270467],"\"\"\"\nNTLM authenticating pool, contributed by erikcederstran\n\nIssue #10, see: http://code.google.com/p/urllib3/issues/detail?id=10\n\"\"\"\nfrom __future__ import absolute_import\n\nimport warnings\nfrom logging import getLogger\n\nfrom ntlm import ntlm\n\nfrom .. import HTTPSConnectionPool\nfrom ..packages.six.moves.http_client import HTTPSConnection\n\nwarnings.warn(\n \"The 'urllib3.contrib.ntlmpool' module is deprecated and will be removed \"\n \"in urllib3 v2.0 release, urllib3 is not able to support it properly due \"\n \"to reasons listed in issue: https://github.com/urllib3/urllib3/issues/2282. \"\n \"If you are a user of this module please comment in the mentioned issue.\",\n DeprecationWarning,\n)\n\nlog = getLogger(__name__)\n\n\nclass NTLMConnectionPool(HTTPSConnectionPool):\n \"\"\"\n Implements an NTLM authentication version of an urllib3 connection pool\n \"\"\"\n\n scheme = \"https\"\n\n def __init__(self, user, pw, authurl, *args, **kwargs):\n \"\"\"\n authurl is a random URL on the server that is protected by NTLM.\n user is the Windows user, probably in the DOMAIN\\\\username format.\n pw is the password for the user.\n \"\"\"\n super(NTLMConnectionPool, self).__init__(*args, **kwargs)\n self.authurl = authurl\n self.rawuser = user\n user_parts = user.split(\"\\\\\", 1)\n self.domain = user_parts[0].upper()\n self.user = user_parts[1]\n self.pw = pw\n\n def _new_conn(self):\n # Performs the NTLM handshake that secures the connection. The socket\n # must be kept open while requests are performed.\n self.num_connections += 1\n log.debug(\n \"Starting NTLM HTTPS connection no. %d: https://%s%s\",\n self.num_connections,\n self.host,\n self.authurl,\n )\n\n headers = {\"Connection\": \"Keep-Alive\"}\n req_header = \"Authorization\"\n resp_header = \"www-authenticate\"\n\n conn = HTTPSConnection(host=self.host, port=self.port)\n\n # Send negotiation message\n headers[req_header] = \"NTLM %s\" % ntlm.create_NTLM_NEGOTIATE_MESSAGE(\n self.rawuser\n )\n log.debug(\"Request headers: %s\", headers)\n conn.request(\"GET\", self.authurl, None, headers)\n res = conn.getresponse()\n reshdr = dict(res.headers)\n log.debug(\"Response status: %s %s\", res.status, res.reason)\n log.debug(\"Response headers: %s\", reshdr)\n log.debug(\"Response data: %s [...]\", res.read(100))\n\n # Remove the reference to the socket, so that it can not be closed by\n # the response object (we want to keep the socket open)\n res.fp = None\n\n # Server should respond with a challenge message\n auth_header_values = reshdr[resp_header].split(\", \")\n auth_header_value = None\n for s in auth_header_values:\n if s[:5] == \"NTLM \":\n auth_header_value = s[5:]\n if auth_header_value is None:\n raise Exception(\n \"Unexpected %s response header: %s\" % (resp_header, reshdr[resp_header])\n )\n\n # Send authentication message\n ServerChallenge, NegotiateFlags = ntlm.parse_NTLM_CHALLENGE_MESSAGE(\n auth_header_value\n )\n auth_msg = ntlm.create_NTLM_AUTHENTICATE_MESSAGE(\n ServerChallenge, self.user, self.domain, self.pw, NegotiateFlags\n )\n headers[req_header] = \"NTLM %s\" % auth_msg\n log.debug(\"Request headers: %s\", headers)\n conn.request(\"GET\", self.authurl, None, headers)\n res = conn.getresponse()\n log.debug(\"Response status: %s %s\", res.status, res.reason)\n log.debug(\"Response headers: %s\", dict(res.headers))\n log.debug(\"Response data: %s [...]\", res.read()[:100])\n if res.status != 200:\n if res.status == 401:\n raise Exception(\"Server rejected request: wrong username or password\")\n raise Exception(\"Wrong server response: %s %s\" % (res.status, res.reason))\n\n res.fp = None\n log.debug(\"Connection established\")\n return conn\n\n def urlopen(\n self,\n method,\n url,\n body=None,\n headers=None,\n retries=3,\n redirect=True,\n assert_same_host=True,\n ):\n if headers is None:\n headers = {}\n headers[\"Connection\"] = \"Keep-Alive\"\n return super(NTLMConnectionPool, self).urlopen(\n method, url, body, headers, retries, redirect, assert_same_host\n )\n",[],[213,919,920,921,1016,1050,1067,1301,1319],"0d70b120-67fc-11f0-95df-0224a6c84d84","appengine.py","0d70b1f2-67fc-11f0-95df-0224a6c84d84",499,["D",1753299270333],"\"\"\"\nThis module provides a pool manager that uses Google App Engine's\n`URLFetch Service `_.\n\nExample usage::\n\n from pip._vendor.urllib3 import PoolManager\n from pip._vendor.urllib3.contrib.appengine import AppEngineManager, is_appengine_sandbox\n\n if is_appengine_sandbox():\n # AppEngineManager uses AppEngine's URLFetch API behind the scenes\n http = AppEngineManager()\n else:\n # PoolManager uses a socket-level API behind the scenes\n http = PoolManager()\n\n r = http.request('GET', 'https://google.com/')\n\nThere are `limitations `_ to the URLFetch service and it may not be\nthe best choice for your application. There are three options for using\nurllib3 on Google App Engine:\n\n1. You can use :class:`AppEngineManager` with URLFetch. URLFetch is\n cost-effective in many circumstances as long as your usage is within the\n limitations.\n2. You can use a normal :class:`~urllib3.PoolManager` by enabling sockets.\n Sockets also have `limitations and restrictions\n `_ and have a lower free quota than URLFetch.\n To use sockets, be sure to specify the following in your ``app.yaml``::\n\n env_variables:\n GAE_USE_SOCKETS_HTTPLIB : 'true'\n\n3. If you are using `App Engine Flexible\n`_, you can use the standard\n:class:`PoolManager` without any configuration or special environment variables.\n\"\"\"\n\nfrom __future__ import absolute_import\n\nimport io\nimport logging\nimport warnings\n\nfrom ..exceptions import (\n HTTPError,\n HTTPWarning,\n MaxRetryError,\n ProtocolError,\n SSLError,\n TimeoutError,\n)\nfrom ..packages.six.moves.urllib.parse import urljoin\nfrom ..request import RequestMethods\nfrom ..response import HTTPResponse\nfrom ..util.retry import Retry\nfrom ..util.timeout import Timeout\nfrom . import _appengine_environ\n\ntry:\n from google.appengine.api import urlfetch\nexcept ImportError:\n urlfetch = None\n\n\nlog = logging.getLogger(__name__)\n\n\nclass AppEnginePlatformWarning(HTTPWarning):\n pass\n\n\nclass AppEnginePlatformError(HTTPError):\n pass\n\n\nclass AppEngineManager(RequestMethods):\n \"\"\"\n Connection manager for Google App Engine sandbox applications.\n\n This manager uses the URLFetch service directly instead of using the\n emulated httplib, and is subject to URLFetch limitations as described in\n the App Engine documentation `here\n `_.\n\n Notably it will raise an :class:`AppEnginePlatformError` if:\n * URLFetch is not available.\n * If you attempt to use this on App Engine Flexible, as full socket\n support is available.\n * If a request size is more than 10 megabytes.\n * If a response size is more than 32 megabytes.\n * If you use an unsupported request method such as OPTIONS.\n\n Beyond those cases, it will raise normal urllib3 errors.\n \"\"\"\n\n def __init__(\n self,\n headers=None,\n retries=None,\n validate_certificate=True,\n urlfetch_retries=True,\n ):\n if not urlfetch:\n raise AppEnginePlatformError(\n \"URLFetch is not available in this environment.\"\n )\n\n warnings.warn(\n \"urllib3 is using URLFetch on Google App Engine sandbox instead \"\n \"of sockets. To use sockets directly instead of URLFetch see \"\n \"https://urllib3.readthedocs.io/en/1.26.x/reference/urllib3.contrib.html.\",\n AppEnginePlatformWarning,\n )\n\n RequestMethods.__init__(self, headers)\n self.validate_certificate = validate_certificate\n self.urlfetch_retries = urlfetch_retries\n\n self.retries = retries or Retry.DEFAULT\n\n def __enter__(self):\n return self\n\n def __exit__(self, exc_type, exc_val, exc_tb):\n # Return False to re-raise any potential exceptions\n return False\n\n def urlopen(\n self,\n method,\n url,\n body=None,\n headers=None,\n retries=None,\n redirect=True,\n timeout=Timeout.DEFAULT_TIMEOUT,\n **response_kw\n ):\n\n retries = self._get_retries(retries, redirect)\n\n try:\n follow_redirects = redirect and retries.redirect != 0 and retries.total\n response = urlfetch.fetch(\n url,\n payload=body,\n method=method,\n headers=headers or {},\n allow_truncated=False,\n follow_redirects=self.urlfetch_retries and follow_redirects,\n deadline=self._get_absolute_timeout(timeout),\n validate_certificate=self.validate_certificate,\n )\n except urlfetch.DeadlineExceededError as e:\n raise TimeoutError(self, e)\n\n except urlfetch.InvalidURLError as e:\n if \"too large\" in str(e):\n raise AppEnginePlatformError(\n \"URLFetch request too large, URLFetch only \"\n \"supports requests up to 10mb in size.\",\n e,\n )\n raise ProtocolError(e)\n\n except urlfetch.DownloadError as e:\n if \"Too many redirects\" in str(e):\n raise MaxRetryError(self, url, reason=e)\n raise ProtocolError(e)\n\n except urlfetch.ResponseTooLargeError as e:\n raise AppEnginePlatformError(\n \"URLFetch response too large, URLFetch only supports\"\n \"responses up to 32mb in size.\",\n e,\n )\n\n except urlfetch.SSLCertificateError as e:\n raise SSLError(e)\n\n except urlfetch.InvalidMethodError as e:\n raise AppEnginePlatformError(\n \"URLFetch does not support method: %s\" % method, e\n )\n\n http_response = self._urlfetch_response_to_http_response(\n response, retries=retries, **response_kw\n )\n\n # Handle redirect?\n redirect_location = redirect and http_response.get_redirect_location()\n if redirect_location:\n # Check for redirect response\n if self.urlfetch_retries and retries.raise_on_redirect:\n raise MaxRetryError(self, url, \"too many redirects\")\n else:\n if http_response.status == 303:\n method = \"GET\"\n\n try:\n retries = retries.increment(\n method, url, response=http_response, _pool=self\n )\n except MaxRetryError:\n if retries.raise_on_redirect:\n raise MaxRetryError(self, url, \"too many redirects\")\n return http_response\n\n retries.sleep_for_retry(http_response)\n log.debug(\"Redirecting %s -> %s\", url, redirect_location)\n redirect_url = urljoin(url, redirect_location)\n return self.urlopen(\n method,\n redirect_url,\n body,\n headers,\n retries=retries,\n redirect=redirect,\n timeout=timeout,\n **response_kw\n )\n\n # Check if we should retry the HTTP response.\n has_retry_after = bool(http_response.headers.get(\"Retry-After\"))\n if retries.is_retry(method, http_response.status, has_retry_after):\n retries = retries.increment(method, url, response=http_response, _pool=self)\n log.debug(\"Retry: %s\", url)\n retries.sleep(http_response)\n return self.urlopen(\n method,\n url,\n body=body,\n headers=headers,\n retries=retries,\n redirect=redirect,\n timeout=timeout,\n **response_kw\n )\n\n return http_response\n\n def _urlfetch_response_to_http_response(self, urlfetch_resp, **response_kw):\n\n if is_prod_appengine():\n # Production GAE handles deflate encoding automatically, but does\n # not remove the encoding header.\n content_encoding = urlfetch_resp.headers.get(\"content-encoding\")\n\n if content_encoding == \"deflate\":\n del urlfetch_resp.headers[\"content-encoding\"]\n\n transfer_encoding = urlfetch_resp.headers.get(\"transfer-encoding\")\n # We have a full response's content,\n # so let's make sure we don't report ourselves as chunked data.\n if transfer_encoding == \"chunked\":\n encodings = transfer_encoding.split(\",\")\n encodings.remove(\"chunked\")\n urlfetch_resp.headers[\"transfer-encoding\"] = \",\".join(encodings)\n\n original_response = HTTPResponse(\n # In order for decoding to work, we must present the content as\n # a file-like object.\n body=io.BytesIO(urlfetch_resp.content),\n msg=urlfetch_resp.header_msg,\n headers=urlfetch_resp.headers,\n status=urlfetch_resp.status_code,\n **response_kw\n )\n\n return HTTPResponse(\n body=io.BytesIO(urlfetch_resp.content),\n headers=urlfetch_resp.headers,\n status=urlfetch_resp.status_code,\n original_response=original_response,\n **response_kw\n )\n\n def _get_absolute_timeout(self, timeout):\n if timeout is Timeout.DEFAULT_TIMEOUT:\n return None # Defer to URLFetch's default.\n if isinstance(timeout, Timeout):\n if timeout._read is not None or timeout._connect is not None:\n warnings.warn(\n \"URLFetch does not support granular timeout settings, \"\n \"reverting to total or default URLFetch timeout.\",\n AppEnginePlatformWarning,\n )\n return timeout.total\n return timeout\n\n def _get_retries(self, retries, redirect):\n if not isinstance(retries, Retry):\n retries = Retry.from_int(retries, redirect=redirect, default=self.retries)\n\n if retries.connect or retries.read or retries.redirect:\n warnings.warn(\n \"URLFetch only supports total retries and does not \"\n \"recognize connect, read, or redirect retry parameters.\",\n AppEnginePlatformWarning,\n )\n\n return retries\n\n\n# Alias methods from _appengine_environ to maintain public API interface.\n\nis_appengine = _appengine_environ.is_appengine\nis_appengine_sandbox = _appengine_environ.is_appengine_sandbox\nis_local_appengine = _appengine_environ.is_local_appengine\nis_prod_appengine = _appengine_environ.is_prod_appengine\nis_prod_appengine_mvms = _appengine_environ.is_prod_appengine_mvms\n",[],[213,919,920,921,1016,1050,1067,1301,1327],"0d650168-67fc-11f0-bcbe-0224a6c84d84","_appengine_environ.py","0d65023a-67fc-11f0-bcbe-0224a6c84d84",497,["D",1753299270256],"\"\"\"\nThis module provides means to detect the App Engine environment.\n\"\"\"\n\nimport os\n\n\ndef is_appengine():\n return is_local_appengine() or is_prod_appengine()\n\n\ndef is_appengine_sandbox():\n \"\"\"Reports if the app is running in the first generation sandbox.\n\n The second generation runtimes are technically still in a sandbox, but it\n is much less restrictive, so generally you shouldn't need to check for it.\n see https://cloud.google.com/appengine/docs/standard/runtimes\n \"\"\"\n return is_appengine() and os.environ[\"APPENGINE_RUNTIME\"] == \"python27\"\n\n\ndef is_local_appengine():\n return \"APPENGINE_RUNTIME\" in os.environ and os.environ.get(\n \"SERVER_SOFTWARE\", \"\"\n ).startswith(\"Development/\")\n\n\ndef is_prod_appengine():\n return \"APPENGINE_RUNTIME\" in os.environ and os.environ.get(\n \"SERVER_SOFTWARE\", \"\"\n ).startswith(\"Google App Engine/\")\n\n\ndef is_prod_appengine_mvms():\n \"\"\"Deprecated.\"\"\"\n return False\n",[],[213,919,920,921,1016,1050,1067,1301,1335],"0d7514cc-67fc-11f0-b5f5-0224a6c84d84","low_level.py","0d75159e-67fc-11f0-b5f5-0224a6c84d84","03898902-67fc-11f0-a988-0224a6c84d84",500,["D",1753299270364],"\"\"\"\nLow-level helpers for the SecureTransport bindings.\n\nThese are Python functions that are not directly related to the high-level APIs\nbut are necessary to get them to work. They include a whole bunch of low-level\nCoreFoundation messing about and memory management. The concerns in this module\nare almost entirely about trying to avoid memory leaks and providing\nappropriate and useful assistance to the higher-level code.\n\"\"\"\nimport base64\nimport ctypes\nimport itertools\nimport os\nimport re\nimport ssl\nimport struct\nimport tempfile\n\nfrom .bindings import CFConst, CoreFoundation, Security\n\n# This regular expression is used to grab PEM data out of a PEM bundle.\n_PEM_CERTS_RE = re.compile(\n b\"-----BEGIN CERTIFICATE-----\\n(.*?)\\n-----END CERTIFICATE-----\", re.DOTALL\n)\n\n\ndef _cf_data_from_bytes(bytestring):\n \"\"\"\n Given a bytestring, create a CFData object from it. This CFData object must\n be CFReleased by the caller.\n \"\"\"\n return CoreFoundation.CFDataCreate(\n CoreFoundation.kCFAllocatorDefault, bytestring, len(bytestring)\n )\n\n\ndef _cf_dictionary_from_tuples(tuples):\n \"\"\"\n Given a list of Python tuples, create an associated CFDictionary.\n \"\"\"\n dictionary_size = len(tuples)\n\n # We need to get the dictionary keys and values out in the same order.\n keys = (t[0] for t in tuples)\n values = (t[1] for t in tuples)\n cf_keys = (CoreFoundation.CFTypeRef * dictionary_size)(*keys)\n cf_values = (CoreFoundation.CFTypeRef * dictionary_size)(*values)\n\n return CoreFoundation.CFDictionaryCreate(\n CoreFoundation.kCFAllocatorDefault,\n cf_keys,\n cf_values,\n dictionary_size,\n CoreFoundation.kCFTypeDictionaryKeyCallBacks,\n CoreFoundation.kCFTypeDictionaryValueCallBacks,\n )\n\n\ndef _cfstr(py_bstr):\n \"\"\"\n Given a Python binary data, create a CFString.\n The string must be CFReleased by the caller.\n \"\"\"\n c_str = ctypes.c_char_p(py_bstr)\n cf_str = CoreFoundation.CFStringCreateWithCString(\n CoreFoundation.kCFAllocatorDefault,\n c_str,\n CFConst.kCFStringEncodingUTF8,\n )\n return cf_str\n\n\ndef _create_cfstring_array(lst):\n \"\"\"\n Given a list of Python binary data, create an associated CFMutableArray.\n The array must be CFReleased by the caller.\n\n Raises an ssl.SSLError on failure.\n \"\"\"\n cf_arr = None\n try:\n cf_arr = CoreFoundation.CFArrayCreateMutable(\n CoreFoundation.kCFAllocatorDefault,\n 0,\n ctypes.byref(CoreFoundation.kCFTypeArrayCallBacks),\n )\n if not cf_arr:\n raise MemoryError(\"Unable to allocate memory!\")\n for item in lst:\n cf_str = _cfstr(item)\n if not cf_str:\n raise MemoryError(\"Unable to allocate memory!\")\n try:\n CoreFoundation.CFArrayAppendValue(cf_arr, cf_str)\n finally:\n CoreFoundation.CFRelease(cf_str)\n except BaseException as e:\n if cf_arr:\n CoreFoundation.CFRelease(cf_arr)\n raise ssl.SSLError(\"Unable to allocate array: %s\" % (e,))\n return cf_arr\n\n\ndef _cf_string_to_unicode(value):\n \"\"\"\n Creates a Unicode string from a CFString object. Used entirely for error\n reporting.\n\n Yes, it annoys me quite a lot that this function is this complex.\n \"\"\"\n value_as_void_p = ctypes.cast(value, ctypes.POINTER(ctypes.c_void_p))\n\n string = CoreFoundation.CFStringGetCStringPtr(\n value_as_void_p, CFConst.kCFStringEncodingUTF8\n )\n if string is None:\n buffer = ctypes.create_string_buffer(1024)\n result = CoreFoundation.CFStringGetCString(\n value_as_void_p, buffer, 1024, CFConst.kCFStringEncodingUTF8\n )\n if not result:\n raise OSError(\"Error copying C string from CFStringRef\")\n string = buffer.value\n if string is not None:\n string = string.decode(\"utf-8\")\n return string\n\n\ndef _assert_no_error(error, exception_class=None):\n \"\"\"\n Checks the return code and throws an exception if there is an error to\n report\n \"\"\"\n if error == 0:\n return\n\n cf_error_string = Security.SecCopyErrorMessageString(error, None)\n output = _cf_string_to_unicode(cf_error_string)\n CoreFoundation.CFRelease(cf_error_string)\n\n if output is None or output == u\"\":\n output = u\"OSStatus %s\" % error\n\n if exception_class is None:\n exception_class = ssl.SSLError\n\n raise exception_class(output)\n\n\ndef _cert_array_from_pem(pem_bundle):\n \"\"\"\n Given a bundle of certs in PEM format, turns them into a CFArray of certs\n that can be used to validate a cert chain.\n \"\"\"\n # Normalize the PEM bundle's line endings.\n pem_bundle = pem_bundle.replace(b\"\\r\\n\", b\"\\n\")\n\n der_certs = [\n base64.b64decode(match.group(1)) for match in _PEM_CERTS_RE.finditer(pem_bundle)\n ]\n if not der_certs:\n raise ssl.SSLError(\"No root certificates specified\")\n\n cert_array = CoreFoundation.CFArrayCreateMutable(\n CoreFoundation.kCFAllocatorDefault,\n 0,\n ctypes.byref(CoreFoundation.kCFTypeArrayCallBacks),\n )\n if not cert_array:\n raise ssl.SSLError(\"Unable to allocate memory!\")\n\n try:\n for der_bytes in der_certs:\n certdata = _cf_data_from_bytes(der_bytes)\n if not certdata:\n raise ssl.SSLError(\"Unable to allocate memory!\")\n cert = Security.SecCertificateCreateWithData(\n CoreFoundation.kCFAllocatorDefault, certdata\n )\n CoreFoundation.CFRelease(certdata)\n if not cert:\n raise ssl.SSLError(\"Unable to build cert object!\")\n\n CoreFoundation.CFArrayAppendValue(cert_array, cert)\n CoreFoundation.CFRelease(cert)\n except Exception:\n # We need to free the array before the exception bubbles further.\n # We only want to do that if an error occurs: otherwise, the caller\n # should free.\n CoreFoundation.CFRelease(cert_array)\n raise\n\n return cert_array\n\n\ndef _is_cert(item):\n \"\"\"\n Returns True if a given CFTypeRef is a certificate.\n \"\"\"\n expected = Security.SecCertificateGetTypeID()\n return CoreFoundation.CFGetTypeID(item) == expected\n\n\ndef _is_identity(item):\n \"\"\"\n Returns True if a given CFTypeRef is an identity.\n \"\"\"\n expected = Security.SecIdentityGetTypeID()\n return CoreFoundation.CFGetTypeID(item) == expected\n\n\ndef _temporary_keychain():\n \"\"\"\n This function creates a temporary Mac keychain that we can use to work with\n credentials. This keychain uses a one-time password and a temporary file to\n store the data. We expect to have one keychain per socket. The returned\n SecKeychainRef must be freed by the caller, including calling\n SecKeychainDelete.\n\n Returns a tuple of the SecKeychainRef and the path to the temporary\n directory that contains it.\n \"\"\"\n # Unfortunately, SecKeychainCreate requires a path to a keychain. This\n # means we cannot use mkstemp to use a generic temporary file. Instead,\n # we're going to create a temporary directory and a filename to use there.\n # This filename will be 8 random bytes expanded into base64. We also need\n # some random bytes to password-protect the keychain we're creating, so we\n # ask for 40 random bytes.\n random_bytes = os.urandom(40)\n filename = base64.b16encode(random_bytes[:8]).decode(\"utf-8\")\n password = base64.b16encode(random_bytes[8:]) # Must be valid UTF-8\n tempdirectory = tempfile.mkdtemp()\n\n keychain_path = os.path.join(tempdirectory, filename).encode(\"utf-8\")\n\n # We now want to create the keychain itself.\n keychain = Security.SecKeychainRef()\n status = Security.SecKeychainCreate(\n keychain_path, len(password), password, False, None, ctypes.byref(keychain)\n )\n _assert_no_error(status)\n\n # Having created the keychain, we want to pass it off to the caller.\n return keychain, tempdirectory\n\n\ndef _load_items_from_file(keychain, path):\n \"\"\"\n Given a single file, loads all the trust objects from it into arrays and\n the keychain.\n Returns a tuple of lists: the first list is a list of identities, the\n second a list of certs.\n \"\"\"\n certificates = []\n identities = []\n result_array = None\n\n with open(path, \"rb\") as f:\n raw_filedata = f.read()\n\n try:\n filedata = CoreFoundation.CFDataCreate(\n CoreFoundation.kCFAllocatorDefault, raw_filedata, len(raw_filedata)\n )\n result_array = CoreFoundation.CFArrayRef()\n result = Security.SecItemImport(\n filedata, # cert data\n None, # Filename, leaving it out for now\n None, # What the type of the file is, we don't care\n None, # what's in the file, we don't care\n 0, # import flags\n None, # key params, can include passphrase in the future\n keychain, # The keychain to insert into\n ctypes.byref(result_array), # Results\n )\n _assert_no_error(result)\n\n # A CFArray is not very useful to us as an intermediary\n # representation, so we are going to extract the objects we want\n # and then free the array. We don't need to keep hold of keys: the\n # keychain already has them!\n result_count = CoreFoundation.CFArrayGetCount(result_array)\n for index in range(result_count):\n item = CoreFoundation.CFArrayGetValueAtIndex(result_array, index)\n item = ctypes.cast(item, CoreFoundation.CFTypeRef)\n\n if _is_cert(item):\n CoreFoundation.CFRetain(item)\n certificates.append(item)\n elif _is_identity(item):\n CoreFoundation.CFRetain(item)\n identities.append(item)\n finally:\n if result_array:\n CoreFoundation.CFRelease(result_array)\n\n CoreFoundation.CFRelease(filedata)\n\n return (identities, certificates)\n\n\ndef _load_client_cert_chain(keychain, *paths):\n \"\"\"\n Load certificates and maybe keys from a number of files. Has the end goal\n of returning a CFArray containing one SecIdentityRef, and then zero or more\n SecCertificateRef objects, suitable for use as a client certificate trust\n chain.\n \"\"\"\n # Ok, the strategy.\n #\n # This relies on knowing that macOS will not give you a SecIdentityRef\n # unless you have imported a key into a keychain. This is a somewhat\n # artificial limitation of macOS (for example, it doesn't necessarily\n # affect iOS), but there is nothing inside Security.framework that lets you\n # get a SecIdentityRef without having a key in a keychain.\n #\n # So the policy here is we take all the files and iterate them in order.\n # Each one will use SecItemImport to have one or more objects loaded from\n # it. We will also point at a keychain that macOS can use to work with the\n # private key.\n #\n # Once we have all the objects, we'll check what we actually have. If we\n # already have a SecIdentityRef in hand, fab: we'll use that. Otherwise,\n # we'll take the first certificate (which we assume to be our leaf) and\n # ask the keychain to give us a SecIdentityRef with that cert's associated\n # key.\n #\n # We'll then return a CFArray containing the trust chain: one\n # SecIdentityRef and then zero-or-more SecCertificateRef objects. The\n # responsibility for freeing this CFArray will be with the caller. This\n # CFArray must remain alive for the entire connection, so in practice it\n # will be stored with a single SSLSocket, along with the reference to the\n # keychain.\n certificates = []\n identities = []\n\n # Filter out bad paths.\n paths = (path for path in paths if path)\n\n try:\n for file_path in paths:\n new_identities, new_certs = _load_items_from_file(keychain, file_path)\n identities.extend(new_identities)\n certificates.extend(new_certs)\n\n # Ok, we have everything. The question is: do we have an identity? If\n # not, we want to grab one from the first cert we have.\n if not identities:\n new_identity = Security.SecIdentityRef()\n status = Security.SecIdentityCreateWithCertificate(\n keychain, certificates[0], ctypes.byref(new_identity)\n )\n _assert_no_error(status)\n identities.append(new_identity)\n\n # We now want to release the original certificate, as we no longer\n # need it.\n CoreFoundation.CFRelease(certificates.pop(0))\n\n # We now need to build a new CFArray that holds the trust chain.\n trust_chain = CoreFoundation.CFArrayCreateMutable(\n CoreFoundation.kCFAllocatorDefault,\n 0,\n ctypes.byref(CoreFoundation.kCFTypeArrayCallBacks),\n )\n for item in itertools.chain(identities, certificates):\n # ArrayAppendValue does a CFRetain on the item. That's fine,\n # because the finally block will release our other refs to them.\n CoreFoundation.CFArrayAppendValue(trust_chain, item)\n\n return trust_chain\n finally:\n for obj in itertools.chain(identities, certificates):\n CoreFoundation.CFRelease(obj)\n\n\nTLS_PROTOCOL_VERSIONS = {\n \"SSLv2\": (0, 2),\n \"SSLv3\": (3, 0),\n \"TLSv1\": (3, 1),\n \"TLSv1.1\": (3, 2),\n \"TLSv1.2\": (3, 3),\n}\n\n\ndef _build_tls_unknown_ca_alert(version):\n \"\"\"\n Builds a TLS alert record for an unknown CA.\n \"\"\"\n ver_maj, ver_min = TLS_PROTOCOL_VERSIONS[version]\n severity_fatal = 0x02\n description_unknown_ca = 0x30\n msg = struct.pack(\">BB\", severity_fatal, description_unknown_ca)\n msg_len = len(msg)\n record_type_alert = 0x15\n record = struct.pack(\">BBBH\", record_type_alert, ver_maj, ver_min, msg_len) + msg\n return record\n",[],[213,919,920,921,1016,1050,1067,1301,1351,1343],"_securetransport","0d79a546-67fc-11f0-8a1c-0224a6c84d84","bindings.py","0d79a5d2-67fc-11f0-8a1c-0224a6c84d84",501,["D",1753299270393],"\"\"\"\nThis module uses ctypes to bind a whole bunch of functions and constants from\nSecureTransport. The goal here is to provide the low-level API to\nSecureTransport. These are essentially the C-level functions and constants, and\nthey're pretty gross to work with.\n\nThis code is a bastardised version of the code found in Will Bond's oscrypto\nlibrary. An enormous debt is owed to him for blazing this trail for us. For\nthat reason, this code should be considered to be covered both by urllib3's\nlicense and by oscrypto's:\n\n Copyright (c) 2015-2016 Will Bond \n\n Permission is hereby granted, free of charge, to any person obtaining a\n copy of this software and associated documentation files (the \"Software\"),\n to deal in the Software without restriction, including without limitation\n the rights to use, copy, modify, merge, publish, distribute, sublicense,\n and/or sell copies of the Software, and to permit persons to whom the\n Software is furnished to do so, subject to the following conditions:\n\n The above copyright notice and this permission notice shall be included in\n all copies or substantial portions of the Software.\n\n THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\n DEALINGS IN THE SOFTWARE.\n\"\"\"\nfrom __future__ import absolute_import\n\nimport platform\nfrom ctypes import (\n CDLL,\n CFUNCTYPE,\n POINTER,\n c_bool,\n c_byte,\n c_char_p,\n c_int32,\n c_long,\n c_size_t,\n c_uint32,\n c_ulong,\n c_void_p,\n)\nfrom ctypes.util import find_library\n\nfrom ...packages.six import raise_from\n\nif platform.system() != \"Darwin\":\n raise ImportError(\"Only macOS is supported\")\n\nversion = platform.mac_ver()[0]\nversion_info = tuple(map(int, version.split(\".\")))\nif version_info < (10, 8):\n raise OSError(\n \"Only OS X 10.8 and newer are supported, not %s.%s\"\n % (version_info[0], version_info[1])\n )\n\n\ndef load_cdll(name, macos10_16_path):\n \"\"\"Loads a CDLL by name, falling back to known path on 10.16+\"\"\"\n try:\n # Big Sur is technically 11 but we use 10.16 due to the Big Sur\n # beta being labeled as 10.16.\n if version_info >= (10, 16):\n path = macos10_16_path\n else:\n path = find_library(name)\n if not path:\n raise OSError # Caught and reraised as 'ImportError'\n return CDLL(path, use_errno=True)\n except OSError:\n raise_from(ImportError(\"The library %s failed to load\" % name), None)\n\n\nSecurity = load_cdll(\n \"Security\", \"/System/Library/Frameworks/Security.framework/Security\"\n)\nCoreFoundation = load_cdll(\n \"CoreFoundation\",\n \"/System/Library/Frameworks/CoreFoundation.framework/CoreFoundation\",\n)\n\n\nBoolean = c_bool\nCFIndex = c_long\nCFStringEncoding = c_uint32\nCFData = c_void_p\nCFString = c_void_p\nCFArray = c_void_p\nCFMutableArray = c_void_p\nCFDictionary = c_void_p\nCFError = c_void_p\nCFType = c_void_p\nCFTypeID = c_ulong\n\nCFTypeRef = POINTER(CFType)\nCFAllocatorRef = c_void_p\n\nOSStatus = c_int32\n\nCFDataRef = POINTER(CFData)\nCFStringRef = POINTER(CFString)\nCFArrayRef = POINTER(CFArray)\nCFMutableArrayRef = POINTER(CFMutableArray)\nCFDictionaryRef = POINTER(CFDictionary)\nCFArrayCallBacks = c_void_p\nCFDictionaryKeyCallBacks = c_void_p\nCFDictionaryValueCallBacks = c_void_p\n\nSecCertificateRef = POINTER(c_void_p)\nSecExternalFormat = c_uint32\nSecExternalItemType = c_uint32\nSecIdentityRef = POINTER(c_void_p)\nSecItemImportExportFlags = c_uint32\nSecItemImportExportKeyParameters = c_void_p\nSecKeychainRef = POINTER(c_void_p)\nSSLProtocol = c_uint32\nSSLCipherSuite = c_uint32\nSSLContextRef = POINTER(c_void_p)\nSecTrustRef = POINTER(c_void_p)\nSSLConnectionRef = c_uint32\nSecTrustResultType = c_uint32\nSecTrustOptionFlags = c_uint32\nSSLProtocolSide = c_uint32\nSSLConnectionType = c_uint32\nSSLSessionOption = c_uint32\n\n\ntry:\n Security.SecItemImport.argtypes = [\n CFDataRef,\n CFStringRef,\n POINTER(SecExternalFormat),\n POINTER(SecExternalItemType),\n SecItemImportExportFlags,\n POINTER(SecItemImportExportKeyParameters),\n SecKeychainRef,\n POINTER(CFArrayRef),\n ]\n Security.SecItemImport.restype = OSStatus\n\n Security.SecCertificateGetTypeID.argtypes = []\n Security.SecCertificateGetTypeID.restype = CFTypeID\n\n Security.SecIdentityGetTypeID.argtypes = []\n Security.SecIdentityGetTypeID.restype = CFTypeID\n\n Security.SecKeyGetTypeID.argtypes = []\n Security.SecKeyGetTypeID.restype = CFTypeID\n\n Security.SecCertificateCreateWithData.argtypes = [CFAllocatorRef, CFDataRef]\n Security.SecCertificateCreateWithData.restype = SecCertificateRef\n\n Security.SecCertificateCopyData.argtypes = [SecCertificateRef]\n Security.SecCertificateCopyData.restype = CFDataRef\n\n Security.SecCopyErrorMessageString.argtypes = [OSStatus, c_void_p]\n Security.SecCopyErrorMessageString.restype = CFStringRef\n\n Security.SecIdentityCreateWithCertificate.argtypes = [\n CFTypeRef,\n SecCertificateRef,\n POINTER(SecIdentityRef),\n ]\n Security.SecIdentityCreateWithCertificate.restype = OSStatus\n\n Security.SecKeychainCreate.argtypes = [\n c_char_p,\n c_uint32,\n c_void_p,\n Boolean,\n c_void_p,\n POINTER(SecKeychainRef),\n ]\n Security.SecKeychainCreate.restype = OSStatus\n\n Security.SecKeychainDelete.argtypes = [SecKeychainRef]\n Security.SecKeychainDelete.restype = OSStatus\n\n Security.SecPKCS12Import.argtypes = [\n CFDataRef,\n CFDictionaryRef,\n POINTER(CFArrayRef),\n ]\n Security.SecPKCS12Import.restype = OSStatus\n\n SSLReadFunc = CFUNCTYPE(OSStatus, SSLConnectionRef, c_void_p, POINTER(c_size_t))\n SSLWriteFunc = CFUNCTYPE(\n OSStatus, SSLConnectionRef, POINTER(c_byte), POINTER(c_size_t)\n )\n\n Security.SSLSetIOFuncs.argtypes = [SSLContextRef, SSLReadFunc, SSLWriteFunc]\n Security.SSLSetIOFuncs.restype = OSStatus\n\n Security.SSLSetPeerID.argtypes = [SSLContextRef, c_char_p, c_size_t]\n Security.SSLSetPeerID.restype = OSStatus\n\n Security.SSLSetCertificate.argtypes = [SSLContextRef, CFArrayRef]\n Security.SSLSetCertificate.restype = OSStatus\n\n Security.SSLSetCertificateAuthorities.argtypes = [SSLContextRef, CFTypeRef, Boolean]\n Security.SSLSetCertificateAuthorities.restype = OSStatus\n\n Security.SSLSetConnection.argtypes = [SSLContextRef, SSLConnectionRef]\n Security.SSLSetConnection.restype = OSStatus\n\n Security.SSLSetPeerDomainName.argtypes = [SSLContextRef, c_char_p, c_size_t]\n Security.SSLSetPeerDomainName.restype = OSStatus\n\n Security.SSLHandshake.argtypes = [SSLContextRef]\n Security.SSLHandshake.restype = OSStatus\n\n Security.SSLRead.argtypes = [SSLContextRef, c_char_p, c_size_t, POINTER(c_size_t)]\n Security.SSLRead.restype = OSStatus\n\n Security.SSLWrite.argtypes = [SSLContextRef, c_char_p, c_size_t, POINTER(c_size_t)]\n Security.SSLWrite.restype = OSStatus\n\n Security.SSLClose.argtypes = [SSLContextRef]\n Security.SSLClose.restype = OSStatus\n\n Security.SSLGetNumberSupportedCiphers.argtypes = [SSLContextRef, POINTER(c_size_t)]\n Security.SSLGetNumberSupportedCiphers.restype = OSStatus\n\n Security.SSLGetSupportedCiphers.argtypes = [\n SSLContextRef,\n POINTER(SSLCipherSuite),\n POINTER(c_size_t),\n ]\n Security.SSLGetSupportedCiphers.restype = OSStatus\n\n Security.SSLSetEnabledCiphers.argtypes = [\n SSLContextRef,\n POINTER(SSLCipherSuite),\n c_size_t,\n ]\n Security.SSLSetEnabledCiphers.restype = OSStatus\n\n Security.SSLGetNumberEnabledCiphers.argtype = [SSLContextRef, POINTER(c_size_t)]\n Security.SSLGetNumberEnabledCiphers.restype = OSStatus\n\n Security.SSLGetEnabledCiphers.argtypes = [\n SSLContextRef,\n POINTER(SSLCipherSuite),\n POINTER(c_size_t),\n ]\n Security.SSLGetEnabledCiphers.restype = OSStatus\n\n Security.SSLGetNegotiatedCipher.argtypes = [SSLContextRef, POINTER(SSLCipherSuite)]\n Security.SSLGetNegotiatedCipher.restype = OSStatus\n\n Security.SSLGetNegotiatedProtocolVersion.argtypes = [\n SSLContextRef,\n POINTER(SSLProtocol),\n ]\n Security.SSLGetNegotiatedProtocolVersion.restype = OSStatus\n\n Security.SSLCopyPeerTrust.argtypes = [SSLContextRef, POINTER(SecTrustRef)]\n Security.SSLCopyPeerTrust.restype = OSStatus\n\n Security.SecTrustSetAnchorCertificates.argtypes = [SecTrustRef, CFArrayRef]\n Security.SecTrustSetAnchorCertificates.restype = OSStatus\n\n Security.SecTrustSetAnchorCertificatesOnly.argstypes = [SecTrustRef, Boolean]\n Security.SecTrustSetAnchorCertificatesOnly.restype = OSStatus\n\n Security.SecTrustEvaluate.argtypes = [SecTrustRef, POINTER(SecTrustResultType)]\n Security.SecTrustEvaluate.restype = OSStatus\n\n Security.SecTrustGetCertificateCount.argtypes = [SecTrustRef]\n Security.SecTrustGetCertificateCount.restype = CFIndex\n\n Security.SecTrustGetCertificateAtIndex.argtypes = [SecTrustRef, CFIndex]\n Security.SecTrustGetCertificateAtIndex.restype = SecCertificateRef\n\n Security.SSLCreateContext.argtypes = [\n CFAllocatorRef,\n SSLProtocolSide,\n SSLConnectionType,\n ]\n Security.SSLCreateContext.restype = SSLContextRef\n\n Security.SSLSetSessionOption.argtypes = [SSLContextRef, SSLSessionOption, Boolean]\n Security.SSLSetSessionOption.restype = OSStatus\n\n Security.SSLSetProtocolVersionMin.argtypes = [SSLContextRef, SSLProtocol]\n Security.SSLSetProtocolVersionMin.restype = OSStatus\n\n Security.SSLSetProtocolVersionMax.argtypes = [SSLContextRef, SSLProtocol]\n Security.SSLSetProtocolVersionMax.restype = OSStatus\n\n try:\n Security.SSLSetALPNProtocols.argtypes = [SSLContextRef, CFArrayRef]\n Security.SSLSetALPNProtocols.restype = OSStatus\n except AttributeError:\n # Supported only in 10.12+\n pass\n\n Security.SecCopyErrorMessageString.argtypes = [OSStatus, c_void_p]\n Security.SecCopyErrorMessageString.restype = CFStringRef\n\n Security.SSLReadFunc = SSLReadFunc\n Security.SSLWriteFunc = SSLWriteFunc\n Security.SSLContextRef = SSLContextRef\n Security.SSLProtocol = SSLProtocol\n Security.SSLCipherSuite = SSLCipherSuite\n Security.SecIdentityRef = SecIdentityRef\n Security.SecKeychainRef = SecKeychainRef\n Security.SecTrustRef = SecTrustRef\n Security.SecTrustResultType = SecTrustResultType\n Security.SecExternalFormat = SecExternalFormat\n Security.OSStatus = OSStatus\n\n Security.kSecImportExportPassphrase = CFStringRef.in_dll(\n Security, \"kSecImportExportPassphrase\"\n )\n Security.kSecImportItemIdentity = CFStringRef.in_dll(\n Security, \"kSecImportItemIdentity\"\n )\n\n # CoreFoundation time!\n CoreFoundation.CFRetain.argtypes = [CFTypeRef]\n CoreFoundation.CFRetain.restype = CFTypeRef\n\n CoreFoundation.CFRelease.argtypes = [CFTypeRef]\n CoreFoundation.CFRelease.restype = None\n\n CoreFoundation.CFGetTypeID.argtypes = [CFTypeRef]\n CoreFoundation.CFGetTypeID.restype = CFTypeID\n\n CoreFoundation.CFStringCreateWithCString.argtypes = [\n CFAllocatorRef,\n c_char_p,\n CFStringEncoding,\n ]\n CoreFoundation.CFStringCreateWithCString.restype = CFStringRef\n\n CoreFoundation.CFStringGetCStringPtr.argtypes = [CFStringRef, CFStringEncoding]\n CoreFoundation.CFStringGetCStringPtr.restype = c_char_p\n\n CoreFoundation.CFStringGetCString.argtypes = [\n CFStringRef,\n c_char_p,\n CFIndex,\n CFStringEncoding,\n ]\n CoreFoundation.CFStringGetCString.restype = c_bool\n\n CoreFoundation.CFDataCreate.argtypes = [CFAllocatorRef, c_char_p, CFIndex]\n CoreFoundation.CFDataCreate.restype = CFDataRef\n\n CoreFoundation.CFDataGetLength.argtypes = [CFDataRef]\n CoreFoundation.CFDataGetLength.restype = CFIndex\n\n CoreFoundation.CFDataGetBytePtr.argtypes = [CFDataRef]\n CoreFoundation.CFDataGetBytePtr.restype = c_void_p\n\n CoreFoundation.CFDictionaryCreate.argtypes = [\n CFAllocatorRef,\n POINTER(CFTypeRef),\n POINTER(CFTypeRef),\n CFIndex,\n CFDictionaryKeyCallBacks,\n CFDictionaryValueCallBacks,\n ]\n CoreFoundation.CFDictionaryCreate.restype = CFDictionaryRef\n\n CoreFoundation.CFDictionaryGetValue.argtypes = [CFDictionaryRef, CFTypeRef]\n CoreFoundation.CFDictionaryGetValue.restype = CFTypeRef\n\n CoreFoundation.CFArrayCreate.argtypes = [\n CFAllocatorRef,\n POINTER(CFTypeRef),\n CFIndex,\n CFArrayCallBacks,\n ]\n CoreFoundation.CFArrayCreate.restype = CFArrayRef\n\n CoreFoundation.CFArrayCreateMutable.argtypes = [\n CFAllocatorRef,\n CFIndex,\n CFArrayCallBacks,\n ]\n CoreFoundation.CFArrayCreateMutable.restype = CFMutableArrayRef\n\n CoreFoundation.CFArrayAppendValue.argtypes = [CFMutableArrayRef, c_void_p]\n CoreFoundation.CFArrayAppendValue.restype = None\n\n CoreFoundation.CFArrayGetCount.argtypes = [CFArrayRef]\n CoreFoundation.CFArrayGetCount.restype = CFIndex\n\n CoreFoundation.CFArrayGetValueAtIndex.argtypes = [CFArrayRef, CFIndex]\n CoreFoundation.CFArrayGetValueAtIndex.restype = c_void_p\n\n CoreFoundation.kCFAllocatorDefault = CFAllocatorRef.in_dll(\n CoreFoundation, \"kCFAllocatorDefault\"\n )\n CoreFoundation.kCFTypeArrayCallBacks = c_void_p.in_dll(\n CoreFoundation, \"kCFTypeArrayCallBacks\"\n )\n CoreFoundation.kCFTypeDictionaryKeyCallBacks = c_void_p.in_dll(\n CoreFoundation, \"kCFTypeDictionaryKeyCallBacks\"\n )\n CoreFoundation.kCFTypeDictionaryValueCallBacks = c_void_p.in_dll(\n CoreFoundation, \"kCFTypeDictionaryValueCallBacks\"\n )\n\n CoreFoundation.CFTypeRef = CFTypeRef\n CoreFoundation.CFArrayRef = CFArrayRef\n CoreFoundation.CFStringRef = CFStringRef\n CoreFoundation.CFDictionaryRef = CFDictionaryRef\n\nexcept (AttributeError):\n raise ImportError(\"Error initializing ctypes\")\n\n\nclass CFConst(object):\n \"\"\"\n A class object that acts as essentially a namespace for CoreFoundation\n constants.\n \"\"\"\n\n kCFStringEncodingUTF8 = CFStringEncoding(0x08000100)\n\n\nclass SecurityConst(object):\n \"\"\"\n A class object that acts as essentially a namespace for Security constants.\n \"\"\"\n\n kSSLSessionOptionBreakOnServerAuth = 0\n\n kSSLProtocol2 = 1\n kSSLProtocol3 = 2\n kTLSProtocol1 = 4\n kTLSProtocol11 = 7\n kTLSProtocol12 = 8\n # SecureTransport does not support TLS 1.3 even if there's a constant for it\n kTLSProtocol13 = 10\n kTLSProtocolMaxSupported = 999\n\n kSSLClientSide = 1\n kSSLStreamType = 0\n\n kSecFormatPEMSequence = 10\n\n kSecTrustResultInvalid = 0\n kSecTrustResultProceed = 1\n # This gap is present on purpose: this was kSecTrustResultConfirm, which\n # is deprecated.\n kSecTrustResultDeny = 3\n kSecTrustResultUnspecified = 4\n kSecTrustResultRecoverableTrustFailure = 5\n kSecTrustResultFatalTrustFailure = 6\n kSecTrustResultOtherError = 7\n\n errSSLProtocol = -9800\n errSSLWouldBlock = -9803\n errSSLClosedGraceful = -9805\n errSSLClosedNoNotify = -9816\n errSSLClosedAbort = -9806\n\n errSSLXCertChainInvalid = -9807\n errSSLCrypto = -9809\n errSSLInternal = -9810\n errSSLCertExpired = -9814\n errSSLCertNotYetValid = -9815\n errSSLUnknownRootCert = -9812\n errSSLNoRootCert = -9813\n errSSLHostNameMismatch = -9843\n errSSLPeerHandshakeFail = -9824\n errSSLPeerUserCancelled = -9839\n errSSLWeakPeerEphemeralDHKey = -9850\n errSSLServerAuthCompleted = -9841\n errSSLRecordOverflow = -9847\n\n errSecVerifyFailed = -67808\n errSecNoTrustSettings = -25263\n errSecItemNotFound = -25300\n errSecInvalidTrustSettings = -25262\n\n # Cipher suites. We only pick the ones our default cipher string allows.\n # Source: https://developer.apple.com/documentation/security/1550981-ssl_cipher_suite_values\n TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 = 0xC02C\n TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 = 0xC030\n TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 = 0xC02B\n TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 = 0xC02F\n TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256 = 0xCCA9\n TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256 = 0xCCA8\n TLS_DHE_RSA_WITH_AES_256_GCM_SHA384 = 0x009F\n TLS_DHE_RSA_WITH_AES_128_GCM_SHA256 = 0x009E\n TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384 = 0xC024\n TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384 = 0xC028\n TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA = 0xC00A\n TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA = 0xC014\n TLS_DHE_RSA_WITH_AES_256_CBC_SHA256 = 0x006B\n TLS_DHE_RSA_WITH_AES_256_CBC_SHA = 0x0039\n TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256 = 0xC023\n TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256 = 0xC027\n TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA = 0xC009\n TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA = 0xC013\n TLS_DHE_RSA_WITH_AES_128_CBC_SHA256 = 0x0067\n TLS_DHE_RSA_WITH_AES_128_CBC_SHA = 0x0033\n TLS_RSA_WITH_AES_256_GCM_SHA384 = 0x009D\n TLS_RSA_WITH_AES_128_GCM_SHA256 = 0x009C\n TLS_RSA_WITH_AES_256_CBC_SHA256 = 0x003D\n TLS_RSA_WITH_AES_128_CBC_SHA256 = 0x003C\n TLS_RSA_WITH_AES_256_CBC_SHA = 0x0035\n TLS_RSA_WITH_AES_128_CBC_SHA = 0x002F\n TLS_AES_128_GCM_SHA256 = 0x1301\n TLS_AES_256_GCM_SHA384 = 0x1302\n TLS_AES_128_CCM_8_SHA256 = 0x1305\n TLS_AES_128_CCM_SHA256 = 0x1304\n",[],[213,919,920,921,1016,1050,1067,1301,1351,1353],"0389883a-67fc-11f0-a988-0224a6c84d84",105,["D",1753299253715],[688,689],[213,919,920,921,1016,1050,1067,1301,1351],"033a8762-67fc-11f0-b800-0224a6c84d84",102,["D",1753299253196],[687,690,691,692,693,694,695],[213,919,920,921,1016,1050,1067,1301],"fee07cbc-67fb-11f0-928e-0224a6c84d84",85,["D",1753299245897],[686,696,701,715,716,717,718,719,720,721,722,723,724,725],[213,919,920,921,1016,1050,1067],"0828322e-67fc-11f0-85ab-0224a6c84d84","_windows.py","082832ce-67fc-11f0-85ab-0224a6c84d84","fd7f4d6c-67fb-11f0-aedf-0224a6c84d84",296,["D",1753299261469],"import contextlib\nimport ssl\nimport typing\nfrom ctypes import WinDLL # type: ignore\nfrom ctypes import WinError # type: ignore\nfrom ctypes import (\n POINTER,\n Structure,\n c_char_p,\n c_ulong,\n c_void_p,\n c_wchar_p,\n cast,\n create_unicode_buffer,\n pointer,\n sizeof,\n)\nfrom ctypes.wintypes import (\n BOOL,\n DWORD,\n HANDLE,\n LONG,\n LPCSTR,\n LPCVOID,\n LPCWSTR,\n LPFILETIME,\n LPSTR,\n LPWSTR,\n)\nfrom typing import TYPE_CHECKING, Any\n\nfrom ._ssl_constants import _set_ssl_context_verify_mode\n\nHCERTCHAINENGINE = HANDLE\nHCERTSTORE = HANDLE\nHCRYPTPROV_LEGACY = HANDLE\n\n\nclass CERT_CONTEXT(Structure):\n _fields_ = (\n (\"dwCertEncodingType\", DWORD),\n (\"pbCertEncoded\", c_void_p),\n (\"cbCertEncoded\", DWORD),\n (\"pCertInfo\", c_void_p),\n (\"hCertStore\", HCERTSTORE),\n )\n\n\nPCERT_CONTEXT = POINTER(CERT_CONTEXT)\nPCCERT_CONTEXT = POINTER(PCERT_CONTEXT)\n\n\nclass CERT_ENHKEY_USAGE(Structure):\n _fields_ = (\n (\"cUsageIdentifier\", DWORD),\n (\"rgpszUsageIdentifier\", POINTER(LPSTR)),\n )\n\n\nPCERT_ENHKEY_USAGE = POINTER(CERT_ENHKEY_USAGE)\n\n\nclass CERT_USAGE_MATCH(Structure):\n _fields_ = (\n (\"dwType\", DWORD),\n (\"Usage\", CERT_ENHKEY_USAGE),\n )\n\n\nclass CERT_CHAIN_PARA(Structure):\n _fields_ = (\n (\"cbSize\", DWORD),\n (\"RequestedUsage\", CERT_USAGE_MATCH),\n (\"RequestedIssuancePolicy\", CERT_USAGE_MATCH),\n (\"dwUrlRetrievalTimeout\", DWORD),\n (\"fCheckRevocationFreshnessTime\", BOOL),\n (\"dwRevocationFreshnessTime\", DWORD),\n (\"pftCacheResync\", LPFILETIME),\n (\"pStrongSignPara\", c_void_p),\n (\"dwStrongSignFlags\", DWORD),\n )\n\n\nif TYPE_CHECKING:\n PCERT_CHAIN_PARA = pointer[CERT_CHAIN_PARA] # type: ignore[misc]\nelse:\n PCERT_CHAIN_PARA = POINTER(CERT_CHAIN_PARA)\n\n\nclass CERT_TRUST_STATUS(Structure):\n _fields_ = (\n (\"dwErrorStatus\", DWORD),\n (\"dwInfoStatus\", DWORD),\n )\n\n\nclass CERT_CHAIN_ELEMENT(Structure):\n _fields_ = (\n (\"cbSize\", DWORD),\n (\"pCertContext\", PCERT_CONTEXT),\n (\"TrustStatus\", CERT_TRUST_STATUS),\n (\"pRevocationInfo\", c_void_p),\n (\"pIssuanceUsage\", PCERT_ENHKEY_USAGE),\n (\"pApplicationUsage\", PCERT_ENHKEY_USAGE),\n (\"pwszExtendedErrorInfo\", LPCWSTR),\n )\n\n\nPCERT_CHAIN_ELEMENT = POINTER(CERT_CHAIN_ELEMENT)\n\n\nclass CERT_SIMPLE_CHAIN(Structure):\n _fields_ = (\n (\"cbSize\", DWORD),\n (\"TrustStatus\", CERT_TRUST_STATUS),\n (\"cElement\", DWORD),\n (\"rgpElement\", POINTER(PCERT_CHAIN_ELEMENT)),\n (\"pTrustListInfo\", c_void_p),\n (\"fHasRevocationFreshnessTime\", BOOL),\n (\"dwRevocationFreshnessTime\", DWORD),\n )\n\n\nPCERT_SIMPLE_CHAIN = POINTER(CERT_SIMPLE_CHAIN)\n\n\nclass CERT_CHAIN_CONTEXT(Structure):\n _fields_ = (\n (\"cbSize\", DWORD),\n (\"TrustStatus\", CERT_TRUST_STATUS),\n (\"cChain\", DWORD),\n (\"rgpChain\", POINTER(PCERT_SIMPLE_CHAIN)),\n (\"cLowerQualityChainContext\", DWORD),\n (\"rgpLowerQualityChainContext\", c_void_p),\n (\"fHasRevocationFreshnessTime\", BOOL),\n (\"dwRevocationFreshnessTime\", DWORD),\n )\n\n\nPCERT_CHAIN_CONTEXT = POINTER(CERT_CHAIN_CONTEXT)\nPCCERT_CHAIN_CONTEXT = POINTER(PCERT_CHAIN_CONTEXT)\n\n\nclass SSL_EXTRA_CERT_CHAIN_POLICY_PARA(Structure):\n _fields_ = (\n (\"cbSize\", DWORD),\n (\"dwAuthType\", DWORD),\n (\"fdwChecks\", DWORD),\n (\"pwszServerName\", LPCWSTR),\n )\n\n\nclass CERT_CHAIN_POLICY_PARA(Structure):\n _fields_ = (\n (\"cbSize\", DWORD),\n (\"dwFlags\", DWORD),\n (\"pvExtraPolicyPara\", c_void_p),\n )\n\n\nPCERT_CHAIN_POLICY_PARA = POINTER(CERT_CHAIN_POLICY_PARA)\n\n\nclass CERT_CHAIN_POLICY_STATUS(Structure):\n _fields_ = (\n (\"cbSize\", DWORD),\n (\"dwError\", DWORD),\n (\"lChainIndex\", LONG),\n (\"lElementIndex\", LONG),\n (\"pvExtraPolicyStatus\", c_void_p),\n )\n\n\nPCERT_CHAIN_POLICY_STATUS = POINTER(CERT_CHAIN_POLICY_STATUS)\n\n\nclass CERT_CHAIN_ENGINE_CONFIG(Structure):\n _fields_ = (\n (\"cbSize\", DWORD),\n (\"hRestrictedRoot\", HCERTSTORE),\n (\"hRestrictedTrust\", HCERTSTORE),\n (\"hRestrictedOther\", HCERTSTORE),\n (\"cAdditionalStore\", DWORD),\n (\"rghAdditionalStore\", c_void_p),\n (\"dwFlags\", DWORD),\n (\"dwUrlRetrievalTimeout\", DWORD),\n (\"MaximumCachedCertificates\", DWORD),\n (\"CycleDetectionModulus\", DWORD),\n (\"hExclusiveRoot\", HCERTSTORE),\n (\"hExclusiveTrustedPeople\", HCERTSTORE),\n (\"dwExclusiveFlags\", DWORD),\n )\n\n\nPCERT_CHAIN_ENGINE_CONFIG = POINTER(CERT_CHAIN_ENGINE_CONFIG)\nPHCERTCHAINENGINE = POINTER(HCERTCHAINENGINE)\n\nX509_ASN_ENCODING = 0x00000001\nPKCS_7_ASN_ENCODING = 0x00010000\nCERT_STORE_PROV_MEMORY = b\"Memory\"\nCERT_STORE_ADD_USE_EXISTING = 2\nUSAGE_MATCH_TYPE_OR = 1\nOID_PKIX_KP_SERVER_AUTH = c_char_p(b\"1.3.6.1.5.5.7.3.1\")\nCERT_CHAIN_REVOCATION_CHECK_END_CERT = 0x10000000\nCERT_CHAIN_REVOCATION_CHECK_CHAIN = 0x20000000\nCERT_CHAIN_POLICY_IGNORE_ALL_NOT_TIME_VALID_FLAGS = 0x00000007\nCERT_CHAIN_POLICY_IGNORE_INVALID_BASIC_CONSTRAINTS_FLAG = 0x00000008\nCERT_CHAIN_POLICY_ALLOW_UNKNOWN_CA_FLAG = 0x00000010\nCERT_CHAIN_POLICY_IGNORE_INVALID_NAME_FLAG = 0x00000040\nCERT_CHAIN_POLICY_IGNORE_WRONG_USAGE_FLAG = 0x00000020\nCERT_CHAIN_POLICY_IGNORE_INVALID_POLICY_FLAG = 0x00000080\nCERT_CHAIN_POLICY_IGNORE_ALL_REV_UNKNOWN_FLAGS = 0x00000F00\nCERT_CHAIN_POLICY_ALLOW_TESTROOT_FLAG = 0x00008000\nCERT_CHAIN_POLICY_TRUST_TESTROOT_FLAG = 0x00004000\nSECURITY_FLAG_IGNORE_CERT_CN_INVALID = 0x00001000\nAUTHTYPE_SERVER = 2\nCERT_CHAIN_POLICY_SSL = 4\nFORMAT_MESSAGE_FROM_SYSTEM = 0x00001000\nFORMAT_MESSAGE_IGNORE_INSERTS = 0x00000200\n\n# Flags to set for SSLContext.verify_mode=CERT_NONE\nCERT_CHAIN_POLICY_VERIFY_MODE_NONE_FLAGS = (\n CERT_CHAIN_POLICY_IGNORE_ALL_NOT_TIME_VALID_FLAGS\n | CERT_CHAIN_POLICY_IGNORE_INVALID_BASIC_CONSTRAINTS_FLAG\n | CERT_CHAIN_POLICY_ALLOW_UNKNOWN_CA_FLAG\n | CERT_CHAIN_POLICY_IGNORE_INVALID_NAME_FLAG\n | CERT_CHAIN_POLICY_IGNORE_WRONG_USAGE_FLAG\n | CERT_CHAIN_POLICY_IGNORE_INVALID_POLICY_FLAG\n | CERT_CHAIN_POLICY_IGNORE_ALL_REV_UNKNOWN_FLAGS\n | CERT_CHAIN_POLICY_ALLOW_TESTROOT_FLAG\n | CERT_CHAIN_POLICY_TRUST_TESTROOT_FLAG\n)\n\nwincrypt = WinDLL(\"crypt32.dll\")\nkernel32 = WinDLL(\"kernel32.dll\")\n\n\ndef _handle_win_error(result: bool, _: Any, args: Any) -> Any:\n if not result:\n # Note, actually raises OSError after calling GetLastError and FormatMessage\n raise WinError()\n return args\n\n\nCertCreateCertificateChainEngine = wincrypt.CertCreateCertificateChainEngine\nCertCreateCertificateChainEngine.argtypes = (\n PCERT_CHAIN_ENGINE_CONFIG,\n PHCERTCHAINENGINE,\n)\nCertCreateCertificateChainEngine.errcheck = _handle_win_error\n\nCertOpenStore = wincrypt.CertOpenStore\nCertOpenStore.argtypes = (LPCSTR, DWORD, HCRYPTPROV_LEGACY, DWORD, c_void_p)\nCertOpenStore.restype = HCERTSTORE\nCertOpenStore.errcheck = _handle_win_error\n\nCertAddEncodedCertificateToStore = wincrypt.CertAddEncodedCertificateToStore\nCertAddEncodedCertificateToStore.argtypes = (\n HCERTSTORE,\n DWORD,\n c_char_p,\n DWORD,\n DWORD,\n PCCERT_CONTEXT,\n)\nCertAddEncodedCertificateToStore.restype = BOOL\n\nCertCreateCertificateContext = wincrypt.CertCreateCertificateContext\nCertCreateCertificateContext.argtypes = (DWORD, c_char_p, DWORD)\nCertCreateCertificateContext.restype = PCERT_CONTEXT\nCertCreateCertificateContext.errcheck = _handle_win_error\n\nCertGetCertificateChain = wincrypt.CertGetCertificateChain\nCertGetCertificateChain.argtypes = (\n HCERTCHAINENGINE,\n PCERT_CONTEXT,\n LPFILETIME,\n HCERTSTORE,\n PCERT_CHAIN_PARA,\n DWORD,\n c_void_p,\n PCCERT_CHAIN_CONTEXT,\n)\nCertGetCertificateChain.restype = BOOL\nCertGetCertificateChain.errcheck = _handle_win_error\n\nCertVerifyCertificateChainPolicy = wincrypt.CertVerifyCertificateChainPolicy\nCertVerifyCertificateChainPolicy.argtypes = (\n c_ulong,\n PCERT_CHAIN_CONTEXT,\n PCERT_CHAIN_POLICY_PARA,\n PCERT_CHAIN_POLICY_STATUS,\n)\nCertVerifyCertificateChainPolicy.restype = BOOL\n\nCertCloseStore = wincrypt.CertCloseStore\nCertCloseStore.argtypes = (HCERTSTORE, DWORD)\nCertCloseStore.restype = BOOL\nCertCloseStore.errcheck = _handle_win_error\n\nCertFreeCertificateChain = wincrypt.CertFreeCertificateChain\nCertFreeCertificateChain.argtypes = (PCERT_CHAIN_CONTEXT,)\n\nCertFreeCertificateContext = wincrypt.CertFreeCertificateContext\nCertFreeCertificateContext.argtypes = (PCERT_CONTEXT,)\n\nCertFreeCertificateChainEngine = wincrypt.CertFreeCertificateChainEngine\nCertFreeCertificateChainEngine.argtypes = (HCERTCHAINENGINE,)\n\nFormatMessageW = kernel32.FormatMessageW\nFormatMessageW.argtypes = (\n DWORD,\n LPCVOID,\n DWORD,\n DWORD,\n LPWSTR,\n DWORD,\n c_void_p,\n)\nFormatMessageW.restype = DWORD\n\n\ndef _verify_peercerts_impl(\n ssl_context: ssl.SSLContext,\n cert_chain: list[bytes],\n server_hostname: str | None = None,\n) -> None:\n \"\"\"Verify the cert_chain from the server using Windows APIs.\"\"\"\n\n # If the peer didn't send any certificates then\n # we can't do verification. Raise an error.\n if not cert_chain:\n raise ssl.SSLCertVerificationError(\"Peer sent no certificates to verify\")\n\n pCertContext = None\n hIntermediateCertStore = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, None, 0, None)\n try:\n # Add intermediate certs to an in-memory cert store\n for cert_bytes in cert_chain[1:]:\n CertAddEncodedCertificateToStore(\n hIntermediateCertStore,\n X509_ASN_ENCODING | PKCS_7_ASN_ENCODING,\n cert_bytes,\n len(cert_bytes),\n CERT_STORE_ADD_USE_EXISTING,\n None,\n )\n\n # Cert context for leaf cert\n leaf_cert = cert_chain[0]\n pCertContext = CertCreateCertificateContext(\n X509_ASN_ENCODING | PKCS_7_ASN_ENCODING, leaf_cert, len(leaf_cert)\n )\n\n # Chain params to match certs for serverAuth extended usage\n cert_enhkey_usage = CERT_ENHKEY_USAGE()\n cert_enhkey_usage.cUsageIdentifier = 1\n cert_enhkey_usage.rgpszUsageIdentifier = (c_char_p * 1)(OID_PKIX_KP_SERVER_AUTH)\n cert_usage_match = CERT_USAGE_MATCH()\n cert_usage_match.Usage = cert_enhkey_usage\n chain_params = CERT_CHAIN_PARA()\n chain_params.RequestedUsage = cert_usage_match\n chain_params.cbSize = sizeof(chain_params)\n pChainPara = pointer(chain_params)\n\n if ssl_context.verify_flags & ssl.VERIFY_CRL_CHECK_CHAIN:\n chain_flags = CERT_CHAIN_REVOCATION_CHECK_CHAIN\n elif ssl_context.verify_flags & ssl.VERIFY_CRL_CHECK_LEAF:\n chain_flags = CERT_CHAIN_REVOCATION_CHECK_END_CERT\n else:\n chain_flags = 0\n\n try:\n # First attempt to verify using the default Windows system trust roots\n # (default chain engine).\n _get_and_verify_cert_chain(\n ssl_context,\n None,\n hIntermediateCertStore,\n pCertContext,\n pChainPara,\n server_hostname,\n chain_flags=chain_flags,\n )\n except ssl.SSLCertVerificationError as e:\n # If that fails but custom CA certs have been added\n # to the SSLContext using load_verify_locations,\n # try verifying using a custom chain engine\n # that trusts the custom CA certs.\n custom_ca_certs: list[bytes] | None = ssl_context.get_ca_certs(\n binary_form=True\n )\n if custom_ca_certs:\n try:\n _verify_using_custom_ca_certs(\n ssl_context,\n custom_ca_certs,\n hIntermediateCertStore,\n pCertContext,\n pChainPara,\n server_hostname,\n chain_flags=chain_flags,\n )\n # Raise the original error, not the new error.\n except ssl.SSLCertVerificationError:\n raise e from None\n else:\n raise\n finally:\n CertCloseStore(hIntermediateCertStore, 0)\n if pCertContext:\n CertFreeCertificateContext(pCertContext)\n\n\ndef _get_and_verify_cert_chain(\n ssl_context: ssl.SSLContext,\n hChainEngine: HCERTCHAINENGINE | None,\n hIntermediateCertStore: HCERTSTORE,\n pPeerCertContext: c_void_p,\n pChainPara: PCERT_CHAIN_PARA, # type: ignore[valid-type]\n server_hostname: str | None,\n chain_flags: int,\n) -> None:\n ppChainContext = None\n try:\n # Get cert chain\n ppChainContext = pointer(PCERT_CHAIN_CONTEXT())\n CertGetCertificateChain(\n hChainEngine, # chain engine\n pPeerCertContext, # leaf cert context\n None, # current system time\n hIntermediateCertStore, # additional in-memory cert store\n pChainPara, # chain-building parameters\n chain_flags,\n None, # reserved\n ppChainContext, # the resulting chain context\n )\n pChainContext = ppChainContext.contents\n\n # Verify cert chain\n ssl_extra_cert_chain_policy_para = SSL_EXTRA_CERT_CHAIN_POLICY_PARA()\n ssl_extra_cert_chain_policy_para.cbSize = sizeof(\n ssl_extra_cert_chain_policy_para\n )\n ssl_extra_cert_chain_policy_para.dwAuthType = AUTHTYPE_SERVER\n ssl_extra_cert_chain_policy_para.fdwChecks = 0\n if ssl_context.check_hostname is False:\n ssl_extra_cert_chain_policy_para.fdwChecks = (\n SECURITY_FLAG_IGNORE_CERT_CN_INVALID\n )\n if server_hostname:\n ssl_extra_cert_chain_policy_para.pwszServerName = c_wchar_p(server_hostname)\n\n chain_policy = CERT_CHAIN_POLICY_PARA()\n chain_policy.pvExtraPolicyPara = cast(\n pointer(ssl_extra_cert_chain_policy_para), c_void_p\n )\n if ssl_context.verify_mode == ssl.CERT_NONE:\n chain_policy.dwFlags |= CERT_CHAIN_POLICY_VERIFY_MODE_NONE_FLAGS\n chain_policy.cbSize = sizeof(chain_policy)\n\n pPolicyPara = pointer(chain_policy)\n policy_status = CERT_CHAIN_POLICY_STATUS()\n policy_status.cbSize = sizeof(policy_status)\n pPolicyStatus = pointer(policy_status)\n CertVerifyCertificateChainPolicy(\n CERT_CHAIN_POLICY_SSL,\n pChainContext,\n pPolicyPara,\n pPolicyStatus,\n )\n\n # Check status\n error_code = policy_status.dwError\n if error_code:\n # Try getting a human readable message for an error code.\n error_message_buf = create_unicode_buffer(1024)\n error_message_chars = FormatMessageW(\n FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,\n None,\n error_code,\n 0,\n error_message_buf,\n sizeof(error_message_buf),\n None,\n )\n\n # See if we received a message for the error,\n # otherwise we use a generic error with the\n # error code and hope that it's search-able.\n if error_message_chars <= 0:\n error_message = f\"Certificate chain policy error {error_code:#x} [{policy_status.lElementIndex}]\"\n else:\n error_message = error_message_buf.value.strip()\n\n err = ssl.SSLCertVerificationError(error_message)\n err.verify_message = error_message\n err.verify_code = error_code\n raise err from None\n finally:\n if ppChainContext:\n CertFreeCertificateChain(ppChainContext.contents)\n\n\ndef _verify_using_custom_ca_certs(\n ssl_context: ssl.SSLContext,\n custom_ca_certs: list[bytes],\n hIntermediateCertStore: HCERTSTORE,\n pPeerCertContext: c_void_p,\n pChainPara: PCERT_CHAIN_PARA, # type: ignore[valid-type]\n server_hostname: str | None,\n chain_flags: int,\n) -> None:\n hChainEngine = None\n hRootCertStore = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, None, 0, None)\n try:\n # Add custom CA certs to an in-memory cert store\n for cert_bytes in custom_ca_certs:\n CertAddEncodedCertificateToStore(\n hRootCertStore,\n X509_ASN_ENCODING | PKCS_7_ASN_ENCODING,\n cert_bytes,\n len(cert_bytes),\n CERT_STORE_ADD_USE_EXISTING,\n None,\n )\n\n # Create a custom cert chain engine which exclusively trusts\n # certs from our hRootCertStore\n cert_chain_engine_config = CERT_CHAIN_ENGINE_CONFIG()\n cert_chain_engine_config.cbSize = sizeof(cert_chain_engine_config)\n cert_chain_engine_config.hExclusiveRoot = hRootCertStore\n pConfig = pointer(cert_chain_engine_config)\n phChainEngine = pointer(HCERTCHAINENGINE())\n CertCreateCertificateChainEngine(\n pConfig,\n phChainEngine,\n )\n hChainEngine = phChainEngine.contents\n\n # Get and verify a cert chain using the custom chain engine\n _get_and_verify_cert_chain(\n ssl_context,\n hChainEngine,\n hIntermediateCertStore,\n pPeerCertContext,\n pChainPara,\n server_hostname,\n chain_flags,\n )\n finally:\n if hChainEngine:\n CertFreeCertificateChainEngine(hChainEngine)\n CertCloseStore(hRootCertStore, 0)\n\n\n@contextlib.contextmanager\ndef _configure_context(ctx: ssl.SSLContext) -> typing.Iterator[None]:\n check_hostname = ctx.check_hostname\n verify_mode = ctx.verify_mode\n ctx.check_hostname = False\n _set_ssl_context_verify_mode(ctx, ssl.CERT_NONE)\n try:\n yield\n finally:\n ctx.check_hostname = check_hostname\n _set_ssl_context_verify_mode(ctx, verify_mode)\n",[],[213,919,920,921,1016,1050,1384,1376],"truststore","08301322-67fc-11f0-b489-0224a6c84d84","_ssl_constants.py","083013d6-67fc-11f0-b489-0224a6c84d84",297,["D",1753299261434],"import ssl\nimport sys\nimport typing\n\n# Hold on to the original class so we can create it consistently\n# even if we inject our own SSLContext into the ssl module.\n_original_SSLContext = ssl.SSLContext\n_original_super_SSLContext = super(_original_SSLContext, _original_SSLContext)\n\n# CPython is known to be good, but non-CPython implementations\n# may implement SSLContext differently so to be safe we don't\n# subclass the SSLContext.\n\n# This is returned by truststore.SSLContext.__class__()\n_truststore_SSLContext_dunder_class: typing.Optional[type]\n\n# This value is the superclass of truststore.SSLContext.\n_truststore_SSLContext_super_class: type\n\nif sys.implementation.name == \"cpython\":\n _truststore_SSLContext_super_class = _original_SSLContext\n _truststore_SSLContext_dunder_class = None\nelse:\n _truststore_SSLContext_super_class = object\n _truststore_SSLContext_dunder_class = _original_SSLContext\n\n\ndef _set_ssl_context_verify_mode(\n ssl_context: ssl.SSLContext, verify_mode: ssl.VerifyMode\n) -> None:\n _original_super_SSLContext.verify_mode.__set__(ssl_context, verify_mode) # type: ignore[attr-defined]\n",[],[213,919,920,921,1016,1050,1384,1386],"080c7250-67fc-11f0-aedf-0224a6c84d84","_openssl.py","080c7336-67fc-11f0-aedf-0224a6c84d84",292,["D",1753299261275],"import contextlib\nimport os\nimport re\nimport ssl\nimport typing\n\n# candidates based on https://github.com/tiran/certifi-system-store by Christian Heimes\n_CA_FILE_CANDIDATES = [\n # Alpine, Arch, Fedora 34+, OpenWRT, RHEL 9+, BSD\n \"/etc/ssl/cert.pem\",\n # Fedora <= 34, RHEL <= 9, CentOS <= 9\n \"/etc/pki/tls/cert.pem\",\n # Debian, Ubuntu (requires ca-certificates)\n \"/etc/ssl/certs/ca-certificates.crt\",\n # SUSE\n \"/etc/ssl/ca-bundle.pem\",\n]\n\n_HASHED_CERT_FILENAME_RE = re.compile(r\"^[0-9a-fA-F]{8}\\.[0-9]$\")\n\n\n@contextlib.contextmanager\ndef _configure_context(ctx: ssl.SSLContext) -> typing.Iterator[None]:\n # First, check whether the default locations from OpenSSL\n # seem like they will give us a usable set of CA certs.\n # ssl.get_default_verify_paths already takes care of:\n # - getting cafile from either the SSL_CERT_FILE env var\n # or the path configured when OpenSSL was compiled,\n # and verifying that that path exists\n # - getting capath from either the SSL_CERT_DIR env var\n # or the path configured when OpenSSL was compiled,\n # and verifying that that path exists\n # In addition we'll check whether capath appears to contain certs.\n defaults = ssl.get_default_verify_paths()\n if defaults.cafile or (defaults.capath and _capath_contains_certs(defaults.capath)):\n ctx.set_default_verify_paths()\n else:\n # cafile from OpenSSL doesn't exist\n # and capath from OpenSSL doesn't contain certs.\n # Let's search other common locations instead.\n for cafile in _CA_FILE_CANDIDATES:\n if os.path.isfile(cafile):\n ctx.load_verify_locations(cafile=cafile)\n break\n\n yield\n\n\ndef _capath_contains_certs(capath: str) -> bool:\n \"\"\"Check whether capath exists and contains certs in the expected format.\"\"\"\n if not os.path.isdir(capath):\n return False\n for name in os.listdir(capath):\n if _HASHED_CERT_FILENAME_RE.match(name):\n return True\n return False\n\n\ndef _verify_peercerts_impl(\n ssl_context: ssl.SSLContext,\n cert_chain: list[bytes],\n server_hostname: str | None = None,\n) -> None:\n # This is a no-op because we've enabled SSLContext's built-in\n # verification via verify_mode=CERT_REQUIRED, and don't need to repeat it.\n pass\n",[],[213,919,920,921,1016,1050,1384,1394],"08186f88-67fc-11f0-85ab-0224a6c84d84","_macos.py","0818701e-67fc-11f0-85ab-0224a6c84d84",293,["D",1753299261365],"import contextlib\nimport ctypes\nimport platform\nimport ssl\nimport typing\nfrom ctypes import (\n CDLL,\n POINTER,\n c_bool,\n c_char_p,\n c_int32,\n c_long,\n c_uint32,\n c_ulong,\n c_void_p,\n)\nfrom ctypes.util import find_library\n\nfrom ._ssl_constants import _set_ssl_context_verify_mode\n\n_mac_version = platform.mac_ver()[0]\n_mac_version_info = tuple(map(int, _mac_version.split(\".\")))\nif _mac_version_info < (10, 8):\n raise ImportError(\n f\"Only OS X 10.8 and newer are supported, not {_mac_version_info[0]}.{_mac_version_info[1]}\"\n )\n\n_is_macos_version_10_14_or_later = _mac_version_info >= (10, 14)\n\n\ndef _load_cdll(name: str, macos10_16_path: str) -> CDLL:\n \"\"\"Loads a CDLL by name, falling back to known path on 10.16+\"\"\"\n try:\n # Big Sur is technically 11 but we use 10.16 due to the Big Sur\n # beta being labeled as 10.16.\n path: str | None\n if _mac_version_info >= (10, 16):\n path = macos10_16_path\n else:\n path = find_library(name)\n if not path:\n raise OSError # Caught and reraised as 'ImportError'\n return CDLL(path, use_errno=True)\n except OSError:\n raise ImportError(f\"The library {name} failed to load\") from None\n\n\nSecurity = _load_cdll(\n \"Security\", \"/System/Library/Frameworks/Security.framework/Security\"\n)\nCoreFoundation = _load_cdll(\n \"CoreFoundation\",\n \"/System/Library/Frameworks/CoreFoundation.framework/CoreFoundation\",\n)\n\nBoolean = c_bool\nCFIndex = c_long\nCFStringEncoding = c_uint32\nCFData = c_void_p\nCFString = c_void_p\nCFArray = c_void_p\nCFMutableArray = c_void_p\nCFError = c_void_p\nCFType = c_void_p\nCFTypeID = c_ulong\nCFTypeRef = POINTER(CFType)\nCFAllocatorRef = c_void_p\n\nOSStatus = c_int32\n\nCFErrorRef = POINTER(CFError)\nCFDataRef = POINTER(CFData)\nCFStringRef = POINTER(CFString)\nCFArrayRef = POINTER(CFArray)\nCFMutableArrayRef = POINTER(CFMutableArray)\nCFArrayCallBacks = c_void_p\nCFOptionFlags = c_uint32\n\nSecCertificateRef = POINTER(c_void_p)\nSecPolicyRef = POINTER(c_void_p)\nSecTrustRef = POINTER(c_void_p)\nSecTrustResultType = c_uint32\nSecTrustOptionFlags = c_uint32\n\ntry:\n Security.SecCertificateCreateWithData.argtypes = [CFAllocatorRef, CFDataRef]\n Security.SecCertificateCreateWithData.restype = SecCertificateRef\n\n Security.SecCertificateCopyData.argtypes = [SecCertificateRef]\n Security.SecCertificateCopyData.restype = CFDataRef\n\n Security.SecCopyErrorMessageString.argtypes = [OSStatus, c_void_p]\n Security.SecCopyErrorMessageString.restype = CFStringRef\n\n Security.SecTrustSetAnchorCertificates.argtypes = [SecTrustRef, CFArrayRef]\n Security.SecTrustSetAnchorCertificates.restype = OSStatus\n\n Security.SecTrustSetAnchorCertificatesOnly.argtypes = [SecTrustRef, Boolean]\n Security.SecTrustSetAnchorCertificatesOnly.restype = OSStatus\n\n Security.SecPolicyCreateRevocation.argtypes = [CFOptionFlags]\n Security.SecPolicyCreateRevocation.restype = SecPolicyRef\n\n Security.SecPolicyCreateSSL.argtypes = [Boolean, CFStringRef]\n Security.SecPolicyCreateSSL.restype = SecPolicyRef\n\n Security.SecTrustCreateWithCertificates.argtypes = [\n CFTypeRef,\n CFTypeRef,\n POINTER(SecTrustRef),\n ]\n Security.SecTrustCreateWithCertificates.restype = OSStatus\n\n Security.SecTrustGetTrustResult.argtypes = [\n SecTrustRef,\n POINTER(SecTrustResultType),\n ]\n Security.SecTrustGetTrustResult.restype = OSStatus\n\n Security.SecTrustEvaluate.argtypes = [\n SecTrustRef,\n POINTER(SecTrustResultType),\n ]\n Security.SecTrustEvaluate.restype = OSStatus\n\n Security.SecTrustRef = SecTrustRef # type: ignore[attr-defined]\n Security.SecTrustResultType = SecTrustResultType # type: ignore[attr-defined]\n Security.OSStatus = OSStatus # type: ignore[attr-defined]\n\n kSecRevocationUseAnyAvailableMethod = 3\n kSecRevocationRequirePositiveResponse = 8\n\n CoreFoundation.CFRelease.argtypes = [CFTypeRef]\n CoreFoundation.CFRelease.restype = None\n\n CoreFoundation.CFGetTypeID.argtypes = [CFTypeRef]\n CoreFoundation.CFGetTypeID.restype = CFTypeID\n\n CoreFoundation.CFStringCreateWithCString.argtypes = [\n CFAllocatorRef,\n c_char_p,\n CFStringEncoding,\n ]\n CoreFoundation.CFStringCreateWithCString.restype = CFStringRef\n\n CoreFoundation.CFStringGetCStringPtr.argtypes = [CFStringRef, CFStringEncoding]\n CoreFoundation.CFStringGetCStringPtr.restype = c_char_p\n\n CoreFoundation.CFStringGetCString.argtypes = [\n CFStringRef,\n c_char_p,\n CFIndex,\n CFStringEncoding,\n ]\n CoreFoundation.CFStringGetCString.restype = c_bool\n\n CoreFoundation.CFDataCreate.argtypes = [CFAllocatorRef, c_char_p, CFIndex]\n CoreFoundation.CFDataCreate.restype = CFDataRef\n\n CoreFoundation.CFDataGetLength.argtypes = [CFDataRef]\n CoreFoundation.CFDataGetLength.restype = CFIndex\n\n CoreFoundation.CFDataGetBytePtr.argtypes = [CFDataRef]\n CoreFoundation.CFDataGetBytePtr.restype = c_void_p\n\n CoreFoundation.CFArrayCreate.argtypes = [\n CFAllocatorRef,\n POINTER(CFTypeRef),\n CFIndex,\n CFArrayCallBacks,\n ]\n CoreFoundation.CFArrayCreate.restype = CFArrayRef\n\n CoreFoundation.CFArrayCreateMutable.argtypes = [\n CFAllocatorRef,\n CFIndex,\n CFArrayCallBacks,\n ]\n CoreFoundation.CFArrayCreateMutable.restype = CFMutableArrayRef\n\n CoreFoundation.CFArrayAppendValue.argtypes = [CFMutableArrayRef, c_void_p]\n CoreFoundation.CFArrayAppendValue.restype = None\n\n CoreFoundation.CFArrayGetCount.argtypes = [CFArrayRef]\n CoreFoundation.CFArrayGetCount.restype = CFIndex\n\n CoreFoundation.CFArrayGetValueAtIndex.argtypes = [CFArrayRef, CFIndex]\n CoreFoundation.CFArrayGetValueAtIndex.restype = c_void_p\n\n CoreFoundation.CFErrorGetCode.argtypes = [CFErrorRef]\n CoreFoundation.CFErrorGetCode.restype = CFIndex\n\n CoreFoundation.CFErrorCopyDescription.argtypes = [CFErrorRef]\n CoreFoundation.CFErrorCopyDescription.restype = CFStringRef\n\n CoreFoundation.kCFAllocatorDefault = CFAllocatorRef.in_dll( # type: ignore[attr-defined]\n CoreFoundation, \"kCFAllocatorDefault\"\n )\n CoreFoundation.kCFTypeArrayCallBacks = c_void_p.in_dll( # type: ignore[attr-defined]\n CoreFoundation, \"kCFTypeArrayCallBacks\"\n )\n\n CoreFoundation.CFTypeRef = CFTypeRef # type: ignore[attr-defined]\n CoreFoundation.CFArrayRef = CFArrayRef # type: ignore[attr-defined]\n CoreFoundation.CFStringRef = CFStringRef # type: ignore[attr-defined]\n CoreFoundation.CFErrorRef = CFErrorRef # type: ignore[attr-defined]\n\nexcept AttributeError as e:\n raise ImportError(f\"Error initializing ctypes: {e}\") from None\n\n# SecTrustEvaluateWithError is macOS 10.14+\nif _is_macos_version_10_14_or_later:\n try:\n Security.SecTrustEvaluateWithError.argtypes = [\n SecTrustRef,\n POINTER(CFErrorRef),\n ]\n Security.SecTrustEvaluateWithError.restype = c_bool\n except AttributeError as e:\n raise ImportError(f\"Error initializing ctypes: {e}\") from None\n\n\ndef _handle_osstatus(result: OSStatus, _: typing.Any, args: typing.Any) -> typing.Any:\n \"\"\"\n Raises an error if the OSStatus value is non-zero.\n \"\"\"\n if int(result) == 0:\n return args\n\n # Returns a CFString which we need to transform\n # into a UTF-8 Python string.\n error_message_cfstring = None\n try:\n error_message_cfstring = Security.SecCopyErrorMessageString(result, None)\n\n # First step is convert the CFString into a C string pointer.\n # We try the fast no-copy way first.\n error_message_cfstring_c_void_p = ctypes.cast(\n error_message_cfstring, ctypes.POINTER(ctypes.c_void_p)\n )\n message = CoreFoundation.CFStringGetCStringPtr(\n error_message_cfstring_c_void_p, CFConst.kCFStringEncodingUTF8\n )\n\n # Quoting the Apple dev docs:\n #\n # \"A pointer to a C string or NULL if the internal\n # storage of theString does not allow this to be\n # returned efficiently.\"\n #\n # So we need to get our hands dirty.\n if message is None:\n buffer = ctypes.create_string_buffer(1024)\n result = CoreFoundation.CFStringGetCString(\n error_message_cfstring_c_void_p,\n buffer,\n 1024,\n CFConst.kCFStringEncodingUTF8,\n )\n if not result:\n raise OSError(\"Error copying C string from CFStringRef\")\n message = buffer.value\n\n finally:\n if error_message_cfstring is not None:\n CoreFoundation.CFRelease(error_message_cfstring)\n\n # If no message can be found for this status we come\n # up with a generic one that forwards the status code.\n if message is None or message == \"\":\n message = f\"SecureTransport operation returned a non-zero OSStatus: {result}\"\n\n raise ssl.SSLError(message)\n\n\nSecurity.SecTrustCreateWithCertificates.errcheck = _handle_osstatus # type: ignore[assignment]\nSecurity.SecTrustSetAnchorCertificates.errcheck = _handle_osstatus # type: ignore[assignment]\nSecurity.SecTrustSetAnchorCertificatesOnly.errcheck = _handle_osstatus # type: ignore[assignment]\nSecurity.SecTrustGetTrustResult.errcheck = _handle_osstatus # type: ignore[assignment]\nSecurity.SecTrustEvaluate.errcheck = _handle_osstatus # type: ignore[assignment]\n\n\nclass CFConst:\n \"\"\"CoreFoundation constants\"\"\"\n\n kCFStringEncodingUTF8 = CFStringEncoding(0x08000100)\n\n errSecIncompleteCertRevocationCheck = -67635\n errSecHostNameMismatch = -67602\n errSecCertificateExpired = -67818\n errSecNotTrusted = -67843\n\n\ndef _bytes_to_cf_data_ref(value: bytes) -> CFDataRef: # type: ignore[valid-type]\n return CoreFoundation.CFDataCreate( # type: ignore[no-any-return]\n CoreFoundation.kCFAllocatorDefault, value, len(value)\n )\n\n\ndef _bytes_to_cf_string(value: bytes) -> CFString:\n \"\"\"\n Given a Python binary data, create a CFString.\n The string must be CFReleased by the caller.\n \"\"\"\n c_str = ctypes.c_char_p(value)\n cf_str = CoreFoundation.CFStringCreateWithCString(\n CoreFoundation.kCFAllocatorDefault,\n c_str,\n CFConst.kCFStringEncodingUTF8,\n )\n return cf_str # type: ignore[no-any-return]\n\n\ndef _cf_string_ref_to_str(cf_string_ref: CFStringRef) -> str | None: # type: ignore[valid-type]\n \"\"\"\n Creates a Unicode string from a CFString object. Used entirely for error\n reporting.\n Yes, it annoys me quite a lot that this function is this complex.\n \"\"\"\n\n string = CoreFoundation.CFStringGetCStringPtr(\n cf_string_ref, CFConst.kCFStringEncodingUTF8\n )\n if string is None:\n buffer = ctypes.create_string_buffer(1024)\n result = CoreFoundation.CFStringGetCString(\n cf_string_ref, buffer, 1024, CFConst.kCFStringEncodingUTF8\n )\n if not result:\n raise OSError(\"Error copying C string from CFStringRef\")\n string = buffer.value\n if string is not None:\n string = string.decode(\"utf-8\")\n return string # type: ignore[no-any-return]\n\n\ndef _der_certs_to_cf_cert_array(certs: list[bytes]) -> CFMutableArrayRef: # type: ignore[valid-type]\n \"\"\"Builds a CFArray of SecCertificateRefs from a list of DER-encoded certificates.\n Responsibility of the caller to call CoreFoundation.CFRelease on the CFArray.\n \"\"\"\n cf_array = CoreFoundation.CFArrayCreateMutable(\n CoreFoundation.kCFAllocatorDefault,\n 0,\n ctypes.byref(CoreFoundation.kCFTypeArrayCallBacks),\n )\n if not cf_array:\n raise MemoryError(\"Unable to allocate memory!\")\n\n for cert_data in certs:\n cf_data = None\n sec_cert_ref = None\n try:\n cf_data = _bytes_to_cf_data_ref(cert_data)\n sec_cert_ref = Security.SecCertificateCreateWithData(\n CoreFoundation.kCFAllocatorDefault, cf_data\n )\n CoreFoundation.CFArrayAppendValue(cf_array, sec_cert_ref)\n finally:\n if cf_data:\n CoreFoundation.CFRelease(cf_data)\n if sec_cert_ref:\n CoreFoundation.CFRelease(sec_cert_ref)\n\n return cf_array # type: ignore[no-any-return]\n\n\n@contextlib.contextmanager\ndef _configure_context(ctx: ssl.SSLContext) -> typing.Iterator[None]:\n check_hostname = ctx.check_hostname\n verify_mode = ctx.verify_mode\n ctx.check_hostname = False\n _set_ssl_context_verify_mode(ctx, ssl.CERT_NONE)\n try:\n yield\n finally:\n ctx.check_hostname = check_hostname\n _set_ssl_context_verify_mode(ctx, verify_mode)\n\n\ndef _verify_peercerts_impl(\n ssl_context: ssl.SSLContext,\n cert_chain: list[bytes],\n server_hostname: str | None = None,\n) -> None:\n certs = None\n policies = None\n trust = None\n try:\n # Only set a hostname on the policy if we're verifying the hostname\n # on the leaf certificate.\n if server_hostname is not None and ssl_context.check_hostname:\n cf_str_hostname = None\n try:\n cf_str_hostname = _bytes_to_cf_string(server_hostname.encode(\"ascii\"))\n ssl_policy = Security.SecPolicyCreateSSL(True, cf_str_hostname)\n finally:\n if cf_str_hostname:\n CoreFoundation.CFRelease(cf_str_hostname)\n else:\n ssl_policy = Security.SecPolicyCreateSSL(True, None)\n\n policies = ssl_policy\n if ssl_context.verify_flags & ssl.VERIFY_CRL_CHECK_CHAIN:\n # Add explicit policy requiring positive revocation checks\n policies = CoreFoundation.CFArrayCreateMutable(\n CoreFoundation.kCFAllocatorDefault,\n 0,\n ctypes.byref(CoreFoundation.kCFTypeArrayCallBacks),\n )\n CoreFoundation.CFArrayAppendValue(policies, ssl_policy)\n CoreFoundation.CFRelease(ssl_policy)\n revocation_policy = Security.SecPolicyCreateRevocation(\n kSecRevocationUseAnyAvailableMethod\n | kSecRevocationRequirePositiveResponse\n )\n CoreFoundation.CFArrayAppendValue(policies, revocation_policy)\n CoreFoundation.CFRelease(revocation_policy)\n elif ssl_context.verify_flags & ssl.VERIFY_CRL_CHECK_LEAF:\n raise NotImplementedError(\"VERIFY_CRL_CHECK_LEAF not implemented for macOS\")\n\n certs = None\n try:\n certs = _der_certs_to_cf_cert_array(cert_chain)\n\n # Now that we have certificates loaded and a SecPolicy\n # we can finally create a SecTrust object!\n trust = Security.SecTrustRef()\n Security.SecTrustCreateWithCertificates(\n certs, policies, ctypes.byref(trust)\n )\n\n finally:\n # The certs are now being held by SecTrust so we can\n # release our handles for the array.\n if certs:\n CoreFoundation.CFRelease(certs)\n\n # If there are additional trust anchors to load we need to transform\n # the list of DER-encoded certificates into a CFArray.\n ctx_ca_certs_der: list[bytes] | None = ssl_context.get_ca_certs(\n binary_form=True\n )\n if ctx_ca_certs_der:\n ctx_ca_certs = None\n try:\n ctx_ca_certs = _der_certs_to_cf_cert_array(ctx_ca_certs_der)\n Security.SecTrustSetAnchorCertificates(trust, ctx_ca_certs)\n finally:\n if ctx_ca_certs:\n CoreFoundation.CFRelease(ctx_ca_certs)\n\n # We always want system certificates.\n Security.SecTrustSetAnchorCertificatesOnly(trust, False)\n\n # macOS 10.13 and earlier don't support SecTrustEvaluateWithError()\n # so we use SecTrustEvaluate() which means we need to construct error\n # messages ourselves.\n if _is_macos_version_10_14_or_later:\n _verify_peercerts_impl_macos_10_14(ssl_context, trust)\n else:\n _verify_peercerts_impl_macos_10_13(ssl_context, trust)\n finally:\n if policies:\n CoreFoundation.CFRelease(policies)\n if trust:\n CoreFoundation.CFRelease(trust)\n\n\ndef _verify_peercerts_impl_macos_10_13(\n ssl_context: ssl.SSLContext, sec_trust_ref: typing.Any\n) -> None:\n \"\"\"Verify using 'SecTrustEvaluate' API for macOS 10.13 and earlier.\n macOS 10.14 added the 'SecTrustEvaluateWithError' API.\n \"\"\"\n sec_trust_result_type = Security.SecTrustResultType()\n Security.SecTrustEvaluate(sec_trust_ref, ctypes.byref(sec_trust_result_type))\n\n try:\n sec_trust_result_type_as_int = int(sec_trust_result_type.value)\n except (ValueError, TypeError):\n sec_trust_result_type_as_int = -1\n\n # Apple doesn't document these values in their own API docs.\n # See: https://github.com/xybp888/iOS-SDKs/blob/master/iPhoneOS13.0.sdk/System/Library/Frameworks/Security.framework/Headers/SecTrust.h#L84\n if (\n ssl_context.verify_mode == ssl.CERT_REQUIRED\n and sec_trust_result_type_as_int not in (1, 4)\n ):\n # Note that we're not able to ignore only hostname errors\n # for macOS 10.13 and earlier, so check_hostname=False will\n # still return an error.\n sec_trust_result_type_to_message = {\n 0: \"Invalid trust result type\",\n # 1: \"Trust evaluation succeeded\",\n 2: \"User confirmation required\",\n 3: \"User specified that certificate is not trusted\",\n # 4: \"Trust result is unspecified\",\n 5: \"Recoverable trust failure occurred\",\n 6: \"Fatal trust failure occurred\",\n 7: \"Other error occurred, certificate may be revoked\",\n }\n error_message = sec_trust_result_type_to_message.get(\n sec_trust_result_type_as_int,\n f\"Unknown trust result: {sec_trust_result_type_as_int}\",\n )\n\n err = ssl.SSLCertVerificationError(error_message)\n err.verify_message = error_message\n err.verify_code = sec_trust_result_type_as_int\n raise err\n\n\ndef _verify_peercerts_impl_macos_10_14(\n ssl_context: ssl.SSLContext, sec_trust_ref: typing.Any\n) -> None:\n \"\"\"Verify using 'SecTrustEvaluateWithError' API for macOS 10.14+.\"\"\"\n cf_error = CoreFoundation.CFErrorRef()\n sec_trust_eval_result = Security.SecTrustEvaluateWithError(\n sec_trust_ref, ctypes.byref(cf_error)\n )\n # sec_trust_eval_result is a bool (0 or 1)\n # where 1 means that the certs are trusted.\n if sec_trust_eval_result == 1:\n is_trusted = True\n elif sec_trust_eval_result == 0:\n is_trusted = False\n else:\n raise ssl.SSLError(\n f\"Unknown result from Security.SecTrustEvaluateWithError: {sec_trust_eval_result!r}\"\n )\n\n cf_error_code = 0\n if not is_trusted:\n cf_error_code = CoreFoundation.CFErrorGetCode(cf_error)\n\n # If the error is a known failure that we're\n # explicitly okay with from SSLContext configuration\n # we can set is_trusted accordingly.\n if ssl_context.verify_mode != ssl.CERT_REQUIRED and (\n cf_error_code == CFConst.errSecNotTrusted\n or cf_error_code == CFConst.errSecCertificateExpired\n ):\n is_trusted = True\n\n # If we're still not trusted then we start to\n # construct and raise the SSLCertVerificationError.\n if not is_trusted:\n cf_error_string_ref = None\n try:\n cf_error_string_ref = CoreFoundation.CFErrorCopyDescription(cf_error)\n\n # Can this ever return 'None' if there's a CFError?\n cf_error_message = (\n _cf_string_ref_to_str(cf_error_string_ref)\n or \"Certificate verification failed\"\n )\n\n # TODO: Not sure if we need the SecTrustResultType for anything?\n # We only care whether or not it's a success or failure for now.\n sec_trust_result_type = Security.SecTrustResultType()\n Security.SecTrustGetTrustResult(\n sec_trust_ref, ctypes.byref(sec_trust_result_type)\n )\n\n err = ssl.SSLCertVerificationError(cf_error_message)\n err.verify_message = cf_error_message\n err.verify_code = cf_error_code\n raise err\n finally:\n if cf_error_string_ref:\n CoreFoundation.CFRelease(cf_error_string_ref)\n",[],[213,919,920,921,1016,1050,1384,1402],"081bd272-67fc-11f0-95df-0224a6c84d84","_api.py","081bd312-67fc-11f0-95df-0224a6c84d84",294,["D",1753299261376],"import os\nimport platform\nimport socket\nimport ssl\nimport sys\nimport typing\n\nimport _ssl\n\nfrom ._ssl_constants import (\n _original_SSLContext,\n _original_super_SSLContext,\n _truststore_SSLContext_dunder_class,\n _truststore_SSLContext_super_class,\n)\n\nif platform.system() == \"Windows\":\n from ._windows import _configure_context, _verify_peercerts_impl\nelif platform.system() == \"Darwin\":\n from ._macos import _configure_context, _verify_peercerts_impl\nelse:\n from ._openssl import _configure_context, _verify_peercerts_impl\n\nif typing.TYPE_CHECKING:\n from pip._vendor.typing_extensions import Buffer\n\n# From typeshed/stdlib/ssl.pyi\n_StrOrBytesPath: typing.TypeAlias = str | bytes | os.PathLike[str] | os.PathLike[bytes]\n_PasswordType: typing.TypeAlias = str | bytes | typing.Callable[[], str | bytes]\n\n\ndef inject_into_ssl() -> None:\n \"\"\"Injects the :class:`truststore.SSLContext` into the ``ssl``\n module by replacing :class:`ssl.SSLContext`.\n \"\"\"\n setattr(ssl, \"SSLContext\", SSLContext)\n # urllib3 holds on to its own reference of ssl.SSLContext\n # so we need to replace that reference too.\n try:\n import pip._vendor.urllib3.util.ssl_ as urllib3_ssl\n\n setattr(urllib3_ssl, \"SSLContext\", SSLContext)\n except ImportError:\n pass\n\n # requests starting with 2.32.0 added a preloaded SSL context to improve concurrent performance;\n # this unfortunately leads to a RecursionError, which can be avoided by patching the preloaded SSL context with\n # the truststore patched instance\n # also see https://github.com/psf/requests/pull/6667\n try:\n from pip._vendor.requests import adapters as requests_adapters\n\n preloaded_context = getattr(requests_adapters, \"_preloaded_ssl_context\", None)\n if preloaded_context is not None:\n setattr(\n requests_adapters,\n \"_preloaded_ssl_context\",\n SSLContext(ssl.PROTOCOL_TLS_CLIENT),\n )\n except ImportError:\n pass\n\n\ndef extract_from_ssl() -> None:\n \"\"\"Restores the :class:`ssl.SSLContext` class to its original state\"\"\"\n setattr(ssl, \"SSLContext\", _original_SSLContext)\n try:\n import pip._vendor.urllib3.util.ssl_ as urllib3_ssl\n\n urllib3_ssl.SSLContext = _original_SSLContext # type: ignore[assignment]\n except ImportError:\n pass\n\n\nclass SSLContext(_truststore_SSLContext_super_class): # type: ignore[misc]\n \"\"\"SSLContext API that uses system certificates on all platforms\"\"\"\n\n @property # type: ignore[misc]\n def __class__(self) -> type:\n # Dirty hack to get around isinstance() checks\n # for ssl.SSLContext instances in aiohttp/trustme\n # when using non-CPython implementations.\n return _truststore_SSLContext_dunder_class or SSLContext\n\n def __init__(self, protocol: int = None) -> None: # type: ignore[assignment]\n self._ctx = _original_SSLContext(protocol)\n\n class TruststoreSSLObject(ssl.SSLObject):\n # This object exists because wrap_bio() doesn't\n # immediately do the handshake so we need to do\n # certificate verifications after SSLObject.do_handshake()\n\n def do_handshake(self) -> None:\n ret = super().do_handshake()\n _verify_peercerts(self, server_hostname=self.server_hostname)\n return ret\n\n self._ctx.sslobject_class = TruststoreSSLObject\n\n def wrap_socket(\n self,\n sock: socket.socket,\n server_side: bool = False,\n do_handshake_on_connect: bool = True,\n suppress_ragged_eofs: bool = True,\n server_hostname: str | None = None,\n session: ssl.SSLSession | None = None,\n ) -> ssl.SSLSocket:\n # Use a context manager here because the\n # inner SSLContext holds on to our state\n # but also does the actual handshake.\n with _configure_context(self._ctx):\n ssl_sock = self._ctx.wrap_socket(\n sock,\n server_side=server_side,\n server_hostname=server_hostname,\n do_handshake_on_connect=do_handshake_on_connect,\n suppress_ragged_eofs=suppress_ragged_eofs,\n session=session,\n )\n try:\n _verify_peercerts(ssl_sock, server_hostname=server_hostname)\n except Exception:\n ssl_sock.close()\n raise\n return ssl_sock\n\n def wrap_bio(\n self,\n incoming: ssl.MemoryBIO,\n outgoing: ssl.MemoryBIO,\n server_side: bool = False,\n server_hostname: str | None = None,\n session: ssl.SSLSession | None = None,\n ) -> ssl.SSLObject:\n with _configure_context(self._ctx):\n ssl_obj = self._ctx.wrap_bio(\n incoming,\n outgoing,\n server_hostname=server_hostname,\n server_side=server_side,\n session=session,\n )\n return ssl_obj\n\n def load_verify_locations(\n self,\n cafile: str | bytes | os.PathLike[str] | os.PathLike[bytes] | None = None,\n capath: str | bytes | os.PathLike[str] | os.PathLike[bytes] | None = None,\n cadata: typing.Union[str, \"Buffer\", None] = None,\n ) -> None:\n return self._ctx.load_verify_locations(\n cafile=cafile, capath=capath, cadata=cadata\n )\n\n def load_cert_chain(\n self,\n certfile: _StrOrBytesPath,\n keyfile: _StrOrBytesPath | None = None,\n password: _PasswordType | None = None,\n ) -> None:\n return self._ctx.load_cert_chain(\n certfile=certfile, keyfile=keyfile, password=password\n )\n\n def load_default_certs(\n self, purpose: ssl.Purpose = ssl.Purpose.SERVER_AUTH\n ) -> None:\n return self._ctx.load_default_certs(purpose)\n\n def set_alpn_protocols(self, alpn_protocols: typing.Iterable[str]) -> None:\n return self._ctx.set_alpn_protocols(alpn_protocols)\n\n def set_npn_protocols(self, npn_protocols: typing.Iterable[str]) -> None:\n return self._ctx.set_npn_protocols(npn_protocols)\n\n def set_ciphers(self, __cipherlist: str) -> None:\n return self._ctx.set_ciphers(__cipherlist)\n\n def get_ciphers(self) -> typing.Any:\n return self._ctx.get_ciphers()\n\n def session_stats(self) -> dict[str, int]:\n return self._ctx.session_stats()\n\n def cert_store_stats(self) -> dict[str, int]:\n raise NotImplementedError()\n\n def set_default_verify_paths(self) -> None:\n self._ctx.set_default_verify_paths()\n\n @typing.overload\n def get_ca_certs(\n self, binary_form: typing.Literal[False] = ...\n ) -> list[typing.Any]: ...\n\n @typing.overload\n def get_ca_certs(self, binary_form: typing.Literal[True] = ...) -> list[bytes]: ...\n\n @typing.overload\n def get_ca_certs(self, binary_form: bool = ...) -> typing.Any: ...\n\n def get_ca_certs(self, binary_form: bool = False) -> list[typing.Any] | list[bytes]:\n raise NotImplementedError()\n\n @property\n def check_hostname(self) -> bool:\n return self._ctx.check_hostname\n\n @check_hostname.setter\n def check_hostname(self, value: bool) -> None:\n self._ctx.check_hostname = value\n\n @property\n def hostname_checks_common_name(self) -> bool:\n return self._ctx.hostname_checks_common_name\n\n @hostname_checks_common_name.setter\n def hostname_checks_common_name(self, value: bool) -> None:\n self._ctx.hostname_checks_common_name = value\n\n @property\n def keylog_filename(self) -> str:\n return self._ctx.keylog_filename\n\n @keylog_filename.setter\n def keylog_filename(self, value: str) -> None:\n self._ctx.keylog_filename = value\n\n @property\n def maximum_version(self) -> ssl.TLSVersion:\n return self._ctx.maximum_version\n\n @maximum_version.setter\n def maximum_version(self, value: ssl.TLSVersion) -> None:\n _original_super_SSLContext.maximum_version.__set__( # type: ignore[attr-defined]\n self._ctx, value\n )\n\n @property\n def minimum_version(self) -> ssl.TLSVersion:\n return self._ctx.minimum_version\n\n @minimum_version.setter\n def minimum_version(self, value: ssl.TLSVersion) -> None:\n _original_super_SSLContext.minimum_version.__set__( # type: ignore[attr-defined]\n self._ctx, value\n )\n\n @property\n def options(self) -> ssl.Options:\n return self._ctx.options\n\n @options.setter\n def options(self, value: ssl.Options) -> None:\n _original_super_SSLContext.options.__set__( # type: ignore[attr-defined]\n self._ctx, value\n )\n\n @property\n def post_handshake_auth(self) -> bool:\n return self._ctx.post_handshake_auth\n\n @post_handshake_auth.setter\n def post_handshake_auth(self, value: bool) -> None:\n self._ctx.post_handshake_auth = value\n\n @property\n def protocol(self) -> ssl._SSLMethod:\n return self._ctx.protocol\n\n @property\n def security_level(self) -> int:\n return self._ctx.security_level\n\n @property\n def verify_flags(self) -> ssl.VerifyFlags:\n return self._ctx.verify_flags\n\n @verify_flags.setter\n def verify_flags(self, value: ssl.VerifyFlags) -> None:\n _original_super_SSLContext.verify_flags.__set__( # type: ignore[attr-defined]\n self._ctx, value\n )\n\n @property\n def verify_mode(self) -> ssl.VerifyMode:\n return self._ctx.verify_mode\n\n @verify_mode.setter\n def verify_mode(self, value: ssl.VerifyMode) -> None:\n _original_super_SSLContext.verify_mode.__set__( # type: ignore[attr-defined]\n self._ctx, value\n )\n\n\n# Python 3.13+ makes get_unverified_chain() a public API that only returns DER\n# encoded certificates. We detect whether we need to call public_bytes() for 3.10->3.12\n# Pre-3.13 returned None instead of an empty list from get_unverified_chain()\nif sys.version_info >= (3, 13):\n\n def _get_unverified_chain_bytes(sslobj: ssl.SSLObject) -> list[bytes]:\n unverified_chain = sslobj.get_unverified_chain() or () # type: ignore[attr-defined]\n return [\n cert if isinstance(cert, bytes) else cert.public_bytes(_ssl.ENCODING_DER)\n for cert in unverified_chain\n ]\n\nelse:\n\n def _get_unverified_chain_bytes(sslobj: ssl.SSLObject) -> list[bytes]:\n unverified_chain = sslobj.get_unverified_chain() or () # type: ignore[attr-defined]\n return [cert.public_bytes(_ssl.ENCODING_DER) for cert in unverified_chain]\n\n\ndef _verify_peercerts(\n sock_or_sslobj: ssl.SSLSocket | ssl.SSLObject, server_hostname: str | None\n) -> None:\n \"\"\"\n Verifies the peer certificates from an SSLSocket or SSLObject\n against the certificates in the OS trust store.\n \"\"\"\n sslobj: ssl.SSLObject = sock_or_sslobj # type: ignore[assignment]\n try:\n while not hasattr(sslobj, \"get_unverified_chain\"):\n sslobj = sslobj._sslobj # type: ignore[attr-defined]\n except AttributeError:\n pass\n\n cert_bytes = _get_unverified_chain_bytes(sslobj)\n _verify_peercerts_impl(\n sock_or_sslobj.context, cert_bytes, server_hostname=server_hostname\n )\n",[],[213,919,920,921,1016,1050,1384,1410],"082173f8-67fc-11f0-8791-0224a6c84d84","082175ec-67fc-11f0-8791-0224a6c84d84",295,["D",1753299261387],"\"\"\"Verify certificates using native system trust stores\"\"\"\n\nimport sys as _sys\n\nif _sys.version_info < (3, 10):\n raise ImportError(\"truststore requires Python 3.10 or later\")\n\n# Detect Python runtimes which don't implement SSLObject.get_unverified_chain() API\n# This API only became public in Python 3.13 but was available in CPython and PyPy since 3.10.\nif _sys.version_info < (3, 13) and _sys.implementation.name not in (\"cpython\", \"pypy\"):\n try:\n import ssl as _ssl\n except ImportError:\n raise ImportError(\"truststore requires the 'ssl' module\")\n else:\n _sslmem = _ssl.MemoryBIO()\n _sslobj = _ssl.create_default_context().wrap_bio(\n _sslmem,\n _sslmem,\n )\n try:\n while not hasattr(_sslobj, \"get_unverified_chain\"):\n _sslobj = _sslobj._sslobj # type: ignore[attr-defined]\n except AttributeError:\n raise ImportError(\n \"truststore requires peer certificate chain APIs to be available\"\n ) from None\n\n del _ssl, _sslobj, _sslmem # noqa: F821\n\nfrom ._api import SSLContext, extract_from_ssl, inject_into_ssl # noqa: E402\n\ndel _api, _sys # type: ignore[name-defined] # noqa: F821\n\n__all__ = [\"SSLContext\", \"inject_into_ssl\", \"extract_from_ssl\"]\n__version__ = \"0.10.1\"\n",[],[213,919,920,921,1016,1050,1384,1034],"fd7f4ca4-67fb-11f0-aedf-0224a6c84d84",71,["D",1753299243586],[679,680,681,682,683,684],[213,919,920,921,1016,1050,1384],"0ce01d40-67fc-11f0-bfb3-0224a6c84d84","0ce01dd6-67fc-11f0-bfb3-0224a6c84d84","fec7fa5c-67fb-11f0-ad3e-0224a6c84d84",476,["D",1753299269309],"# Marker file for PEP 561\n",[],[213,919,920,921,1016,1050,1437,1008],"tomli_w","0cbd6bd8-67fc-11f0-8d4e-0224a6c84d84","_writer.py","0cbd6caa-67fc-11f0-8d4e-0224a6c84d84",471,["D",1753299269145],"from __future__ import annotations\n\nfrom collections.abc import Mapping\nfrom datetime import date, datetime, time\nfrom types import MappingProxyType\n\nTYPE_CHECKING = False\nif TYPE_CHECKING:\n from collections.abc import Generator\n from decimal import Decimal\n from typing import IO, Any, Final\n\nASCII_CTRL = frozenset(chr(i) for i in range(32)) | frozenset(chr(127))\nILLEGAL_BASIC_STR_CHARS = frozenset('\"\\\\') | ASCII_CTRL - frozenset(\"\\t\")\nBARE_KEY_CHARS = frozenset(\n \"abcdefghijklmnopqrstuvwxyz\" \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\" \"0123456789\" \"-_\"\n)\nARRAY_TYPES = (list, tuple)\nMAX_LINE_LENGTH = 100\n\nCOMPACT_ESCAPES = MappingProxyType(\n {\n \"\\u0008\": \"\\\\b\", # backspace\n \"\\u000A\": \"\\\\n\", # linefeed\n \"\\u000C\": \"\\\\f\", # form feed\n \"\\u000D\": \"\\\\r\", # carriage return\n \"\\u0022\": '\\\\\"', # quote\n \"\\u005C\": \"\\\\\\\\\", # backslash\n }\n)\n\n\nclass Context:\n def __init__(self, allow_multiline: bool, indent: int):\n if indent < 0:\n raise ValueError(\"Indent width must be non-negative\")\n self.allow_multiline: Final = allow_multiline\n # cache rendered inline tables (mapping from object id to rendered inline table)\n self.inline_table_cache: Final[dict[int, str]] = {}\n self.indent_str: Final = \" \" * indent\n\n\ndef dump(\n obj: Mapping[str, Any],\n fp: IO[bytes],\n /,\n *,\n multiline_strings: bool = False,\n indent: int = 4,\n) -> None:\n ctx = Context(multiline_strings, indent)\n for chunk in gen_table_chunks(obj, ctx, name=\"\"):\n fp.write(chunk.encode())\n\n\ndef dumps(\n obj: Mapping[str, Any], /, *, multiline_strings: bool = False, indent: int = 4\n) -> str:\n ctx = Context(multiline_strings, indent)\n return \"\".join(gen_table_chunks(obj, ctx, name=\"\"))\n\n\ndef gen_table_chunks(\n table: Mapping[str, Any],\n ctx: Context,\n *,\n name: str,\n inside_aot: bool = False,\n) -> Generator[str, None, None]:\n yielded = False\n literals = []\n tables: list[tuple[str, Any, bool]] = [] # => [(key, value, inside_aot)]\n for k, v in table.items():\n if isinstance(v, Mapping):\n tables.append((k, v, False))\n elif is_aot(v) and not all(is_suitable_inline_table(t, ctx) for t in v):\n tables.extend((k, t, True) for t in v)\n else:\n literals.append((k, v))\n\n if inside_aot or name and (literals or not tables):\n yielded = True\n yield f\"[[{name}]]\\n\" if inside_aot else f\"[{name}]\\n\"\n\n if literals:\n yielded = True\n for k, v in literals:\n yield f\"{format_key_part(k)} = {format_literal(v, ctx)}\\n\"\n\n for k, v, in_aot in tables:\n if yielded:\n yield \"\\n\"\n else:\n yielded = True\n key_part = format_key_part(k)\n display_name = f\"{name}.{key_part}\" if name else key_part\n yield from gen_table_chunks(v, ctx, name=display_name, inside_aot=in_aot)\n\n\ndef format_literal(obj: object, ctx: Context, *, nest_level: int = 0) -> str:\n if isinstance(obj, bool):\n return \"true\" if obj else \"false\"\n if isinstance(obj, (int, float, date, datetime)):\n return str(obj)\n if isinstance(obj, time):\n if obj.tzinfo:\n raise ValueError(\"TOML does not support offset times\")\n return str(obj)\n if isinstance(obj, str):\n return format_string(obj, allow_multiline=ctx.allow_multiline)\n if isinstance(obj, ARRAY_TYPES):\n return format_inline_array(obj, ctx, nest_level)\n if isinstance(obj, Mapping):\n return format_inline_table(obj, ctx)\n\n # Lazy import to improve module import time\n from decimal import Decimal\n\n if isinstance(obj, Decimal):\n return format_decimal(obj)\n raise TypeError(\n f\"Object of type '{type(obj).__qualname__}' is not TOML serializable\"\n )\n\n\ndef format_decimal(obj: Decimal) -> str:\n if obj.is_nan():\n return \"nan\"\n if obj.is_infinite():\n return \"-inf\" if obj.is_signed() else \"inf\"\n dec_str = str(obj).lower()\n return dec_str if \".\" in dec_str or \"e\" in dec_str else dec_str + \".0\"\n\n\ndef format_inline_table(obj: Mapping, ctx: Context) -> str:\n # check cache first\n obj_id = id(obj)\n if obj_id in ctx.inline_table_cache:\n return ctx.inline_table_cache[obj_id]\n\n if not obj:\n rendered = \"{}\"\n else:\n rendered = (\n \"{ \"\n + \", \".join(\n f\"{format_key_part(k)} = {format_literal(v, ctx)}\"\n for k, v in obj.items()\n )\n + \" }\"\n )\n ctx.inline_table_cache[obj_id] = rendered\n return rendered\n\n\ndef format_inline_array(obj: tuple | list, ctx: Context, nest_level: int) -> str:\n if not obj:\n return \"[]\"\n item_indent = ctx.indent_str * (1 + nest_level)\n closing_bracket_indent = ctx.indent_str * nest_level\n return (\n \"[\\n\"\n + \",\\n\".join(\n item_indent + format_literal(item, ctx, nest_level=nest_level + 1)\n for item in obj\n )\n + f\",\\n{closing_bracket_indent}]\"\n )\n\n\ndef format_key_part(part: str) -> str:\n try:\n only_bare_key_chars = BARE_KEY_CHARS.issuperset(part)\n except TypeError:\n raise TypeError(\n f\"Invalid mapping key '{part}' of type '{type(part).__qualname__}'.\"\n \" A string is required.\"\n ) from None\n\n if part and only_bare_key_chars:\n return part\n return format_string(part, allow_multiline=False)\n\n\ndef format_string(s: str, *, allow_multiline: bool) -> str:\n do_multiline = allow_multiline and \"\\n\" in s\n if do_multiline:\n result = '\"\"\"\\n'\n s = s.replace(\"\\r\\n\", \"\\n\")\n else:\n result = '\"'\n\n pos = seq_start = 0\n while True:\n try:\n char = s[pos]\n except IndexError:\n result += s[seq_start:pos]\n if do_multiline:\n return result + '\"\"\"'\n return result + '\"'\n if char in ILLEGAL_BASIC_STR_CHARS:\n result += s[seq_start:pos]\n if char in COMPACT_ESCAPES:\n if do_multiline and char == \"\\n\":\n result += \"\\n\"\n else:\n result += COMPACT_ESCAPES[char]\n else:\n result += \"\\\\u\" + hex(ord(char))[2:].rjust(4, \"0\")\n seq_start = pos + 1\n pos += 1\n\n\ndef is_aot(obj: Any) -> bool:\n \"\"\"Decides if an object behaves as an array of tables (i.e. a nonempty list\n of dicts).\"\"\"\n return bool(\n isinstance(obj, ARRAY_TYPES)\n and obj\n and all(isinstance(v, Mapping) for v in obj)\n )\n\n\ndef is_suitable_inline_table(obj: Mapping, ctx: Context) -> bool:\n \"\"\"Use heuristics to decide if the inline-style representation is a good\n choice for a given table.\"\"\"\n rendered_inline = f\"{ctx.indent_str}{format_inline_table(obj, ctx)},\"\n return len(rendered_inline) <= MAX_LINE_LENGTH and \"\\n\" not in rendered_inline\n",[],[213,919,920,921,1016,1050,1437,1439],"0cca8b9c-67fc-11f0-a516-0224a6c84d84","0cca8c82-67fc-11f0-a516-0224a6c84d84",473,["D",1753299269241],"__all__ = (\"dumps\", \"dump\")\n__version__ = \"1.2.0\" # DO NOT EDIT THIS LINE MANUALLY. LET bump2version UTILITY DO IT\n\nfrom pip._vendor.tomli_w._writer import dump, dumps\n",[],[213,919,920,921,1016,1050,1437,1034],"fec7f980-67fb-11f0-ad3e-0224a6c84d84",84,["D",1753299245739],[675,676,677],[213,919,920,921,1016,1050,1437],"0aa31550-67fc-11f0-9454-0224a6c84d84","0aa3160e-67fc-11f0-9454-0224a6c84d84","fe628a00-67fb-11f0-847e-0224a6c84d84",387,["D",1753299265628],[],[213,919,920,921,1016,1050,1465,1008],"tomli","0a871ca6-67fc-11f0-9454-0224a6c84d84","_types.py","0a871d6e-67fc-11f0-9454-0224a6c84d84",385,["D",1753299265438],"# SPDX-License-Identifier: MIT\n# SPDX-FileCopyrightText: 2021 Taneli Hukkinen\n# Licensed to PSF under a Contributor Agreement.\n\nfrom typing import Any, Callable, Tuple\n\n# Type annotations\nParseFloat = Callable[[str], Any]\nKey = Tuple[str, ...]\nPos = int\n",[],[213,919,920,921,1016,1050,1465,1467],"0aab2aa6-67fc-11f0-aad3-0224a6c84d84","_re.py","0aab2b5a-67fc-11f0-aad3-0224a6c84d84",389,["D",1753299265585],"# SPDX-License-Identifier: MIT\n# SPDX-FileCopyrightText: 2021 Taneli Hukkinen\n# Licensed to PSF under a Contributor Agreement.\n\nfrom __future__ import annotations\n\nfrom datetime import date, datetime, time, timedelta, timezone, tzinfo\nfrom functools import lru_cache\nimport re\nfrom typing import Any, Final\n\nfrom ._types import ParseFloat\n\n# E.g.\n# - 00:32:00.999999\n# - 00:32:00\n_TIME_RE_STR: Final = (\n r\"([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])(?:\\.([0-9]{1,6})[0-9]*)?\"\n)\n\nRE_NUMBER: Final = re.compile(\n r\"\"\"\n0\n(?:\n x[0-9A-Fa-f](?:_?[0-9A-Fa-f])* # hex\n |\n b[01](?:_?[01])* # bin\n |\n o[0-7](?:_?[0-7])* # oct\n)\n|\n[+-]?(?:0|[1-9](?:_?[0-9])*) # dec, integer part\n(?P\n (?:\\.[0-9](?:_?[0-9])*)? # optional fractional part\n (?:[eE][+-]?[0-9](?:_?[0-9])*)? # optional exponent part\n)\n\"\"\",\n flags=re.VERBOSE,\n)\nRE_LOCALTIME: Final = re.compile(_TIME_RE_STR)\nRE_DATETIME: Final = re.compile(\n rf\"\"\"\n([0-9]{{4}})-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01]) # date, e.g. 1988-10-27\n(?:\n [Tt ]\n {_TIME_RE_STR}\n (?:([Zz])|([+-])([01][0-9]|2[0-3]):([0-5][0-9]))? # optional time offset\n)?\n\"\"\",\n flags=re.VERBOSE,\n)\n\n\ndef match_to_datetime(match: re.Match) -> datetime | date:\n \"\"\"Convert a `RE_DATETIME` match to `datetime.datetime` or `datetime.date`.\n\n Raises ValueError if the match does not correspond to a valid date\n or datetime.\n \"\"\"\n (\n year_str,\n month_str,\n day_str,\n hour_str,\n minute_str,\n sec_str,\n micros_str,\n zulu_time,\n offset_sign_str,\n offset_hour_str,\n offset_minute_str,\n ) = match.groups()\n year, month, day = int(year_str), int(month_str), int(day_str)\n if hour_str is None:\n return date(year, month, day)\n hour, minute, sec = int(hour_str), int(minute_str), int(sec_str)\n micros = int(micros_str.ljust(6, \"0\")) if micros_str else 0\n if offset_sign_str:\n tz: tzinfo | None = cached_tz(\n offset_hour_str, offset_minute_str, offset_sign_str\n )\n elif zulu_time:\n tz = timezone.utc\n else: # local date-time\n tz = None\n return datetime(year, month, day, hour, minute, sec, micros, tzinfo=tz)\n\n\n# No need to limit cache size. This is only ever called on input\n# that matched RE_DATETIME, so there is an implicit bound of\n# 24 (hours) * 60 (minutes) * 2 (offset direction) = 2880.\n@lru_cache(maxsize=None)\ndef cached_tz(hour_str: str, minute_str: str, sign_str: str) -> timezone:\n sign = 1 if sign_str == \"+\" else -1\n return timezone(\n timedelta(\n hours=sign * int(hour_str),\n minutes=sign * int(minute_str),\n )\n )\n\n\ndef match_to_localtime(match: re.Match) -> time:\n hour_str, minute_str, sec_str, micros_str = match.groups()\n micros = int(micros_str.ljust(6, \"0\")) if micros_str else 0\n return time(int(hour_str), int(minute_str), int(sec_str), micros)\n\n\ndef match_to_number(match: re.Match, parse_float: ParseFloat) -> Any:\n if match.group(\"floatpart\"):\n return parse_float(match.group())\n return int(match.group(), 0)\n",[],[213,919,920,921,1016,1050,1465,1475],"0a9790fe-67fc-11f0-bfb3-0224a6c84d84","_parser.py","0a97919e-67fc-11f0-bfb3-0224a6c84d84",386,["D",1753299265548],"# SPDX-License-Identifier: MIT\n# SPDX-FileCopyrightText: 2021 Taneli Hukkinen\n# Licensed to PSF under a Contributor Agreement.\n\nfrom __future__ import annotations\n\nfrom collections.abc import Iterable\nimport string\nimport sys\nfrom types import MappingProxyType\nfrom typing import IO, Any, Final, NamedTuple\nimport warnings\n\nfrom ._re import (\n RE_DATETIME,\n RE_LOCALTIME,\n RE_NUMBER,\n match_to_datetime,\n match_to_localtime,\n match_to_number,\n)\nfrom ._types import Key, ParseFloat, Pos\n\n# Inline tables/arrays are implemented using recursion. Pathologically\n# nested documents cause pure Python to raise RecursionError (which is OK),\n# but mypyc binary wheels will crash unrecoverably (not OK). According to\n# mypyc docs this will be fixed in the future:\n# https://mypyc.readthedocs.io/en/latest/differences_from_python.html#stack-overflows\n# Before mypyc's fix is in, recursion needs to be limited by this library.\n# Choosing `sys.getrecursionlimit()` as maximum inline table/array nesting\n# level, as it allows more nesting than pure Python, but still seems a far\n# lower number than where mypyc binaries crash.\nMAX_INLINE_NESTING: Final = sys.getrecursionlimit()\n\nASCII_CTRL: Final = frozenset(chr(i) for i in range(32)) | frozenset(chr(127))\n\n# Neither of these sets include quotation mark or backslash. They are\n# currently handled as separate cases in the parser functions.\nILLEGAL_BASIC_STR_CHARS: Final = ASCII_CTRL - frozenset(\"\\t\")\nILLEGAL_MULTILINE_BASIC_STR_CHARS: Final = ASCII_CTRL - frozenset(\"\\t\\n\")\n\nILLEGAL_LITERAL_STR_CHARS: Final = ILLEGAL_BASIC_STR_CHARS\nILLEGAL_MULTILINE_LITERAL_STR_CHARS: Final = ILLEGAL_MULTILINE_BASIC_STR_CHARS\n\nILLEGAL_COMMENT_CHARS: Final = ILLEGAL_BASIC_STR_CHARS\n\nTOML_WS: Final = frozenset(\" \\t\")\nTOML_WS_AND_NEWLINE: Final = TOML_WS | frozenset(\"\\n\")\nBARE_KEY_CHARS: Final = frozenset(string.ascii_letters + string.digits + \"-_\")\nKEY_INITIAL_CHARS: Final = BARE_KEY_CHARS | frozenset(\"\\\"'\")\nHEXDIGIT_CHARS: Final = frozenset(string.hexdigits)\n\nBASIC_STR_ESCAPE_REPLACEMENTS: Final = MappingProxyType(\n {\n \"\\\\b\": \"\\u0008\", # backspace\n \"\\\\t\": \"\\u0009\", # tab\n \"\\\\n\": \"\\u000A\", # linefeed\n \"\\\\f\": \"\\u000C\", # form feed\n \"\\\\r\": \"\\u000D\", # carriage return\n '\\\\\"': \"\\u0022\", # quote\n \"\\\\\\\\\": \"\\u005C\", # backslash\n }\n)\n\n\nclass DEPRECATED_DEFAULT:\n \"\"\"Sentinel to be used as default arg during deprecation\n period of TOMLDecodeError's free-form arguments.\"\"\"\n\n\nclass TOMLDecodeError(ValueError):\n \"\"\"An error raised if a document is not valid TOML.\n\n Adds the following attributes to ValueError:\n msg: The unformatted error message\n doc: The TOML document being parsed\n pos: The index of doc where parsing failed\n lineno: The line corresponding to pos\n colno: The column corresponding to pos\n \"\"\"\n\n def __init__(\n self,\n msg: str | type[DEPRECATED_DEFAULT] = DEPRECATED_DEFAULT,\n doc: str | type[DEPRECATED_DEFAULT] = DEPRECATED_DEFAULT,\n pos: Pos | type[DEPRECATED_DEFAULT] = DEPRECATED_DEFAULT,\n *args: Any,\n ):\n if (\n args\n or not isinstance(msg, str)\n or not isinstance(doc, str)\n or not isinstance(pos, int)\n ):\n warnings.warn(\n \"Free-form arguments for TOMLDecodeError are deprecated. \"\n \"Please set 'msg' (str), 'doc' (str) and 'pos' (int) arguments only.\",\n DeprecationWarning,\n stacklevel=2,\n )\n if pos is not DEPRECATED_DEFAULT:\n args = pos, *args\n if doc is not DEPRECATED_DEFAULT:\n args = doc, *args\n if msg is not DEPRECATED_DEFAULT:\n args = msg, *args\n ValueError.__init__(self, *args)\n return\n\n lineno = doc.count(\"\\n\", 0, pos) + 1\n if lineno == 1:\n colno = pos + 1\n else:\n colno = pos - doc.rindex(\"\\n\", 0, pos)\n\n if pos >= len(doc):\n coord_repr = \"end of document\"\n else:\n coord_repr = f\"line {lineno}, column {colno}\"\n errmsg = f\"{msg} (at {coord_repr})\"\n ValueError.__init__(self, errmsg)\n\n self.msg = msg\n self.doc = doc\n self.pos = pos\n self.lineno = lineno\n self.colno = colno\n\n\ndef load(__fp: IO[bytes], *, parse_float: ParseFloat = float) -> dict[str, Any]:\n \"\"\"Parse TOML from a binary file object.\"\"\"\n b = __fp.read()\n try:\n s = b.decode()\n except AttributeError:\n raise TypeError(\n \"File must be opened in binary mode, e.g. use `open('foo.toml', 'rb')`\"\n ) from None\n return loads(s, parse_float=parse_float)\n\n\ndef loads(__s: str, *, parse_float: ParseFloat = float) -> dict[str, Any]: # noqa: C901\n \"\"\"Parse TOML from a string.\"\"\"\n\n # The spec allows converting \"\\r\\n\" to \"\\n\", even in string\n # literals. Let's do so to simplify parsing.\n try:\n src = __s.replace(\"\\r\\n\", \"\\n\")\n except (AttributeError, TypeError):\n raise TypeError(\n f\"Expected str object, not '{type(__s).__qualname__}'\"\n ) from None\n pos = 0\n out = Output(NestedDict(), Flags())\n header: Key = ()\n parse_float = make_safe_parse_float(parse_float)\n\n # Parse one statement at a time\n # (typically means one line in TOML source)\n while True:\n # 1. Skip line leading whitespace\n pos = skip_chars(src, pos, TOML_WS)\n\n # 2. Parse rules. Expect one of the following:\n # - end of file\n # - end of line\n # - comment\n # - key/value pair\n # - append dict to list (and move to its namespace)\n # - create dict (and move to its namespace)\n # Skip trailing whitespace when applicable.\n try:\n char = src[pos]\n except IndexError:\n break\n if char == \"\\n\":\n pos += 1\n continue\n if char in KEY_INITIAL_CHARS:\n pos = key_value_rule(src, pos, out, header, parse_float)\n pos = skip_chars(src, pos, TOML_WS)\n elif char == \"[\":\n try:\n second_char: str | None = src[pos + 1]\n except IndexError:\n second_char = None\n out.flags.finalize_pending()\n if second_char == \"[\":\n pos, header = create_list_rule(src, pos, out)\n else:\n pos, header = create_dict_rule(src, pos, out)\n pos = skip_chars(src, pos, TOML_WS)\n elif char != \"#\":\n raise TOMLDecodeError(\"Invalid statement\", src, pos)\n\n # 3. Skip comment\n pos = skip_comment(src, pos)\n\n # 4. Expect end of line or end of file\n try:\n char = src[pos]\n except IndexError:\n break\n if char != \"\\n\":\n raise TOMLDecodeError(\n \"Expected newline or end of document after a statement\", src, pos\n )\n pos += 1\n\n return out.data.dict\n\n\nclass Flags:\n \"\"\"Flags that map to parsed keys/namespaces.\"\"\"\n\n # Marks an immutable namespace (inline array or inline table).\n FROZEN: Final = 0\n # Marks a nest that has been explicitly created and can no longer\n # be opened using the \"[table]\" syntax.\n EXPLICIT_NEST: Final = 1\n\n def __init__(self) -> None:\n self._flags: dict[str, dict] = {}\n self._pending_flags: set[tuple[Key, int]] = set()\n\n def add_pending(self, key: Key, flag: int) -> None:\n self._pending_flags.add((key, flag))\n\n def finalize_pending(self) -> None:\n for key, flag in self._pending_flags:\n self.set(key, flag, recursive=False)\n self._pending_flags.clear()\n\n def unset_all(self, key: Key) -> None:\n cont = self._flags\n for k in key[:-1]:\n if k not in cont:\n return\n cont = cont[k][\"nested\"]\n cont.pop(key[-1], None)\n\n def set(self, key: Key, flag: int, *, recursive: bool) -> None: # noqa: A003\n cont = self._flags\n key_parent, key_stem = key[:-1], key[-1]\n for k in key_parent:\n if k not in cont:\n cont[k] = {\"flags\": set(), \"recursive_flags\": set(), \"nested\": {}}\n cont = cont[k][\"nested\"]\n if key_stem not in cont:\n cont[key_stem] = {\"flags\": set(), \"recursive_flags\": set(), \"nested\": {}}\n cont[key_stem][\"recursive_flags\" if recursive else \"flags\"].add(flag)\n\n def is_(self, key: Key, flag: int) -> bool:\n if not key:\n return False # document root has no flags\n cont = self._flags\n for k in key[:-1]:\n if k not in cont:\n return False\n inner_cont = cont[k]\n if flag in inner_cont[\"recursive_flags\"]:\n return True\n cont = inner_cont[\"nested\"]\n key_stem = key[-1]\n if key_stem in cont:\n inner_cont = cont[key_stem]\n return flag in inner_cont[\"flags\"] or flag in inner_cont[\"recursive_flags\"]\n return False\n\n\nclass NestedDict:\n def __init__(self) -> None:\n # The parsed content of the TOML document\n self.dict: dict[str, Any] = {}\n\n def get_or_create_nest(\n self,\n key: Key,\n *,\n access_lists: bool = True,\n ) -> dict:\n cont: Any = self.dict\n for k in key:\n if k not in cont:\n cont[k] = {}\n cont = cont[k]\n if access_lists and isinstance(cont, list):\n cont = cont[-1]\n if not isinstance(cont, dict):\n raise KeyError(\"There is no nest behind this key\")\n return cont\n\n def append_nest_to_list(self, key: Key) -> None:\n cont = self.get_or_create_nest(key[:-1])\n last_key = key[-1]\n if last_key in cont:\n list_ = cont[last_key]\n if not isinstance(list_, list):\n raise KeyError(\"An object other than list found behind this key\")\n list_.append({})\n else:\n cont[last_key] = [{}]\n\n\nclass Output(NamedTuple):\n data: NestedDict\n flags: Flags\n\n\ndef skip_chars(src: str, pos: Pos, chars: Iterable[str]) -> Pos:\n try:\n while src[pos] in chars:\n pos += 1\n except IndexError:\n pass\n return pos\n\n\ndef skip_until(\n src: str,\n pos: Pos,\n expect: str,\n *,\n error_on: frozenset[str],\n error_on_eof: bool,\n) -> Pos:\n try:\n new_pos = src.index(expect, pos)\n except ValueError:\n new_pos = len(src)\n if error_on_eof:\n raise TOMLDecodeError(f\"Expected {expect!r}\", src, new_pos) from None\n\n if not error_on.isdisjoint(src[pos:new_pos]):\n while src[pos] not in error_on:\n pos += 1\n raise TOMLDecodeError(f\"Found invalid character {src[pos]!r}\", src, pos)\n return new_pos\n\n\ndef skip_comment(src: str, pos: Pos) -> Pos:\n try:\n char: str | None = src[pos]\n except IndexError:\n char = None\n if char == \"#\":\n return skip_until(\n src, pos + 1, \"\\n\", error_on=ILLEGAL_COMMENT_CHARS, error_on_eof=False\n )\n return pos\n\n\ndef skip_comments_and_array_ws(src: str, pos: Pos) -> Pos:\n while True:\n pos_before_skip = pos\n pos = skip_chars(src, pos, TOML_WS_AND_NEWLINE)\n pos = skip_comment(src, pos)\n if pos == pos_before_skip:\n return pos\n\n\ndef create_dict_rule(src: str, pos: Pos, out: Output) -> tuple[Pos, Key]:\n pos += 1 # Skip \"[\"\n pos = skip_chars(src, pos, TOML_WS)\n pos, key = parse_key(src, pos)\n\n if out.flags.is_(key, Flags.EXPLICIT_NEST) or out.flags.is_(key, Flags.FROZEN):\n raise TOMLDecodeError(f\"Cannot declare {key} twice\", src, pos)\n out.flags.set(key, Flags.EXPLICIT_NEST, recursive=False)\n try:\n out.data.get_or_create_nest(key)\n except KeyError:\n raise TOMLDecodeError(\"Cannot overwrite a value\", src, pos) from None\n\n if not src.startswith(\"]\", pos):\n raise TOMLDecodeError(\n \"Expected ']' at the end of a table declaration\", src, pos\n )\n return pos + 1, key\n\n\ndef create_list_rule(src: str, pos: Pos, out: Output) -> tuple[Pos, Key]:\n pos += 2 # Skip \"[[\"\n pos = skip_chars(src, pos, TOML_WS)\n pos, key = parse_key(src, pos)\n\n if out.flags.is_(key, Flags.FROZEN):\n raise TOMLDecodeError(f\"Cannot mutate immutable namespace {key}\", src, pos)\n # Free the namespace now that it points to another empty list item...\n out.flags.unset_all(key)\n # ...but this key precisely is still prohibited from table declaration\n out.flags.set(key, Flags.EXPLICIT_NEST, recursive=False)\n try:\n out.data.append_nest_to_list(key)\n except KeyError:\n raise TOMLDecodeError(\"Cannot overwrite a value\", src, pos) from None\n\n if not src.startswith(\"]]\", pos):\n raise TOMLDecodeError(\n \"Expected ']]' at the end of an array declaration\", src, pos\n )\n return pos + 2, key\n\n\ndef key_value_rule(\n src: str, pos: Pos, out: Output, header: Key, parse_float: ParseFloat\n) -> Pos:\n pos, key, value = parse_key_value_pair(src, pos, parse_float, nest_lvl=0)\n key_parent, key_stem = key[:-1], key[-1]\n abs_key_parent = header + key_parent\n\n relative_path_cont_keys = (header + key[:i] for i in range(1, len(key)))\n for cont_key in relative_path_cont_keys:\n # Check that dotted key syntax does not redefine an existing table\n if out.flags.is_(cont_key, Flags.EXPLICIT_NEST):\n raise TOMLDecodeError(f\"Cannot redefine namespace {cont_key}\", src, pos)\n # Containers in the relative path can't be opened with the table syntax or\n # dotted key/value syntax in following table sections.\n out.flags.add_pending(cont_key, Flags.EXPLICIT_NEST)\n\n if out.flags.is_(abs_key_parent, Flags.FROZEN):\n raise TOMLDecodeError(\n f\"Cannot mutate immutable namespace {abs_key_parent}\", src, pos\n )\n\n try:\n nest = out.data.get_or_create_nest(abs_key_parent)\n except KeyError:\n raise TOMLDecodeError(\"Cannot overwrite a value\", src, pos) from None\n if key_stem in nest:\n raise TOMLDecodeError(\"Cannot overwrite a value\", src, pos)\n # Mark inline table and array namespaces recursively immutable\n if isinstance(value, (dict, list)):\n out.flags.set(header + key, Flags.FROZEN, recursive=True)\n nest[key_stem] = value\n return pos\n\n\ndef parse_key_value_pair(\n src: str, pos: Pos, parse_float: ParseFloat, nest_lvl: int\n) -> tuple[Pos, Key, Any]:\n pos, key = parse_key(src, pos)\n try:\n char: str | None = src[pos]\n except IndexError:\n char = None\n if char != \"=\":\n raise TOMLDecodeError(\"Expected '=' after a key in a key/value pair\", src, pos)\n pos += 1\n pos = skip_chars(src, pos, TOML_WS)\n pos, value = parse_value(src, pos, parse_float, nest_lvl)\n return pos, key, value\n\n\ndef parse_key(src: str, pos: Pos) -> tuple[Pos, Key]:\n pos, key_part = parse_key_part(src, pos)\n key: Key = (key_part,)\n pos = skip_chars(src, pos, TOML_WS)\n while True:\n try:\n char: str | None = src[pos]\n except IndexError:\n char = None\n if char != \".\":\n return pos, key\n pos += 1\n pos = skip_chars(src, pos, TOML_WS)\n pos, key_part = parse_key_part(src, pos)\n key += (key_part,)\n pos = skip_chars(src, pos, TOML_WS)\n\n\ndef parse_key_part(src: str, pos: Pos) -> tuple[Pos, str]:\n try:\n char: str | None = src[pos]\n except IndexError:\n char = None\n if char in BARE_KEY_CHARS:\n start_pos = pos\n pos = skip_chars(src, pos, BARE_KEY_CHARS)\n return pos, src[start_pos:pos]\n if char == \"'\":\n return parse_literal_str(src, pos)\n if char == '\"':\n return parse_one_line_basic_str(src, pos)\n raise TOMLDecodeError(\"Invalid initial character for a key part\", src, pos)\n\n\ndef parse_one_line_basic_str(src: str, pos: Pos) -> tuple[Pos, str]:\n pos += 1\n return parse_basic_str(src, pos, multiline=False)\n\n\ndef parse_array(\n src: str, pos: Pos, parse_float: ParseFloat, nest_lvl: int\n) -> tuple[Pos, list]:\n pos += 1\n array: list = []\n\n pos = skip_comments_and_array_ws(src, pos)\n if src.startswith(\"]\", pos):\n return pos + 1, array\n while True:\n pos, val = parse_value(src, pos, parse_float, nest_lvl)\n array.append(val)\n pos = skip_comments_and_array_ws(src, pos)\n\n c = src[pos : pos + 1]\n if c == \"]\":\n return pos + 1, array\n if c != \",\":\n raise TOMLDecodeError(\"Unclosed array\", src, pos)\n pos += 1\n\n pos = skip_comments_and_array_ws(src, pos)\n if src.startswith(\"]\", pos):\n return pos + 1, array\n\n\ndef parse_inline_table(\n src: str, pos: Pos, parse_float: ParseFloat, nest_lvl: int\n) -> tuple[Pos, dict]:\n pos += 1\n nested_dict = NestedDict()\n flags = Flags()\n\n pos = skip_chars(src, pos, TOML_WS)\n if src.startswith(\"}\", pos):\n return pos + 1, nested_dict.dict\n while True:\n pos, key, value = parse_key_value_pair(src, pos, parse_float, nest_lvl)\n key_parent, key_stem = key[:-1], key[-1]\n if flags.is_(key, Flags.FROZEN):\n raise TOMLDecodeError(f\"Cannot mutate immutable namespace {key}\", src, pos)\n try:\n nest = nested_dict.get_or_create_nest(key_parent, access_lists=False)\n except KeyError:\n raise TOMLDecodeError(\"Cannot overwrite a value\", src, pos) from None\n if key_stem in nest:\n raise TOMLDecodeError(f\"Duplicate inline table key {key_stem!r}\", src, pos)\n nest[key_stem] = value\n pos = skip_chars(src, pos, TOML_WS)\n c = src[pos : pos + 1]\n if c == \"}\":\n return pos + 1, nested_dict.dict\n if c != \",\":\n raise TOMLDecodeError(\"Unclosed inline table\", src, pos)\n if isinstance(value, (dict, list)):\n flags.set(key, Flags.FROZEN, recursive=True)\n pos += 1\n pos = skip_chars(src, pos, TOML_WS)\n\n\ndef parse_basic_str_escape(\n src: str, pos: Pos, *, multiline: bool = False\n) -> tuple[Pos, str]:\n escape_id = src[pos : pos + 2]\n pos += 2\n if multiline and escape_id in {\"\\\\ \", \"\\\\\\t\", \"\\\\\\n\"}:\n # Skip whitespace until next non-whitespace character or end of\n # the doc. Error if non-whitespace is found before newline.\n if escape_id != \"\\\\\\n\":\n pos = skip_chars(src, pos, TOML_WS)\n try:\n char = src[pos]\n except IndexError:\n return pos, \"\"\n if char != \"\\n\":\n raise TOMLDecodeError(\"Unescaped '\\\\' in a string\", src, pos)\n pos += 1\n pos = skip_chars(src, pos, TOML_WS_AND_NEWLINE)\n return pos, \"\"\n if escape_id == \"\\\\u\":\n return parse_hex_char(src, pos, 4)\n if escape_id == \"\\\\U\":\n return parse_hex_char(src, pos, 8)\n try:\n return pos, BASIC_STR_ESCAPE_REPLACEMENTS[escape_id]\n except KeyError:\n raise TOMLDecodeError(\"Unescaped '\\\\' in a string\", src, pos) from None\n\n\ndef parse_basic_str_escape_multiline(src: str, pos: Pos) -> tuple[Pos, str]:\n return parse_basic_str_escape(src, pos, multiline=True)\n\n\ndef parse_hex_char(src: str, pos: Pos, hex_len: int) -> tuple[Pos, str]:\n hex_str = src[pos : pos + hex_len]\n if len(hex_str) != hex_len or not HEXDIGIT_CHARS.issuperset(hex_str):\n raise TOMLDecodeError(\"Invalid hex value\", src, pos)\n pos += hex_len\n hex_int = int(hex_str, 16)\n if not is_unicode_scalar_value(hex_int):\n raise TOMLDecodeError(\n \"Escaped character is not a Unicode scalar value\", src, pos\n )\n return pos, chr(hex_int)\n\n\ndef parse_literal_str(src: str, pos: Pos) -> tuple[Pos, str]:\n pos += 1 # Skip starting apostrophe\n start_pos = pos\n pos = skip_until(\n src, pos, \"'\", error_on=ILLEGAL_LITERAL_STR_CHARS, error_on_eof=True\n )\n return pos + 1, src[start_pos:pos] # Skip ending apostrophe\n\n\ndef parse_multiline_str(src: str, pos: Pos, *, literal: bool) -> tuple[Pos, str]:\n pos += 3\n if src.startswith(\"\\n\", pos):\n pos += 1\n\n if literal:\n delim = \"'\"\n end_pos = skip_until(\n src,\n pos,\n \"'''\",\n error_on=ILLEGAL_MULTILINE_LITERAL_STR_CHARS,\n error_on_eof=True,\n )\n result = src[pos:end_pos]\n pos = end_pos + 3\n else:\n delim = '\"'\n pos, result = parse_basic_str(src, pos, multiline=True)\n\n # Add at maximum two extra apostrophes/quotes if the end sequence\n # is 4 or 5 chars long instead of just 3.\n if not src.startswith(delim, pos):\n return pos, result\n pos += 1\n if not src.startswith(delim, pos):\n return pos, result + delim\n pos += 1\n return pos, result + (delim * 2)\n\n\ndef parse_basic_str(src: str, pos: Pos, *, multiline: bool) -> tuple[Pos, str]:\n if multiline:\n error_on = ILLEGAL_MULTILINE_BASIC_STR_CHARS\n parse_escapes = parse_basic_str_escape_multiline\n else:\n error_on = ILLEGAL_BASIC_STR_CHARS\n parse_escapes = parse_basic_str_escape\n result = \"\"\n start_pos = pos\n while True:\n try:\n char = src[pos]\n except IndexError:\n raise TOMLDecodeError(\"Unterminated string\", src, pos) from None\n if char == '\"':\n if not multiline:\n return pos + 1, result + src[start_pos:pos]\n if src.startswith('\"\"\"', pos):\n return pos + 3, result + src[start_pos:pos]\n pos += 1\n continue\n if char == \"\\\\\":\n result += src[start_pos:pos]\n pos, parsed_escape = parse_escapes(src, pos)\n result += parsed_escape\n start_pos = pos\n continue\n if char in error_on:\n raise TOMLDecodeError(f\"Illegal character {char!r}\", src, pos)\n pos += 1\n\n\ndef parse_value( # noqa: C901\n src: str, pos: Pos, parse_float: ParseFloat, nest_lvl: int\n) -> tuple[Pos, Any]:\n if nest_lvl > MAX_INLINE_NESTING:\n # Pure Python should have raised RecursionError already.\n # This ensures mypyc binaries eventually do the same.\n raise RecursionError( # pragma: no cover\n \"TOML inline arrays/tables are nested more than the allowed\"\n f\" {MAX_INLINE_NESTING} levels\"\n )\n\n try:\n char: str | None = src[pos]\n except IndexError:\n char = None\n\n # IMPORTANT: order conditions based on speed of checking and likelihood\n\n # Basic strings\n if char == '\"':\n if src.startswith('\"\"\"', pos):\n return parse_multiline_str(src, pos, literal=False)\n return parse_one_line_basic_str(src, pos)\n\n # Literal strings\n if char == \"'\":\n if src.startswith(\"'''\", pos):\n return parse_multiline_str(src, pos, literal=True)\n return parse_literal_str(src, pos)\n\n # Booleans\n if char == \"t\":\n if src.startswith(\"true\", pos):\n return pos + 4, True\n if char == \"f\":\n if src.startswith(\"false\", pos):\n return pos + 5, False\n\n # Arrays\n if char == \"[\":\n return parse_array(src, pos, parse_float, nest_lvl + 1)\n\n # Inline tables\n if char == \"{\":\n return parse_inline_table(src, pos, parse_float, nest_lvl + 1)\n\n # Dates and times\n datetime_match = RE_DATETIME.match(src, pos)\n if datetime_match:\n try:\n datetime_obj = match_to_datetime(datetime_match)\n except ValueError as e:\n raise TOMLDecodeError(\"Invalid date or datetime\", src, pos) from e\n return datetime_match.end(), datetime_obj\n localtime_match = RE_LOCALTIME.match(src, pos)\n if localtime_match:\n return localtime_match.end(), match_to_localtime(localtime_match)\n\n # Integers and \"normal\" floats.\n # The regex will greedily match any type starting with a decimal\n # char, so needs to be located after handling of dates and times.\n number_match = RE_NUMBER.match(src, pos)\n if number_match:\n return number_match.end(), match_to_number(number_match, parse_float)\n\n # Special floats\n first_three = src[pos : pos + 3]\n if first_three in {\"inf\", \"nan\"}:\n return pos + 3, parse_float(first_three)\n first_four = src[pos : pos + 4]\n if first_four in {\"-inf\", \"+inf\", \"-nan\", \"+nan\"}:\n return pos + 4, parse_float(first_four)\n\n raise TOMLDecodeError(\"Invalid value\", src, pos)\n\n\ndef is_unicode_scalar_value(codepoint: int) -> bool:\n return (0 <= codepoint <= 55295) or (57344 <= codepoint <= 1114111)\n\n\ndef make_safe_parse_float(parse_float: ParseFloat) -> ParseFloat:\n \"\"\"A decorator to make `parse_float` safe.\n\n `parse_float` must not return dicts or lists, because these types\n would be mixed with parsed TOML tables and arrays, thus confusing\n the parser. The returned decorated callable raises `ValueError`\n instead of returning illegal types.\n \"\"\"\n # The default `float` callable never returns illegal types. Optimize it.\n if parse_float is float:\n return float\n\n def safe_parse_float(float_str: str) -> Any:\n float_value = parse_float(float_str)\n if isinstance(float_value, (dict, list)):\n raise ValueError(\"parse_float must not return dicts or lists\")\n return float_value\n\n return safe_parse_float\n",[],[213,919,920,921,1016,1050,1465,1483],"0aaf6256-67fc-11f0-a516-0224a6c84d84","0aaf6314-67fc-11f0-a516-0224a6c84d84",390,["D",1753299265605],"# SPDX-License-Identifier: MIT\n# SPDX-FileCopyrightText: 2021 Taneli Hukkinen\n# Licensed to PSF under a Contributor Agreement.\n\n__all__ = (\"loads\", \"load\", \"TOMLDecodeError\")\n__version__ = \"2.2.1\" # DO NOT EDIT THIS LINE MANUALLY. LET bump2version UTILITY DO IT\n\nfrom ._parser import TOMLDecodeError, load, loads\n",[],[213,919,920,921,1016,1050,1465,1034],"fe62894c-67fb-11f0-847e-0224a6c84d84",80,["D",1753299245074],[669,670,671,672,673],[213,919,920,921,1016,1050,1465],"0af8b00a-67fc-11f0-8d4e-0224a6c84d84","tree.py","0af8b226-67fc-11f0-8d4e-0224a6c84d84","feb14ac8-67fb-11f0-b5ac-0224a6c84d84",400,["D",1753299266190],"from typing import Iterator, List, Optional, Tuple\n\nfrom ._loop import loop_first, loop_last\nfrom .console import Console, ConsoleOptions, RenderableType, RenderResult\nfrom .jupyter import JupyterMixin\nfrom .measure import Measurement\nfrom .segment import Segment\nfrom .style import Style, StyleStack, StyleType\nfrom .styled import Styled\n\nGuideType = Tuple[str, str, str, str]\n\n\nclass Tree(JupyterMixin):\n \"\"\"A renderable for a tree structure.\n\n Attributes:\n ASCII_GUIDES (GuideType): Guide lines used when Console.ascii_only is True.\n TREE_GUIDES (List[GuideType, GuideType, GuideType]): Default guide lines.\n\n Args:\n label (RenderableType): The renderable or str for the tree label.\n style (StyleType, optional): Style of this tree. Defaults to \"tree\".\n guide_style (StyleType, optional): Style of the guide lines. Defaults to \"tree.line\".\n expanded (bool, optional): Also display children. Defaults to True.\n highlight (bool, optional): Highlight renderable (if str). Defaults to False.\n hide_root (bool, optional): Hide the root node. Defaults to False.\n \"\"\"\n\n ASCII_GUIDES = (\" \", \"| \", \"+-- \", \"`-- \")\n TREE_GUIDES = [\n (\" \", \"│ \", \"├── \", \"└── \"),\n (\" \", \"┃ \", \"┣━━ \", \"┗━━ \"),\n (\" \", \"║ \", \"╠══ \", \"╚══ \"),\n ]\n\n def __init__(\n self,\n label: RenderableType,\n *,\n style: StyleType = \"tree\",\n guide_style: StyleType = \"tree.line\",\n expanded: bool = True,\n highlight: bool = False,\n hide_root: bool = False,\n ) -> None:\n self.label = label\n self.style = style\n self.guide_style = guide_style\n self.children: List[Tree] = []\n self.expanded = expanded\n self.highlight = highlight\n self.hide_root = hide_root\n\n def add(\n self,\n label: RenderableType,\n *,\n style: Optional[StyleType] = None,\n guide_style: Optional[StyleType] = None,\n expanded: bool = True,\n highlight: Optional[bool] = False,\n ) -> \"Tree\":\n \"\"\"Add a child tree.\n\n Args:\n label (RenderableType): The renderable or str for the tree label.\n style (StyleType, optional): Style of this tree. Defaults to \"tree\".\n guide_style (StyleType, optional): Style of the guide lines. Defaults to \"tree.line\".\n expanded (bool, optional): Also display children. Defaults to True.\n highlight (Optional[bool], optional): Highlight renderable (if str). Defaults to False.\n\n Returns:\n Tree: A new child Tree, which may be further modified.\n \"\"\"\n node = Tree(\n label,\n style=self.style if style is None else style,\n guide_style=self.guide_style if guide_style is None else guide_style,\n expanded=expanded,\n highlight=self.highlight if highlight is None else highlight,\n )\n self.children.append(node)\n return node\n\n def __rich_console__(\n self, console: \"Console\", options: \"ConsoleOptions\"\n ) -> \"RenderResult\":\n stack: List[Iterator[Tuple[bool, Tree]]] = []\n pop = stack.pop\n push = stack.append\n new_line = Segment.line()\n\n get_style = console.get_style\n null_style = Style.null()\n guide_style = get_style(self.guide_style, default=\"\") or null_style\n SPACE, CONTINUE, FORK, END = range(4)\n\n _Segment = Segment\n\n def make_guide(index: int, style: Style) -> Segment:\n \"\"\"Make a Segment for a level of the guide lines.\"\"\"\n if options.ascii_only:\n line = self.ASCII_GUIDES[index]\n else:\n guide = 1 if style.bold else (2 if style.underline2 else 0)\n line = self.TREE_GUIDES[0 if options.legacy_windows else guide][index]\n return _Segment(line, style)\n\n levels: List[Segment] = [make_guide(CONTINUE, guide_style)]\n push(iter(loop_last([self])))\n\n guide_style_stack = StyleStack(get_style(self.guide_style))\n style_stack = StyleStack(get_style(self.style))\n remove_guide_styles = Style(bold=False, underline2=False)\n\n depth = 0\n\n while stack:\n stack_node = pop()\n try:\n last, node = next(stack_node)\n except StopIteration:\n levels.pop()\n if levels:\n guide_style = levels[-1].style or null_style\n levels[-1] = make_guide(FORK, guide_style)\n guide_style_stack.pop()\n style_stack.pop()\n continue\n push(stack_node)\n if last:\n levels[-1] = make_guide(END, levels[-1].style or null_style)\n\n guide_style = guide_style_stack.current + get_style(node.guide_style)\n style = style_stack.current + get_style(node.style)\n prefix = levels[(2 if self.hide_root else 1) :]\n renderable_lines = console.render_lines(\n Styled(node.label, style),\n options.update(\n width=options.max_width\n - sum(level.cell_length for level in prefix),\n highlight=self.highlight,\n height=None,\n ),\n pad=options.justify is not None,\n )\n\n if not (depth == 0 and self.hide_root):\n for first, line in loop_first(renderable_lines):\n if prefix:\n yield from _Segment.apply_style(\n prefix,\n style.background_style,\n post_style=remove_guide_styles,\n )\n yield from line\n yield new_line\n if first and prefix:\n prefix[-1] = make_guide(\n SPACE if last else CONTINUE, prefix[-1].style or null_style\n )\n\n if node.expanded and node.children:\n levels[-1] = make_guide(\n SPACE if last else CONTINUE, levels[-1].style or null_style\n )\n levels.append(\n make_guide(END if len(node.children) == 1 else FORK, guide_style)\n )\n style_stack.push(get_style(node.style))\n guide_style_stack.push(get_style(node.guide_style))\n push(iter(loop_last(node.children)))\n depth += 1\n\n def __rich_measure__(\n self, console: \"Console\", options: \"ConsoleOptions\"\n ) -> \"Measurement\":\n stack: List[Iterator[Tree]] = [iter([self])]\n pop = stack.pop\n push = stack.append\n minimum = 0\n maximum = 0\n measure = Measurement.get\n level = 0\n while stack:\n iter_tree = pop()\n try:\n tree = next(iter_tree)\n except StopIteration:\n level -= 1\n continue\n push(iter_tree)\n min_measure, max_measure = measure(console, options, tree.label)\n indent = level * 4\n minimum = max(min_measure + indent, minimum)\n maximum = max(max_measure + indent, maximum)\n if tree.expanded and tree.children:\n push(iter(tree.children))\n level += 1\n return Measurement(minimum, maximum)\n\n\nif __name__ == \"__main__\": # pragma: no cover\n from pip._vendor.rich.console import Group\n from pip._vendor.rich.markdown import Markdown\n from pip._vendor.rich.panel import Panel\n from pip._vendor.rich.syntax import Syntax\n from pip._vendor.rich.table import Table\n\n table = Table(row_styles=[\"\", \"dim\"])\n\n table.add_column(\"Released\", style=\"cyan\", no_wrap=True)\n table.add_column(\"Title\", style=\"magenta\")\n table.add_column(\"Box Office\", justify=\"right\", style=\"green\")\n\n table.add_row(\"Dec 20, 2019\", \"Star Wars: The Rise of Skywalker\", \"$952,110,690\")\n table.add_row(\"May 25, 2018\", \"Solo: A Star Wars Story\", \"$393,151,347\")\n table.add_row(\"Dec 15, 2017\", \"Star Wars Ep. V111: The Last Jedi\", \"$1,332,539,889\")\n table.add_row(\"Dec 16, 2016\", \"Rogue One: A Star Wars Story\", \"$1,332,439,889\")\n\n code = \"\"\"\\\nclass Segment(NamedTuple):\n text: str = \"\"\n style: Optional[Style] = None\n is_control: bool = False\n\"\"\"\n syntax = Syntax(code, \"python\", theme=\"monokai\", line_numbers=True)\n\n markdown = Markdown(\n \"\"\"\\\n### example.md\n> Hello, World!\n>\n> Markdown _all_ the things\n\"\"\"\n )\n\n root = Tree(\"🌲 [b green]Rich Tree\", highlight=True, hide_root=True)\n\n node = root.add(\":file_folder: Renderables\", guide_style=\"red\")\n simple_node = node.add(\":file_folder: [bold yellow]Atomic\", guide_style=\"uu green\")\n simple_node.add(Group(\"📄 Syntax\", syntax))\n simple_node.add(Group(\"📄 Markdown\", Panel(markdown, border_style=\"green\")))\n\n containers_node = node.add(\n \":file_folder: [bold magenta]Containers\", guide_style=\"bold magenta\"\n )\n containers_node.expanded = True\n panel = Panel.fit(\"Just a panel\", border_style=\"red\")\n containers_node.add(Group(\"📄 Panels\", panel))\n\n containers_node.add(Group(\"📄 [b magenta]Table\", table))\n\n console = Console()\n\n console.print(root)\n",[],[213,919,920,921,1016,1050,1511,1503],"rich","0b61bc9e-67fc-11f0-bcbe-0224a6c84d84","traceback.py","0b61bd3e-67fc-11f0-bcbe-0224a6c84d84",417,["D",1753299266865],"import inspect\nimport linecache\nimport os\nimport sys\nfrom dataclasses import dataclass, field\nfrom itertools import islice\nfrom traceback import walk_tb\nfrom types import ModuleType, TracebackType\nfrom typing import (\n Any,\n Callable,\n Dict,\n Iterable,\n List,\n Optional,\n Sequence,\n Tuple,\n Type,\n Union,\n)\n\nfrom pip._vendor.pygments.lexers import guess_lexer_for_filename\nfrom pip._vendor.pygments.token import Comment, Keyword, Name, Number, Operator, String\nfrom pip._vendor.pygments.token import Text as TextToken\nfrom pip._vendor.pygments.token import Token\nfrom pip._vendor.pygments.util import ClassNotFound\n\nfrom . import pretty\nfrom ._loop import loop_first_last, loop_last\nfrom .columns import Columns\nfrom .console import (\n Console,\n ConsoleOptions,\n ConsoleRenderable,\n Group,\n RenderResult,\n group,\n)\nfrom .constrain import Constrain\nfrom .highlighter import RegexHighlighter, ReprHighlighter\nfrom .panel import Panel\nfrom .scope import render_scope\nfrom .style import Style\nfrom .syntax import Syntax, SyntaxPosition\nfrom .text import Text\nfrom .theme import Theme\n\nWINDOWS = sys.platform == \"win32\"\n\nLOCALS_MAX_LENGTH = 10\nLOCALS_MAX_STRING = 80\n\n\ndef _iter_syntax_lines(\n start: SyntaxPosition, end: SyntaxPosition\n) -> Iterable[Tuple[int, int, int]]:\n \"\"\"Yield start and end positions per line.\n\n Args:\n start: Start position.\n end: End position.\n\n Returns:\n Iterable of (LINE, COLUMN1, COLUMN2).\n \"\"\"\n\n line1, column1 = start\n line2, column2 = end\n\n if line1 == line2:\n yield line1, column1, column2\n else:\n for first, last, line_no in loop_first_last(range(line1, line2 + 1)):\n if first:\n yield line_no, column1, -1\n elif last:\n yield line_no, 0, column2\n else:\n yield line_no, 0, -1\n\n\ndef install(\n *,\n console: Optional[Console] = None,\n width: Optional[int] = 100,\n code_width: Optional[int] = 88,\n extra_lines: int = 3,\n theme: Optional[str] = None,\n word_wrap: bool = False,\n show_locals: bool = False,\n locals_max_length: int = LOCALS_MAX_LENGTH,\n locals_max_string: int = LOCALS_MAX_STRING,\n locals_hide_dunder: bool = True,\n locals_hide_sunder: Optional[bool] = None,\n indent_guides: bool = True,\n suppress: Iterable[Union[str, ModuleType]] = (),\n max_frames: int = 100,\n) -> Callable[[Type[BaseException], BaseException, Optional[TracebackType]], Any]:\n \"\"\"Install a rich traceback handler.\n\n Once installed, any tracebacks will be printed with syntax highlighting and rich formatting.\n\n\n Args:\n console (Optional[Console], optional): Console to write exception to. Default uses internal Console instance.\n width (Optional[int], optional): Width (in characters) of traceback. Defaults to 100.\n code_width (Optional[int], optional): Code width (in characters) of traceback. Defaults to 88.\n extra_lines (int, optional): Extra lines of code. Defaults to 3.\n theme (Optional[str], optional): Pygments theme to use in traceback. Defaults to ``None`` which will pick\n a theme appropriate for the platform.\n word_wrap (bool, optional): Enable word wrapping of long lines. Defaults to False.\n show_locals (bool, optional): Enable display of local variables. Defaults to False.\n locals_max_length (int, optional): Maximum length of containers before abbreviating, or None for no abbreviation.\n Defaults to 10.\n locals_max_string (int, optional): Maximum length of string before truncating, or None to disable. Defaults to 80.\n locals_hide_dunder (bool, optional): Hide locals prefixed with double underscore. Defaults to True.\n locals_hide_sunder (bool, optional): Hide locals prefixed with single underscore. Defaults to False.\n indent_guides (bool, optional): Enable indent guides in code and locals. Defaults to True.\n suppress (Sequence[Union[str, ModuleType]]): Optional sequence of modules or paths to exclude from traceback.\n\n Returns:\n Callable: The previous exception handler that was replaced.\n\n \"\"\"\n traceback_console = Console(stderr=True) if console is None else console\n\n locals_hide_sunder = (\n True\n if (traceback_console.is_jupyter and locals_hide_sunder is None)\n else locals_hide_sunder\n )\n\n def excepthook(\n type_: Type[BaseException],\n value: BaseException,\n traceback: Optional[TracebackType],\n ) -> None:\n exception_traceback = Traceback.from_exception(\n type_,\n value,\n traceback,\n width=width,\n code_width=code_width,\n extra_lines=extra_lines,\n theme=theme,\n word_wrap=word_wrap,\n show_locals=show_locals,\n locals_max_length=locals_max_length,\n locals_max_string=locals_max_string,\n locals_hide_dunder=locals_hide_dunder,\n locals_hide_sunder=bool(locals_hide_sunder),\n indent_guides=indent_guides,\n suppress=suppress,\n max_frames=max_frames,\n )\n traceback_console.print(exception_traceback)\n\n def ipy_excepthook_closure(ip: Any) -> None: # pragma: no cover\n tb_data = {} # store information about showtraceback call\n default_showtraceback = ip.showtraceback # keep reference of default traceback\n\n def ipy_show_traceback(*args: Any, **kwargs: Any) -> None:\n \"\"\"wrap the default ip.showtraceback to store info for ip._showtraceback\"\"\"\n nonlocal tb_data\n tb_data = kwargs\n default_showtraceback(*args, **kwargs)\n\n def ipy_display_traceback(\n *args: Any, is_syntax: bool = False, **kwargs: Any\n ) -> None:\n \"\"\"Internally called traceback from ip._showtraceback\"\"\"\n nonlocal tb_data\n exc_tuple = ip._get_exc_info()\n\n # do not display trace on syntax error\n tb: Optional[TracebackType] = None if is_syntax else exc_tuple[2]\n\n # determine correct tb_offset\n compiled = tb_data.get(\"running_compiled_code\", False)\n tb_offset = tb_data.get(\"tb_offset\", 1 if compiled else 0)\n # remove ipython internal frames from trace with tb_offset\n for _ in range(tb_offset):\n if tb is None:\n break\n tb = tb.tb_next\n\n excepthook(exc_tuple[0], exc_tuple[1], tb)\n tb_data = {} # clear data upon usage\n\n # replace _showtraceback instead of showtraceback to allow ipython features such as debugging to work\n # this is also what the ipython docs recommends to modify when subclassing InteractiveShell\n ip._showtraceback = ipy_display_traceback\n # add wrapper to capture tb_data\n ip.showtraceback = ipy_show_traceback\n ip.showsyntaxerror = lambda *args, **kwargs: ipy_display_traceback(\n *args, is_syntax=True, **kwargs\n )\n\n try: # pragma: no cover\n # if within ipython, use customized traceback\n ip = get_ipython() # type: ignore[name-defined]\n ipy_excepthook_closure(ip)\n return sys.excepthook\n except Exception:\n # otherwise use default system hook\n old_excepthook = sys.excepthook\n sys.excepthook = excepthook\n return old_excepthook\n\n\n@dataclass\nclass Frame:\n filename: str\n lineno: int\n name: str\n line: str = \"\"\n locals: Optional[Dict[str, pretty.Node]] = None\n last_instruction: Optional[Tuple[Tuple[int, int], Tuple[int, int]]] = None\n\n\n@dataclass\nclass _SyntaxError:\n offset: int\n filename: str\n line: str\n lineno: int\n msg: str\n notes: List[str] = field(default_factory=list)\n\n\n@dataclass\nclass Stack:\n exc_type: str\n exc_value: str\n syntax_error: Optional[_SyntaxError] = None\n is_cause: bool = False\n frames: List[Frame] = field(default_factory=list)\n notes: List[str] = field(default_factory=list)\n is_group: bool = False\n exceptions: List[\"Trace\"] = field(default_factory=list)\n\n\n@dataclass\nclass Trace:\n stacks: List[Stack]\n\n\nclass PathHighlighter(RegexHighlighter):\n highlights = [r\"(?P.*/)(?P.+)\"]\n\n\nclass Traceback:\n \"\"\"A Console renderable that renders a traceback.\n\n Args:\n trace (Trace, optional): A `Trace` object produced from `extract`. Defaults to None, which uses\n the last exception.\n width (Optional[int], optional): Number of characters used to traceback. Defaults to 100.\n code_width (Optional[int], optional): Number of code characters used to traceback. Defaults to 88.\n extra_lines (int, optional): Additional lines of code to render. Defaults to 3.\n theme (str, optional): Override pygments theme used in traceback.\n word_wrap (bool, optional): Enable word wrapping of long lines. Defaults to False.\n show_locals (bool, optional): Enable display of local variables. Defaults to False.\n indent_guides (bool, optional): Enable indent guides in code and locals. Defaults to True.\n locals_max_length (int, optional): Maximum length of containers before abbreviating, or None for no abbreviation.\n Defaults to 10.\n locals_max_string (int, optional): Maximum length of string before truncating, or None to disable. Defaults to 80.\n locals_hide_dunder (bool, optional): Hide locals prefixed with double underscore. Defaults to True.\n locals_hide_sunder (bool, optional): Hide locals prefixed with single underscore. Defaults to False.\n suppress (Sequence[Union[str, ModuleType]]): Optional sequence of modules or paths to exclude from traceback.\n max_frames (int): Maximum number of frames to show in a traceback, 0 for no maximum. Defaults to 100.\n\n \"\"\"\n\n LEXERS = {\n \"\": \"text\",\n \".py\": \"python\",\n \".pxd\": \"cython\",\n \".pyx\": \"cython\",\n \".pxi\": \"pyrex\",\n }\n\n def __init__(\n self,\n trace: Optional[Trace] = None,\n *,\n width: Optional[int] = 100,\n code_width: Optional[int] = 88,\n extra_lines: int = 3,\n theme: Optional[str] = None,\n word_wrap: bool = False,\n show_locals: bool = False,\n locals_max_length: int = LOCALS_MAX_LENGTH,\n locals_max_string: int = LOCALS_MAX_STRING,\n locals_hide_dunder: bool = True,\n locals_hide_sunder: bool = False,\n indent_guides: bool = True,\n suppress: Iterable[Union[str, ModuleType]] = (),\n max_frames: int = 100,\n ):\n if trace is None:\n exc_type, exc_value, traceback = sys.exc_info()\n if exc_type is None or exc_value is None or traceback is None:\n raise ValueError(\n \"Value for 'trace' required if not called in except: block\"\n )\n trace = self.extract(\n exc_type, exc_value, traceback, show_locals=show_locals\n )\n self.trace = trace\n self.width = width\n self.code_width = code_width\n self.extra_lines = extra_lines\n self.theme = Syntax.get_theme(theme or \"ansi_dark\")\n self.word_wrap = word_wrap\n self.show_locals = show_locals\n self.indent_guides = indent_guides\n self.locals_max_length = locals_max_length\n self.locals_max_string = locals_max_string\n self.locals_hide_dunder = locals_hide_dunder\n self.locals_hide_sunder = locals_hide_sunder\n\n self.suppress: Sequence[str] = []\n for suppress_entity in suppress:\n if not isinstance(suppress_entity, str):\n assert (\n suppress_entity.__file__ is not None\n ), f\"{suppress_entity!r} must be a module with '__file__' attribute\"\n path = os.path.dirname(suppress_entity.__file__)\n else:\n path = suppress_entity\n path = os.path.normpath(os.path.abspath(path))\n self.suppress.append(path)\n self.max_frames = max(4, max_frames) if max_frames > 0 else 0\n\n @classmethod\n def from_exception(\n cls,\n exc_type: Type[Any],\n exc_value: BaseException,\n traceback: Optional[TracebackType],\n *,\n width: Optional[int] = 100,\n code_width: Optional[int] = 88,\n extra_lines: int = 3,\n theme: Optional[str] = None,\n word_wrap: bool = False,\n show_locals: bool = False,\n locals_max_length: int = LOCALS_MAX_LENGTH,\n locals_max_string: int = LOCALS_MAX_STRING,\n locals_hide_dunder: bool = True,\n locals_hide_sunder: bool = False,\n indent_guides: bool = True,\n suppress: Iterable[Union[str, ModuleType]] = (),\n max_frames: int = 100,\n ) -> \"Traceback\":\n \"\"\"Create a traceback from exception info\n\n Args:\n exc_type (Type[BaseException]): Exception type.\n exc_value (BaseException): Exception value.\n traceback (TracebackType): Python Traceback object.\n width (Optional[int], optional): Number of characters used to traceback. Defaults to 100.\n code_width (Optional[int], optional): Number of code characters used to traceback. Defaults to 88.\n extra_lines (int, optional): Additional lines of code to render. Defaults to 3.\n theme (str, optional): Override pygments theme used in traceback.\n word_wrap (bool, optional): Enable word wrapping of long lines. Defaults to False.\n show_locals (bool, optional): Enable display of local variables. Defaults to False.\n indent_guides (bool, optional): Enable indent guides in code and locals. Defaults to True.\n locals_max_length (int, optional): Maximum length of containers before abbreviating, or None for no abbreviation.\n Defaults to 10.\n locals_max_string (int, optional): Maximum length of string before truncating, or None to disable. Defaults to 80.\n locals_hide_dunder (bool, optional): Hide locals prefixed with double underscore. Defaults to True.\n locals_hide_sunder (bool, optional): Hide locals prefixed with single underscore. Defaults to False.\n suppress (Iterable[Union[str, ModuleType]]): Optional sequence of modules or paths to exclude from traceback.\n max_frames (int): Maximum number of frames to show in a traceback, 0 for no maximum. Defaults to 100.\n\n Returns:\n Traceback: A Traceback instance that may be printed.\n \"\"\"\n rich_traceback = cls.extract(\n exc_type,\n exc_value,\n traceback,\n show_locals=show_locals,\n locals_max_length=locals_max_length,\n locals_max_string=locals_max_string,\n locals_hide_dunder=locals_hide_dunder,\n locals_hide_sunder=locals_hide_sunder,\n )\n\n return cls(\n rich_traceback,\n width=width,\n code_width=code_width,\n extra_lines=extra_lines,\n theme=theme,\n word_wrap=word_wrap,\n show_locals=show_locals,\n indent_guides=indent_guides,\n locals_max_length=locals_max_length,\n locals_max_string=locals_max_string,\n locals_hide_dunder=locals_hide_dunder,\n locals_hide_sunder=locals_hide_sunder,\n suppress=suppress,\n max_frames=max_frames,\n )\n\n @classmethod\n def extract(\n cls,\n exc_type: Type[BaseException],\n exc_value: BaseException,\n traceback: Optional[TracebackType],\n *,\n show_locals: bool = False,\n locals_max_length: int = LOCALS_MAX_LENGTH,\n locals_max_string: int = LOCALS_MAX_STRING,\n locals_hide_dunder: bool = True,\n locals_hide_sunder: bool = False,\n ) -> Trace:\n \"\"\"Extract traceback information.\n\n Args:\n exc_type (Type[BaseException]): Exception type.\n exc_value (BaseException): Exception value.\n traceback (TracebackType): Python Traceback object.\n show_locals (bool, optional): Enable display of local variables. Defaults to False.\n locals_max_length (int, optional): Maximum length of containers before abbreviating, or None for no abbreviation.\n Defaults to 10.\n locals_max_string (int, optional): Maximum length of string before truncating, or None to disable. Defaults to 80.\n locals_hide_dunder (bool, optional): Hide locals prefixed with double underscore. Defaults to True.\n locals_hide_sunder (bool, optional): Hide locals prefixed with single underscore. Defaults to False.\n\n Returns:\n Trace: A Trace instance which you can use to construct a `Traceback`.\n \"\"\"\n\n stacks: List[Stack] = []\n is_cause = False\n\n from pip._vendor.rich import _IMPORT_CWD\n\n notes: List[str] = getattr(exc_value, \"__notes__\", None) or []\n\n def safe_str(_object: Any) -> str:\n \"\"\"Don't allow exceptions from __str__ to propagate.\"\"\"\n try:\n return str(_object)\n except Exception:\n return \"\"\n\n while True:\n stack = Stack(\n exc_type=safe_str(exc_type.__name__),\n exc_value=safe_str(exc_value),\n is_cause=is_cause,\n notes=notes,\n )\n\n if sys.version_info >= (3, 11):\n if isinstance(exc_value, (BaseExceptionGroup, ExceptionGroup)):\n stack.is_group = True\n for exception in exc_value.exceptions:\n stack.exceptions.append(\n Traceback.extract(\n type(exception),\n exception,\n exception.__traceback__,\n show_locals=show_locals,\n locals_max_length=locals_max_length,\n locals_hide_dunder=locals_hide_dunder,\n locals_hide_sunder=locals_hide_sunder,\n )\n )\n\n if isinstance(exc_value, SyntaxError):\n stack.syntax_error = _SyntaxError(\n offset=exc_value.offset or 0,\n filename=exc_value.filename or \"?\",\n lineno=exc_value.lineno or 0,\n line=exc_value.text or \"\",\n msg=exc_value.msg,\n notes=notes,\n )\n\n stacks.append(stack)\n append = stack.frames.append\n\n def get_locals(\n iter_locals: Iterable[Tuple[str, object]],\n ) -> Iterable[Tuple[str, object]]:\n \"\"\"Extract locals from an iterator of key pairs.\"\"\"\n if not (locals_hide_dunder or locals_hide_sunder):\n yield from iter_locals\n return\n for key, value in iter_locals:\n if locals_hide_dunder and key.startswith(\"__\"):\n continue\n if locals_hide_sunder and key.startswith(\"_\"):\n continue\n yield key, value\n\n for frame_summary, line_no in walk_tb(traceback):\n filename = frame_summary.f_code.co_filename\n\n last_instruction: Optional[Tuple[Tuple[int, int], Tuple[int, int]]]\n last_instruction = None\n if sys.version_info >= (3, 11):\n instruction_index = frame_summary.f_lasti // 2\n instruction_position = next(\n islice(\n frame_summary.f_code.co_positions(),\n instruction_index,\n instruction_index + 1,\n )\n )\n (\n start_line,\n end_line,\n start_column,\n end_column,\n ) = instruction_position\n if (\n start_line is not None\n and end_line is not None\n and start_column is not None\n and end_column is not None\n ):\n last_instruction = (\n (start_line, start_column),\n (end_line, end_column),\n )\n\n if filename and not filename.startswith(\"<\"):\n if not os.path.isabs(filename):\n filename = os.path.join(_IMPORT_CWD, filename)\n if frame_summary.f_locals.get(\"_rich_traceback_omit\", False):\n continue\n\n frame = Frame(\n filename=filename or \"?\",\n lineno=line_no,\n name=frame_summary.f_code.co_name,\n locals=(\n {\n key: pretty.traverse(\n value,\n max_length=locals_max_length,\n max_string=locals_max_string,\n )\n for key, value in get_locals(frame_summary.f_locals.items())\n if not (inspect.isfunction(value) or inspect.isclass(value))\n }\n if show_locals\n else None\n ),\n last_instruction=last_instruction,\n )\n append(frame)\n if frame_summary.f_locals.get(\"_rich_traceback_guard\", False):\n del stack.frames[:]\n\n cause = getattr(exc_value, \"__cause__\", None)\n if cause:\n exc_type = cause.__class__\n exc_value = cause\n # __traceback__ can be None, e.g. for exceptions raised by the\n # 'multiprocessing' module\n traceback = cause.__traceback__\n is_cause = True\n continue\n\n cause = exc_value.__context__\n if cause and not getattr(exc_value, \"__suppress_context__\", False):\n exc_type = cause.__class__\n exc_value = cause\n traceback = cause.__traceback__\n is_cause = False\n continue\n # No cover, code is reached but coverage doesn't recognize it.\n break # pragma: no cover\n\n trace = Trace(stacks=stacks)\n\n return trace\n\n def __rich_console__(\n self, console: Console, options: ConsoleOptions\n ) -> RenderResult:\n theme = self.theme\n background_style = theme.get_background_style()\n token_style = theme.get_style_for_token\n\n traceback_theme = Theme(\n {\n \"pretty\": token_style(TextToken),\n \"pygments.text\": token_style(Token),\n \"pygments.string\": token_style(String),\n \"pygments.function\": token_style(Name.Function),\n \"pygments.number\": token_style(Number),\n \"repr.indent\": token_style(Comment) + Style(dim=True),\n \"repr.str\": token_style(String),\n \"repr.brace\": token_style(TextToken) + Style(bold=True),\n \"repr.number\": token_style(Number),\n \"repr.bool_true\": token_style(Keyword.Constant),\n \"repr.bool_false\": token_style(Keyword.Constant),\n \"repr.none\": token_style(Keyword.Constant),\n \"scope.border\": token_style(String.Delimiter),\n \"scope.equals\": token_style(Operator),\n \"scope.key\": token_style(Name),\n \"scope.key.special\": token_style(Name.Constant) + Style(dim=True),\n },\n inherit=False,\n )\n\n highlighter = ReprHighlighter()\n\n @group()\n def render_stack(stack: Stack, last: bool) -> RenderResult:\n if stack.frames:\n stack_renderable: ConsoleRenderable = Panel(\n self._render_stack(stack),\n title=\"[traceback.title]Traceback [dim](most recent call last)\",\n style=background_style,\n border_style=\"traceback.border\",\n expand=True,\n padding=(0, 1),\n )\n stack_renderable = Constrain(stack_renderable, self.width)\n with console.use_theme(traceback_theme):\n yield stack_renderable\n\n if stack.syntax_error is not None:\n with console.use_theme(traceback_theme):\n yield Constrain(\n Panel(\n self._render_syntax_error(stack.syntax_error),\n style=background_style,\n border_style=\"traceback.border.syntax_error\",\n expand=True,\n padding=(0, 1),\n width=self.width,\n ),\n self.width,\n )\n yield Text.assemble(\n (f\"{stack.exc_type}: \", \"traceback.exc_type\"),\n highlighter(stack.syntax_error.msg),\n )\n elif stack.exc_value:\n yield Text.assemble(\n (f\"{stack.exc_type}: \", \"traceback.exc_type\"),\n highlighter(stack.exc_value),\n )\n else:\n yield Text.assemble((f\"{stack.exc_type}\", \"traceback.exc_type\"))\n\n for note in stack.notes:\n yield Text.assemble((\"[NOTE] \", \"traceback.note\"), highlighter(note))\n\n if stack.is_group:\n for group_no, group_exception in enumerate(stack.exceptions, 1):\n grouped_exceptions: List[Group] = []\n for group_last, group_stack in loop_last(group_exception.stacks):\n grouped_exceptions.append(render_stack(group_stack, group_last))\n yield \"\"\n yield Constrain(\n Panel(\n Group(*grouped_exceptions),\n title=f\"Sub-exception #{group_no}\",\n border_style=\"traceback.group.border\",\n ),\n self.width,\n )\n\n if not last:\n if stack.is_cause:\n yield Text.from_markup(\n \"\\n[i]The above exception was the direct cause of the following exception:\\n\",\n )\n else:\n yield Text.from_markup(\n \"\\n[i]During handling of the above exception, another exception occurred:\\n\",\n )\n\n for last, stack in loop_last(reversed(self.trace.stacks)):\n yield render_stack(stack, last)\n\n @group()\n def _render_syntax_error(self, syntax_error: _SyntaxError) -> RenderResult:\n highlighter = ReprHighlighter()\n path_highlighter = PathHighlighter()\n if syntax_error.filename != \"\":\n if os.path.exists(syntax_error.filename):\n text = Text.assemble(\n (f\" {syntax_error.filename}\", \"pygments.string\"),\n (\":\", \"pygments.text\"),\n (str(syntax_error.lineno), \"pygments.number\"),\n style=\"pygments.text\",\n )\n yield path_highlighter(text)\n syntax_error_text = highlighter(syntax_error.line.rstrip())\n syntax_error_text.no_wrap = True\n offset = min(syntax_error.offset - 1, len(syntax_error_text))\n syntax_error_text.stylize(\"bold underline\", offset, offset)\n syntax_error_text += Text.from_markup(\n \"\\n\" + \" \" * offset + \"[traceback.offset]▲[/]\",\n style=\"pygments.text\",\n )\n yield syntax_error_text\n\n @classmethod\n def _guess_lexer(cls, filename: str, code: str) -> str:\n ext = os.path.splitext(filename)[-1]\n if not ext:\n # No extension, look at first line to see if it is a hashbang\n # Note, this is an educated guess and not a guarantee\n # If it fails, the only downside is that the code is highlighted strangely\n new_line_index = code.index(\"\\n\")\n first_line = code[:new_line_index] if new_line_index != -1 else code\n if first_line.startswith(\"#!\") and \"python\" in first_line.lower():\n return \"python\"\n try:\n return cls.LEXERS.get(ext) or guess_lexer_for_filename(filename, code).name\n except ClassNotFound:\n return \"text\"\n\n @group()\n def _render_stack(self, stack: Stack) -> RenderResult:\n path_highlighter = PathHighlighter()\n theme = self.theme\n\n def render_locals(frame: Frame) -> Iterable[ConsoleRenderable]:\n if frame.locals:\n yield render_scope(\n frame.locals,\n title=\"locals\",\n indent_guides=self.indent_guides,\n max_length=self.locals_max_length,\n max_string=self.locals_max_string,\n )\n\n exclude_frames: Optional[range] = None\n if self.max_frames != 0:\n exclude_frames = range(\n self.max_frames // 2,\n len(stack.frames) - self.max_frames // 2,\n )\n\n excluded = False\n for frame_index, frame in enumerate(stack.frames):\n if exclude_frames and frame_index in exclude_frames:\n excluded = True\n continue\n\n if excluded:\n assert exclude_frames is not None\n yield Text(\n f\"\\n... {len(exclude_frames)} frames hidden ...\",\n justify=\"center\",\n style=\"traceback.error\",\n )\n excluded = False\n\n first = frame_index == 0\n frame_filename = frame.filename\n suppressed = any(frame_filename.startswith(path) for path in self.suppress)\n\n if os.path.exists(frame.filename):\n text = Text.assemble(\n path_highlighter(Text(frame.filename, style=\"pygments.string\")),\n (\":\", \"pygments.text\"),\n (str(frame.lineno), \"pygments.number\"),\n \" in \",\n (frame.name, \"pygments.function\"),\n style=\"pygments.text\",\n )\n else:\n text = Text.assemble(\n \"in \",\n (frame.name, \"pygments.function\"),\n (\":\", \"pygments.text\"),\n (str(frame.lineno), \"pygments.number\"),\n style=\"pygments.text\",\n )\n if not frame.filename.startswith(\"<\") and not first:\n yield \"\"\n yield text\n if frame.filename.startswith(\"<\"):\n yield from render_locals(frame)\n continue\n if not suppressed:\n try:\n code_lines = linecache.getlines(frame.filename)\n code = \"\".join(code_lines)\n if not code:\n # code may be an empty string if the file doesn't exist, OR\n # if the traceback filename is generated dynamically\n continue\n lexer_name = self._guess_lexer(frame.filename, code)\n syntax = Syntax(\n code,\n lexer_name,\n theme=theme,\n line_numbers=True,\n line_range=(\n frame.lineno - self.extra_lines,\n frame.lineno + self.extra_lines,\n ),\n highlight_lines={frame.lineno},\n word_wrap=self.word_wrap,\n code_width=self.code_width,\n indent_guides=self.indent_guides,\n dedent=False,\n )\n yield \"\"\n except Exception as error:\n yield Text.assemble(\n (f\"\\n{error}\", \"traceback.error\"),\n )\n else:\n if frame.last_instruction is not None:\n start, end = frame.last_instruction\n\n # Stylize a line at a time\n # So that indentation isn't underlined (which looks bad)\n for line1, column1, column2 in _iter_syntax_lines(start, end):\n try:\n if column1 == 0:\n line = code_lines[line1 - 1]\n column1 = len(line) - len(line.lstrip())\n if column2 == -1:\n column2 = len(code_lines[line1 - 1])\n except IndexError:\n # Being defensive here\n # If last_instruction reports a line out-of-bounds, we don't want to crash\n continue\n\n syntax.stylize_range(\n style=\"traceback.error_range\",\n start=(line1, column1),\n end=(line1, column2),\n )\n yield (\n Columns(\n [\n syntax,\n *render_locals(frame),\n ],\n padding=1,\n )\n if frame.locals\n else syntax\n )\n\n\nif __name__ == \"__main__\": # pragma: no cover\n install(show_locals=True)\n import sys\n\n def bar(\n a: Any,\n ) -> None: # 这是对亚洲语言支持的测试。面对模棱两可的想法，拒绝猜测的诱惑\n one = 1\n print(one / a)\n\n def foo(a: Any) -> None:\n _rich_traceback_guard = True\n zed = {\n \"characters\": {\n \"Paul Atreides\",\n \"Vladimir Harkonnen\",\n \"Thufir Hawat\",\n \"Duncan Idaho\",\n },\n \"atomic_types\": (None, False, True),\n }\n bar(a)\n\n def error() -> None:\n foo(0)\n\n error()\n",[],[213,919,920,921,1016,1050,1511,1513],"0ae4b514-67fc-11f0-a516-0224a6c84d84","themes.py","0ae4b604-67fc-11f0-a516-0224a6c84d84",397,["D",1753299266055],"from .default_styles import DEFAULT_STYLES\nfrom .theme import Theme\n\n\nDEFAULT = Theme(DEFAULT_STYLES)\n",[],[213,919,920,921,1016,1050,1511,1521],"0b2296f4-67fc-11f0-a516-0224a6c84d84","theme.py","0b229794-67fc-11f0-a516-0224a6c84d84",407,["D",1753299266463],"import configparser\nfrom typing import IO, Dict, List, Mapping, Optional\n\nfrom .default_styles import DEFAULT_STYLES\nfrom .style import Style, StyleType\n\n\nclass Theme:\n \"\"\"A container for style information, used by :class:`~rich.console.Console`.\n\n Args:\n styles (Dict[str, Style], optional): A mapping of style names on to styles. Defaults to None for a theme with no styles.\n inherit (bool, optional): Inherit default styles. Defaults to True.\n \"\"\"\n\n styles: Dict[str, Style]\n\n def __init__(\n self, styles: Optional[Mapping[str, StyleType]] = None, inherit: bool = True\n ):\n self.styles = DEFAULT_STYLES.copy() if inherit else {}\n if styles is not None:\n self.styles.update(\n {\n name: style if isinstance(style, Style) else Style.parse(style)\n for name, style in styles.items()\n }\n )\n\n @property\n def config(self) -> str:\n \"\"\"Get contents of a config file for this theme.\"\"\"\n config = \"[styles]\\n\" + \"\\n\".join(\n f\"{name} = {style}\" for name, style in sorted(self.styles.items())\n )\n return config\n\n @classmethod\n def from_file(\n cls, config_file: IO[str], source: Optional[str] = None, inherit: bool = True\n ) -> \"Theme\":\n \"\"\"Load a theme from a text mode file.\n\n Args:\n config_file (IO[str]): An open conf file.\n source (str, optional): The filename of the open file. Defaults to None.\n inherit (bool, optional): Inherit default styles. Defaults to True.\n\n Returns:\n Theme: A New theme instance.\n \"\"\"\n config = configparser.ConfigParser()\n config.read_file(config_file, source=source)\n styles = {name: Style.parse(value) for name, value in config.items(\"styles\")}\n theme = Theme(styles, inherit=inherit)\n return theme\n\n @classmethod\n def read(\n cls, path: str, inherit: bool = True, encoding: Optional[str] = None\n ) -> \"Theme\":\n \"\"\"Read a theme from a path.\n\n Args:\n path (str): Path to a config file readable by Python configparser module.\n inherit (bool, optional): Inherit default styles. Defaults to True.\n encoding (str, optional): Encoding of the config file. Defaults to None.\n\n Returns:\n Theme: A new theme instance.\n \"\"\"\n with open(path, encoding=encoding) as config_file:\n return cls.from_file(config_file, source=path, inherit=inherit)\n\n\nclass ThemeStackError(Exception):\n \"\"\"Base exception for errors related to the theme stack.\"\"\"\n\n\nclass ThemeStack:\n \"\"\"A stack of themes.\n\n Args:\n theme (Theme): A theme instance\n \"\"\"\n\n def __init__(self, theme: Theme) -> None:\n self._entries: List[Dict[str, Style]] = [theme.styles]\n self.get = self._entries[-1].get\n\n def push_theme(self, theme: Theme, inherit: bool = True) -> None:\n \"\"\"Push a theme on the top of the stack.\n\n Args:\n theme (Theme): A Theme instance.\n inherit (boolean, optional): Inherit styles from current top of stack.\n \"\"\"\n styles: Dict[str, Style]\n styles = (\n {**self._entries[-1], **theme.styles} if inherit else theme.styles.copy()\n )\n self._entries.append(styles)\n self.get = self._entries[-1].get\n\n def pop_theme(self) -> None:\n \"\"\"Pop (and discard) the top-most theme.\"\"\"\n if len(self._entries) == 1:\n raise ThemeStackError(\"Unable to pop base theme\")\n self._entries.pop()\n self.get = self._entries[-1].get\n\n\nif __name__ == \"__main__\": # pragma: no cover\n theme = Theme()\n print(theme.config)\n",[],[213,919,920,921,1016,1050,1511,1529],"0be39aa2-67fc-11f0-9167-0224a6c84d84","text.py","0be39b9c-67fc-11f0-9167-0224a6c84d84",438,["D",1753299267725],"import re\nfrom functools import partial, reduce\nfrom math import gcd\nfrom operator import itemgetter\nfrom typing import (\n TYPE_CHECKING,\n Any,\n Callable,\n Dict,\n Iterable,\n List,\n NamedTuple,\n Optional,\n Pattern,\n Tuple,\n Union,\n)\n\nfrom ._loop import loop_last\nfrom ._pick import pick_bool\nfrom ._wrap import divide_line\nfrom .align import AlignMethod\nfrom .cells import cell_len, set_cell_size\nfrom .containers import Lines\nfrom .control import strip_control_codes\nfrom .emoji import EmojiVariant\nfrom .jupyter import JupyterMixin\nfrom .measure import Measurement\nfrom .segment import Segment\nfrom .style import Style, StyleType\n\nif TYPE_CHECKING: # pragma: no cover\n from .console import Console, ConsoleOptions, JustifyMethod, OverflowMethod\n\nDEFAULT_JUSTIFY: \"JustifyMethod\" = \"default\"\nDEFAULT_OVERFLOW: \"OverflowMethod\" = \"fold\"\n\n\n_re_whitespace = re.compile(r\"\\s+$\")\n\nTextType = Union[str, \"Text\"]\n\"\"\"A plain string or a :class:`Text` instance.\"\"\"\n\nGetStyleCallable = Callable[[str], Optional[StyleType]]\n\n\nclass Span(NamedTuple):\n \"\"\"A marked up region in some text.\"\"\"\n\n start: int\n \"\"\"Span start index.\"\"\"\n end: int\n \"\"\"Span end index.\"\"\"\n style: Union[str, Style]\n \"\"\"Style associated with the span.\"\"\"\n\n def __repr__(self) -> str:\n return f\"Span({self.start}, {self.end}, {self.style!r})\"\n\n def __bool__(self) -> bool:\n return self.end > self.start\n\n def split(self, offset: int) -> Tuple[\"Span\", Optional[\"Span\"]]:\n \"\"\"Split a span in to 2 from a given offset.\"\"\"\n\n if offset < self.start:\n return self, None\n if offset >= self.end:\n return self, None\n\n start, end, style = self\n span1 = Span(start, min(end, offset), style)\n span2 = Span(span1.end, end, style)\n return span1, span2\n\n def move(self, offset: int) -> \"Span\":\n \"\"\"Move start and end by a given offset.\n\n Args:\n offset (int): Number of characters to add to start and end.\n\n Returns:\n TextSpan: A new TextSpan with adjusted position.\n \"\"\"\n start, end, style = self\n return Span(start + offset, end + offset, style)\n\n def right_crop(self, offset: int) -> \"Span\":\n \"\"\"Crop the span at the given offset.\n\n Args:\n offset (int): A value between start and end.\n\n Returns:\n Span: A new (possibly smaller) span.\n \"\"\"\n start, end, style = self\n if offset >= end:\n return self\n return Span(start, min(offset, end), style)\n\n def extend(self, cells: int) -> \"Span\":\n \"\"\"Extend the span by the given number of cells.\n\n Args:\n cells (int): Additional space to add to end of span.\n\n Returns:\n Span: A span.\n \"\"\"\n if cells:\n start, end, style = self\n return Span(start, end + cells, style)\n else:\n return self\n\n\nclass Text(JupyterMixin):\n \"\"\"Text with color / style.\n\n Args:\n text (str, optional): Default unstyled text. Defaults to \"\".\n style (Union[str, Style], optional): Base style for text. Defaults to \"\".\n justify (str, optional): Justify method: \"left\", \"center\", \"full\", \"right\". Defaults to None.\n overflow (str, optional): Overflow method: \"crop\", \"fold\", \"ellipsis\". Defaults to None.\n no_wrap (bool, optional): Disable text wrapping, or None for default. Defaults to None.\n end (str, optional): Character to end text with. Defaults to \"\\\\\\\\n\".\n tab_size (int): Number of spaces per tab, or ``None`` to use ``console.tab_size``. Defaults to None.\n spans (List[Span], optional). A list of predefined style spans. Defaults to None.\n \"\"\"\n\n __slots__ = [\n \"_text\",\n \"style\",\n \"justify\",\n \"overflow\",\n \"no_wrap\",\n \"end\",\n \"tab_size\",\n \"_spans\",\n \"_length\",\n ]\n\n def __init__(\n self,\n text: str = \"\",\n style: Union[str, Style] = \"\",\n *,\n justify: Optional[\"JustifyMethod\"] = None,\n overflow: Optional[\"OverflowMethod\"] = None,\n no_wrap: Optional[bool] = None,\n end: str = \"\\n\",\n tab_size: Optional[int] = None,\n spans: Optional[List[Span]] = None,\n ) -> None:\n sanitized_text = strip_control_codes(text)\n self._text = [sanitized_text]\n self.style = style\n self.justify: Optional[\"JustifyMethod\"] = justify\n self.overflow: Optional[\"OverflowMethod\"] = overflow\n self.no_wrap = no_wrap\n self.end = end\n self.tab_size = tab_size\n self._spans: List[Span] = spans or []\n self._length: int = len(sanitized_text)\n\n def __len__(self) -> int:\n return self._length\n\n def __bool__(self) -> bool:\n return bool(self._length)\n\n def __str__(self) -> str:\n return self.plain\n\n def __repr__(self) -> str:\n return f\"\"\n\n def __add__(self, other: Any) -> \"Text\":\n if isinstance(other, (str, Text)):\n result = self.copy()\n result.append(other)\n return result\n return NotImplemented\n\n def __eq__(self, other: object) -> bool:\n if not isinstance(other, Text):\n return NotImplemented\n return self.plain == other.plain and self._spans == other._spans\n\n def __contains__(self, other: object) -> bool:\n if isinstance(other, str):\n return other in self.plain\n elif isinstance(other, Text):\n return other.plain in self.plain\n return False\n\n def __getitem__(self, slice: Union[int, slice]) -> \"Text\":\n def get_text_at(offset: int) -> \"Text\":\n _Span = Span\n text = Text(\n self.plain[offset],\n spans=[\n _Span(0, 1, style)\n for start, end, style in self._spans\n if end > offset >= start\n ],\n end=\"\",\n )\n return text\n\n if isinstance(slice, int):\n return get_text_at(slice)\n else:\n start, stop, step = slice.indices(len(self.plain))\n if step == 1:\n lines = self.divide([start, stop])\n return lines[1]\n else:\n # This would be a bit of work to implement efficiently\n # For now, its not required\n raise TypeError(\"slices with step!=1 are not supported\")\n\n @property\n def cell_len(self) -> int:\n \"\"\"Get the number of cells required to render this text.\"\"\"\n return cell_len(self.plain)\n\n @property\n def markup(self) -> str:\n \"\"\"Get console markup to render this Text.\n\n Returns:\n str: A string potentially creating markup tags.\n \"\"\"\n from .markup import escape\n\n output: List[str] = []\n\n plain = self.plain\n markup_spans = [\n (0, False, self.style),\n *((span.start, False, span.style) for span in self._spans),\n *((span.end, True, span.style) for span in self._spans),\n (len(plain), True, self.style),\n ]\n markup_spans.sort(key=itemgetter(0, 1))\n position = 0\n append = output.append\n for offset, closing, style in markup_spans:\n if offset > position:\n append(escape(plain[position:offset]))\n position = offset\n if style:\n append(f\"[/{style}]\" if closing else f\"[{style}]\")\n markup = \"\".join(output)\n return markup\n\n @classmethod\n def from_markup(\n cls,\n text: str,\n *,\n style: Union[str, Style] = \"\",\n emoji: bool = True,\n emoji_variant: Optional[EmojiVariant] = None,\n justify: Optional[\"JustifyMethod\"] = None,\n overflow: Optional[\"OverflowMethod\"] = None,\n end: str = \"\\n\",\n ) -> \"Text\":\n \"\"\"Create Text instance from markup.\n\n Args:\n text (str): A string containing console markup.\n style (Union[str, Style], optional): Base style for text. Defaults to \"\".\n emoji (bool, optional): Also render emoji code. Defaults to True.\n emoji_variant (str, optional): Optional emoji variant, either \"text\" or \"emoji\". Defaults to None.\n justify (str, optional): Justify method: \"left\", \"center\", \"full\", \"right\". Defaults to None.\n overflow (str, optional): Overflow method: \"crop\", \"fold\", \"ellipsis\". Defaults to None.\n end (str, optional): Character to end text with. Defaults to \"\\\\\\\\n\".\n\n Returns:\n Text: A Text instance with markup rendered.\n \"\"\"\n from .markup import render\n\n rendered_text = render(text, style, emoji=emoji, emoji_variant=emoji_variant)\n rendered_text.justify = justify\n rendered_text.overflow = overflow\n rendered_text.end = end\n return rendered_text\n\n @classmethod\n def from_ansi(\n cls,\n text: str,\n *,\n style: Union[str, Style] = \"\",\n justify: Optional[\"JustifyMethod\"] = None,\n overflow: Optional[\"OverflowMethod\"] = None,\n no_wrap: Optional[bool] = None,\n end: str = \"\\n\",\n tab_size: Optional[int] = 8,\n ) -> \"Text\":\n \"\"\"Create a Text object from a string containing ANSI escape codes.\n\n Args:\n text (str): A string containing escape codes.\n style (Union[str, Style], optional): Base style for text. Defaults to \"\".\n justify (str, optional): Justify method: \"left\", \"center\", \"full\", \"right\". Defaults to None.\n overflow (str, optional): Overflow method: \"crop\", \"fold\", \"ellipsis\". Defaults to None.\n no_wrap (bool, optional): Disable text wrapping, or None for default. Defaults to None.\n end (str, optional): Character to end text with. Defaults to \"\\\\\\\\n\".\n tab_size (int): Number of spaces per tab, or ``None`` to use ``console.tab_size``. Defaults to None.\n \"\"\"\n from .ansi import AnsiDecoder\n\n joiner = Text(\n \"\\n\",\n justify=justify,\n overflow=overflow,\n no_wrap=no_wrap,\n end=end,\n tab_size=tab_size,\n style=style,\n )\n decoder = AnsiDecoder()\n result = joiner.join(line for line in decoder.decode(text))\n return result\n\n @classmethod\n def styled(\n cls,\n text: str,\n style: StyleType = \"\",\n *,\n justify: Optional[\"JustifyMethod\"] = None,\n overflow: Optional[\"OverflowMethod\"] = None,\n ) -> \"Text\":\n \"\"\"Construct a Text instance with a pre-applied styled. A style applied in this way won't be used\n to pad the text when it is justified.\n\n Args:\n text (str): A string containing console markup.\n style (Union[str, Style]): Style to apply to the text. Defaults to \"\".\n justify (str, optional): Justify method: \"left\", \"center\", \"full\", \"right\". Defaults to None.\n overflow (str, optional): Overflow method: \"crop\", \"fold\", \"ellipsis\". Defaults to None.\n\n Returns:\n Text: A text instance with a style applied to the entire string.\n \"\"\"\n styled_text = cls(text, justify=justify, overflow=overflow)\n styled_text.stylize(style)\n return styled_text\n\n @classmethod\n def assemble(\n cls,\n *parts: Union[str, \"Text\", Tuple[str, StyleType]],\n style: Union[str, Style] = \"\",\n justify: Optional[\"JustifyMethod\"] = None,\n overflow: Optional[\"OverflowMethod\"] = None,\n no_wrap: Optional[bool] = None,\n end: str = \"\\n\",\n tab_size: int = 8,\n meta: Optional[Dict[str, Any]] = None,\n ) -> \"Text\":\n \"\"\"Construct a text instance by combining a sequence of strings with optional styles.\n The positional arguments should be either strings, or a tuple of string + style.\n\n Args:\n style (Union[str, Style], optional): Base style for text. Defaults to \"\".\n justify (str, optional): Justify method: \"left\", \"center\", \"full\", \"right\". Defaults to None.\n overflow (str, optional): Overflow method: \"crop\", \"fold\", \"ellipsis\". Defaults to None.\n no_wrap (bool, optional): Disable text wrapping, or None for default. Defaults to None.\n end (str, optional): Character to end text with. Defaults to \"\\\\\\\\n\".\n tab_size (int): Number of spaces per tab, or ``None`` to use ``console.tab_size``. Defaults to None.\n meta (Dict[str, Any], optional). Meta data to apply to text, or None for no meta data. Default to None\n\n Returns:\n Text: A new text instance.\n \"\"\"\n text = cls(\n style=style,\n justify=justify,\n overflow=overflow,\n no_wrap=no_wrap,\n end=end,\n tab_size=tab_size,\n )\n append = text.append\n _Text = Text\n for part in parts:\n if isinstance(part, (_Text, str)):\n append(part)\n else:\n append(*part)\n if meta:\n text.apply_meta(meta)\n return text\n\n @property\n def plain(self) -> str:\n \"\"\"Get the text as a single string.\"\"\"\n if len(self._text) != 1:\n self._text[:] = [\"\".join(self._text)]\n return self._text[0]\n\n @plain.setter\n def plain(self, new_text: str) -> None:\n \"\"\"Set the text to a new value.\"\"\"\n if new_text != self.plain:\n sanitized_text = strip_control_codes(new_text)\n self._text[:] = [sanitized_text]\n old_length = self._length\n self._length = len(sanitized_text)\n if old_length > self._length:\n self._trim_spans()\n\n @property\n def spans(self) -> List[Span]:\n \"\"\"Get a reference to the internal list of spans.\"\"\"\n return self._spans\n\n @spans.setter\n def spans(self, spans: List[Span]) -> None:\n \"\"\"Set spans.\"\"\"\n self._spans = spans[:]\n\n def blank_copy(self, plain: str = \"\") -> \"Text\":\n \"\"\"Return a new Text instance with copied metadata (but not the string or spans).\"\"\"\n copy_self = Text(\n plain,\n style=self.style,\n justify=self.justify,\n overflow=self.overflow,\n no_wrap=self.no_wrap,\n end=self.end,\n tab_size=self.tab_size,\n )\n return copy_self\n\n def copy(self) -> \"Text\":\n \"\"\"Return a copy of this instance.\"\"\"\n copy_self = Text(\n self.plain,\n style=self.style,\n justify=self.justify,\n overflow=self.overflow,\n no_wrap=self.no_wrap,\n end=self.end,\n tab_size=self.tab_size,\n )\n copy_self._spans[:] = self._spans\n return copy_self\n\n def stylize(\n self,\n style: Union[str, Style],\n start: int = 0,\n end: Optional[int] = None,\n ) -> None:\n \"\"\"Apply a style to the text, or a portion of the text.\n\n Args:\n style (Union[str, Style]): Style instance or style definition to apply.\n start (int): Start offset (negative indexing is supported). Defaults to 0.\n end (Optional[int], optional): End offset (negative indexing is supported), or None for end of text. Defaults to None.\n \"\"\"\n if style:\n length = len(self)\n if start < 0:\n start = length + start\n if end is None:\n end = length\n if end < 0:\n end = length + end\n if start >= length or end <= start:\n # Span not in text or not valid\n return\n self._spans.append(Span(start, min(length, end), style))\n\n def stylize_before(\n self,\n style: Union[str, Style],\n start: int = 0,\n end: Optional[int] = None,\n ) -> None:\n \"\"\"Apply a style to the text, or a portion of the text. Styles will be applied before other styles already present.\n\n Args:\n style (Union[str, Style]): Style instance or style definition to apply.\n start (int): Start offset (negative indexing is supported). Defaults to 0.\n end (Optional[int], optional): End offset (negative indexing is supported), or None for end of text. Defaults to None.\n \"\"\"\n if style:\n length = len(self)\n if start < 0:\n start = length + start\n if end is None:\n end = length\n if end < 0:\n end = length + end\n if start >= length or end <= start:\n # Span not in text or not valid\n return\n self._spans.insert(0, Span(start, min(length, end), style))\n\n def apply_meta(\n self, meta: Dict[str, Any], start: int = 0, end: Optional[int] = None\n ) -> None:\n \"\"\"Apply metadata to the text, or a portion of the text.\n\n Args:\n meta (Dict[str, Any]): A dict of meta information.\n start (int): Start offset (negative indexing is supported). Defaults to 0.\n end (Optional[int], optional): End offset (negative indexing is supported), or None for end of text. Defaults to None.\n\n \"\"\"\n style = Style.from_meta(meta)\n self.stylize(style, start=start, end=end)\n\n def on(self, meta: Optional[Dict[str, Any]] = None, **handlers: Any) -> \"Text\":\n \"\"\"Apply event handlers (used by Textual project).\n\n Example:\n >>> from rich.text import Text\n >>> text = Text(\"hello world\")\n >>> text.on(click=\"view.toggle('world')\")\n\n Args:\n meta (Dict[str, Any]): Mapping of meta information.\n **handlers: Keyword args are prefixed with \"@\" to defined handlers.\n\n Returns:\n Text: Self is returned to method may be chained.\n \"\"\"\n meta = {} if meta is None else meta\n meta.update({f\"@{key}\": value for key, value in handlers.items()})\n self.stylize(Style.from_meta(meta))\n return self\n\n def remove_suffix(self, suffix: str) -> None:\n \"\"\"Remove a suffix if it exists.\n\n Args:\n suffix (str): Suffix to remove.\n \"\"\"\n if self.plain.endswith(suffix):\n self.right_crop(len(suffix))\n\n def get_style_at_offset(self, console: \"Console\", offset: int) -> Style:\n \"\"\"Get the style of a character at give offset.\n\n Args:\n console (~Console): Console where text will be rendered.\n offset (int): Offset in to text (negative indexing supported)\n\n Returns:\n Style: A Style instance.\n \"\"\"\n # TODO: This is a little inefficient, it is only used by full justify\n if offset < 0:\n offset = len(self) + offset\n get_style = console.get_style\n style = get_style(self.style).copy()\n for start, end, span_style in self._spans:\n if end > offset >= start:\n style += get_style(span_style, default=\"\")\n return style\n\n def extend_style(self, spaces: int) -> None:\n \"\"\"Extend the Text given number of spaces where the spaces have the same style as the last character.\n\n Args:\n spaces (int): Number of spaces to add to the Text.\n \"\"\"\n if spaces <= 0:\n return\n spans = self.spans\n new_spaces = \" \" * spaces\n if spans:\n end_offset = len(self)\n self._spans[:] = [\n span.extend(spaces) if span.end >= end_offset else span\n for span in spans\n ]\n self._text.append(new_spaces)\n self._length += spaces\n else:\n self.plain += new_spaces\n\n def highlight_regex(\n self,\n re_highlight: Union[Pattern[str], str],\n style: Optional[Union[GetStyleCallable, StyleType]] = None,\n *,\n style_prefix: str = \"\",\n ) -> int:\n \"\"\"Highlight text with a regular expression, where group names are\n translated to styles.\n\n Args:\n re_highlight (Union[re.Pattern, str]): A regular expression object or string.\n style (Union[GetStyleCallable, StyleType]): Optional style to apply to whole match, or a callable\n which accepts the matched text and returns a style. Defaults to None.\n style_prefix (str, optional): Optional prefix to add to style group names.\n\n Returns:\n int: Number of regex matches\n \"\"\"\n count = 0\n append_span = self._spans.append\n _Span = Span\n plain = self.plain\n if isinstance(re_highlight, str):\n re_highlight = re.compile(re_highlight)\n for match in re_highlight.finditer(plain):\n get_span = match.span\n if style:\n start, end = get_span()\n match_style = style(plain[start:end]) if callable(style) else style\n if match_style is not None and end > start:\n append_span(_Span(start, end, match_style))\n\n count += 1\n for name in match.groupdict().keys():\n start, end = get_span(name)\n if start != -1 and end > start:\n append_span(_Span(start, end, f\"{style_prefix}{name}\"))\n return count\n\n def highlight_words(\n self,\n words: Iterable[str],\n style: Union[str, Style],\n *,\n case_sensitive: bool = True,\n ) -> int:\n \"\"\"Highlight words with a style.\n\n Args:\n words (Iterable[str]): Words to highlight.\n style (Union[str, Style]): Style to apply.\n case_sensitive (bool, optional): Enable case sensitive matching. Defaults to True.\n\n Returns:\n int: Number of words highlighted.\n \"\"\"\n re_words = \"|\".join(re.escape(word) for word in words)\n add_span = self._spans.append\n count = 0\n _Span = Span\n for match in re.finditer(\n re_words, self.plain, flags=0 if case_sensitive else re.IGNORECASE\n ):\n start, end = match.span(0)\n add_span(_Span(start, end, style))\n count += 1\n return count\n\n def rstrip(self) -> None:\n \"\"\"Strip whitespace from end of text.\"\"\"\n self.plain = self.plain.rstrip()\n\n def rstrip_end(self, size: int) -> None:\n \"\"\"Remove whitespace beyond a certain width at the end of the text.\n\n Args:\n size (int): The desired size of the text.\n \"\"\"\n text_length = len(self)\n if text_length > size:\n excess = text_length - size\n whitespace_match = _re_whitespace.search(self.plain)\n if whitespace_match is not None:\n whitespace_count = len(whitespace_match.group(0))\n self.right_crop(min(whitespace_count, excess))\n\n def set_length(self, new_length: int) -> None:\n \"\"\"Set new length of the text, clipping or padding is required.\"\"\"\n length = len(self)\n if length != new_length:\n if length < new_length:\n self.pad_right(new_length - length)\n else:\n self.right_crop(length - new_length)\n\n def __rich_console__(\n self, console: \"Console\", options: \"ConsoleOptions\"\n ) -> Iterable[Segment]:\n tab_size: int = console.tab_size if self.tab_size is None else self.tab_size\n justify = self.justify or options.justify or DEFAULT_JUSTIFY\n\n overflow = self.overflow or options.overflow or DEFAULT_OVERFLOW\n\n lines = self.wrap(\n console,\n options.max_width,\n justify=justify,\n overflow=overflow,\n tab_size=tab_size or 8,\n no_wrap=pick_bool(self.no_wrap, options.no_wrap, False),\n )\n all_lines = Text(\"\\n\").join(lines)\n yield from all_lines.render(console, end=self.end)\n\n def __rich_measure__(\n self, console: \"Console\", options: \"ConsoleOptions\"\n ) -> Measurement:\n text = self.plain\n lines = text.splitlines()\n max_text_width = max(cell_len(line) for line in lines) if lines else 0\n words = text.split()\n min_text_width = (\n max(cell_len(word) for word in words) if words else max_text_width\n )\n return Measurement(min_text_width, max_text_width)\n\n def render(self, console: \"Console\", end: str = \"\") -> Iterable[\"Segment\"]:\n \"\"\"Render the text as Segments.\n\n Args:\n console (Console): Console instance.\n end (Optional[str], optional): Optional end character.\n\n Returns:\n Iterable[Segment]: Result of render that may be written to the console.\n \"\"\"\n _Segment = Segment\n text = self.plain\n if not self._spans:\n yield Segment(text)\n if end:\n yield _Segment(end)\n return\n get_style = partial(console.get_style, default=Style.null())\n\n enumerated_spans = list(enumerate(self._spans, 1))\n style_map = {index: get_style(span.style) for index, span in enumerated_spans}\n style_map[0] = get_style(self.style)\n\n spans = [\n (0, False, 0),\n *((span.start, False, index) for index, span in enumerated_spans),\n *((span.end, True, index) for index, span in enumerated_spans),\n (len(text), True, 0),\n ]\n spans.sort(key=itemgetter(0, 1))\n\n stack: List[int] = []\n stack_append = stack.append\n stack_pop = stack.remove\n\n style_cache: Dict[Tuple[Style, ...], Style] = {}\n style_cache_get = style_cache.get\n combine = Style.combine\n\n def get_current_style() -> Style:\n \"\"\"Construct current style from stack.\"\"\"\n styles = tuple(style_map[_style_id] for _style_id in sorted(stack))\n cached_style = style_cache_get(styles)\n if cached_style is not None:\n return cached_style\n current_style = combine(styles)\n style_cache[styles] = current_style\n return current_style\n\n for (offset, leaving, style_id), (next_offset, _, _) in zip(spans, spans[1:]):\n if leaving:\n stack_pop(style_id)\n else:\n stack_append(style_id)\n if next_offset > offset:\n yield _Segment(text[offset:next_offset], get_current_style())\n if end:\n yield _Segment(end)\n\n def join(self, lines: Iterable[\"Text\"]) -> \"Text\":\n \"\"\"Join text together with this instance as the separator.\n\n Args:\n lines (Iterable[Text]): An iterable of Text instances to join.\n\n Returns:\n Text: A new text instance containing join text.\n \"\"\"\n\n new_text = self.blank_copy()\n\n def iter_text() -> Iterable[\"Text\"]:\n if self.plain:\n for last, line in loop_last(lines):\n yield line\n if not last:\n yield self\n else:\n yield from lines\n\n extend_text = new_text._text.extend\n append_span = new_text._spans.append\n extend_spans = new_text._spans.extend\n offset = 0\n _Span = Span\n\n for text in iter_text():\n extend_text(text._text)\n if text.style:\n append_span(_Span(offset, offset + len(text), text.style))\n extend_spans(\n _Span(offset + start, offset + end, style)\n for start, end, style in text._spans\n )\n offset += len(text)\n new_text._length = offset\n return new_text\n\n def expand_tabs(self, tab_size: Optional[int] = None) -> None:\n \"\"\"Converts tabs to spaces.\n\n Args:\n tab_size (int, optional): Size of tabs. Defaults to 8.\n\n \"\"\"\n if \"\\t\" not in self.plain:\n return\n if tab_size is None:\n tab_size = self.tab_size\n if tab_size is None:\n tab_size = 8\n\n new_text: List[Text] = []\n append = new_text.append\n\n for line in self.split(\"\\n\", include_separator=True):\n if \"\\t\" not in line.plain:\n append(line)\n else:\n cell_position = 0\n parts = line.split(\"\\t\", include_separator=True)\n for part in parts:\n if part.plain.endswith(\"\\t\"):\n part._text[-1] = part._text[-1][:-1] + \" \"\n cell_position += part.cell_len\n tab_remainder = cell_position % tab_size\n if tab_remainder:\n spaces = tab_size - tab_remainder\n part.extend_style(spaces)\n cell_position += spaces\n else:\n cell_position += part.cell_len\n append(part)\n\n result = Text(\"\").join(new_text)\n\n self._text = [result.plain]\n self._length = len(self.plain)\n self._spans[:] = result._spans\n\n def truncate(\n self,\n max_width: int,\n *,\n overflow: Optional[\"OverflowMethod\"] = None,\n pad: bool = False,\n ) -> None:\n \"\"\"Truncate text if it is longer that a given width.\n\n Args:\n max_width (int): Maximum number of characters in text.\n overflow (str, optional): Overflow method: \"crop\", \"fold\", or \"ellipsis\". Defaults to None, to use self.overflow.\n pad (bool, optional): Pad with spaces if the length is less than max_width. Defaults to False.\n \"\"\"\n _overflow = overflow or self.overflow or DEFAULT_OVERFLOW\n if _overflow != \"ignore\":\n length = cell_len(self.plain)\n if length > max_width:\n if _overflow == \"ellipsis\":\n self.plain = set_cell_size(self.plain, max_width - 1) + \"…\"\n else:\n self.plain = set_cell_size(self.plain, max_width)\n if pad and length < max_width:\n spaces = max_width - length\n self._text = [f\"{self.plain}{' ' * spaces}\"]\n self._length = len(self.plain)\n\n def _trim_spans(self) -> None:\n \"\"\"Remove or modify any spans that are over the end of the text.\"\"\"\n max_offset = len(self.plain)\n _Span = Span\n self._spans[:] = [\n (\n span\n if span.end < max_offset\n else _Span(span.start, min(max_offset, span.end), span.style)\n )\n for span in self._spans\n if span.start < max_offset\n ]\n\n def pad(self, count: int, character: str = \" \") -> None:\n \"\"\"Pad left and right with a given number of characters.\n\n Args:\n count (int): Width of padding.\n character (str): The character to pad with. Must be a string of length 1.\n \"\"\"\n assert len(character) == 1, \"Character must be a string of length 1\"\n if count:\n pad_characters = character * count\n self.plain = f\"{pad_characters}{self.plain}{pad_characters}\"\n _Span = Span\n self._spans[:] = [\n _Span(start + count, end + count, style)\n for start, end, style in self._spans\n ]\n\n def pad_left(self, count: int, character: str = \" \") -> None:\n \"\"\"Pad the left with a given character.\n\n Args:\n count (int): Number of characters to pad.\n character (str, optional): Character to pad with. Defaults to \" \".\n \"\"\"\n assert len(character) == 1, \"Character must be a string of length 1\"\n if count:\n self.plain = f\"{character * count}{self.plain}\"\n _Span = Span\n self._spans[:] = [\n _Span(start + count, end + count, style)\n for start, end, style in self._spans\n ]\n\n def pad_right(self, count: int, character: str = \" \") -> None:\n \"\"\"Pad the right with a given character.\n\n Args:\n count (int): Number of characters to pad.\n character (str, optional): Character to pad with. Defaults to \" \".\n \"\"\"\n assert len(character) == 1, \"Character must be a string of length 1\"\n if count:\n self.plain = f\"{self.plain}{character * count}\"\n\n def align(self, align: AlignMethod, width: int, character: str = \" \") -> None:\n \"\"\"Align text to a given width.\n\n Args:\n align (AlignMethod): One of \"left\", \"center\", or \"right\".\n width (int): Desired width.\n character (str, optional): Character to pad with. Defaults to \" \".\n \"\"\"\n self.truncate(width)\n excess_space = width - cell_len(self.plain)\n if excess_space:\n if align == \"left\":\n self.pad_right(excess_space, character)\n elif align == \"center\":\n left = excess_space // 2\n self.pad_left(left, character)\n self.pad_right(excess_space - left, character)\n else:\n self.pad_left(excess_space, character)\n\n def append(\n self, text: Union[\"Text\", str], style: Optional[Union[str, \"Style\"]] = None\n ) -> \"Text\":\n \"\"\"Add text with an optional style.\n\n Args:\n text (Union[Text, str]): A str or Text to append.\n style (str, optional): A style name. Defaults to None.\n\n Returns:\n Text: Returns self for chaining.\n \"\"\"\n\n if not isinstance(text, (str, Text)):\n raise TypeError(\"Only str or Text can be appended to Text\")\n\n if len(text):\n if isinstance(text, str):\n sanitized_text = strip_control_codes(text)\n self._text.append(sanitized_text)\n offset = len(self)\n text_length = len(sanitized_text)\n if style:\n self._spans.append(Span(offset, offset + text_length, style))\n self._length += text_length\n elif isinstance(text, Text):\n _Span = Span\n if style is not None:\n raise ValueError(\n \"style must not be set when appending Text instance\"\n )\n text_length = self._length\n if text.style:\n self._spans.append(\n _Span(text_length, text_length + len(text), text.style)\n )\n self._text.append(text.plain)\n self._spans.extend(\n _Span(start + text_length, end + text_length, style)\n for start, end, style in text._spans.copy()\n )\n self._length += len(text)\n return self\n\n def append_text(self, text: \"Text\") -> \"Text\":\n \"\"\"Append another Text instance. This method is more performant that Text.append, but\n only works for Text.\n\n Args:\n text (Text): The Text instance to append to this instance.\n\n Returns:\n Text: Returns self for chaining.\n \"\"\"\n _Span = Span\n text_length = self._length\n if text.style:\n self._spans.append(_Span(text_length, text_length + len(text), text.style))\n self._text.append(text.plain)\n self._spans.extend(\n _Span(start + text_length, end + text_length, style)\n for start, end, style in text._spans.copy()\n )\n self._length += len(text)\n return self\n\n def append_tokens(\n self, tokens: Iterable[Tuple[str, Optional[StyleType]]]\n ) -> \"Text\":\n \"\"\"Append iterable of str and style. Style may be a Style instance or a str style definition.\n\n Args:\n tokens (Iterable[Tuple[str, Optional[StyleType]]]): An iterable of tuples containing str content and style.\n\n Returns:\n Text: Returns self for chaining.\n \"\"\"\n append_text = self._text.append\n append_span = self._spans.append\n _Span = Span\n offset = len(self)\n for content, style in tokens:\n content = strip_control_codes(content)\n append_text(content)\n if style:\n append_span(_Span(offset, offset + len(content), style))\n offset += len(content)\n self._length = offset\n return self\n\n def copy_styles(self, text: \"Text\") -> None:\n \"\"\"Copy styles from another Text instance.\n\n Args:\n text (Text): A Text instance to copy styles from, must be the same length.\n \"\"\"\n self._spans.extend(text._spans)\n\n def split(\n self,\n separator: str = \"\\n\",\n *,\n include_separator: bool = False,\n allow_blank: bool = False,\n ) -> Lines:\n \"\"\"Split rich text in to lines, preserving styles.\n\n Args:\n separator (str, optional): String to split on. Defaults to \"\\\\\\\\n\".\n include_separator (bool, optional): Include the separator in the lines. Defaults to False.\n allow_blank (bool, optional): Return a blank line if the text ends with a separator. Defaults to False.\n\n Returns:\n List[RichText]: A list of rich text, one per line of the original.\n \"\"\"\n assert separator, \"separator must not be empty\"\n\n text = self.plain\n if separator not in text:\n return Lines([self.copy()])\n\n if include_separator:\n lines = self.divide(\n match.end() for match in re.finditer(re.escape(separator), text)\n )\n else:\n\n def flatten_spans() -> Iterable[int]:\n for match in re.finditer(re.escape(separator), text):\n start, end = match.span()\n yield start\n yield end\n\n lines = Lines(\n line for line in self.divide(flatten_spans()) if line.plain != separator\n )\n\n if not allow_blank and text.endswith(separator):\n lines.pop()\n\n return lines\n\n def divide(self, offsets: Iterable[int]) -> Lines:\n \"\"\"Divide text in to a number of lines at given offsets.\n\n Args:\n offsets (Iterable[int]): Offsets used to divide text.\n\n Returns:\n Lines: New RichText instances between offsets.\n \"\"\"\n _offsets = list(offsets)\n\n if not _offsets:\n return Lines([self.copy()])\n\n text = self.plain\n text_length = len(text)\n divide_offsets = [0, *_offsets, text_length]\n line_ranges = list(zip(divide_offsets, divide_offsets[1:]))\n\n style = self.style\n justify = self.justify\n overflow = self.overflow\n _Text = Text\n new_lines = Lines(\n _Text(\n text[start:end],\n style=style,\n justify=justify,\n overflow=overflow,\n )\n for start, end in line_ranges\n )\n if not self._spans:\n return new_lines\n\n _line_appends = [line._spans.append for line in new_lines._lines]\n line_count = len(line_ranges)\n _Span = Span\n\n for span_start, span_end, style in self._spans:\n lower_bound = 0\n upper_bound = line_count\n start_line_no = (lower_bound + upper_bound) // 2\n\n while True:\n line_start, line_end = line_ranges[start_line_no]\n if span_start < line_start:\n upper_bound = start_line_no - 1\n elif span_start > line_end:\n lower_bound = start_line_no + 1\n else:\n break\n start_line_no = (lower_bound + upper_bound) // 2\n\n if span_end < line_end:\n end_line_no = start_line_no\n else:\n end_line_no = lower_bound = start_line_no\n upper_bound = line_count\n\n while True:\n line_start, line_end = line_ranges[end_line_no]\n if span_end < line_start:\n upper_bound = end_line_no - 1\n elif span_end > line_end:\n lower_bound = end_line_no + 1\n else:\n break\n end_line_no = (lower_bound + upper_bound) // 2\n\n for line_no in range(start_line_no, end_line_no + 1):\n line_start, line_end = line_ranges[line_no]\n new_start = max(0, span_start - line_start)\n new_end = min(span_end - line_start, line_end - line_start)\n if new_end > new_start:\n _line_appends[line_no](_Span(new_start, new_end, style))\n\n return new_lines\n\n def right_crop(self, amount: int = 1) -> None:\n \"\"\"Remove a number of characters from the end of the text.\"\"\"\n max_offset = len(self.plain) - amount\n _Span = Span\n self._spans[:] = [\n (\n span\n if span.end < max_offset\n else _Span(span.start, min(max_offset, span.end), span.style)\n )\n for span in self._spans\n if span.start < max_offset\n ]\n self._text = [self.plain[:-amount]]\n self._length -= amount\n\n def wrap(\n self,\n console: \"Console\",\n width: int,\n *,\n justify: Optional[\"JustifyMethod\"] = None,\n overflow: Optional[\"OverflowMethod\"] = None,\n tab_size: int = 8,\n no_wrap: Optional[bool] = None,\n ) -> Lines:\n \"\"\"Word wrap the text.\n\n Args:\n console (Console): Console instance.\n width (int): Number of cells available per line.\n justify (str, optional): Justify method: \"default\", \"left\", \"center\", \"full\", \"right\". Defaults to \"default\".\n overflow (str, optional): Overflow method: \"crop\", \"fold\", or \"ellipsis\". Defaults to None.\n tab_size (int, optional): Default tab size. Defaults to 8.\n no_wrap (bool, optional): Disable wrapping, Defaults to False.\n\n Returns:\n Lines: Number of lines.\n \"\"\"\n wrap_justify = justify or self.justify or DEFAULT_JUSTIFY\n wrap_overflow = overflow or self.overflow or DEFAULT_OVERFLOW\n\n no_wrap = pick_bool(no_wrap, self.no_wrap, False) or overflow == \"ignore\"\n\n lines = Lines()\n for line in self.split(allow_blank=True):\n if \"\\t\" in line:\n line.expand_tabs(tab_size)\n if no_wrap:\n new_lines = Lines([line])\n else:\n offsets = divide_line(str(line), width, fold=wrap_overflow == \"fold\")\n new_lines = line.divide(offsets)\n for line in new_lines:\n line.rstrip_end(width)\n if wrap_justify:\n new_lines.justify(\n console, width, justify=wrap_justify, overflow=wrap_overflow\n )\n for line in new_lines:\n line.truncate(width, overflow=wrap_overflow)\n lines.extend(new_lines)\n return lines\n\n def fit(self, width: int) -> Lines:\n \"\"\"Fit the text in to given width by chopping in to lines.\n\n Args:\n width (int): Maximum characters in a line.\n\n Returns:\n Lines: Lines container.\n \"\"\"\n lines: Lines = Lines()\n append = lines.append\n for line in self.split():\n line.set_length(width)\n append(line)\n return lines\n\n def detect_indentation(self) -> int:\n \"\"\"Auto-detect indentation of code.\n\n Returns:\n int: Number of spaces used to indent code.\n \"\"\"\n\n _indentations = {\n len(match.group(1))\n for match in re.finditer(r\"^( *)(.*)$\", self.plain, flags=re.MULTILINE)\n }\n\n try:\n indentation = (\n reduce(gcd, [indent for indent in _indentations if not indent % 2]) or 1\n )\n except TypeError:\n indentation = 1\n\n return indentation\n\n def with_indent_guides(\n self,\n indent_size: Optional[int] = None,\n *,\n character: str = \"│\",\n style: StyleType = \"dim green\",\n ) -> \"Text\":\n \"\"\"Adds indent guide lines to text.\n\n Args:\n indent_size (Optional[int]): Size of indentation, or None to auto detect. Defaults to None.\n character (str, optional): Character to use for indentation. Defaults to \"│\".\n style (Union[Style, str], optional): Style of indent guides.\n\n Returns:\n Text: New text with indentation guides.\n \"\"\"\n\n _indent_size = self.detect_indentation() if indent_size is None else indent_size\n\n text = self.copy()\n text.expand_tabs()\n indent_line = f\"{character}{' ' * (_indent_size - 1)}\"\n\n re_indent = re.compile(r\"^( *)(.*)$\")\n new_lines: List[Text] = []\n add_line = new_lines.append\n blank_lines = 0\n for line in text.split(allow_blank=True):\n match = re_indent.match(line.plain)\n if not match or not match.group(2):\n blank_lines += 1\n continue\n indent = match.group(1)\n full_indents, remaining_space = divmod(len(indent), _indent_size)\n new_indent = f\"{indent_line * full_indents}{' ' * remaining_space}\"\n line.plain = new_indent + line.plain[len(new_indent) :]\n line.stylize(style, 0, len(new_indent))\n if blank_lines:\n new_lines.extend([Text(new_indent, style=style)] * blank_lines)\n blank_lines = 0\n add_line(line)\n if blank_lines:\n new_lines.extend([Text(\"\", style=style)] * blank_lines)\n\n new_text = text.blank_copy(\"\\n\").join(new_lines)\n return new_text\n\n\nif __name__ == \"__main__\": # pragma: no cover\n from pip._vendor.rich.console import Console\n\n text = Text(\n \"\"\"\\nLorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.\\n\"\"\"\n )\n text.highlight_words([\"Lorem\"], \"bold\")\n text.highlight_words([\"ipsum\"], \"italic\")\n\n console = Console()\n\n console.rule(\"justify='left'\")\n console.print(text, style=\"red\")\n console.print()\n\n console.rule(\"justify='center'\")\n console.print(text, style=\"green\", justify=\"center\")\n console.print()\n\n console.rule(\"justify='right'\")\n console.print(text, style=\"blue\", justify=\"right\")\n console.print()\n\n console.rule(\"justify='full'\")\n console.print(text, style=\"magenta\", justify=\"full\")\n console.print()\n",[],[213,919,920,921,1016,1050,1511,1537],"0bf64738-67fc-11f0-9bd1-0224a6c84d84","terminal_theme.py","0bf647f6-67fc-11f0-9bd1-0224a6c84d84",442,["D",1753299267821],"from typing import List, Optional, Tuple\n\nfrom .color_triplet import ColorTriplet\nfrom .palette import Palette\n\n_ColorTuple = Tuple[int, int, int]\n\n\nclass TerminalTheme:\n \"\"\"A color theme used when exporting console content.\n\n Args:\n background (Tuple[int, int, int]): The background color.\n foreground (Tuple[int, int, int]): The foreground (text) color.\n normal (List[Tuple[int, int, int]]): A list of 8 normal intensity colors.\n bright (List[Tuple[int, int, int]], optional): A list of 8 bright colors, or None\n to repeat normal intensity. Defaults to None.\n \"\"\"\n\n def __init__(\n self,\n background: _ColorTuple,\n foreground: _ColorTuple,\n normal: List[_ColorTuple],\n bright: Optional[List[_ColorTuple]] = None,\n ) -> None:\n self.background_color = ColorTriplet(*background)\n self.foreground_color = ColorTriplet(*foreground)\n self.ansi_colors = Palette(normal + (bright or normal))\n\n\nDEFAULT_TERMINAL_THEME = TerminalTheme(\n (255, 255, 255),\n (0, 0, 0),\n [\n (0, 0, 0),\n (128, 0, 0),\n (0, 128, 0),\n (128, 128, 0),\n (0, 0, 128),\n (128, 0, 128),\n (0, 128, 128),\n (192, 192, 192),\n ],\n [\n (128, 128, 128),\n (255, 0, 0),\n (0, 255, 0),\n (255, 255, 0),\n (0, 0, 255),\n (255, 0, 255),\n (0, 255, 255),\n (255, 255, 255),\n ],\n)\n\nMONOKAI = TerminalTheme(\n (12, 12, 12),\n (217, 217, 217),\n [\n (26, 26, 26),\n (244, 0, 95),\n (152, 224, 36),\n (253, 151, 31),\n (157, 101, 255),\n (244, 0, 95),\n (88, 209, 235),\n (196, 197, 181),\n (98, 94, 76),\n ],\n [\n (244, 0, 95),\n (152, 224, 36),\n (224, 213, 97),\n (157, 101, 255),\n (244, 0, 95),\n (88, 209, 235),\n (246, 246, 239),\n ],\n)\nDIMMED_MONOKAI = TerminalTheme(\n (25, 25, 25),\n (185, 188, 186),\n [\n (58, 61, 67),\n (190, 63, 72),\n (135, 154, 59),\n (197, 166, 53),\n (79, 118, 161),\n (133, 92, 141),\n (87, 143, 164),\n (185, 188, 186),\n (136, 137, 135),\n ],\n [\n (251, 0, 31),\n (15, 114, 47),\n (196, 112, 51),\n (24, 109, 227),\n (251, 0, 103),\n (46, 112, 109),\n (253, 255, 185),\n ],\n)\nNIGHT_OWLISH = TerminalTheme(\n (255, 255, 255),\n (64, 63, 83),\n [\n (1, 22, 39),\n (211, 66, 62),\n (42, 162, 152),\n (218, 170, 1),\n (72, 118, 214),\n (64, 63, 83),\n (8, 145, 106),\n (122, 129, 129),\n (122, 129, 129),\n ],\n [\n (247, 110, 110),\n (73, 208, 197),\n (218, 194, 107),\n (92, 167, 228),\n (105, 112, 152),\n (0, 201, 144),\n (152, 159, 177),\n ],\n)\n\nSVG_EXPORT_THEME = TerminalTheme(\n (41, 41, 41),\n (197, 200, 198),\n [\n (75, 78, 85),\n (204, 85, 90),\n (152, 168, 75),\n (208, 179, 68),\n (96, 138, 177),\n (152, 114, 159),\n (104, 160, 179),\n (197, 200, 198),\n (154, 155, 153),\n ],\n [\n (255, 38, 39),\n (0, 130, 61),\n (208, 132, 66),\n (25, 132, 233),\n (255, 44, 122),\n (57, 130, 128),\n (253, 253, 197),\n ],\n)\n",[],[213,919,920,921,1016,1050,1511,1545],"0c2c6c96-67fc-11f0-a319-0224a6c84d84","table.py","0c2c6d40-67fc-11f0-a319-0224a6c84d84",450,["D",1753299268039],"from dataclasses import dataclass, field, replace\nfrom typing import (\n TYPE_CHECKING,\n Dict,\n Iterable,\n List,\n NamedTuple,\n Optional,\n Sequence,\n Tuple,\n Union,\n)\n\nfrom . import box, errors\nfrom ._loop import loop_first_last, loop_last\nfrom ._pick import pick_bool\nfrom ._ratio import ratio_distribute, ratio_reduce\nfrom .align import VerticalAlignMethod\nfrom .jupyter import JupyterMixin\nfrom .measure import Measurement\nfrom .padding import Padding, PaddingDimensions\nfrom .protocol import is_renderable\nfrom .segment import Segment\nfrom .style import Style, StyleType\nfrom .text import Text, TextType\n\nif TYPE_CHECKING:\n from .console import (\n Console,\n ConsoleOptions,\n JustifyMethod,\n OverflowMethod,\n RenderableType,\n RenderResult,\n )\n\n\n@dataclass\nclass Column:\n \"\"\"Defines a column within a ~Table.\n\n Args:\n title (Union[str, Text], optional): The title of the table rendered at the top. Defaults to None.\n caption (Union[str, Text], optional): The table caption rendered below. Defaults to None.\n width (int, optional): The width in characters of the table, or ``None`` to automatically fit. Defaults to None.\n min_width (Optional[int], optional): The minimum width of the table, or ``None`` for no minimum. Defaults to None.\n box (box.Box, optional): One of the constants in box.py used to draw the edges (see :ref:`appendix_box`), or ``None`` for no box lines. Defaults to box.HEAVY_HEAD.\n safe_box (Optional[bool], optional): Disable box characters that don't display on windows legacy terminal with *raster* fonts. Defaults to True.\n padding (PaddingDimensions, optional): Padding for cells (top, right, bottom, left). Defaults to (0, 1).\n collapse_padding (bool, optional): Enable collapsing of padding around cells. Defaults to False.\n pad_edge (bool, optional): Enable padding of edge cells. Defaults to True.\n expand (bool, optional): Expand the table to fit the available space if ``True``, otherwise the table width will be auto-calculated. Defaults to False.\n show_header (bool, optional): Show a header row. Defaults to True.\n show_footer (bool, optional): Show a footer row. Defaults to False.\n show_edge (bool, optional): Draw a box around the outside of the table. Defaults to True.\n show_lines (bool, optional): Draw lines between every row. Defaults to False.\n leading (int, optional): Number of blank lines between rows (precludes ``show_lines``). Defaults to 0.\n style (Union[str, Style], optional): Default style for the table. Defaults to \"none\".\n row_styles (List[Union, str], optional): Optional list of row styles, if more than one style is given then the styles will alternate. Defaults to None.\n header_style (Union[str, Style], optional): Style of the header. Defaults to \"table.header\".\n footer_style (Union[str, Style], optional): Style of the footer. Defaults to \"table.footer\".\n border_style (Union[str, Style], optional): Style of the border. Defaults to None.\n title_style (Union[str, Style], optional): Style of the title. Defaults to None.\n caption_style (Union[str, Style], optional): Style of the caption. Defaults to None.\n title_justify (str, optional): Justify method for title. Defaults to \"center\".\n caption_justify (str, optional): Justify method for caption. Defaults to \"center\".\n highlight (bool, optional): Highlight cell contents (if str). Defaults to False.\n \"\"\"\n\n header: \"RenderableType\" = \"\"\n \"\"\"RenderableType: Renderable for the header (typically a string)\"\"\"\n\n footer: \"RenderableType\" = \"\"\n \"\"\"RenderableType: Renderable for the footer (typically a string)\"\"\"\n\n header_style: StyleType = \"\"\n \"\"\"StyleType: The style of the header.\"\"\"\n\n footer_style: StyleType = \"\"\n \"\"\"StyleType: The style of the footer.\"\"\"\n\n style: StyleType = \"\"\n \"\"\"StyleType: The style of the column.\"\"\"\n\n justify: \"JustifyMethod\" = \"left\"\n \"\"\"str: How to justify text within the column (\"left\", \"center\", \"right\", or \"full\")\"\"\"\n\n vertical: \"VerticalAlignMethod\" = \"top\"\n \"\"\"str: How to vertically align content (\"top\", \"middle\", or \"bottom\")\"\"\"\n\n overflow: \"OverflowMethod\" = \"ellipsis\"\n \"\"\"str: Overflow method.\"\"\"\n\n width: Optional[int] = None\n \"\"\"Optional[int]: Width of the column, or ``None`` (default) to auto calculate width.\"\"\"\n\n min_width: Optional[int] = None\n \"\"\"Optional[int]: Minimum width of column, or ``None`` for no minimum. Defaults to None.\"\"\"\n\n max_width: Optional[int] = None\n \"\"\"Optional[int]: Maximum width of column, or ``None`` for no maximum. Defaults to None.\"\"\"\n\n ratio: Optional[int] = None\n \"\"\"Optional[int]: Ratio to use when calculating column width, or ``None`` (default) to adapt to column contents.\"\"\"\n\n no_wrap: bool = False\n \"\"\"bool: Prevent wrapping of text within the column. Defaults to ``False``.\"\"\"\n\n highlight: bool = False\n \"\"\"bool: Apply highlighter to column. Defaults to ``False``.\"\"\"\n\n _index: int = 0\n \"\"\"Index of column.\"\"\"\n\n _cells: List[\"RenderableType\"] = field(default_factory=list)\n\n def copy(self) -> \"Column\":\n \"\"\"Return a copy of this Column.\"\"\"\n return replace(self, _cells=[])\n\n @property\n def cells(self) -> Iterable[\"RenderableType\"]:\n \"\"\"Get all cells in the column, not including header.\"\"\"\n yield from self._cells\n\n @property\n def flexible(self) -> bool:\n \"\"\"Check if this column is flexible.\"\"\"\n return self.ratio is not None\n\n\n@dataclass\nclass Row:\n \"\"\"Information regarding a row.\"\"\"\n\n style: Optional[StyleType] = None\n \"\"\"Style to apply to row.\"\"\"\n\n end_section: bool = False\n \"\"\"Indicated end of section, which will force a line beneath the row.\"\"\"\n\n\nclass _Cell(NamedTuple):\n \"\"\"A single cell in a table.\"\"\"\n\n style: StyleType\n \"\"\"Style to apply to cell.\"\"\"\n renderable: \"RenderableType\"\n \"\"\"Cell renderable.\"\"\"\n vertical: VerticalAlignMethod\n \"\"\"Cell vertical alignment.\"\"\"\n\n\nclass Table(JupyterMixin):\n \"\"\"A console renderable to draw a table.\n\n Args:\n *headers (Union[Column, str]): Column headers, either as a string, or :class:`~rich.table.Column` instance.\n title (Union[str, Text], optional): The title of the table rendered at the top. Defaults to None.\n caption (Union[str, Text], optional): The table caption rendered below. Defaults to None.\n width (int, optional): The width in characters of the table, or ``None`` to automatically fit. Defaults to None.\n min_width (Optional[int], optional): The minimum width of the table, or ``None`` for no minimum. Defaults to None.\n box (box.Box, optional): One of the constants in box.py used to draw the edges (see :ref:`appendix_box`), or ``None`` for no box lines. Defaults to box.HEAVY_HEAD.\n safe_box (Optional[bool], optional): Disable box characters that don't display on windows legacy terminal with *raster* fonts. Defaults to True.\n padding (PaddingDimensions, optional): Padding for cells (top, right, bottom, left). Defaults to (0, 1).\n collapse_padding (bool, optional): Enable collapsing of padding around cells. Defaults to False.\n pad_edge (bool, optional): Enable padding of edge cells. Defaults to True.\n expand (bool, optional): Expand the table to fit the available space if ``True``, otherwise the table width will be auto-calculated. Defaults to False.\n show_header (bool, optional): Show a header row. Defaults to True.\n show_footer (bool, optional): Show a footer row. Defaults to False.\n show_edge (bool, optional): Draw a box around the outside of the table. Defaults to True.\n show_lines (bool, optional): Draw lines between every row. Defaults to False.\n leading (int, optional): Number of blank lines between rows (precludes ``show_lines``). Defaults to 0.\n style (Union[str, Style], optional): Default style for the table. Defaults to \"none\".\n row_styles (List[Union, str], optional): Optional list of row styles, if more than one style is given then the styles will alternate. Defaults to None.\n header_style (Union[str, Style], optional): Style of the header. Defaults to \"table.header\".\n footer_style (Union[str, Style], optional): Style of the footer. Defaults to \"table.footer\".\n border_style (Union[str, Style], optional): Style of the border. Defaults to None.\n title_style (Union[str, Style], optional): Style of the title. Defaults to None.\n caption_style (Union[str, Style], optional): Style of the caption. Defaults to None.\n title_justify (str, optional): Justify method for title. Defaults to \"center\".\n caption_justify (str, optional): Justify method for caption. Defaults to \"center\".\n highlight (bool, optional): Highlight cell contents (if str). Defaults to False.\n \"\"\"\n\n columns: List[Column]\n rows: List[Row]\n\n def __init__(\n self,\n *headers: Union[Column, str],\n title: Optional[TextType] = None,\n caption: Optional[TextType] = None,\n width: Optional[int] = None,\n min_width: Optional[int] = None,\n box: Optional[box.Box] = box.HEAVY_HEAD,\n safe_box: Optional[bool] = None,\n padding: PaddingDimensions = (0, 1),\n collapse_padding: bool = False,\n pad_edge: bool = True,\n expand: bool = False,\n show_header: bool = True,\n show_footer: bool = False,\n show_edge: bool = True,\n show_lines: bool = False,\n leading: int = 0,\n style: StyleType = \"none\",\n row_styles: Optional[Iterable[StyleType]] = None,\n header_style: Optional[StyleType] = \"table.header\",\n footer_style: Optional[StyleType] = \"table.footer\",\n border_style: Optional[StyleType] = None,\n title_style: Optional[StyleType] = None,\n caption_style: Optional[StyleType] = None,\n title_justify: \"JustifyMethod\" = \"center\",\n caption_justify: \"JustifyMethod\" = \"center\",\n highlight: bool = False,\n ) -> None:\n self.columns: List[Column] = []\n self.rows: List[Row] = []\n self.title = title\n self.caption = caption\n self.width = width\n self.min_width = min_width\n self.box = box\n self.safe_box = safe_box\n self._padding = Padding.unpack(padding)\n self.pad_edge = pad_edge\n self._expand = expand\n self.show_header = show_header\n self.show_footer = show_footer\n self.show_edge = show_edge\n self.show_lines = show_lines\n self.leading = leading\n self.collapse_padding = collapse_padding\n self.style = style\n self.header_style = header_style or \"\"\n self.footer_style = footer_style or \"\"\n self.border_style = border_style\n self.title_style = title_style\n self.caption_style = caption_style\n self.title_justify: \"JustifyMethod\" = title_justify\n self.caption_justify: \"JustifyMethod\" = caption_justify\n self.highlight = highlight\n self.row_styles: Sequence[StyleType] = list(row_styles or [])\n append_column = self.columns.append\n for header in headers:\n if isinstance(header, str):\n self.add_column(header=header)\n else:\n header._index = len(self.columns)\n append_column(header)\n\n @classmethod\n def grid(\n cls,\n *headers: Union[Column, str],\n padding: PaddingDimensions = 0,\n collapse_padding: bool = True,\n pad_edge: bool = False,\n expand: bool = False,\n ) -> \"Table\":\n \"\"\"Get a table with no lines, headers, or footer.\n\n Args:\n *headers (Union[Column, str]): Column headers, either as a string, or :class:`~rich.table.Column` instance.\n padding (PaddingDimensions, optional): Get padding around cells. Defaults to 0.\n collapse_padding (bool, optional): Enable collapsing of padding around cells. Defaults to True.\n pad_edge (bool, optional): Enable padding around edges of table. Defaults to False.\n expand (bool, optional): Expand the table to fit the available space if ``True``, otherwise the table width will be auto-calculated. Defaults to False.\n\n Returns:\n Table: A table instance.\n \"\"\"\n return cls(\n *headers,\n box=None,\n padding=padding,\n collapse_padding=collapse_padding,\n show_header=False,\n show_footer=False,\n show_edge=False,\n pad_edge=pad_edge,\n expand=expand,\n )\n\n @property\n def expand(self) -> bool:\n \"\"\"Setting a non-None self.width implies expand.\"\"\"\n return self._expand or self.width is not None\n\n @expand.setter\n def expand(self, expand: bool) -> None:\n \"\"\"Set expand.\"\"\"\n self._expand = expand\n\n @property\n def _extra_width(self) -> int:\n \"\"\"Get extra width to add to cell content.\"\"\"\n width = 0\n if self.box and self.show_edge:\n width += 2\n if self.box:\n width += len(self.columns) - 1\n return width\n\n @property\n def row_count(self) -> int:\n \"\"\"Get the current number of rows.\"\"\"\n return len(self.rows)\n\n def get_row_style(self, console: \"Console\", index: int) -> StyleType:\n \"\"\"Get the current row style.\"\"\"\n style = Style.null()\n if self.row_styles:\n style += console.get_style(self.row_styles[index % len(self.row_styles)])\n row_style = self.rows[index].style\n if row_style is not None:\n style += console.get_style(row_style)\n return style\n\n def __rich_measure__(\n self, console: \"Console\", options: \"ConsoleOptions\"\n ) -> Measurement:\n max_width = options.max_width\n if self.width is not None:\n max_width = self.width\n if max_width < 0:\n return Measurement(0, 0)\n\n extra_width = self._extra_width\n max_width = sum(\n self._calculate_column_widths(\n console, options.update_width(max_width - extra_width)\n )\n )\n _measure_column = self._measure_column\n\n measurements = [\n _measure_column(console, options.update_width(max_width), column)\n for column in self.columns\n ]\n minimum_width = (\n sum(measurement.minimum for measurement in measurements) + extra_width\n )\n maximum_width = (\n sum(measurement.maximum for measurement in measurements) + extra_width\n if (self.width is None)\n else self.width\n )\n measurement = Measurement(minimum_width, maximum_width)\n measurement = measurement.clamp(self.min_width)\n return measurement\n\n @property\n def padding(self) -> Tuple[int, int, int, int]:\n \"\"\"Get cell padding.\"\"\"\n return self._padding\n\n @padding.setter\n def padding(self, padding: PaddingDimensions) -> \"Table\":\n \"\"\"Set cell padding.\"\"\"\n self._padding = Padding.unpack(padding)\n return self\n\n def add_column(\n self,\n header: \"RenderableType\" = \"\",\n footer: \"RenderableType\" = \"\",\n *,\n header_style: Optional[StyleType] = None,\n highlight: Optional[bool] = None,\n footer_style: Optional[StyleType] = None,\n style: Optional[StyleType] = None,\n justify: \"JustifyMethod\" = \"left\",\n vertical: \"VerticalAlignMethod\" = \"top\",\n overflow: \"OverflowMethod\" = \"ellipsis\",\n width: Optional[int] = None,\n min_width: Optional[int] = None,\n max_width: Optional[int] = None,\n ratio: Optional[int] = None,\n no_wrap: bool = False,\n ) -> None:\n \"\"\"Add a column to the table.\n\n Args:\n header (RenderableType, optional): Text or renderable for the header.\n Defaults to \"\".\n footer (RenderableType, optional): Text or renderable for the footer.\n Defaults to \"\".\n header_style (Union[str, Style], optional): Style for the header, or None for default. Defaults to None.\n highlight (bool, optional): Whether to highlight the text. The default of None uses the value of the table (self) object.\n footer_style (Union[str, Style], optional): Style for the footer, or None for default. Defaults to None.\n style (Union[str, Style], optional): Style for the column cells, or None for default. Defaults to None.\n justify (JustifyMethod, optional): Alignment for cells. Defaults to \"left\".\n vertical (VerticalAlignMethod, optional): Vertical alignment, one of \"top\", \"middle\", or \"bottom\". Defaults to \"top\".\n overflow (OverflowMethod): Overflow method: \"crop\", \"fold\", \"ellipsis\". Defaults to \"ellipsis\".\n width (int, optional): Desired width of column in characters, or None to fit to contents. Defaults to None.\n min_width (Optional[int], optional): Minimum width of column, or ``None`` for no minimum. Defaults to None.\n max_width (Optional[int], optional): Maximum width of column, or ``None`` for no maximum. Defaults to None.\n ratio (int, optional): Flexible ratio for the column (requires ``Table.expand`` or ``Table.width``). Defaults to None.\n no_wrap (bool, optional): Set to ``True`` to disable wrapping of this column.\n \"\"\"\n\n column = Column(\n _index=len(self.columns),\n header=header,\n footer=footer,\n header_style=header_style or \"\",\n highlight=highlight if highlight is not None else self.highlight,\n footer_style=footer_style or \"\",\n style=style or \"\",\n justify=justify,\n vertical=vertical,\n overflow=overflow,\n width=width,\n min_width=min_width,\n max_width=max_width,\n ratio=ratio,\n no_wrap=no_wrap,\n )\n self.columns.append(column)\n\n def add_row(\n self,\n *renderables: Optional[\"RenderableType\"],\n style: Optional[StyleType] = None,\n end_section: bool = False,\n ) -> None:\n \"\"\"Add a row of renderables.\n\n Args:\n *renderables (None or renderable): Each cell in a row must be a renderable object (including str),\n or ``None`` for a blank cell.\n style (StyleType, optional): An optional style to apply to the entire row. Defaults to None.\n end_section (bool, optional): End a section and draw a line. Defaults to False.\n\n Raises:\n errors.NotRenderableError: If you add something that can't be rendered.\n \"\"\"\n\n def add_cell(column: Column, renderable: \"RenderableType\") -> None:\n column._cells.append(renderable)\n\n cell_renderables: List[Optional[\"RenderableType\"]] = list(renderables)\n\n columns = self.columns\n if len(cell_renderables) < len(columns):\n cell_renderables = [\n *cell_renderables,\n *[None] * (len(columns) - len(cell_renderables)),\n ]\n for index, renderable in enumerate(cell_renderables):\n if index == len(columns):\n column = Column(_index=index, highlight=self.highlight)\n for _ in self.rows:\n add_cell(column, Text(\"\"))\n self.columns.append(column)\n else:\n column = columns[index]\n if renderable is None:\n add_cell(column, \"\")\n elif is_renderable(renderable):\n add_cell(column, renderable)\n else:\n raise errors.NotRenderableError(\n f\"unable to render {type(renderable).__name__}; a string or other renderable object is required\"\n )\n self.rows.append(Row(style=style, end_section=end_section))\n\n def add_section(self) -> None:\n \"\"\"Add a new section (draw a line after current row).\"\"\"\n\n if self.rows:\n self.rows[-1].end_section = True\n\n def __rich_console__(\n self, console: \"Console\", options: \"ConsoleOptions\"\n ) -> \"RenderResult\":\n if not self.columns:\n yield Segment(\"\\n\")\n return\n\n max_width = options.max_width\n if self.width is not None:\n max_width = self.width\n\n extra_width = self._extra_width\n widths = self._calculate_column_widths(\n console, options.update_width(max_width - extra_width)\n )\n table_width = sum(widths) + extra_width\n\n render_options = options.update(\n width=table_width, highlight=self.highlight, height=None\n )\n\n def render_annotation(\n text: TextType, style: StyleType, justify: \"JustifyMethod\" = \"center\"\n ) -> \"RenderResult\":\n render_text = (\n console.render_str(text, style=style, highlight=False)\n if isinstance(text, str)\n else text\n )\n return console.render(\n render_text, options=render_options.update(justify=justify)\n )\n\n if self.title:\n yield from render_annotation(\n self.title,\n style=Style.pick_first(self.title_style, \"table.title\"),\n justify=self.title_justify,\n )\n yield from self._render(console, render_options, widths)\n if self.caption:\n yield from render_annotation(\n self.caption,\n style=Style.pick_first(self.caption_style, \"table.caption\"),\n justify=self.caption_justify,\n )\n\n def _calculate_column_widths(\n self, console: \"Console\", options: \"ConsoleOptions\"\n ) -> List[int]:\n \"\"\"Calculate the widths of each column, including padding, not including borders.\"\"\"\n max_width = options.max_width\n columns = self.columns\n width_ranges = [\n self._measure_column(console, options, column) for column in columns\n ]\n widths = [_range.maximum or 1 for _range in width_ranges]\n get_padding_width = self._get_padding_width\n extra_width = self._extra_width\n if self.expand:\n ratios = [col.ratio or 0 for col in columns if col.flexible]\n if any(ratios):\n fixed_widths = [\n 0 if column.flexible else _range.maximum\n for _range, column in zip(width_ranges, columns)\n ]\n flex_minimum = [\n (column.width or 1) + get_padding_width(column._index)\n for column in columns\n if column.flexible\n ]\n flexible_width = max_width - sum(fixed_widths)\n flex_widths = ratio_distribute(flexible_width, ratios, flex_minimum)\n iter_flex_widths = iter(flex_widths)\n for index, column in enumerate(columns):\n if column.flexible:\n widths[index] = fixed_widths[index] + next(iter_flex_widths)\n table_width = sum(widths)\n\n if table_width > max_width:\n widths = self._collapse_widths(\n widths,\n [(column.width is None and not column.no_wrap) for column in columns],\n max_width,\n )\n table_width = sum(widths)\n # last resort, reduce columns evenly\n if table_width > max_width:\n excess_width = table_width - max_width\n widths = ratio_reduce(excess_width, [1] * len(widths), widths, widths)\n table_width = sum(widths)\n\n width_ranges = [\n self._measure_column(console, options.update_width(width), column)\n for width, column in zip(widths, columns)\n ]\n widths = [_range.maximum or 0 for _range in width_ranges]\n\n if (table_width < max_width and self.expand) or (\n self.min_width is not None and table_width < (self.min_width - extra_width)\n ):\n _max_width = (\n max_width\n if self.min_width is None\n else min(self.min_width - extra_width, max_width)\n )\n pad_widths = ratio_distribute(_max_width - table_width, widths)\n widths = [_width + pad for _width, pad in zip(widths, pad_widths)]\n\n return widths\n\n @classmethod\n def _collapse_widths(\n cls, widths: List[int], wrapable: List[bool], max_width: int\n ) -> List[int]:\n \"\"\"Reduce widths so that the total is under max_width.\n\n Args:\n widths (List[int]): List of widths.\n wrapable (List[bool]): List of booleans that indicate if a column may shrink.\n max_width (int): Maximum width to reduce to.\n\n Returns:\n List[int]: A new list of widths.\n \"\"\"\n total_width = sum(widths)\n excess_width = total_width - max_width\n if any(wrapable):\n while total_width and excess_width > 0:\n max_column = max(\n width for width, allow_wrap in zip(widths, wrapable) if allow_wrap\n )\n second_max_column = max(\n width if allow_wrap and width != max_column else 0\n for width, allow_wrap in zip(widths, wrapable)\n )\n column_difference = max_column - second_max_column\n ratios = [\n (1 if (width == max_column and allow_wrap) else 0)\n for width, allow_wrap in zip(widths, wrapable)\n ]\n if not any(ratios) or not column_difference:\n break\n max_reduce = [min(excess_width, column_difference)] * len(widths)\n widths = ratio_reduce(excess_width, ratios, max_reduce, widths)\n\n total_width = sum(widths)\n excess_width = total_width - max_width\n return widths\n\n def _get_cells(\n self, console: \"Console\", column_index: int, column: Column\n ) -> Iterable[_Cell]:\n \"\"\"Get all the cells with padding and optional header.\"\"\"\n\n collapse_padding = self.collapse_padding\n pad_edge = self.pad_edge\n padding = self.padding\n any_padding = any(padding)\n\n first_column = column_index == 0\n last_column = column_index == len(self.columns) - 1\n\n _padding_cache: Dict[Tuple[bool, bool], Tuple[int, int, int, int]] = {}\n\n def get_padding(first_row: bool, last_row: bool) -> Tuple[int, int, int, int]:\n cached = _padding_cache.get((first_row, last_row))\n if cached:\n return cached\n top, right, bottom, left = padding\n\n if collapse_padding:\n if not first_column:\n left = max(0, left - right)\n if not last_row:\n bottom = max(0, top - bottom)\n\n if not pad_edge:\n if first_column:\n left = 0\n if last_column:\n right = 0\n if first_row:\n top = 0\n if last_row:\n bottom = 0\n _padding = (top, right, bottom, left)\n _padding_cache[(first_row, last_row)] = _padding\n return _padding\n\n raw_cells: List[Tuple[StyleType, \"RenderableType\"]] = []\n _append = raw_cells.append\n get_style = console.get_style\n if self.show_header:\n header_style = get_style(self.header_style or \"\") + get_style(\n column.header_style\n )\n _append((header_style, column.header))\n cell_style = get_style(column.style or \"\")\n for cell in column.cells:\n _append((cell_style, cell))\n if self.show_footer:\n footer_style = get_style(self.footer_style or \"\") + get_style(\n column.footer_style\n )\n _append((footer_style, column.footer))\n\n if any_padding:\n _Padding = Padding\n for first, last, (style, renderable) in loop_first_last(raw_cells):\n yield _Cell(\n style,\n _Padding(renderable, get_padding(first, last)),\n getattr(renderable, \"vertical\", None) or column.vertical,\n )\n else:\n for style, renderable in raw_cells:\n yield _Cell(\n style,\n renderable,\n getattr(renderable, \"vertical\", None) or column.vertical,\n )\n\n def _get_padding_width(self, column_index: int) -> int:\n \"\"\"Get extra width from padding.\"\"\"\n _, pad_right, _, pad_left = self.padding\n if self.collapse_padding:\n if column_index > 0:\n pad_left = max(0, pad_left - pad_right)\n return pad_left + pad_right\n\n def _measure_column(\n self,\n console: \"Console\",\n options: \"ConsoleOptions\",\n column: Column,\n ) -> Measurement:\n \"\"\"Get the minimum and maximum width of the column.\"\"\"\n\n max_width = options.max_width\n if max_width < 1:\n return Measurement(0, 0)\n\n padding_width = self._get_padding_width(column._index)\n\n if column.width is not None:\n # Fixed width column\n return Measurement(\n column.width + padding_width, column.width + padding_width\n ).with_maximum(max_width)\n # Flexible column, we need to measure contents\n min_widths: List[int] = []\n max_widths: List[int] = []\n append_min = min_widths.append\n append_max = max_widths.append\n get_render_width = Measurement.get\n for cell in self._get_cells(console, column._index, column):\n _min, _max = get_render_width(console, options, cell.renderable)\n append_min(_min)\n append_max(_max)\n\n measurement = Measurement(\n max(min_widths) if min_widths else 1,\n max(max_widths) if max_widths else max_width,\n ).with_maximum(max_width)\n measurement = measurement.clamp(\n None if column.min_width is None else column.min_width + padding_width,\n None if column.max_width is None else column.max_width + padding_width,\n )\n return measurement\n\n def _render(\n self, console: \"Console\", options: \"ConsoleOptions\", widths: List[int]\n ) -> \"RenderResult\":\n table_style = console.get_style(self.style or \"\")\n\n border_style = table_style + console.get_style(self.border_style or \"\")\n _column_cells = (\n self._get_cells(console, column_index, column)\n for column_index, column in enumerate(self.columns)\n )\n row_cells: List[Tuple[_Cell, ...]] = list(zip(*_column_cells))\n _box = (\n self.box.substitute(\n options, safe=pick_bool(self.safe_box, console.safe_box)\n )\n if self.box\n else None\n )\n _box = _box.get_plain_headed_box() if _box and not self.show_header else _box\n\n new_line = Segment.line()\n\n columns = self.columns\n show_header = self.show_header\n show_footer = self.show_footer\n show_edge = self.show_edge\n show_lines = self.show_lines\n leading = self.leading\n\n _Segment = Segment\n if _box:\n box_segments = [\n (\n _Segment(_box.head_left, border_style),\n _Segment(_box.head_right, border_style),\n _Segment(_box.head_vertical, border_style),\n ),\n (\n _Segment(_box.mid_left, border_style),\n _Segment(_box.mid_right, border_style),\n _Segment(_box.mid_vertical, border_style),\n ),\n (\n _Segment(_box.foot_left, border_style),\n _Segment(_box.foot_right, border_style),\n _Segment(_box.foot_vertical, border_style),\n ),\n ]\n if show_edge:\n yield _Segment(_box.get_top(widths), border_style)\n yield new_line\n else:\n box_segments = []\n\n get_row_style = self.get_row_style\n get_style = console.get_style\n\n for index, (first, last, row_cell) in enumerate(loop_first_last(row_cells)):\n header_row = first and show_header\n footer_row = last and show_footer\n row = (\n self.rows[index - show_header]\n if (not header_row and not footer_row)\n else None\n )\n max_height = 1\n cells: List[List[List[Segment]]] = []\n if header_row or footer_row:\n row_style = Style.null()\n else:\n row_style = get_style(\n get_row_style(console, index - 1 if show_header else index)\n )\n for width, cell, column in zip(widths, row_cell, columns):\n render_options = options.update(\n width=width,\n justify=column.justify,\n no_wrap=column.no_wrap,\n overflow=column.overflow,\n height=None,\n highlight=column.highlight,\n )\n lines = console.render_lines(\n cell.renderable,\n render_options,\n style=get_style(cell.style) + row_style,\n )\n max_height = max(max_height, len(lines))\n cells.append(lines)\n\n row_height = max(len(cell) for cell in cells)\n\n def align_cell(\n cell: List[List[Segment]],\n vertical: \"VerticalAlignMethod\",\n width: int,\n style: Style,\n ) -> List[List[Segment]]:\n if header_row:\n vertical = \"bottom\"\n elif footer_row:\n vertical = \"top\"\n\n if vertical == \"top\":\n return _Segment.align_top(cell, width, row_height, style)\n elif vertical == \"middle\":\n return _Segment.align_middle(cell, width, row_height, style)\n return _Segment.align_bottom(cell, width, row_height, style)\n\n cells[:] = [\n _Segment.set_shape(\n align_cell(\n cell,\n _cell.vertical,\n width,\n get_style(_cell.style) + row_style,\n ),\n width,\n max_height,\n )\n for width, _cell, cell, column in zip(widths, row_cell, cells, columns)\n ]\n\n if _box:\n if last and show_footer:\n yield _Segment(\n _box.get_row(widths, \"foot\", edge=show_edge), border_style\n )\n yield new_line\n left, right, _divider = box_segments[0 if first else (2 if last else 1)]\n\n # If the column divider is whitespace also style it with the row background\n divider = (\n _divider\n if _divider.text.strip()\n else _Segment(\n _divider.text, row_style.background_style + _divider.style\n )\n )\n for line_no in range(max_height):\n if show_edge:\n yield left\n for last_cell, rendered_cell in loop_last(cells):\n yield from rendered_cell[line_no]\n if not last_cell:\n yield divider\n if show_edge:\n yield right\n yield new_line\n else:\n for line_no in range(max_height):\n for rendered_cell in cells:\n yield from rendered_cell[line_no]\n yield new_line\n if _box and first and show_header:\n yield _Segment(\n _box.get_row(widths, \"head\", edge=show_edge), border_style\n )\n yield new_line\n end_section = row and row.end_section\n if _box and (show_lines or leading or end_section):\n if (\n not last\n and not (show_footer and index >= len(row_cells) - 2)\n and not (show_header and header_row)\n ):\n if leading:\n yield _Segment(\n _box.get_row(widths, \"mid\", edge=show_edge) * leading,\n border_style,\n )\n else:\n yield _Segment(\n _box.get_row(widths, \"row\", edge=show_edge), border_style\n )\n yield new_line\n\n if _box and show_edge:\n yield _Segment(_box.get_bottom(widths), border_style)\n yield new_line\n\n\nif __name__ == \"__main__\": # pragma: no cover\n from pip._vendor.rich.console import Console\n from pip._vendor.rich.highlighter import ReprHighlighter\n\n from ._timer import timer\n\n with timer(\"Table render\"):\n table = Table(\n title=\"Star Wars Movies\",\n caption=\"Rich example table\",\n caption_justify=\"right\",\n )\n\n table.add_column(\n \"Released\", header_style=\"bright_cyan\", style=\"cyan\", no_wrap=True\n )\n table.add_column(\"Title\", style=\"magenta\")\n table.add_column(\"Box Office\", justify=\"right\", style=\"green\")\n\n table.add_row(\n \"Dec 20, 2019\",\n \"Star Wars: The Rise of Skywalker\",\n \"$952,110,690\",\n )\n table.add_row(\"May 25, 2018\", \"Solo: A Star Wars Story\", \"$393,151,347\")\n table.add_row(\n \"Dec 15, 2017\",\n \"Star Wars Ep. V111: The Last Jedi\",\n \"$1,332,539,889\",\n style=\"on black\",\n end_section=True,\n )\n table.add_row(\n \"Dec 16, 2016\",\n \"Rogue One: A Star Wars Story\",\n \"$1,332,439,889\",\n )\n\n def header(text: str) -> None:\n console.print()\n console.rule(highlight(text))\n console.print()\n\n console = Console()\n highlight = ReprHighlighter()\n header(\"Example Table\")\n console.print(table, justify=\"center\")\n\n table.expand = True\n header(\"expand=True\")\n console.print(table)\n\n table.width = 50\n header(\"width=50\")\n\n console.print(table, justify=\"center\")\n\n table.width = None\n table.expand = False\n table.row_styles = [\"dim\", \"none\"]\n header(\"row_styles=['dim', 'none']\")\n\n console.print(table, justify=\"center\")\n\n table.width = None\n table.expand = False\n table.row_styles = [\"dim\", \"none\"]\n table.leading = 1\n header(\"leading=1, row_styles=['dim', 'none']\")\n console.print(table, justify=\"center\")\n\n table.width = None\n table.expand = False\n table.row_styles = [\"dim\", \"none\"]\n table.show_lines = True\n table.leading = 0\n header(\"show_lines=True, row_styles=['dim', 'none']\")\n console.print(table, justify=\"center\")\n",[],[213,919,920,921,1016,1050,1511,1553],"0c099824-67fc-11f0-9bd1-0224a6c84d84","syntax.py","0c0998f6-67fc-11f0-9bd1-0224a6c84d84",445,["D",1753299267963],"import os.path\nimport re\nimport sys\nimport textwrap\nfrom abc import ABC, abstractmethod\nfrom pathlib import Path\nfrom typing import (\n Any,\n Dict,\n Iterable,\n List,\n NamedTuple,\n Optional,\n Sequence,\n Set,\n Tuple,\n Type,\n Union,\n)\n\nfrom pip._vendor.pygments.lexer import Lexer\nfrom pip._vendor.pygments.lexers import get_lexer_by_name, guess_lexer_for_filename\nfrom pip._vendor.pygments.style import Style as PygmentsStyle\nfrom pip._vendor.pygments.styles import get_style_by_name\nfrom pip._vendor.pygments.token import (\n Comment,\n Error,\n Generic,\n Keyword,\n Name,\n Number,\n Operator,\n String,\n Token,\n Whitespace,\n)\nfrom pip._vendor.pygments.util import ClassNotFound\n\nfrom pip._vendor.rich.containers import Lines\nfrom pip._vendor.rich.padding import Padding, PaddingDimensions\n\nfrom ._loop import loop_first\nfrom .cells import cell_len\nfrom .color import Color, blend_rgb\nfrom .console import Console, ConsoleOptions, JustifyMethod, RenderResult\nfrom .jupyter import JupyterMixin\nfrom .measure import Measurement\nfrom .segment import Segment, Segments\nfrom .style import Style, StyleType\nfrom .text import Text\n\nTokenType = Tuple[str, ...]\n\nWINDOWS = sys.platform == \"win32\"\nDEFAULT_THEME = \"monokai\"\n\n# The following styles are based on https://github.com/pygments/pygments/blob/master/pygments/formatters/terminal.py\n# A few modifications were made\n\nANSI_LIGHT: Dict[TokenType, Style] = {\n Token: Style(),\n Whitespace: Style(color=\"white\"),\n Comment: Style(dim=True),\n Comment.Preproc: Style(color=\"cyan\"),\n Keyword: Style(color=\"blue\"),\n Keyword.Type: Style(color=\"cyan\"),\n Operator.Word: Style(color=\"magenta\"),\n Name.Builtin: Style(color=\"cyan\"),\n Name.Function: Style(color=\"green\"),\n Name.Namespace: Style(color=\"cyan\", underline=True),\n Name.Class: Style(color=\"green\", underline=True),\n Name.Exception: Style(color=\"cyan\"),\n Name.Decorator: Style(color=\"magenta\", bold=True),\n Name.Variable: Style(color=\"red\"),\n Name.Constant: Style(color=\"red\"),\n Name.Attribute: Style(color=\"cyan\"),\n Name.Tag: Style(color=\"bright_blue\"),\n String: Style(color=\"yellow\"),\n Number: Style(color=\"blue\"),\n Generic.Deleted: Style(color=\"bright_red\"),\n Generic.Inserted: Style(color=\"green\"),\n Generic.Heading: Style(bold=True),\n Generic.Subheading: Style(color=\"magenta\", bold=True),\n Generic.Prompt: Style(bold=True),\n Generic.Error: Style(color=\"bright_red\"),\n Error: Style(color=\"red\", underline=True),\n}\n\nANSI_DARK: Dict[TokenType, Style] = {\n Token: Style(),\n Whitespace: Style(color=\"bright_black\"),\n Comment: Style(dim=True),\n Comment.Preproc: Style(color=\"bright_cyan\"),\n Keyword: Style(color=\"bright_blue\"),\n Keyword.Type: Style(color=\"bright_cyan\"),\n Operator.Word: Style(color=\"bright_magenta\"),\n Name.Builtin: Style(color=\"bright_cyan\"),\n Name.Function: Style(color=\"bright_green\"),\n Name.Namespace: Style(color=\"bright_cyan\", underline=True),\n Name.Class: Style(color=\"bright_green\", underline=True),\n Name.Exception: Style(color=\"bright_cyan\"),\n Name.Decorator: Style(color=\"bright_magenta\", bold=True),\n Name.Variable: Style(color=\"bright_red\"),\n Name.Constant: Style(color=\"bright_red\"),\n Name.Attribute: Style(color=\"bright_cyan\"),\n Name.Tag: Style(color=\"bright_blue\"),\n String: Style(color=\"yellow\"),\n Number: Style(color=\"bright_blue\"),\n Generic.Deleted: Style(color=\"bright_red\"),\n Generic.Inserted: Style(color=\"bright_green\"),\n Generic.Heading: Style(bold=True),\n Generic.Subheading: Style(color=\"bright_magenta\", bold=True),\n Generic.Prompt: Style(bold=True),\n Generic.Error: Style(color=\"bright_red\"),\n Error: Style(color=\"red\", underline=True),\n}\n\nRICH_SYNTAX_THEMES = {\"ansi_light\": ANSI_LIGHT, \"ansi_dark\": ANSI_DARK}\nNUMBERS_COLUMN_DEFAULT_PADDING = 2\n\n\nclass SyntaxTheme(ABC):\n \"\"\"Base class for a syntax theme.\"\"\"\n\n @abstractmethod\n def get_style_for_token(self, token_type: TokenType) -> Style:\n \"\"\"Get a style for a given Pygments token.\"\"\"\n raise NotImplementedError # pragma: no cover\n\n @abstractmethod\n def get_background_style(self) -> Style:\n \"\"\"Get the background color.\"\"\"\n raise NotImplementedError # pragma: no cover\n\n\nclass PygmentsSyntaxTheme(SyntaxTheme):\n \"\"\"Syntax theme that delegates to Pygments theme.\"\"\"\n\n def __init__(self, theme: Union[str, Type[PygmentsStyle]]) -> None:\n self._style_cache: Dict[TokenType, Style] = {}\n if isinstance(theme, str):\n try:\n self._pygments_style_class = get_style_by_name(theme)\n except ClassNotFound:\n self._pygments_style_class = get_style_by_name(\"default\")\n else:\n self._pygments_style_class = theme\n\n self._background_color = self._pygments_style_class.background_color\n self._background_style = Style(bgcolor=self._background_color)\n\n def get_style_for_token(self, token_type: TokenType) -> Style:\n \"\"\"Get a style from a Pygments class.\"\"\"\n try:\n return self._style_cache[token_type]\n except KeyError:\n try:\n pygments_style = self._pygments_style_class.style_for_token(token_type)\n except KeyError:\n style = Style.null()\n else:\n color = pygments_style[\"color\"]\n bgcolor = pygments_style[\"bgcolor\"]\n style = Style(\n color=\"#\" + color if color else \"#000000\",\n bgcolor=\"#\" + bgcolor if bgcolor else self._background_color,\n bold=pygments_style[\"bold\"],\n italic=pygments_style[\"italic\"],\n underline=pygments_style[\"underline\"],\n )\n self._style_cache[token_type] = style\n return style\n\n def get_background_style(self) -> Style:\n return self._background_style\n\n\nclass ANSISyntaxTheme(SyntaxTheme):\n \"\"\"Syntax theme to use standard colors.\"\"\"\n\n def __init__(self, style_map: Dict[TokenType, Style]) -> None:\n self.style_map = style_map\n self._missing_style = Style.null()\n self._background_style = Style.null()\n self._style_cache: Dict[TokenType, Style] = {}\n\n def get_style_for_token(self, token_type: TokenType) -> Style:\n \"\"\"Look up style in the style map.\"\"\"\n try:\n return self._style_cache[token_type]\n except KeyError:\n # Styles form a hierarchy\n # We need to go from most to least specific\n # e.g. (\"foo\", \"bar\", \"baz\") to (\"foo\", \"bar\") to (\"foo\",)\n get_style = self.style_map.get\n token = tuple(token_type)\n style = self._missing_style\n while token:\n _style = get_style(token)\n if _style is not None:\n style = _style\n break\n token = token[:-1]\n self._style_cache[token_type] = style\n return style\n\n def get_background_style(self) -> Style:\n return self._background_style\n\n\nSyntaxPosition = Tuple[int, int]\n\n\nclass _SyntaxHighlightRange(NamedTuple):\n \"\"\"\n A range to highlight in a Syntax object.\n `start` and `end` are 2-integers tuples, where the first integer is the line number\n (starting from 1) and the second integer is the column index (starting from 0).\n \"\"\"\n\n style: StyleType\n start: SyntaxPosition\n end: SyntaxPosition\n style_before: bool = False\n\n\nclass Syntax(JupyterMixin):\n \"\"\"Construct a Syntax object to render syntax highlighted code.\n\n Args:\n code (str): Code to highlight.\n lexer (Lexer | str): Lexer to use (see https://pygments.org/docs/lexers/)\n theme (str, optional): Color theme, aka Pygments style (see https://pygments.org/docs/styles/#getting-a-list-of-available-styles). Defaults to \"monokai\".\n dedent (bool, optional): Enable stripping of initial whitespace. Defaults to False.\n line_numbers (bool, optional): Enable rendering of line numbers. Defaults to False.\n start_line (int, optional): Starting number for line numbers. Defaults to 1.\n line_range (Tuple[int | None, int | None], optional): If given should be a tuple of the start and end line to render.\n A value of None in the tuple indicates the range is open in that direction.\n highlight_lines (Set[int]): A set of line numbers to highlight.\n code_width: Width of code to render (not including line numbers), or ``None`` to use all available width.\n tab_size (int, optional): Size of tabs. Defaults to 4.\n word_wrap (bool, optional): Enable word wrapping.\n background_color (str, optional): Optional background color, or None to use theme color. Defaults to None.\n indent_guides (bool, optional): Show indent guides. Defaults to False.\n padding (PaddingDimensions): Padding to apply around the syntax. Defaults to 0 (no padding).\n \"\"\"\n\n _pygments_style_class: Type[PygmentsStyle]\n _theme: SyntaxTheme\n\n @classmethod\n def get_theme(cls, name: Union[str, SyntaxTheme]) -> SyntaxTheme:\n \"\"\"Get a syntax theme instance.\"\"\"\n if isinstance(name, SyntaxTheme):\n return name\n theme: SyntaxTheme\n if name in RICH_SYNTAX_THEMES:\n theme = ANSISyntaxTheme(RICH_SYNTAX_THEMES[name])\n else:\n theme = PygmentsSyntaxTheme(name)\n return theme\n\n def __init__(\n self,\n code: str,\n lexer: Union[Lexer, str],\n *,\n theme: Union[str, SyntaxTheme] = DEFAULT_THEME,\n dedent: bool = False,\n line_numbers: bool = False,\n start_line: int = 1,\n line_range: Optional[Tuple[Optional[int], Optional[int]]] = None,\n highlight_lines: Optional[Set[int]] = None,\n code_width: Optional[int] = None,\n tab_size: int = 4,\n word_wrap: bool = False,\n background_color: Optional[str] = None,\n indent_guides: bool = False,\n padding: PaddingDimensions = 0,\n ) -> None:\n self.code = code\n self._lexer = lexer\n self.dedent = dedent\n self.line_numbers = line_numbers\n self.start_line = start_line\n self.line_range = line_range\n self.highlight_lines = highlight_lines or set()\n self.code_width = code_width\n self.tab_size = tab_size\n self.word_wrap = word_wrap\n self.background_color = background_color\n self.background_style = (\n Style(bgcolor=background_color) if background_color else Style()\n )\n self.indent_guides = indent_guides\n self.padding = padding\n\n self._theme = self.get_theme(theme)\n self._stylized_ranges: List[_SyntaxHighlightRange] = []\n\n @classmethod\n def from_path(\n cls,\n path: str,\n encoding: str = \"utf-8\",\n lexer: Optional[Union[Lexer, str]] = None,\n theme: Union[str, SyntaxTheme] = DEFAULT_THEME,\n dedent: bool = False,\n line_numbers: bool = False,\n line_range: Optional[Tuple[int, int]] = None,\n start_line: int = 1,\n highlight_lines: Optional[Set[int]] = None,\n code_width: Optional[int] = None,\n tab_size: int = 4,\n word_wrap: bool = False,\n background_color: Optional[str] = None,\n indent_guides: bool = False,\n padding: PaddingDimensions = 0,\n ) -> \"Syntax\":\n \"\"\"Construct a Syntax object from a file.\n\n Args:\n path (str): Path to file to highlight.\n encoding (str): Encoding of file.\n lexer (str | Lexer, optional): Lexer to use. If None, lexer will be auto-detected from path/file content.\n theme (str, optional): Color theme, aka Pygments style (see https://pygments.org/docs/styles/#getting-a-list-of-available-styles). Defaults to \"emacs\".\n dedent (bool, optional): Enable stripping of initial whitespace. Defaults to True.\n line_numbers (bool, optional): Enable rendering of line numbers. Defaults to False.\n start_line (int, optional): Starting number for line numbers. Defaults to 1.\n line_range (Tuple[int, int], optional): If given should be a tuple of the start and end line to render.\n highlight_lines (Set[int]): A set of line numbers to highlight.\n code_width: Width of code to render (not including line numbers), or ``None`` to use all available width.\n tab_size (int, optional): Size of tabs. Defaults to 4.\n word_wrap (bool, optional): Enable word wrapping of code.\n background_color (str, optional): Optional background color, or None to use theme color. Defaults to None.\n indent_guides (bool, optional): Show indent guides. Defaults to False.\n padding (PaddingDimensions): Padding to apply around the syntax. Defaults to 0 (no padding).\n\n Returns:\n [Syntax]: A Syntax object that may be printed to the console\n \"\"\"\n code = Path(path).read_text(encoding=encoding)\n\n if not lexer:\n lexer = cls.guess_lexer(path, code=code)\n\n return cls(\n code,\n lexer,\n theme=theme,\n dedent=dedent,\n line_numbers=line_numbers,\n line_range=line_range,\n start_line=start_line,\n highlight_lines=highlight_lines,\n code_width=code_width,\n tab_size=tab_size,\n word_wrap=word_wrap,\n background_color=background_color,\n indent_guides=indent_guides,\n padding=padding,\n )\n\n @classmethod\n def guess_lexer(cls, path: str, code: Optional[str] = None) -> str:\n \"\"\"Guess the alias of the Pygments lexer to use based on a path and an optional string of code.\n If code is supplied, it will use a combination of the code and the filename to determine the\n best lexer to use. For example, if the file is ``index.html`` and the file contains Django\n templating syntax, then \"html+django\" will be returned. If the file is ``index.html``, and no\n templating language is used, the \"html\" lexer will be used. If no string of code\n is supplied, the lexer will be chosen based on the file extension..\n\n Args:\n path (AnyStr): The path to the file containing the code you wish to know the lexer for.\n code (str, optional): Optional string of code that will be used as a fallback if no lexer\n is found for the supplied path.\n\n Returns:\n str: The name of the Pygments lexer that best matches the supplied path/code.\n \"\"\"\n lexer: Optional[Lexer] = None\n lexer_name = \"default\"\n if code:\n try:\n lexer = guess_lexer_for_filename(path, code)\n except ClassNotFound:\n pass\n\n if not lexer:\n try:\n _, ext = os.path.splitext(path)\n if ext:\n extension = ext.lstrip(\".\").lower()\n lexer = get_lexer_by_name(extension)\n except ClassNotFound:\n pass\n\n if lexer:\n if lexer.aliases:\n lexer_name = lexer.aliases[0]\n else:\n lexer_name = lexer.name\n\n return lexer_name\n\n def _get_base_style(self) -> Style:\n \"\"\"Get the base style.\"\"\"\n default_style = self._theme.get_background_style() + self.background_style\n return default_style\n\n def _get_token_color(self, token_type: TokenType) -> Optional[Color]:\n \"\"\"Get a color (if any) for the given token.\n\n Args:\n token_type (TokenType): A token type tuple from Pygments.\n\n Returns:\n Optional[Color]: Color from theme, or None for no color.\n \"\"\"\n style = self._theme.get_style_for_token(token_type)\n return style.color\n\n @property\n def lexer(self) -> Optional[Lexer]:\n \"\"\"The lexer for this syntax, or None if no lexer was found.\n\n Tries to find the lexer by name if a string was passed to the constructor.\n \"\"\"\n\n if isinstance(self._lexer, Lexer):\n return self._lexer\n try:\n return get_lexer_by_name(\n self._lexer,\n stripnl=False,\n ensurenl=True,\n tabsize=self.tab_size,\n )\n except ClassNotFound:\n return None\n\n @property\n def default_lexer(self) -> Lexer:\n \"\"\"A Pygments Lexer to use if one is not specified or invalid.\"\"\"\n return get_lexer_by_name(\n \"text\",\n stripnl=False,\n ensurenl=True,\n tabsize=self.tab_size,\n )\n\n def highlight(\n self,\n code: str,\n line_range: Optional[Tuple[Optional[int], Optional[int]]] = None,\n ) -> Text:\n \"\"\"Highlight code and return a Text instance.\n\n Args:\n code (str): Code to highlight.\n line_range(Tuple[int, int], optional): Optional line range to highlight.\n\n Returns:\n Text: A text instance containing highlighted syntax.\n \"\"\"\n\n base_style = self._get_base_style()\n justify: JustifyMethod = (\n \"default\" if base_style.transparent_background else \"left\"\n )\n\n text = Text(\n justify=justify,\n style=base_style,\n tab_size=self.tab_size,\n no_wrap=not self.word_wrap,\n )\n _get_theme_style = self._theme.get_style_for_token\n\n lexer = self.lexer or self.default_lexer\n\n if lexer is None:\n text.append(code)\n else:\n if line_range:\n # More complicated path to only stylize a portion of the code\n # This speeds up further operations as there are less spans to process\n line_start, line_end = line_range\n\n def line_tokenize() -> Iterable[Tuple[Any, str]]:\n \"\"\"Split tokens to one per line.\"\"\"\n assert lexer # required to make MyPy happy - we know lexer is not None at this point\n\n for token_type, token in lexer.get_tokens(code):\n while token:\n line_token, new_line, token = token.partition(\"\\n\")\n yield token_type, line_token + new_line\n\n def tokens_to_spans() -> Iterable[Tuple[str, Optional[Style]]]:\n \"\"\"Convert tokens to spans.\"\"\"\n tokens = iter(line_tokenize())\n line_no = 0\n _line_start = line_start - 1 if line_start else 0\n\n # Skip over tokens until line start\n while line_no < _line_start:\n try:\n _token_type, token = next(tokens)\n except StopIteration:\n break\n yield (token, None)\n if token.endswith(\"\\n\"):\n line_no += 1\n # Generate spans until line end\n for token_type, token in tokens:\n yield (token, _get_theme_style(token_type))\n if token.endswith(\"\\n\"):\n line_no += 1\n if line_end and line_no >= line_end:\n break\n\n text.append_tokens(tokens_to_spans())\n\n else:\n text.append_tokens(\n (token, _get_theme_style(token_type))\n for token_type, token in lexer.get_tokens(code)\n )\n if self.background_color is not None:\n text.stylize(f\"on {self.background_color}\")\n\n if self._stylized_ranges:\n self._apply_stylized_ranges(text)\n\n return text\n\n def stylize_range(\n self,\n style: StyleType,\n start: SyntaxPosition,\n end: SyntaxPosition,\n style_before: bool = False,\n ) -> None:\n \"\"\"\n Adds a custom style on a part of the code, that will be applied to the syntax display when it's rendered.\n Line numbers are 1-based, while column indexes are 0-based.\n\n Args:\n style (StyleType): The style to apply.\n start (Tuple[int, int]): The start of the range, in the form `[line number, column index]`.\n end (Tuple[int, int]): The end of the range, in the form `[line number, column index]`.\n style_before (bool): Apply the style before any existing styles.\n \"\"\"\n self._stylized_ranges.append(\n _SyntaxHighlightRange(style, start, end, style_before)\n )\n\n def _get_line_numbers_color(self, blend: float = 0.3) -> Color:\n background_style = self._theme.get_background_style() + self.background_style\n background_color = background_style.bgcolor\n if background_color is None or background_color.is_system_defined:\n return Color.default()\n foreground_color = self._get_token_color(Token.Text)\n if foreground_color is None or foreground_color.is_system_defined:\n return foreground_color or Color.default()\n new_color = blend_rgb(\n background_color.get_truecolor(),\n foreground_color.get_truecolor(),\n cross_fade=blend,\n )\n return Color.from_triplet(new_color)\n\n @property\n def _numbers_column_width(self) -> int:\n \"\"\"Get the number of characters used to render the numbers column.\"\"\"\n column_width = 0\n if self.line_numbers:\n column_width = (\n len(str(self.start_line + self.code.count(\"\\n\")))\n + NUMBERS_COLUMN_DEFAULT_PADDING\n )\n return column_width\n\n def _get_number_styles(self, console: Console) -> Tuple[Style, Style, Style]:\n \"\"\"Get background, number, and highlight styles for line numbers.\"\"\"\n background_style = self._get_base_style()\n if background_style.transparent_background:\n return Style.null(), Style(dim=True), Style.null()\n if console.color_system in (\"256\", \"truecolor\"):\n number_style = Style.chain(\n background_style,\n self._theme.get_style_for_token(Token.Text),\n Style(color=self._get_line_numbers_color()),\n self.background_style,\n )\n highlight_number_style = Style.chain(\n background_style,\n self._theme.get_style_for_token(Token.Text),\n Style(bold=True, color=self._get_line_numbers_color(0.9)),\n self.background_style,\n )\n else:\n number_style = background_style + Style(dim=True)\n highlight_number_style = background_style + Style(dim=False)\n return background_style, number_style, highlight_number_style\n\n def __rich_measure__(\n self, console: \"Console\", options: \"ConsoleOptions\"\n ) -> \"Measurement\":\n _, right, _, left = Padding.unpack(self.padding)\n padding = left + right\n if self.code_width is not None:\n width = self.code_width + self._numbers_column_width + padding + 1\n return Measurement(self._numbers_column_width, width)\n lines = self.code.splitlines()\n width = (\n self._numbers_column_width\n + padding\n + (max(cell_len(line) for line in lines) if lines else 0)\n )\n if self.line_numbers:\n width += 1\n return Measurement(self._numbers_column_width, width)\n\n def __rich_console__(\n self, console: Console, options: ConsoleOptions\n ) -> RenderResult:\n segments = Segments(self._get_syntax(console, options))\n if self.padding:\n yield Padding(segments, style=self._get_base_style(), pad=self.padding)\n else:\n yield segments\n\n def _get_syntax(\n self,\n console: Console,\n options: ConsoleOptions,\n ) -> Iterable[Segment]:\n \"\"\"\n Get the Segments for the Syntax object, excluding any vertical/horizontal padding\n \"\"\"\n transparent_background = self._get_base_style().transparent_background\n code_width = (\n (\n (options.max_width - self._numbers_column_width - 1)\n if self.line_numbers\n else options.max_width\n )\n if self.code_width is None\n else self.code_width\n )\n\n ends_on_nl, processed_code = self._process_code(self.code)\n text = self.highlight(processed_code, self.line_range)\n\n if not self.line_numbers and not self.word_wrap and not self.line_range:\n if not ends_on_nl:\n text.remove_suffix(\"\\n\")\n # Simple case of just rendering text\n style = (\n self._get_base_style()\n + self._theme.get_style_for_token(Comment)\n + Style(dim=True)\n + self.background_style\n )\n if self.indent_guides and not options.ascii_only:\n text = text.with_indent_guides(self.tab_size, style=style)\n text.overflow = \"crop\"\n if style.transparent_background:\n yield from console.render(\n text, options=options.update(width=code_width)\n )\n else:\n syntax_lines = console.render_lines(\n text,\n options.update(width=code_width, height=None, justify=\"left\"),\n style=self.background_style,\n pad=True,\n new_lines=True,\n )\n for syntax_line in syntax_lines:\n yield from syntax_line\n return\n\n start_line, end_line = self.line_range or (None, None)\n line_offset = 0\n if start_line:\n line_offset = max(0, start_line - 1)\n lines: Union[List[Text], Lines] = text.split(\"\\n\", allow_blank=ends_on_nl)\n if self.line_range:\n if line_offset > len(lines):\n return\n lines = lines[line_offset:end_line]\n\n if self.indent_guides and not options.ascii_only:\n style = (\n self._get_base_style()\n + self._theme.get_style_for_token(Comment)\n + Style(dim=True)\n + self.background_style\n )\n lines = (\n Text(\"\\n\")\n .join(lines)\n .with_indent_guides(self.tab_size, style=style + Style(italic=False))\n .split(\"\\n\", allow_blank=True)\n )\n\n numbers_column_width = self._numbers_column_width\n render_options = options.update(width=code_width)\n\n highlight_line = self.highlight_lines.__contains__\n _Segment = Segment\n new_line = _Segment(\"\\n\")\n\n line_pointer = \"> \" if options.legacy_windows else \"❱ \"\n\n (\n background_style,\n number_style,\n highlight_number_style,\n ) = self._get_number_styles(console)\n\n for line_no, line in enumerate(lines, self.start_line + line_offset):\n if self.word_wrap:\n wrapped_lines = console.render_lines(\n line,\n render_options.update(height=None, justify=\"left\"),\n style=background_style,\n pad=not transparent_background,\n )\n else:\n segments = list(line.render(console, end=\"\"))\n if options.no_wrap:\n wrapped_lines = [segments]\n else:\n wrapped_lines = [\n _Segment.adjust_line_length(\n segments,\n render_options.max_width,\n style=background_style,\n pad=not transparent_background,\n )\n ]\n\n if self.line_numbers:\n wrapped_line_left_pad = _Segment(\n \" \" * numbers_column_width + \" \", background_style\n )\n for first, wrapped_line in loop_first(wrapped_lines):\n if first:\n line_column = str(line_no).rjust(numbers_column_width - 2) + \" \"\n if highlight_line(line_no):\n yield _Segment(line_pointer, Style(color=\"red\"))\n yield _Segment(line_column, highlight_number_style)\n else:\n yield _Segment(\" \", highlight_number_style)\n yield _Segment(line_column, number_style)\n else:\n yield wrapped_line_left_pad\n yield from wrapped_line\n yield new_line\n else:\n for wrapped_line in wrapped_lines:\n yield from wrapped_line\n yield new_line\n\n def _apply_stylized_ranges(self, text: Text) -> None:\n \"\"\"\n Apply stylized ranges to a text instance,\n using the given code to determine the right portion to apply the style to.\n\n Args:\n text (Text): Text instance to apply the style to.\n \"\"\"\n code = text.plain\n newlines_offsets = [\n # Let's add outer boundaries at each side of the list:\n 0,\n # N.B. using \"\\n\" here is much faster than using metacharacters such as \"^\" or \"\\Z\":\n *[\n match.start() + 1\n for match in re.finditer(\"\\n\", code, flags=re.MULTILINE)\n ],\n len(code) + 1,\n ]\n\n for stylized_range in self._stylized_ranges:\n start = _get_code_index_for_syntax_position(\n newlines_offsets, stylized_range.start\n )\n end = _get_code_index_for_syntax_position(\n newlines_offsets, stylized_range.end\n )\n if start is not None and end is not None:\n if stylized_range.style_before:\n text.stylize_before(stylized_range.style, start, end)\n else:\n text.stylize(stylized_range.style, start, end)\n\n def _process_code(self, code: str) -> Tuple[bool, str]:\n \"\"\"\n Applies various processing to a raw code string\n (normalises it so it always ends with a line return, dedents it if necessary, etc.)\n\n Args:\n code (str): The raw code string to process\n\n Returns:\n Tuple[bool, str]: the boolean indicates whether the raw code ends with a line return,\n while the string is the processed code.\n \"\"\"\n ends_on_nl = code.endswith(\"\\n\")\n processed_code = code if ends_on_nl else code + \"\\n\"\n processed_code = (\n textwrap.dedent(processed_code) if self.dedent else processed_code\n )\n processed_code = processed_code.expandtabs(self.tab_size)\n return ends_on_nl, processed_code\n\n\ndef _get_code_index_for_syntax_position(\n newlines_offsets: Sequence[int], position: SyntaxPosition\n) -> Optional[int]:\n \"\"\"\n Returns the index of the code string for the given positions.\n\n Args:\n newlines_offsets (Sequence[int]): The offset of each newline character found in the code snippet.\n position (SyntaxPosition): The position to search for.\n\n Returns:\n Optional[int]: The index of the code string for this position, or `None`\n if the given position's line number is out of range (if it's the column that is out of range\n we silently clamp its value so that it reaches the end of the line)\n \"\"\"\n lines_count = len(newlines_offsets)\n\n line_number, column_index = position\n if line_number > lines_count or len(newlines_offsets) < (line_number + 1):\n return None # `line_number` is out of range\n line_index = line_number - 1\n line_length = newlines_offsets[line_index + 1] - newlines_offsets[line_index] - 1\n # If `column_index` is out of range: let's silently clamp it:\n column_index = min(line_length, column_index)\n return newlines_offsets[line_index] + column_index\n\n\nif __name__ == \"__main__\": # pragma: no cover\n import argparse\n import sys\n\n parser = argparse.ArgumentParser(\n description=\"Render syntax to the console with Rich\"\n )\n parser.add_argument(\n \"path\",\n metavar=\"PATH\",\n help=\"path to file, or - for stdin\",\n )\n parser.add_argument(\n \"-c\",\n \"--force-color\",\n dest=\"force_color\",\n action=\"store_true\",\n default=None,\n help=\"force color for non-terminals\",\n )\n parser.add_argument(\n \"-i\",\n \"--indent-guides\",\n dest=\"indent_guides\",\n action=\"store_true\",\n default=False,\n help=\"display indent guides\",\n )\n parser.add_argument(\n \"-l\",\n \"--line-numbers\",\n dest=\"line_numbers\",\n action=\"store_true\",\n help=\"render line numbers\",\n )\n parser.add_argument(\n \"-w\",\n \"--width\",\n type=int,\n dest=\"width\",\n default=None,\n help=\"width of output (default will auto-detect)\",\n )\n parser.add_argument(\n \"-r\",\n \"--wrap\",\n dest=\"word_wrap\",\n action=\"store_true\",\n default=False,\n help=\"word wrap long lines\",\n )\n parser.add_argument(\n \"-s\",\n \"--soft-wrap\",\n action=\"store_true\",\n dest=\"soft_wrap\",\n default=False,\n help=\"enable soft wrapping mode\",\n )\n parser.add_argument(\n \"-t\", \"--theme\", dest=\"theme\", default=\"monokai\", help=\"pygments theme\"\n )\n parser.add_argument(\n \"-b\",\n \"--background-color\",\n dest=\"background_color\",\n default=None,\n help=\"Override background color\",\n )\n parser.add_argument(\n \"-x\",\n \"--lexer\",\n default=None,\n dest=\"lexer_name\",\n help=\"Lexer name\",\n )\n parser.add_argument(\n \"-p\", \"--padding\", type=int, default=0, dest=\"padding\", help=\"Padding\"\n )\n parser.add_argument(\n \"--highlight-line\",\n type=int,\n default=None,\n dest=\"highlight_line\",\n help=\"The line number (not index!) to highlight\",\n )\n args = parser.parse_args()\n\n from pip._vendor.rich.console import Console\n\n console = Console(force_terminal=args.force_color, width=args.width)\n\n if args.path == \"-\":\n code = sys.stdin.read()\n syntax = Syntax(\n code=code,\n lexer=args.lexer_name,\n line_numbers=args.line_numbers,\n word_wrap=args.word_wrap,\n theme=args.theme,\n background_color=args.background_color,\n indent_guides=args.indent_guides,\n padding=args.padding,\n highlight_lines={args.highlight_line},\n )\n else:\n syntax = Syntax.from_path(\n args.path,\n lexer=args.lexer_name,\n line_numbers=args.line_numbers,\n word_wrap=args.word_wrap,\n theme=args.theme,\n background_color=args.background_color,\n indent_guides=args.indent_guides,\n padding=args.padding,\n highlight_lines={args.highlight_line},\n )\n console.print(syntax, soft_wrap=args.soft_wrap)\n",[],[213,919,920,921,1016,1050,1511,1561],"0c6c2c82-67fc-11f0-9454-0224a6c84d84","styled.py","0c6c2d22-67fc-11f0-9454-0224a6c84d84",460,["D",1753299268590],"from typing import TYPE_CHECKING\n\nfrom .measure import Measurement\nfrom .segment import Segment\nfrom .style import StyleType\n\nif TYPE_CHECKING:\n from .console import Console, ConsoleOptions, RenderResult, RenderableType\n\n\nclass Styled:\n \"\"\"Apply a style to a renderable.\n\n Args:\n renderable (RenderableType): Any renderable.\n style (StyleType): A style to apply across the entire renderable.\n \"\"\"\n\n def __init__(self, renderable: \"RenderableType\", style: \"StyleType\") -> None:\n self.renderable = renderable\n self.style = style\n\n def __rich_console__(\n self, console: \"Console\", options: \"ConsoleOptions\"\n ) -> \"RenderResult\":\n style = console.get_style(self.style)\n rendered_segments = console.render(self.renderable, options)\n segments = Segment.apply_style(rendered_segments, style)\n return segments\n\n def __rich_measure__(\n self, console: \"Console\", options: \"ConsoleOptions\"\n ) -> Measurement:\n return Measurement.get(console, options, self.renderable)\n\n\nif __name__ == \"__main__\": # pragma: no cover\n from pip._vendor.rich import print\n from pip._vendor.rich.panel import Panel\n\n panel = Styled(Panel(\"hello\"), \"on blue\")\n print(panel)\n",[],[213,919,920,921,1016,1050,1511,1569],"0b29fbf6-67fc-11f0-a319-0224a6c84d84","style.py","0b29fd5e-67fc-11f0-a319-0224a6c84d84",408,["D",1753299266510],"import sys\nfrom functools import lru_cache\nfrom marshal import dumps, loads\nfrom random import randint\nfrom typing import Any, Dict, Iterable, List, Optional, Type, Union, cast\n\nfrom . import errors\nfrom .color import Color, ColorParseError, ColorSystem, blend_rgb\nfrom .repr import Result, rich_repr\nfrom .terminal_theme import DEFAULT_TERMINAL_THEME, TerminalTheme\n\n# Style instances and style definitions are often interchangeable\nStyleType = Union[str, \"Style\"]\n\n\nclass _Bit:\n \"\"\"A descriptor to get/set a style attribute bit.\"\"\"\n\n __slots__ = [\"bit\"]\n\n def __init__(self, bit_no: int) -> None:\n self.bit = 1 << bit_no\n\n def __get__(self, obj: \"Style\", objtype: Type[\"Style\"]) -> Optional[bool]:\n if obj._set_attributes & self.bit:\n return obj._attributes & self.bit != 0\n return None\n\n\n@rich_repr\nclass Style:\n \"\"\"A terminal style.\n\n A terminal style consists of a color (`color`), a background color (`bgcolor`), and a number of attributes, such\n as bold, italic etc. The attributes have 3 states: they can either be on\n (``True``), off (``False``), or not set (``None``).\n\n Args:\n color (Union[Color, str], optional): Color of terminal text. Defaults to None.\n bgcolor (Union[Color, str], optional): Color of terminal background. Defaults to None.\n bold (bool, optional): Enable bold text. Defaults to None.\n dim (bool, optional): Enable dim text. Defaults to None.\n italic (bool, optional): Enable italic text. Defaults to None.\n underline (bool, optional): Enable underlined text. Defaults to None.\n blink (bool, optional): Enabled blinking text. Defaults to None.\n blink2 (bool, optional): Enable fast blinking text. Defaults to None.\n reverse (bool, optional): Enabled reverse text. Defaults to None.\n conceal (bool, optional): Enable concealed text. Defaults to None.\n strike (bool, optional): Enable strikethrough text. Defaults to None.\n underline2 (bool, optional): Enable doubly underlined text. Defaults to None.\n frame (bool, optional): Enable framed text. Defaults to None.\n encircle (bool, optional): Enable encircled text. Defaults to None.\n overline (bool, optional): Enable overlined text. Defaults to None.\n link (str, link): Link URL. Defaults to None.\n\n \"\"\"\n\n _color: Optional[Color]\n _bgcolor: Optional[Color]\n _attributes: int\n _set_attributes: int\n _hash: Optional[int]\n _null: bool\n _meta: Optional[bytes]\n\n __slots__ = [\n \"_color\",\n \"_bgcolor\",\n \"_attributes\",\n \"_set_attributes\",\n \"_link\",\n \"_link_id\",\n \"_ansi\",\n \"_style_definition\",\n \"_hash\",\n \"_null\",\n \"_meta\",\n ]\n\n # maps bits on to SGR parameter\n _style_map = {\n 0: \"1\",\n 1: \"2\",\n 2: \"3\",\n 3: \"4\",\n 4: \"5\",\n 5: \"6\",\n 6: \"7\",\n 7: \"8\",\n 8: \"9\",\n 9: \"21\",\n 10: \"51\",\n 11: \"52\",\n 12: \"53\",\n }\n\n STYLE_ATTRIBUTES = {\n \"dim\": \"dim\",\n \"d\": \"dim\",\n \"bold\": \"bold\",\n \"b\": \"bold\",\n \"italic\": \"italic\",\n \"i\": \"italic\",\n \"underline\": \"underline\",\n \"u\": \"underline\",\n \"blink\": \"blink\",\n \"blink2\": \"blink2\",\n \"reverse\": \"reverse\",\n \"r\": \"reverse\",\n \"conceal\": \"conceal\",\n \"c\": \"conceal\",\n \"strike\": \"strike\",\n \"s\": \"strike\",\n \"underline2\": \"underline2\",\n \"uu\": \"underline2\",\n \"frame\": \"frame\",\n \"encircle\": \"encircle\",\n \"overline\": \"overline\",\n \"o\": \"overline\",\n }\n\n def __init__(\n self,\n *,\n color: Optional[Union[Color, str]] = None,\n bgcolor: Optional[Union[Color, str]] = None,\n bold: Optional[bool] = None,\n dim: Optional[bool] = None,\n italic: Optional[bool] = None,\n underline: Optional[bool] = None,\n blink: Optional[bool] = None,\n blink2: Optional[bool] = None,\n reverse: Optional[bool] = None,\n conceal: Optional[bool] = None,\n strike: Optional[bool] = None,\n underline2: Optional[bool] = None,\n frame: Optional[bool] = None,\n encircle: Optional[bool] = None,\n overline: Optional[bool] = None,\n link: Optional[str] = None,\n meta: Optional[Dict[str, Any]] = None,\n ):\n self._ansi: Optional[str] = None\n self._style_definition: Optional[str] = None\n\n def _make_color(color: Union[Color, str]) -> Color:\n return color if isinstance(color, Color) else Color.parse(color)\n\n self._color = None if color is None else _make_color(color)\n self._bgcolor = None if bgcolor is None else _make_color(bgcolor)\n self._set_attributes = sum(\n (\n bold is not None,\n dim is not None and 2,\n italic is not None and 4,\n underline is not None and 8,\n blink is not None and 16,\n blink2 is not None and 32,\n reverse is not None and 64,\n conceal is not None and 128,\n strike is not None and 256,\n underline2 is not None and 512,\n frame is not None and 1024,\n encircle is not None and 2048,\n overline is not None and 4096,\n )\n )\n self._attributes = (\n sum(\n (\n bold and 1 or 0,\n dim and 2 or 0,\n italic and 4 or 0,\n underline and 8 or 0,\n blink and 16 or 0,\n blink2 and 32 or 0,\n reverse and 64 or 0,\n conceal and 128 or 0,\n strike and 256 or 0,\n underline2 and 512 or 0,\n frame and 1024 or 0,\n encircle and 2048 or 0,\n overline and 4096 or 0,\n )\n )\n if self._set_attributes\n else 0\n )\n\n self._link = link\n self._meta = None if meta is None else dumps(meta)\n self._link_id = (\n f\"{randint(0, 999999)}{hash(self._meta)}\" if (link or meta) else \"\"\n )\n self._hash: Optional[int] = None\n self._null = not (self._set_attributes or color or bgcolor or link or meta)\n\n @classmethod\n def null(cls) -> \"Style\":\n \"\"\"Create an 'null' style, equivalent to Style(), but more performant.\"\"\"\n return NULL_STYLE\n\n @classmethod\n def from_color(\n cls, color: Optional[Color] = None, bgcolor: Optional[Color] = None\n ) -> \"Style\":\n \"\"\"Create a new style with colors and no attributes.\n\n Returns:\n color (Optional[Color]): A (foreground) color, or None for no color. Defaults to None.\n bgcolor (Optional[Color]): A (background) color, or None for no color. Defaults to None.\n \"\"\"\n style: Style = cls.__new__(Style)\n style._ansi = None\n style._style_definition = None\n style._color = color\n style._bgcolor = bgcolor\n style._set_attributes = 0\n style._attributes = 0\n style._link = None\n style._link_id = \"\"\n style._meta = None\n style._null = not (color or bgcolor)\n style._hash = None\n return style\n\n @classmethod\n def from_meta(cls, meta: Optional[Dict[str, Any]]) -> \"Style\":\n \"\"\"Create a new style with meta data.\n\n Returns:\n meta (Optional[Dict[str, Any]]): A dictionary of meta data. Defaults to None.\n \"\"\"\n style: Style = cls.__new__(Style)\n style._ansi = None\n style._style_definition = None\n style._color = None\n style._bgcolor = None\n style._set_attributes = 0\n style._attributes = 0\n style._link = None\n style._meta = dumps(meta)\n style._link_id = f\"{randint(0, 999999)}{hash(style._meta)}\"\n style._hash = None\n style._null = not (meta)\n return style\n\n @classmethod\n def on(cls, meta: Optional[Dict[str, Any]] = None, **handlers: Any) -> \"Style\":\n \"\"\"Create a blank style with meta information.\n\n Example:\n style = Style.on(click=self.on_click)\n\n Args:\n meta (Optional[Dict[str, Any]], optional): An optional dict of meta information.\n **handlers (Any): Keyword arguments are translated in to handlers.\n\n Returns:\n Style: A Style with meta information attached.\n \"\"\"\n meta = {} if meta is None else meta\n meta.update({f\"@{key}\": value for key, value in handlers.items()})\n return cls.from_meta(meta)\n\n bold = _Bit(0)\n dim = _Bit(1)\n italic = _Bit(2)\n underline = _Bit(3)\n blink = _Bit(4)\n blink2 = _Bit(5)\n reverse = _Bit(6)\n conceal = _Bit(7)\n strike = _Bit(8)\n underline2 = _Bit(9)\n frame = _Bit(10)\n encircle = _Bit(11)\n overline = _Bit(12)\n\n @property\n def link_id(self) -> str:\n \"\"\"Get a link id, used in ansi code for links.\"\"\"\n return self._link_id\n\n def __str__(self) -> str:\n \"\"\"Re-generate style definition from attributes.\"\"\"\n if self._style_definition is None:\n attributes: List[str] = []\n append = attributes.append\n bits = self._set_attributes\n if bits & 0b0000000001111:\n if bits & 1:\n append(\"bold\" if self.bold else \"not bold\")\n if bits & (1 << 1):\n append(\"dim\" if self.dim else \"not dim\")\n if bits & (1 << 2):\n append(\"italic\" if self.italic else \"not italic\")\n if bits & (1 << 3):\n append(\"underline\" if self.underline else \"not underline\")\n if bits & 0b0000111110000:\n if bits & (1 << 4):\n append(\"blink\" if self.blink else \"not blink\")\n if bits & (1 << 5):\n append(\"blink2\" if self.blink2 else \"not blink2\")\n if bits & (1 << 6):\n append(\"reverse\" if self.reverse else \"not reverse\")\n if bits & (1 << 7):\n append(\"conceal\" if self.conceal else \"not conceal\")\n if bits & (1 << 8):\n append(\"strike\" if self.strike else \"not strike\")\n if bits & 0b1111000000000:\n if bits & (1 << 9):\n append(\"underline2\" if self.underline2 else \"not underline2\")\n if bits & (1 << 10):\n append(\"frame\" if self.frame else \"not frame\")\n if bits & (1 << 11):\n append(\"encircle\" if self.encircle else \"not encircle\")\n if bits & (1 << 12):\n append(\"overline\" if self.overline else \"not overline\")\n if self._color is not None:\n append(self._color.name)\n if self._bgcolor is not None:\n append(\"on\")\n append(self._bgcolor.name)\n if self._link:\n append(\"link\")\n append(self._link)\n self._style_definition = \" \".join(attributes) or \"none\"\n return self._style_definition\n\n def __bool__(self) -> bool:\n \"\"\"A Style is false if it has no attributes, colors, or links.\"\"\"\n return not self._null\n\n def _make_ansi_codes(self, color_system: ColorSystem) -> str:\n \"\"\"Generate ANSI codes for this style.\n\n Args:\n color_system (ColorSystem): Color system.\n\n Returns:\n str: String containing codes.\n \"\"\"\n\n if self._ansi is None:\n sgr: List[str] = []\n append = sgr.append\n _style_map = self._style_map\n attributes = self._attributes & self._set_attributes\n if attributes:\n if attributes & 1:\n append(_style_map[0])\n if attributes & 2:\n append(_style_map[1])\n if attributes & 4:\n append(_style_map[2])\n if attributes & 8:\n append(_style_map[3])\n if attributes & 0b0000111110000:\n for bit in range(4, 9):\n if attributes & (1 << bit):\n append(_style_map[bit])\n if attributes & 0b1111000000000:\n for bit in range(9, 13):\n if attributes & (1 << bit):\n append(_style_map[bit])\n if self._color is not None:\n sgr.extend(self._color.downgrade(color_system).get_ansi_codes())\n if self._bgcolor is not None:\n sgr.extend(\n self._bgcolor.downgrade(color_system).get_ansi_codes(\n foreground=False\n )\n )\n self._ansi = \";\".join(sgr)\n return self._ansi\n\n @classmethod\n @lru_cache(maxsize=1024)\n def normalize(cls, style: str) -> str:\n \"\"\"Normalize a style definition so that styles with the same effect have the same string\n representation.\n\n Args:\n style (str): A style definition.\n\n Returns:\n str: Normal form of style definition.\n \"\"\"\n try:\n return str(cls.parse(style))\n except errors.StyleSyntaxError:\n return style.strip().lower()\n\n @classmethod\n def pick_first(cls, *values: Optional[StyleType]) -> StyleType:\n \"\"\"Pick first non-None style.\"\"\"\n for value in values:\n if value is not None:\n return value\n raise ValueError(\"expected at least one non-None style\")\n\n def __rich_repr__(self) -> Result:\n yield \"color\", self.color, None\n yield \"bgcolor\", self.bgcolor, None\n yield \"bold\", self.bold, None,\n yield \"dim\", self.dim, None,\n yield \"italic\", self.italic, None\n yield \"underline\", self.underline, None,\n yield \"blink\", self.blink, None\n yield \"blink2\", self.blink2, None\n yield \"reverse\", self.reverse, None\n yield \"conceal\", self.conceal, None\n yield \"strike\", self.strike, None\n yield \"underline2\", self.underline2, None\n yield \"frame\", self.frame, None\n yield \"encircle\", self.encircle, None\n yield \"link\", self.link, None\n if self._meta:\n yield \"meta\", self.meta\n\n def __eq__(self, other: Any) -> bool:\n if not isinstance(other, Style):\n return NotImplemented\n return self.__hash__() == other.__hash__()\n\n def __ne__(self, other: Any) -> bool:\n if not isinstance(other, Style):\n return NotImplemented\n return self.__hash__() != other.__hash__()\n\n def __hash__(self) -> int:\n if self._hash is not None:\n return self._hash\n self._hash = hash(\n (\n self._color,\n self._bgcolor,\n self._attributes,\n self._set_attributes,\n self._link,\n self._meta,\n )\n )\n return self._hash\n\n @property\n def color(self) -> Optional[Color]:\n \"\"\"The foreground color or None if it is not set.\"\"\"\n return self._color\n\n @property\n def bgcolor(self) -> Optional[Color]:\n \"\"\"The background color or None if it is not set.\"\"\"\n return self._bgcolor\n\n @property\n def link(self) -> Optional[str]:\n \"\"\"Link text, if set.\"\"\"\n return self._link\n\n @property\n def transparent_background(self) -> bool:\n \"\"\"Check if the style specified a transparent background.\"\"\"\n return self.bgcolor is None or self.bgcolor.is_default\n\n @property\n def background_style(self) -> \"Style\":\n \"\"\"A Style with background only.\"\"\"\n return Style(bgcolor=self.bgcolor)\n\n @property\n def meta(self) -> Dict[str, Any]:\n \"\"\"Get meta information (can not be changed after construction).\"\"\"\n return {} if self._meta is None else cast(Dict[str, Any], loads(self._meta))\n\n @property\n def without_color(self) -> \"Style\":\n \"\"\"Get a copy of the style with color removed.\"\"\"\n if self._null:\n return NULL_STYLE\n style: Style = self.__new__(Style)\n style._ansi = None\n style._style_definition = None\n style._color = None\n style._bgcolor = None\n style._attributes = self._attributes\n style._set_attributes = self._set_attributes\n style._link = self._link\n style._link_id = f\"{randint(0, 999999)}\" if self._link else \"\"\n style._null = False\n style._meta = None\n style._hash = None\n return style\n\n @classmethod\n @lru_cache(maxsize=4096)\n def parse(cls, style_definition: str) -> \"Style\":\n \"\"\"Parse a style definition.\n\n Args:\n style_definition (str): A string containing a style.\n\n Raises:\n errors.StyleSyntaxError: If the style definition syntax is invalid.\n\n Returns:\n `Style`: A Style instance.\n \"\"\"\n if style_definition.strip() == \"none\" or not style_definition:\n return cls.null()\n\n STYLE_ATTRIBUTES = cls.STYLE_ATTRIBUTES\n color: Optional[str] = None\n bgcolor: Optional[str] = None\n attributes: Dict[str, Optional[Any]] = {}\n link: Optional[str] = None\n\n words = iter(style_definition.split())\n for original_word in words:\n word = original_word.lower()\n if word == \"on\":\n word = next(words, \"\")\n if not word:\n raise errors.StyleSyntaxError(\"color expected after 'on'\")\n try:\n Color.parse(word)\n except ColorParseError as error:\n raise errors.StyleSyntaxError(\n f\"unable to parse {word!r} as background color; {error}\"\n ) from None\n bgcolor = word\n\n elif word == \"not\":\n word = next(words, \"\")\n attribute = STYLE_ATTRIBUTES.get(word)\n if attribute is None:\n raise errors.StyleSyntaxError(\n f\"expected style attribute after 'not', found {word!r}\"\n )\n attributes[attribute] = False\n\n elif word == \"link\":\n word = next(words, \"\")\n if not word:\n raise errors.StyleSyntaxError(\"URL expected after 'link'\")\n link = word\n\n elif word in STYLE_ATTRIBUTES:\n attributes[STYLE_ATTRIBUTES[word]] = True\n\n else:\n try:\n Color.parse(word)\n except ColorParseError as error:\n raise errors.StyleSyntaxError(\n f\"unable to parse {word!r} as color; {error}\"\n ) from None\n color = word\n style = Style(color=color, bgcolor=bgcolor, link=link, **attributes)\n return style\n\n @lru_cache(maxsize=1024)\n def get_html_style(self, theme: Optional[TerminalTheme] = None) -> str:\n \"\"\"Get a CSS style rule.\"\"\"\n theme = theme or DEFAULT_TERMINAL_THEME\n css: List[str] = []\n append = css.append\n\n color = self.color\n bgcolor = self.bgcolor\n if self.reverse:\n color, bgcolor = bgcolor, color\n if self.dim:\n foreground_color = (\n theme.foreground_color if color is None else color.get_truecolor(theme)\n )\n color = Color.from_triplet(\n blend_rgb(foreground_color, theme.background_color, 0.5)\n )\n if color is not None:\n theme_color = color.get_truecolor(theme)\n append(f\"color: {theme_color.hex}\")\n append(f\"text-decoration-color: {theme_color.hex}\")\n if bgcolor is not None:\n theme_color = bgcolor.get_truecolor(theme, foreground=False)\n append(f\"background-color: {theme_color.hex}\")\n if self.bold:\n append(\"font-weight: bold\")\n if self.italic:\n append(\"font-style: italic\")\n if self.underline:\n append(\"text-decoration: underline\")\n if self.strike:\n append(\"text-decoration: line-through\")\n if self.overline:\n append(\"text-decoration: overline\")\n return \"; \".join(css)\n\n @classmethod\n def combine(cls, styles: Iterable[\"Style\"]) -> \"Style\":\n \"\"\"Combine styles and get result.\n\n Args:\n styles (Iterable[Style]): Styles to combine.\n\n Returns:\n Style: A new style instance.\n \"\"\"\n iter_styles = iter(styles)\n return sum(iter_styles, next(iter_styles))\n\n @classmethod\n def chain(cls, *styles: \"Style\") -> \"Style\":\n \"\"\"Combine styles from positional argument in to a single style.\n\n Args:\n *styles (Iterable[Style]): Styles to combine.\n\n Returns:\n Style: A new style instance.\n \"\"\"\n iter_styles = iter(styles)\n return sum(iter_styles, next(iter_styles))\n\n def copy(self) -> \"Style\":\n \"\"\"Get a copy of this style.\n\n Returns:\n Style: A new Style instance with identical attributes.\n \"\"\"\n if self._null:\n return NULL_STYLE\n style: Style = self.__new__(Style)\n style._ansi = self._ansi\n style._style_definition = self._style_definition\n style._color = self._color\n style._bgcolor = self._bgcolor\n style._attributes = self._attributes\n style._set_attributes = self._set_attributes\n style._link = self._link\n style._link_id = f\"{randint(0, 999999)}\" if self._link else \"\"\n style._hash = self._hash\n style._null = False\n style._meta = self._meta\n return style\n\n @lru_cache(maxsize=128)\n def clear_meta_and_links(self) -> \"Style\":\n \"\"\"Get a copy of this style with link and meta information removed.\n\n Returns:\n Style: New style object.\n \"\"\"\n if self._null:\n return NULL_STYLE\n style: Style = self.__new__(Style)\n style._ansi = self._ansi\n style._style_definition = self._style_definition\n style._color = self._color\n style._bgcolor = self._bgcolor\n style._attributes = self._attributes\n style._set_attributes = self._set_attributes\n style._link = None\n style._link_id = \"\"\n style._hash = None\n style._null = False\n style._meta = None\n return style\n\n def update_link(self, link: Optional[str] = None) -> \"Style\":\n \"\"\"Get a copy with a different value for link.\n\n Args:\n link (str, optional): New value for link. Defaults to None.\n\n Returns:\n Style: A new Style instance.\n \"\"\"\n style: Style = self.__new__(Style)\n style._ansi = self._ansi\n style._style_definition = self._style_definition\n style._color = self._color\n style._bgcolor = self._bgcolor\n style._attributes = self._attributes\n style._set_attributes = self._set_attributes\n style._link = link\n style._link_id = f\"{randint(0, 999999)}\" if link else \"\"\n style._hash = None\n style._null = False\n style._meta = self._meta\n return style\n\n def render(\n self,\n text: str = \"\",\n *,\n color_system: Optional[ColorSystem] = ColorSystem.TRUECOLOR,\n legacy_windows: bool = False,\n ) -> str:\n \"\"\"Render the ANSI codes for the style.\n\n Args:\n text (str, optional): A string to style. Defaults to \"\".\n color_system (Optional[ColorSystem], optional): Color system to render to. Defaults to ColorSystem.TRUECOLOR.\n\n Returns:\n str: A string containing ANSI style codes.\n \"\"\"\n if not text or color_system is None:\n return text\n attrs = self._ansi or self._make_ansi_codes(color_system)\n rendered = f\"\\x1b[{attrs}m{text}\\x1b[0m\" if attrs else text\n if self._link and not legacy_windows:\n rendered = (\n f\"\\x1b]8;id={self._link_id};{self._link}\\x1b\\\\{rendered}\\x1b]8;;\\x1b\\\\\"\n )\n return rendered\n\n def test(self, text: Optional[str] = None) -> None:\n \"\"\"Write text with style directly to terminal.\n\n This method is for testing purposes only.\n\n Args:\n text (Optional[str], optional): Text to style or None for style name.\n\n \"\"\"\n text = text or str(self)\n sys.stdout.write(f\"{self.render(text)}\\n\")\n\n @lru_cache(maxsize=1024)\n def _add(self, style: Optional[\"Style\"]) -> \"Style\":\n if style is None or style._null:\n return self\n if self._null:\n return style\n new_style: Style = self.__new__(Style)\n new_style._ansi = None\n new_style._style_definition = None\n new_style._color = style._color or self._color\n new_style._bgcolor = style._bgcolor or self._bgcolor\n new_style._attributes = (self._attributes & ~style._set_attributes) | (\n style._attributes & style._set_attributes\n )\n new_style._set_attributes = self._set_attributes | style._set_attributes\n new_style._link = style._link or self._link\n new_style._link_id = style._link_id or self._link_id\n new_style._null = style._null\n if self._meta and style._meta:\n new_style._meta = dumps({**self.meta, **style.meta})\n else:\n new_style._meta = self._meta or style._meta\n new_style._hash = None\n return new_style\n\n def __add__(self, style: Optional[\"Style\"]) -> \"Style\":\n combined_style = self._add(style)\n return combined_style.copy() if combined_style.link else combined_style\n\n\nNULL_STYLE = Style()\n\n\nclass StyleStack:\n \"\"\"A stack of styles.\"\"\"\n\n __slots__ = [\"_stack\"]\n\n def __init__(self, default_style: \"Style\") -> None:\n self._stack: List[Style] = [default_style]\n\n def __repr__(self) -> str:\n return f\"\"\n\n @property\n def current(self) -> Style:\n \"\"\"Get the Style at the top of the stack.\"\"\"\n return self._stack[-1]\n\n def push(self, style: Style) -> None:\n \"\"\"Push a new style on to the stack.\n\n Args:\n style (Style): New style to combine with current style.\n \"\"\"\n self._stack.append(self._stack[-1] + style)\n\n def pop(self) -> Style:\n \"\"\"Pop last style and discard.\n\n Returns:\n Style: New current style (also available as stack.current)\n \"\"\"\n self._stack.pop()\n return self._stack[-1]\n",[],[213,919,920,921,1016,1050,1511,1577],"0c9cf83a-67fc-11f0-a516-0224a6c84d84","status.py","0c9cf8d0-67fc-11f0-a516-0224a6c84d84",466,["D",1753299268930],"from types import TracebackType\nfrom typing import Optional, Type\n\nfrom .console import Console, RenderableType\nfrom .jupyter import JupyterMixin\nfrom .live import Live\nfrom .spinner import Spinner\nfrom .style import StyleType\n\n\nclass Status(JupyterMixin):\n \"\"\"Displays a status indicator with a 'spinner' animation.\n\n Args:\n status (RenderableType): A status renderable (str or Text typically).\n console (Console, optional): Console instance to use, or None for global console. Defaults to None.\n spinner (str, optional): Name of spinner animation (see python -m rich.spinner). Defaults to \"dots\".\n spinner_style (StyleType, optional): Style of spinner. Defaults to \"status.spinner\".\n speed (float, optional): Speed factor for spinner animation. Defaults to 1.0.\n refresh_per_second (float, optional): Number of refreshes per second. Defaults to 12.5.\n \"\"\"\n\n def __init__(\n self,\n status: RenderableType,\n *,\n console: Optional[Console] = None,\n spinner: str = \"dots\",\n spinner_style: StyleType = \"status.spinner\",\n speed: float = 1.0,\n refresh_per_second: float = 12.5,\n ):\n self.status = status\n self.spinner_style = spinner_style\n self.speed = speed\n self._spinner = Spinner(spinner, text=status, style=spinner_style, speed=speed)\n self._live = Live(\n self.renderable,\n console=console,\n refresh_per_second=refresh_per_second,\n transient=True,\n )\n\n @property\n def renderable(self) -> Spinner:\n return self._spinner\n\n @property\n def console(self) -> \"Console\":\n \"\"\"Get the Console used by the Status objects.\"\"\"\n return self._live.console\n\n def update(\n self,\n status: Optional[RenderableType] = None,\n *,\n spinner: Optional[str] = None,\n spinner_style: Optional[StyleType] = None,\n speed: Optional[float] = None,\n ) -> None:\n \"\"\"Update status.\n\n Args:\n status (Optional[RenderableType], optional): New status renderable or None for no change. Defaults to None.\n spinner (Optional[str], optional): New spinner or None for no change. Defaults to None.\n spinner_style (Optional[StyleType], optional): New spinner style or None for no change. Defaults to None.\n speed (Optional[float], optional): Speed factor for spinner animation or None for no change. Defaults to None.\n \"\"\"\n if status is not None:\n self.status = status\n if spinner_style is not None:\n self.spinner_style = spinner_style\n if speed is not None:\n self.speed = speed\n if spinner is not None:\n self._spinner = Spinner(\n spinner, text=self.status, style=self.spinner_style, speed=self.speed\n )\n self._live.update(self.renderable, refresh=True)\n else:\n self._spinner.update(\n text=self.status, style=self.spinner_style, speed=self.speed\n )\n\n def start(self) -> None:\n \"\"\"Start the status animation.\"\"\"\n self._live.start()\n\n def stop(self) -> None:\n \"\"\"Stop the spinner animation.\"\"\"\n self._live.stop()\n\n def __rich__(self) -> RenderableType:\n return self.renderable\n\n def __enter__(self) -> \"Status\":\n self.start()\n return self\n\n def __exit__(\n self,\n exc_type: Optional[Type[BaseException]],\n exc_val: Optional[BaseException],\n exc_tb: Optional[TracebackType],\n ) -> None:\n self.stop()\n\n\nif __name__ == \"__main__\": # pragma: no cover\n from time import sleep\n\n from .console import Console\n\n console = Console()\n with console.status(\"[magenta]Covid detector booting up\") as status:\n sleep(3)\n console.log(\"Importing advanced AI\")\n sleep(3)\n console.log(\"Advanced Covid AI Ready\")\n sleep(3)\n status.update(status=\"[bold blue] Scanning for Covid\", spinner=\"earth\")\n sleep(3)\n console.log(\"Found 10,000,000,000 copies of Covid32.exe\")\n sleep(3)\n status.update(\n status=\"[bold red]Moving Covid32.exe to Trash\",\n spinner=\"bouncingBall\",\n spinner_style=\"yellow\",\n )\n sleep(5)\n console.print(\"[bold green]Covid deleted successfully\")\n",[],[213,919,920,921,1016,1050,1511,1585],"0c70d048-67fc-11f0-a516-0224a6c84d84","spinner.py","0c70d0fc-67fc-11f0-a516-0224a6c84d84",461,["D",1753299268654],"from typing import cast, List, Optional, TYPE_CHECKING, Union\n\nfrom ._spinners import SPINNERS\nfrom .measure import Measurement\nfrom .table import Table\nfrom .text import Text\n\nif TYPE_CHECKING:\n from .console import Console, ConsoleOptions, RenderResult, RenderableType\n from .style import StyleType\n\n\nclass Spinner:\n \"\"\"A spinner animation.\n\n Args:\n name (str): Name of spinner (run python -m rich.spinner).\n text (RenderableType, optional): A renderable to display at the right of the spinner (str or Text typically). Defaults to \"\".\n style (StyleType, optional): Style for spinner animation. Defaults to None.\n speed (float, optional): Speed factor for animation. Defaults to 1.0.\n\n Raises:\n KeyError: If name isn't one of the supported spinner animations.\n \"\"\"\n\n def __init__(\n self,\n name: str,\n text: \"RenderableType\" = \"\",\n *,\n style: Optional[\"StyleType\"] = None,\n speed: float = 1.0,\n ) -> None:\n try:\n spinner = SPINNERS[name]\n except KeyError:\n raise KeyError(f\"no spinner called {name!r}\")\n self.text: \"Union[RenderableType, Text]\" = (\n Text.from_markup(text) if isinstance(text, str) else text\n )\n self.name = name\n self.frames = cast(List[str], spinner[\"frames\"])[:]\n self.interval = cast(float, spinner[\"interval\"])\n self.start_time: Optional[float] = None\n self.style = style\n self.speed = speed\n self.frame_no_offset: float = 0.0\n self._update_speed = 0.0\n\n def __rich_console__(\n self, console: \"Console\", options: \"ConsoleOptions\"\n ) -> \"RenderResult\":\n yield self.render(console.get_time())\n\n def __rich_measure__(\n self, console: \"Console\", options: \"ConsoleOptions\"\n ) -> Measurement:\n text = self.render(0)\n return Measurement.get(console, options, text)\n\n def render(self, time: float) -> \"RenderableType\":\n \"\"\"Render the spinner for a given time.\n\n Args:\n time (float): Time in seconds.\n\n Returns:\n RenderableType: A renderable containing animation frame.\n \"\"\"\n if self.start_time is None:\n self.start_time = time\n\n frame_no = ((time - self.start_time) * self.speed) / (\n self.interval / 1000.0\n ) + self.frame_no_offset\n frame = Text(\n self.frames[int(frame_no) % len(self.frames)], style=self.style or \"\"\n )\n\n if self._update_speed:\n self.frame_no_offset = frame_no\n self.start_time = time\n self.speed = self._update_speed\n self._update_speed = 0.0\n\n if not self.text:\n return frame\n elif isinstance(self.text, (str, Text)):\n return Text.assemble(frame, \" \", self.text)\n else:\n table = Table.grid(padding=1)\n table.add_row(frame, self.text)\n return table\n\n def update(\n self,\n *,\n text: \"RenderableType\" = \"\",\n style: Optional[\"StyleType\"] = None,\n speed: Optional[float] = None,\n ) -> None:\n \"\"\"Updates attributes of a spinner after it has been started.\n\n Args:\n text (RenderableType, optional): A renderable to display at the right of the spinner (str or Text typically). Defaults to \"\".\n style (StyleType, optional): Style for spinner animation. Defaults to None.\n speed (float, optional): Speed factor for animation. Defaults to None.\n \"\"\"\n if text:\n self.text = Text.from_markup(text) if isinstance(text, str) else text\n if style:\n self.style = style\n if speed:\n self._update_speed = speed\n\n\nif __name__ == \"__main__\": # pragma: no cover\n from time import sleep\n\n from .columns import Columns\n from .panel import Panel\n from .live import Live\n\n all_spinners = Columns(\n [\n Spinner(spinner_name, text=Text(repr(spinner_name), style=\"green\"))\n for spinner_name in sorted(SPINNERS.keys())\n ],\n column_first=True,\n expand=True,\n )\n\n with Live(\n Panel(all_spinners, title=\"Spinners\", border_style=\"blue\"),\n refresh_per_second=20,\n ) as live:\n while True:\n sleep(0.1)\n",[],[213,919,920,921,1016,1050,1511,1593],"0c393b92-67fc-11f0-9454-0224a6c84d84","segment.py","0c393c3c-67fc-11f0-9454-0224a6c84d84",451,["D",1753299268290],"from enum import IntEnum\nfrom functools import lru_cache\nfrom itertools import filterfalse\nfrom logging import getLogger\nfrom operator import attrgetter\nfrom typing import (\n TYPE_CHECKING,\n Dict,\n Iterable,\n List,\n NamedTuple,\n Optional,\n Sequence,\n Tuple,\n Type,\n Union,\n)\n\nfrom .cells import (\n _is_single_cell_widths,\n cached_cell_len,\n cell_len,\n get_character_cell_size,\n set_cell_size,\n)\nfrom .repr import Result, rich_repr\nfrom .style import Style\n\nif TYPE_CHECKING:\n from .console import Console, ConsoleOptions, RenderResult\n\nlog = getLogger(\"rich\")\n\n\nclass ControlType(IntEnum):\n \"\"\"Non-printable control codes which typically translate to ANSI codes.\"\"\"\n\n BELL = 1\n CARRIAGE_RETURN = 2\n HOME = 3\n CLEAR = 4\n SHOW_CURSOR = 5\n HIDE_CURSOR = 6\n ENABLE_ALT_SCREEN = 7\n DISABLE_ALT_SCREEN = 8\n CURSOR_UP = 9\n CURSOR_DOWN = 10\n CURSOR_FORWARD = 11\n CURSOR_BACKWARD = 12\n CURSOR_MOVE_TO_COLUMN = 13\n CURSOR_MOVE_TO = 14\n ERASE_IN_LINE = 15\n SET_WINDOW_TITLE = 16\n\n\nControlCode = Union[\n Tuple[ControlType],\n Tuple[ControlType, Union[int, str]],\n Tuple[ControlType, int, int],\n]\n\n\n@rich_repr()\nclass Segment(NamedTuple):\n \"\"\"A piece of text with associated style. Segments are produced by the Console render process and\n are ultimately converted in to strings to be written to the terminal.\n\n Args:\n text (str): A piece of text.\n style (:class:`~rich.style.Style`, optional): An optional style to apply to the text.\n control (Tuple[ControlCode], optional): Optional sequence of control codes.\n\n Attributes:\n cell_length (int): The cell length of this Segment.\n \"\"\"\n\n text: str\n style: Optional[Style] = None\n control: Optional[Sequence[ControlCode]] = None\n\n @property\n def cell_length(self) -> int:\n \"\"\"The number of terminal cells required to display self.text.\n\n Returns:\n int: A number of cells.\n \"\"\"\n text, _style, control = self\n return 0 if control else cell_len(text)\n\n def __rich_repr__(self) -> Result:\n yield self.text\n if self.control is None:\n if self.style is not None:\n yield self.style\n else:\n yield self.style\n yield self.control\n\n def __bool__(self) -> bool:\n \"\"\"Check if the segment contains text.\"\"\"\n return bool(self.text)\n\n @property\n def is_control(self) -> bool:\n \"\"\"Check if the segment contains control codes.\"\"\"\n return self.control is not None\n\n @classmethod\n @lru_cache(1024 * 16)\n def _split_cells(cls, segment: \"Segment\", cut: int) -> Tuple[\"Segment\", \"Segment\"]:\n \"\"\"Split a segment in to two at a given cell position.\n\n Note that splitting a double-width character, may result in that character turning\n into two spaces.\n\n Args:\n segment (Segment): A segment to split.\n cut (int): A cell position to cut on.\n\n Returns:\n A tuple of two segments.\n \"\"\"\n text, style, control = segment\n _Segment = Segment\n cell_length = segment.cell_length\n if cut >= cell_length:\n return segment, _Segment(\"\", style, control)\n\n cell_size = get_character_cell_size\n\n pos = int((cut / cell_length) * len(text))\n\n while True:\n before = text[:pos]\n cell_pos = cell_len(before)\n out_by = cell_pos - cut\n if not out_by:\n return (\n _Segment(before, style, control),\n _Segment(text[pos:], style, control),\n )\n if out_by == -1 and cell_size(text[pos]) == 2:\n return (\n _Segment(text[:pos] + \" \", style, control),\n _Segment(\" \" + text[pos + 1 :], style, control),\n )\n if out_by == +1 and cell_size(text[pos - 1]) == 2:\n return (\n _Segment(text[: pos - 1] + \" \", style, control),\n _Segment(\" \" + text[pos:], style, control),\n )\n if cell_pos < cut:\n pos += 1\n else:\n pos -= 1\n\n def split_cells(self, cut: int) -> Tuple[\"Segment\", \"Segment\"]:\n \"\"\"Split segment in to two segments at the specified column.\n\n If the cut point falls in the middle of a 2-cell wide character then it is replaced\n by two spaces, to preserve the display width of the parent segment.\n\n Args:\n cut (int): Offset within the segment to cut.\n\n Returns:\n Tuple[Segment, Segment]: Two segments.\n \"\"\"\n text, style, control = self\n assert cut >= 0\n\n if _is_single_cell_widths(text):\n # Fast path with all 1 cell characters\n if cut >= len(text):\n return self, Segment(\"\", style, control)\n return (\n Segment(text[:cut], style, control),\n Segment(text[cut:], style, control),\n )\n\n return self._split_cells(self, cut)\n\n @classmethod\n def line(cls) -> \"Segment\":\n \"\"\"Make a new line segment.\"\"\"\n return cls(\"\\n\")\n\n @classmethod\n def apply_style(\n cls,\n segments: Iterable[\"Segment\"],\n style: Optional[Style] = None,\n post_style: Optional[Style] = None,\n ) -> Iterable[\"Segment\"]:\n \"\"\"Apply style(s) to an iterable of segments.\n\n Returns an iterable of segments where the style is replaced by ``style + segment.style + post_style``.\n\n Args:\n segments (Iterable[Segment]): Segments to process.\n style (Style, optional): Base style. Defaults to None.\n post_style (Style, optional): Style to apply on top of segment style. Defaults to None.\n\n Returns:\n Iterable[Segments]: A new iterable of segments (possibly the same iterable).\n \"\"\"\n result_segments = segments\n if style:\n apply = style.__add__\n result_segments = (\n cls(text, None if control else apply(_style), control)\n for text, _style, control in result_segments\n )\n if post_style:\n result_segments = (\n cls(\n text,\n (\n None\n if control\n else (_style + post_style if _style else post_style)\n ),\n control,\n )\n for text, _style, control in result_segments\n )\n return result_segments\n\n @classmethod\n def filter_control(\n cls, segments: Iterable[\"Segment\"], is_control: bool = False\n ) -> Iterable[\"Segment\"]:\n \"\"\"Filter segments by ``is_control`` attribute.\n\n Args:\n segments (Iterable[Segment]): An iterable of Segment instances.\n is_control (bool, optional): is_control flag to match in search.\n\n Returns:\n Iterable[Segment]: And iterable of Segment instances.\n\n \"\"\"\n if is_control:\n return filter(attrgetter(\"control\"), segments)\n else:\n return filterfalse(attrgetter(\"control\"), segments)\n\n @classmethod\n def split_lines(cls, segments: Iterable[\"Segment\"]) -> Iterable[List[\"Segment\"]]:\n \"\"\"Split a sequence of segments in to a list of lines.\n\n Args:\n segments (Iterable[Segment]): Segments potentially containing line feeds.\n\n Yields:\n Iterable[List[Segment]]: Iterable of segment lists, one per line.\n \"\"\"\n line: List[Segment] = []\n append = line.append\n\n for segment in segments:\n if \"\\n\" in segment.text and not segment.control:\n text, style, _ = segment\n while text:\n _text, new_line, text = text.partition(\"\\n\")\n if _text:\n append(cls(_text, style))\n if new_line:\n yield line\n line = []\n append = line.append\n else:\n append(segment)\n if line:\n yield line\n\n @classmethod\n def split_and_crop_lines(\n cls,\n segments: Iterable[\"Segment\"],\n length: int,\n style: Optional[Style] = None,\n pad: bool = True,\n include_new_lines: bool = True,\n ) -> Iterable[List[\"Segment\"]]:\n \"\"\"Split segments in to lines, and crop lines greater than a given length.\n\n Args:\n segments (Iterable[Segment]): An iterable of segments, probably\n generated from console.render.\n length (int): Desired line length.\n style (Style, optional): Style to use for any padding.\n pad (bool): Enable padding of lines that are less than `length`.\n\n Returns:\n Iterable[List[Segment]]: An iterable of lines of segments.\n \"\"\"\n line: List[Segment] = []\n append = line.append\n\n adjust_line_length = cls.adjust_line_length\n new_line_segment = cls(\"\\n\")\n\n for segment in segments:\n if \"\\n\" in segment.text and not segment.control:\n text, segment_style, _ = segment\n while text:\n _text, new_line, text = text.partition(\"\\n\")\n if _text:\n append(cls(_text, segment_style))\n if new_line:\n cropped_line = adjust_line_length(\n line, length, style=style, pad=pad\n )\n if include_new_lines:\n cropped_line.append(new_line_segment)\n yield cropped_line\n line.clear()\n else:\n append(segment)\n if line:\n yield adjust_line_length(line, length, style=style, pad=pad)\n\n @classmethod\n def adjust_line_length(\n cls,\n line: List[\"Segment\"],\n length: int,\n style: Optional[Style] = None,\n pad: bool = True,\n ) -> List[\"Segment\"]:\n \"\"\"Adjust a line to a given width (cropping or padding as required).\n\n Args:\n segments (Iterable[Segment]): A list of segments in a single line.\n length (int): The desired width of the line.\n style (Style, optional): The style of padding if used (space on the end). Defaults to None.\n pad (bool, optional): Pad lines with spaces if they are shorter than `length`. Defaults to True.\n\n Returns:\n List[Segment]: A line of segments with the desired length.\n \"\"\"\n line_length = sum(segment.cell_length for segment in line)\n new_line: List[Segment]\n\n if line_length < length:\n if pad:\n new_line = line + [cls(\" \" * (length - line_length), style)]\n else:\n new_line = line[:]\n elif line_length > length:\n new_line = []\n append = new_line.append\n line_length = 0\n for segment in line:\n segment_length = segment.cell_length\n if line_length + segment_length < length or segment.control:\n append(segment)\n line_length += segment_length\n else:\n text, segment_style, _ = segment\n text = set_cell_size(text, length - line_length)\n append(cls(text, segment_style))\n break\n else:\n new_line = line[:]\n return new_line\n\n @classmethod\n def get_line_length(cls, line: List[\"Segment\"]) -> int:\n \"\"\"Get the length of list of segments.\n\n Args:\n line (List[Segment]): A line encoded as a list of Segments (assumes no '\\\\\\\\n' characters),\n\n Returns:\n int: The length of the line.\n \"\"\"\n _cell_len = cell_len\n return sum(_cell_len(text) for text, style, control in line if not control)\n\n @classmethod\n def get_shape(cls, lines: List[List[\"Segment\"]]) -> Tuple[int, int]:\n \"\"\"Get the shape (enclosing rectangle) of a list of lines.\n\n Args:\n lines (List[List[Segment]]): A list of lines (no '\\\\\\\\n' characters).\n\n Returns:\n Tuple[int, int]: Width and height in characters.\n \"\"\"\n get_line_length = cls.get_line_length\n max_width = max(get_line_length(line) for line in lines) if lines else 0\n return (max_width, len(lines))\n\n @classmethod\n def set_shape(\n cls,\n lines: List[List[\"Segment\"]],\n width: int,\n height: Optional[int] = None,\n style: Optional[Style] = None,\n new_lines: bool = False,\n ) -> List[List[\"Segment\"]]:\n \"\"\"Set the shape of a list of lines (enclosing rectangle).\n\n Args:\n lines (List[List[Segment]]): A list of lines.\n width (int): Desired width.\n height (int, optional): Desired height or None for no change.\n style (Style, optional): Style of any padding added.\n new_lines (bool, optional): Padded lines should include \"\\n\". Defaults to False.\n\n Returns:\n List[List[Segment]]: New list of lines.\n \"\"\"\n _height = height or len(lines)\n\n blank = (\n [cls(\" \" * width + \"\\n\", style)] if new_lines else [cls(\" \" * width, style)]\n )\n\n adjust_line_length = cls.adjust_line_length\n shaped_lines = lines[:_height]\n shaped_lines[:] = [\n adjust_line_length(line, width, style=style) for line in lines\n ]\n if len(shaped_lines) < _height:\n shaped_lines.extend([blank] * (_height - len(shaped_lines)))\n return shaped_lines\n\n @classmethod\n def align_top(\n cls: Type[\"Segment\"],\n lines: List[List[\"Segment\"]],\n width: int,\n height: int,\n style: Style,\n new_lines: bool = False,\n ) -> List[List[\"Segment\"]]:\n \"\"\"Aligns lines to top (adds extra lines to bottom as required).\n\n Args:\n lines (List[List[Segment]]): A list of lines.\n width (int): Desired width.\n height (int, optional): Desired height or None for no change.\n style (Style): Style of any padding added.\n new_lines (bool, optional): Padded lines should include \"\\n\". Defaults to False.\n\n Returns:\n List[List[Segment]]: New list of lines.\n \"\"\"\n extra_lines = height - len(lines)\n if not extra_lines:\n return lines[:]\n lines = lines[:height]\n blank = cls(\" \" * width + \"\\n\", style) if new_lines else cls(\" \" * width, style)\n lines = lines + [[blank]] * extra_lines\n return lines\n\n @classmethod\n def align_bottom(\n cls: Type[\"Segment\"],\n lines: List[List[\"Segment\"]],\n width: int,\n height: int,\n style: Style,\n new_lines: bool = False,\n ) -> List[List[\"Segment\"]]:\n \"\"\"Aligns render to bottom (adds extra lines above as required).\n\n Args:\n lines (List[List[Segment]]): A list of lines.\n width (int): Desired width.\n height (int, optional): Desired height or None for no change.\n style (Style): Style of any padding added. Defaults to None.\n new_lines (bool, optional): Padded lines should include \"\\n\". Defaults to False.\n\n Returns:\n List[List[Segment]]: New list of lines.\n \"\"\"\n extra_lines = height - len(lines)\n if not extra_lines:\n return lines[:]\n lines = lines[:height]\n blank = cls(\" \" * width + \"\\n\", style) if new_lines else cls(\" \" * width, style)\n lines = [[blank]] * extra_lines + lines\n return lines\n\n @classmethod\n def align_middle(\n cls: Type[\"Segment\"],\n lines: List[List[\"Segment\"]],\n width: int,\n height: int,\n style: Style,\n new_lines: bool = False,\n ) -> List[List[\"Segment\"]]:\n \"\"\"Aligns lines to middle (adds extra lines to above and below as required).\n\n Args:\n lines (List[List[Segment]]): A list of lines.\n width (int): Desired width.\n height (int, optional): Desired height or None for no change.\n style (Style): Style of any padding added.\n new_lines (bool, optional): Padded lines should include \"\\n\". Defaults to False.\n\n Returns:\n List[List[Segment]]: New list of lines.\n \"\"\"\n extra_lines = height - len(lines)\n if not extra_lines:\n return lines[:]\n lines = lines[:height]\n blank = cls(\" \" * width + \"\\n\", style) if new_lines else cls(\" \" * width, style)\n top_lines = extra_lines // 2\n bottom_lines = extra_lines - top_lines\n lines = [[blank]] * top_lines + lines + [[blank]] * bottom_lines\n return lines\n\n @classmethod\n def simplify(cls, segments: Iterable[\"Segment\"]) -> Iterable[\"Segment\"]:\n \"\"\"Simplify an iterable of segments by combining contiguous segments with the same style.\n\n Args:\n segments (Iterable[Segment]): An iterable of segments.\n\n Returns:\n Iterable[Segment]: A possibly smaller iterable of segments that will render the same way.\n \"\"\"\n iter_segments = iter(segments)\n try:\n last_segment = next(iter_segments)\n except StopIteration:\n return\n\n _Segment = Segment\n for segment in iter_segments:\n if last_segment.style == segment.style and not segment.control:\n last_segment = _Segment(\n last_segment.text + segment.text, last_segment.style\n )\n else:\n yield last_segment\n last_segment = segment\n yield last_segment\n\n @classmethod\n def strip_links(cls, segments: Iterable[\"Segment\"]) -> Iterable[\"Segment\"]:\n \"\"\"Remove all links from an iterable of styles.\n\n Args:\n segments (Iterable[Segment]): An iterable segments.\n\n Yields:\n Segment: Segments with link removed.\n \"\"\"\n for segment in segments:\n if segment.control or segment.style is None:\n yield segment\n else:\n text, style, _control = segment\n yield cls(text, style.update_link(None) if style else None)\n\n @classmethod\n def strip_styles(cls, segments: Iterable[\"Segment\"]) -> Iterable[\"Segment\"]:\n \"\"\"Remove all styles from an iterable of segments.\n\n Args:\n segments (Iterable[Segment]): An iterable segments.\n\n Yields:\n Segment: Segments with styles replace with None\n \"\"\"\n for text, _style, control in segments:\n yield cls(text, None, control)\n\n @classmethod\n def remove_color(cls, segments: Iterable[\"Segment\"]) -> Iterable[\"Segment\"]:\n \"\"\"Remove all color from an iterable of segments.\n\n Args:\n segments (Iterable[Segment]): An iterable segments.\n\n Yields:\n Segment: Segments with colorless style.\n \"\"\"\n\n cache: Dict[Style, Style] = {}\n for text, style, control in segments:\n if style:\n colorless_style = cache.get(style)\n if colorless_style is None:\n colorless_style = style.without_color\n cache[style] = colorless_style\n yield cls(text, colorless_style, control)\n else:\n yield cls(text, None, control)\n\n @classmethod\n def divide(\n cls, segments: Iterable[\"Segment\"], cuts: Iterable[int]\n ) -> Iterable[List[\"Segment\"]]:\n \"\"\"Divides an iterable of segments in to portions.\n\n Args:\n cuts (Iterable[int]): Cell positions where to divide.\n\n Yields:\n [Iterable[List[Segment]]]: An iterable of Segments in List.\n \"\"\"\n split_segments: List[\"Segment\"] = []\n add_segment = split_segments.append\n\n iter_cuts = iter(cuts)\n\n while True:\n cut = next(iter_cuts, -1)\n if cut == -1:\n return\n if cut != 0:\n break\n yield []\n pos = 0\n\n segments_clear = split_segments.clear\n segments_copy = split_segments.copy\n\n _cell_len = cached_cell_len\n for segment in segments:\n text, _style, control = segment\n while text:\n end_pos = pos if control else pos + _cell_len(text)\n if end_pos < cut:\n add_segment(segment)\n pos = end_pos\n break\n\n if end_pos == cut:\n add_segment(segment)\n yield segments_copy()\n segments_clear()\n pos = end_pos\n\n cut = next(iter_cuts, -1)\n if cut == -1:\n if split_segments:\n yield segments_copy()\n return\n\n break\n\n else:\n before, segment = segment.split_cells(cut - pos)\n text, _style, control = segment\n add_segment(before)\n yield segments_copy()\n segments_clear()\n pos = cut\n\n cut = next(iter_cuts, -1)\n if cut == -1:\n if split_segments:\n yield segments_copy()\n return\n\n yield segments_copy()\n\n\nclass Segments:\n \"\"\"A simple renderable to render an iterable of segments. This class may be useful if\n you want to print segments outside of a __rich_console__ method.\n\n Args:\n segments (Iterable[Segment]): An iterable of segments.\n new_lines (bool, optional): Add new lines between segments. Defaults to False.\n \"\"\"\n\n def __init__(self, segments: Iterable[Segment], new_lines: bool = False) -> None:\n self.segments = list(segments)\n self.new_lines = new_lines\n\n def __rich_console__(\n self, console: \"Console\", options: \"ConsoleOptions\"\n ) -> \"RenderResult\":\n if self.new_lines:\n line = Segment.line()\n for segment in self.segments:\n yield segment\n yield line\n else:\n yield from self.segments\n\n\nclass SegmentLines:\n def __init__(self, lines: Iterable[List[Segment]], new_lines: bool = False) -> None:\n \"\"\"A simple renderable containing a number of lines of segments. May be used as an intermediate\n in rendering process.\n\n Args:\n lines (Iterable[List[Segment]]): Lists of segments forming lines.\n new_lines (bool, optional): Insert new lines after each line. Defaults to False.\n \"\"\"\n self.lines = list(lines)\n self.new_lines = new_lines\n\n def __rich_console__(\n self, console: \"Console\", options: \"ConsoleOptions\"\n ) -> \"RenderResult\":\n if self.new_lines:\n new_line = Segment.line()\n for line in self.lines:\n yield from line\n yield new_line\n else:\n for line in self.lines:\n yield from line\n\n\nif __name__ == \"__main__\": # pragma: no cover\n from pip._vendor.rich.console import Console\n from pip._vendor.rich.syntax import Syntax\n from pip._vendor.rich.text import Text\n\n code = \"\"\"from rich.console import Console\nconsole = Console()\ntext = Text.from_markup(\"Hello, [bold magenta]World[/]!\")\nconsole.print(text)\"\"\"\n\n text = Text.from_markup(\"Hello, [bold magenta]World[/]!\")\n\n console = Console()\n\n console.rule(\"rich.Segment\")\n console.print(\n \"A Segment is the last step in the Rich render process before generating text with ANSI codes.\"\n )\n console.print(\"\\nConsider the following code:\\n\")\n console.print(Syntax(code, \"python\", line_numbers=True))\n console.print()\n console.print(\n \"When you call [b]print()[/b], Rich [i]renders[/i] the object in to the following:\\n\"\n )\n fragments = list(console.render(text))\n console.print(fragments)\n console.print()\n console.print(\"The Segments are then processed to produce the following output:\\n\")\n console.print(text)\n console.print(\n \"\\nYou will only need to know this if you are implementing your own Rich renderables.\"\n )\n",[],[213,919,920,921,1016,1050,1511,1601],"0af13758-67fc-11f0-9ad5-0224a6c84d84","screen.py","0af1383e-67fc-11f0-9ad5-0224a6c84d84",399,["D",1753299266062],"from typing import Optional, TYPE_CHECKING\n\nfrom .segment import Segment\nfrom .style import StyleType\nfrom ._loop import loop_last\n\n\nif TYPE_CHECKING:\n from .console import (\n Console,\n ConsoleOptions,\n RenderResult,\n RenderableType,\n Group,\n )\n\n\nclass Screen:\n \"\"\"A renderable that fills the terminal screen and crops excess.\n\n Args:\n renderable (RenderableType): Child renderable.\n style (StyleType, optional): Optional background style. Defaults to None.\n \"\"\"\n\n renderable: \"RenderableType\"\n\n def __init__(\n self,\n *renderables: \"RenderableType\",\n style: Optional[StyleType] = None,\n application_mode: bool = False,\n ) -> None:\n from pip._vendor.rich.console import Group\n\n self.renderable = Group(*renderables)\n self.style = style\n self.application_mode = application_mode\n\n def __rich_console__(\n self, console: \"Console\", options: \"ConsoleOptions\"\n ) -> \"RenderResult\":\n width, height = options.size\n style = console.get_style(self.style) if self.style else None\n render_options = options.update(width=width, height=height)\n lines = console.render_lines(\n self.renderable or \"\", render_options, style=style, pad=True\n )\n lines = Segment.set_shape(lines, width, height, style=style)\n new_line = Segment(\"\\n\\r\") if self.application_mode else Segment.line()\n for last, line in loop_last(lines):\n yield from line\n if not last:\n yield new_line\n",[],[213,919,920,921,1016,1050,1511,1609],"0c9973e0-67fc-11f0-95df-0224a6c84d84","scope.py","0c9974a8-67fc-11f0-95df-0224a6c84d84",465,["D",1753299268842],"from collections.abc import Mapping\nfrom typing import TYPE_CHECKING, Any, Optional, Tuple\n\nfrom .highlighter import ReprHighlighter\nfrom .panel import Panel\nfrom .pretty import Pretty\nfrom .table import Table\nfrom .text import Text, TextType\n\nif TYPE_CHECKING:\n from .console import ConsoleRenderable\n\n\ndef render_scope(\n scope: \"Mapping[str, Any]\",\n *,\n title: Optional[TextType] = None,\n sort_keys: bool = True,\n indent_guides: bool = False,\n max_length: Optional[int] = None,\n max_string: Optional[int] = None,\n) -> \"ConsoleRenderable\":\n \"\"\"Render python variables in a given scope.\n\n Args:\n scope (Mapping): A mapping containing variable names and values.\n title (str, optional): Optional title. Defaults to None.\n sort_keys (bool, optional): Enable sorting of items. Defaults to True.\n indent_guides (bool, optional): Enable indentation guides. Defaults to False.\n max_length (int, optional): Maximum length of containers before abbreviating, or None for no abbreviation.\n Defaults to None.\n max_string (int, optional): Maximum length of string before truncating, or None to disable. Defaults to None.\n\n Returns:\n ConsoleRenderable: A renderable object.\n \"\"\"\n highlighter = ReprHighlighter()\n items_table = Table.grid(padding=(0, 1), expand=False)\n items_table.add_column(justify=\"right\")\n\n def sort_items(item: Tuple[str, Any]) -> Tuple[bool, str]:\n \"\"\"Sort special variables first, then alphabetically.\"\"\"\n key, _ = item\n return (not key.startswith(\"__\"), key.lower())\n\n items = sorted(scope.items(), key=sort_items) if sort_keys else scope.items()\n for key, value in items:\n key_text = Text.assemble(\n (key, \"scope.key.special\" if key.startswith(\"__\") else \"scope.key\"),\n (\" =\", \"scope.equals\"),\n )\n items_table.add_row(\n key_text,\n Pretty(\n value,\n highlighter=highlighter,\n indent_guides=indent_guides,\n max_length=max_length,\n max_string=max_string,\n ),\n )\n return Panel.fit(\n items_table,\n title=title,\n border_style=\"scope.border\",\n padding=(0, 1),\n )\n\n\nif __name__ == \"__main__\": # pragma: no cover\n from pip._vendor.rich import print\n\n print()\n\n def test(foo: float, bar: float) -> None:\n list_of_things = [1, 2, 3, None, 4, True, False, \"Hello World\"]\n dict_of_things = {\n \"version\": \"1.1\",\n \"method\": \"confirmFruitPurchase\",\n \"params\": [[\"apple\", \"orange\", \"mangoes\", \"pomelo\"], 1.123],\n \"id\": \"194521489\",\n }\n print(render_scope(locals(), title=\"[i]locals\", sort_keys=False))\n\n test(20.3423, 3.1427)\n print()\n",[],[213,919,920,921,1016,1050,1511,1617],"0bcfe2d2-67fc-11f0-aad3-0224a6c84d84","rule.py","0bcfe3a4-67fc-11f0-aad3-0224a6c84d84",436,["D",1753299267601],"from typing import Union\n\nfrom .align import AlignMethod\nfrom .cells import cell_len, set_cell_size\nfrom .console import Console, ConsoleOptions, RenderResult\nfrom .jupyter import JupyterMixin\nfrom .measure import Measurement\nfrom .style import Style\nfrom .text import Text\n\n\nclass Rule(JupyterMixin):\n \"\"\"A console renderable to draw a horizontal rule (line).\n\n Args:\n title (Union[str, Text], optional): Text to render in the rule. Defaults to \"\".\n characters (str, optional): Character(s) used to draw the line. Defaults to \"─\".\n style (StyleType, optional): Style of Rule. Defaults to \"rule.line\".\n end (str, optional): Character at end of Rule. defaults to \"\\\\\\\\n\"\n align (str, optional): How to align the title, one of \"left\", \"center\", or \"right\". Defaults to \"center\".\n \"\"\"\n\n def __init__(\n self,\n title: Union[str, Text] = \"\",\n *,\n characters: str = \"─\",\n style: Union[str, Style] = \"rule.line\",\n end: str = \"\\n\",\n align: AlignMethod = \"center\",\n ) -> None:\n if cell_len(characters) < 1:\n raise ValueError(\n \"'characters' argument must have a cell width of at least 1\"\n )\n if align not in (\"left\", \"center\", \"right\"):\n raise ValueError(\n f'invalid value for align, expected \"left\", \"center\", \"right\" (not {align!r})'\n )\n self.title = title\n self.characters = characters\n self.style = style\n self.end = end\n self.align = align\n\n def __repr__(self) -> str:\n return f\"Rule({self.title!r}, {self.characters!r})\"\n\n def __rich_console__(\n self, console: Console, options: ConsoleOptions\n ) -> RenderResult:\n width = options.max_width\n\n characters = (\n \"-\"\n if (options.ascii_only and not self.characters.isascii())\n else self.characters\n )\n\n chars_len = cell_len(characters)\n if not self.title:\n yield self._rule_line(chars_len, width)\n return\n\n if isinstance(self.title, Text):\n title_text = self.title\n else:\n title_text = console.render_str(self.title, style=\"rule.text\")\n\n title_text.plain = title_text.plain.replace(\"\\n\", \" \")\n title_text.expand_tabs()\n\n required_space = 4 if self.align == \"center\" else 2\n truncate_width = max(0, width - required_space)\n if not truncate_width:\n yield self._rule_line(chars_len, width)\n return\n\n rule_text = Text(end=self.end)\n if self.align == \"center\":\n title_text.truncate(truncate_width, overflow=\"ellipsis\")\n side_width = (width - cell_len(title_text.plain)) // 2\n left = Text(characters * (side_width // chars_len + 1))\n left.truncate(side_width - 1)\n right_length = width - cell_len(left.plain) - cell_len(title_text.plain)\n right = Text(characters * (side_width // chars_len + 1))\n right.truncate(right_length)\n rule_text.append(left.plain + \" \", self.style)\n rule_text.append(title_text)\n rule_text.append(\" \" + right.plain, self.style)\n elif self.align == \"left\":\n title_text.truncate(truncate_width, overflow=\"ellipsis\")\n rule_text.append(title_text)\n rule_text.append(\" \")\n rule_text.append(characters * (width - rule_text.cell_len), self.style)\n elif self.align == \"right\":\n title_text.truncate(truncate_width, overflow=\"ellipsis\")\n rule_text.append(characters * (width - title_text.cell_len - 1), self.style)\n rule_text.append(\" \")\n rule_text.append(title_text)\n\n rule_text.plain = set_cell_size(rule_text.plain, width)\n yield rule_text\n\n def _rule_line(self, chars_len: int, width: int) -> Text:\n rule_text = Text(self.characters * ((width // chars_len) + 1), self.style)\n rule_text.truncate(width)\n rule_text.plain = set_cell_size(rule_text.plain, width)\n return rule_text\n\n def __rich_measure__(\n self, console: Console, options: ConsoleOptions\n ) -> Measurement:\n return Measurement(1, 1)\n\n\nif __name__ == \"__main__\": # pragma: no cover\n import sys\n\n from pip._vendor.rich.console import Console\n\n try:\n text = sys.argv[1]\n except IndexError:\n text = \"Hello, World\"\n console = Console()\n console.print(Rule(title=text))\n\n console = Console()\n console.print(Rule(\"foo\"), width=4)\n",[],[213,919,920,921,1016,1050,1511,1625],"0bb5593a-67fc-11f0-aad3-0224a6c84d84","repr.py","0bb55a2a-67fc-11f0-aad3-0224a6c84d84",431,["D",1753299267427],"import inspect\nfrom functools import partial\nfrom typing import (\n Any,\n Callable,\n Iterable,\n List,\n Optional,\n Tuple,\n Type,\n TypeVar,\n Union,\n overload,\n)\n\nT = TypeVar(\"T\")\n\n\nResult = Iterable[Union[Any, Tuple[Any], Tuple[str, Any], Tuple[str, Any, Any]]]\nRichReprResult = Result\n\n\nclass ReprError(Exception):\n \"\"\"An error occurred when attempting to build a repr.\"\"\"\n\n\n@overload\ndef auto(cls: Optional[Type[T]]) -> Type[T]:\n ...\n\n\n@overload\ndef auto(*, angular: bool = False) -> Callable[[Type[T]], Type[T]]:\n ...\n\n\ndef auto(\n cls: Optional[Type[T]] = None, *, angular: Optional[bool] = None\n) -> Union[Type[T], Callable[[Type[T]], Type[T]]]:\n \"\"\"Class decorator to create __repr__ from __rich_repr__\"\"\"\n\n def do_replace(cls: Type[T], angular: Optional[bool] = None) -> Type[T]:\n def auto_repr(self: T) -> str:\n \"\"\"Create repr string from __rich_repr__\"\"\"\n repr_str: List[str] = []\n append = repr_str.append\n\n angular: bool = getattr(self.__rich_repr__, \"angular\", False) # type: ignore[attr-defined]\n for arg in self.__rich_repr__(): # type: ignore[attr-defined]\n if isinstance(arg, tuple):\n if len(arg) == 1:\n append(repr(arg[0]))\n else:\n key, value, *default = arg\n if key is None:\n append(repr(value))\n else:\n if default and default[0] == value:\n continue\n append(f\"{key}={value!r}\")\n else:\n append(repr(arg))\n if angular:\n return f\"<{self.__class__.__name__} {' '.join(repr_str)}>\"\n else:\n return f\"{self.__class__.__name__}({', '.join(repr_str)})\"\n\n def auto_rich_repr(self: Type[T]) -> Result:\n \"\"\"Auto generate __rich_rep__ from signature of __init__\"\"\"\n try:\n signature = inspect.signature(self.__init__)\n for name, param in signature.parameters.items():\n if param.kind == param.POSITIONAL_ONLY:\n yield getattr(self, name)\n elif param.kind in (\n param.POSITIONAL_OR_KEYWORD,\n param.KEYWORD_ONLY,\n ):\n if param.default is param.empty:\n yield getattr(self, param.name)\n else:\n yield param.name, getattr(self, param.name), param.default\n except Exception as error:\n raise ReprError(\n f\"Failed to auto generate __rich_repr__; {error}\"\n ) from None\n\n if not hasattr(cls, \"__rich_repr__\"):\n auto_rich_repr.__doc__ = \"Build a rich repr\"\n cls.__rich_repr__ = auto_rich_repr # type: ignore[attr-defined]\n\n auto_repr.__doc__ = \"Return repr(self)\"\n cls.__repr__ = auto_repr # type: ignore[assignment]\n if angular is not None:\n cls.__rich_repr__.angular = angular # type: ignore[attr-defined]\n return cls\n\n if cls is None:\n return partial(do_replace, angular=angular)\n else:\n return do_replace(cls, angular=angular)\n\n\n@overload\ndef rich_repr(cls: Optional[Type[T]]) -> Type[T]:\n ...\n\n\n@overload\ndef rich_repr(*, angular: bool = False) -> Callable[[Type[T]], Type[T]]:\n ...\n\n\ndef rich_repr(\n cls: Optional[Type[T]] = None, *, angular: bool = False\n) -> Union[Type[T], Callable[[Type[T]], Type[T]]]:\n if cls is None:\n return auto(angular=angular)\n else:\n return auto(cls)\n\n\nif __name__ == \"__main__\":\n\n @auto\n class Foo:\n def __rich_repr__(self) -> Result:\n yield \"foo\"\n yield \"bar\", {\"shopping\": [\"eggs\", \"ham\", \"pineapple\"]}\n yield \"buy\", \"hand sanitizer\"\n\n foo = Foo()\n from pip._vendor.rich.console import Console\n\n console = Console()\n\n console.rule(\"Standard repr\")\n console.print(foo)\n\n console.print(foo, width=60)\n console.print(foo, width=30)\n\n console.rule(\"Angular repr\")\n Foo.__rich_repr__.angular = True # type: ignore[attr-defined]\n\n console.print(foo)\n\n console.print(foo, width=60)\n console.print(foo, width=30)\n",[],[213,919,920,921,1016,1050,1511,1633],"0b6e2c54-67fc-11f0-a319-0224a6c84d84","region.py","0b6e2d12-67fc-11f0-a319-0224a6c84d84",419,["D",1753299266946],"from typing import NamedTuple\n\n\nclass Region(NamedTuple):\n \"\"\"Defines a rectangular region of the screen.\"\"\"\n\n x: int\n y: int\n width: int\n height: int\n",[],[213,919,920,921,1016,1050,1511,1641],"0b69e7ca-67fc-11f0-aad3-0224a6c84d84","protocol.py","0b69e96e-67fc-11f0-aad3-0224a6c84d84",418,["D",1753299266933],"from typing import Any, cast, Set, TYPE_CHECKING\nfrom inspect import isclass\n\nif TYPE_CHECKING:\n from pip._vendor.rich.console import RenderableType\n\n_GIBBERISH = \"\"\"aihwerij235234ljsdnp34ksodfipwoe234234jlskjdf\"\"\"\n\n\ndef is_renderable(check_object: Any) -> bool:\n \"\"\"Check if an object may be rendered by Rich.\"\"\"\n return (\n isinstance(check_object, str)\n or hasattr(check_object, \"__rich__\")\n or hasattr(check_object, \"__rich_console__\")\n )\n\n\ndef rich_cast(renderable: object) -> \"RenderableType\":\n \"\"\"Cast an object to a renderable by calling __rich__ if present.\n\n Args:\n renderable (object): A potentially renderable object\n\n Returns:\n object: The result of recursively calling __rich__.\n \"\"\"\n from pip._vendor.rich.console import RenderableType\n\n rich_visited_set: Set[type] = set() # Prevent potential infinite loop\n while hasattr(renderable, \"__rich__\") and not isclass(renderable):\n # Detect object which claim to have all the attributes\n if hasattr(renderable, _GIBBERISH):\n return repr(renderable)\n cast_method = getattr(renderable, \"__rich__\")\n renderable = cast_method()\n renderable_type = type(renderable)\n if renderable_type in rich_visited_set:\n break\n rich_visited_set.add(renderable_type)\n\n return cast(RenderableType, renderable)\n",[],[213,919,920,921,1016,1050,1511,1649],"0c25f884-67fc-11f0-8d4e-0224a6c84d84","prompt.py","0c25f960-67fc-11f0-8d4e-0224a6c84d84",449,["D",1753299268153],"from typing import Any, Generic, List, Optional, TextIO, TypeVar, Union, overload\n\nfrom . import get_console\nfrom .console import Console\nfrom .text import Text, TextType\n\nPromptType = TypeVar(\"PromptType\")\nDefaultType = TypeVar(\"DefaultType\")\n\n\nclass PromptError(Exception):\n \"\"\"Exception base class for prompt related errors.\"\"\"\n\n\nclass InvalidResponse(PromptError):\n \"\"\"Exception to indicate a response was invalid. Raise this within process_response() to indicate an error\n and provide an error message.\n\n Args:\n message (Union[str, Text]): Error message.\n \"\"\"\n\n def __init__(self, message: TextType) -> None:\n self.message = message\n\n def __rich__(self) -> TextType:\n return self.message\n\n\nclass PromptBase(Generic[PromptType]):\n \"\"\"Ask the user for input until a valid response is received. This is the base class, see one of\n the concrete classes for examples.\n\n Args:\n prompt (TextType, optional): Prompt text. Defaults to \"\".\n console (Console, optional): A Console instance or None to use global console. Defaults to None.\n password (bool, optional): Enable password input. Defaults to False.\n choices (List[str], optional): A list of valid choices. Defaults to None.\n case_sensitive (bool, optional): Matching of choices should be case-sensitive. Defaults to True.\n show_default (bool, optional): Show default in prompt. Defaults to True.\n show_choices (bool, optional): Show choices in prompt. Defaults to True.\n \"\"\"\n\n response_type: type = str\n\n validate_error_message = \"[prompt.invalid]Please enter a valid value\"\n illegal_choice_message = (\n \"[prompt.invalid.choice]Please select one of the available options\"\n )\n prompt_suffix = \": \"\n\n choices: Optional[List[str]] = None\n\n def __init__(\n self,\n prompt: TextType = \"\",\n *,\n console: Optional[Console] = None,\n password: bool = False,\n choices: Optional[List[str]] = None,\n case_sensitive: bool = True,\n show_default: bool = True,\n show_choices: bool = True,\n ) -> None:\n self.console = console or get_console()\n self.prompt = (\n Text.from_markup(prompt, style=\"prompt\")\n if isinstance(prompt, str)\n else prompt\n )\n self.password = password\n if choices is not None:\n self.choices = choices\n self.case_sensitive = case_sensitive\n self.show_default = show_default\n self.show_choices = show_choices\n\n @classmethod\n @overload\n def ask(\n cls,\n prompt: TextType = \"\",\n *,\n console: Optional[Console] = None,\n password: bool = False,\n choices: Optional[List[str]] = None,\n case_sensitive: bool = True,\n show_default: bool = True,\n show_choices: bool = True,\n default: DefaultType,\n stream: Optional[TextIO] = None,\n ) -> Union[DefaultType, PromptType]:\n ...\n\n @classmethod\n @overload\n def ask(\n cls,\n prompt: TextType = \"\",\n *,\n console: Optional[Console] = None,\n password: bool = False,\n choices: Optional[List[str]] = None,\n case_sensitive: bool = True,\n show_default: bool = True,\n show_choices: bool = True,\n stream: Optional[TextIO] = None,\n ) -> PromptType:\n ...\n\n @classmethod\n def ask(\n cls,\n prompt: TextType = \"\",\n *,\n console: Optional[Console] = None,\n password: bool = False,\n choices: Optional[List[str]] = None,\n case_sensitive: bool = True,\n show_default: bool = True,\n show_choices: bool = True,\n default: Any = ...,\n stream: Optional[TextIO] = None,\n ) -> Any:\n \"\"\"Shortcut to construct and run a prompt loop and return the result.\n\n Example:\n >>> filename = Prompt.ask(\"Enter a filename\")\n\n Args:\n prompt (TextType, optional): Prompt text. Defaults to \"\".\n console (Console, optional): A Console instance or None to use global console. Defaults to None.\n password (bool, optional): Enable password input. Defaults to False.\n choices (List[str], optional): A list of valid choices. Defaults to None.\n case_sensitive (bool, optional): Matching of choices should be case-sensitive. Defaults to True.\n show_default (bool, optional): Show default in prompt. Defaults to True.\n show_choices (bool, optional): Show choices in prompt. Defaults to True.\n stream (TextIO, optional): Optional text file open for reading to get input. Defaults to None.\n \"\"\"\n _prompt = cls(\n prompt,\n console=console,\n password=password,\n choices=choices,\n case_sensitive=case_sensitive,\n show_default=show_default,\n show_choices=show_choices,\n )\n return _prompt(default=default, stream=stream)\n\n def render_default(self, default: DefaultType) -> Text:\n \"\"\"Turn the supplied default in to a Text instance.\n\n Args:\n default (DefaultType): Default value.\n\n Returns:\n Text: Text containing rendering of default value.\n \"\"\"\n return Text(f\"({default})\", \"prompt.default\")\n\n def make_prompt(self, default: DefaultType) -> Text:\n \"\"\"Make prompt text.\n\n Args:\n default (DefaultType): Default value.\n\n Returns:\n Text: Text to display in prompt.\n \"\"\"\n prompt = self.prompt.copy()\n prompt.end = \"\"\n\n if self.show_choices and self.choices:\n _choices = \"/\".join(self.choices)\n choices = f\"[{_choices}]\"\n prompt.append(\" \")\n prompt.append(choices, \"prompt.choices\")\n\n if (\n default != ...\n and self.show_default\n and isinstance(default, (str, self.response_type))\n ):\n prompt.append(\" \")\n _default = self.render_default(default)\n prompt.append(_default)\n\n prompt.append(self.prompt_suffix)\n\n return prompt\n\n @classmethod\n def get_input(\n cls,\n console: Console,\n prompt: TextType,\n password: bool,\n stream: Optional[TextIO] = None,\n ) -> str:\n \"\"\"Get input from user.\n\n Args:\n console (Console): Console instance.\n prompt (TextType): Prompt text.\n password (bool): Enable password entry.\n\n Returns:\n str: String from user.\n \"\"\"\n return console.input(prompt, password=password, stream=stream)\n\n def check_choice(self, value: str) -> bool:\n \"\"\"Check value is in the list of valid choices.\n\n Args:\n value (str): Value entered by user.\n\n Returns:\n bool: True if choice was valid, otherwise False.\n \"\"\"\n assert self.choices is not None\n if self.case_sensitive:\n return value.strip() in self.choices\n return value.strip().lower() in [choice.lower() for choice in self.choices]\n\n def process_response(self, value: str) -> PromptType:\n \"\"\"Process response from user, convert to prompt type.\n\n Args:\n value (str): String typed by user.\n\n Raises:\n InvalidResponse: If ``value`` is invalid.\n\n Returns:\n PromptType: The value to be returned from ask method.\n \"\"\"\n value = value.strip()\n try:\n return_value: PromptType = self.response_type(value)\n except ValueError:\n raise InvalidResponse(self.validate_error_message)\n\n if self.choices is not None:\n if not self.check_choice(value):\n raise InvalidResponse(self.illegal_choice_message)\n\n if not self.case_sensitive:\n # return the original choice, not the lower case version\n return_value = self.response_type(\n self.choices[\n [choice.lower() for choice in self.choices].index(value.lower())\n ]\n )\n return return_value\n\n def on_validate_error(self, value: str, error: InvalidResponse) -> None:\n \"\"\"Called to handle validation error.\n\n Args:\n value (str): String entered by user.\n error (InvalidResponse): Exception instance the initiated the error.\n \"\"\"\n self.console.print(error)\n\n def pre_prompt(self) -> None:\n \"\"\"Hook to display something before the prompt.\"\"\"\n\n @overload\n def __call__(self, *, stream: Optional[TextIO] = None) -> PromptType:\n ...\n\n @overload\n def __call__(\n self, *, default: DefaultType, stream: Optional[TextIO] = None\n ) -> Union[PromptType, DefaultType]:\n ...\n\n def __call__(self, *, default: Any = ..., stream: Optional[TextIO] = None) -> Any:\n \"\"\"Run the prompt loop.\n\n Args:\n default (Any, optional): Optional default value.\n\n Returns:\n PromptType: Processed value.\n \"\"\"\n while True:\n self.pre_prompt()\n prompt = self.make_prompt(default)\n value = self.get_input(self.console, prompt, self.password, stream=stream)\n if value == \"\" and default != ...:\n return default\n try:\n return_value = self.process_response(value)\n except InvalidResponse as error:\n self.on_validate_error(value, error)\n continue\n else:\n return return_value\n\n\nclass Prompt(PromptBase[str]):\n \"\"\"A prompt that returns a str.\n\n Example:\n >>> name = Prompt.ask(\"Enter your name\")\n\n\n \"\"\"\n\n response_type = str\n\n\nclass IntPrompt(PromptBase[int]):\n \"\"\"A prompt that returns an integer.\n\n Example:\n >>> burrito_count = IntPrompt.ask(\"How many burritos do you want to order\")\n\n \"\"\"\n\n response_type = int\n validate_error_message = \"[prompt.invalid]Please enter a valid integer number\"\n\n\nclass FloatPrompt(PromptBase[float]):\n \"\"\"A prompt that returns a float.\n\n Example:\n >>> temperature = FloatPrompt.ask(\"Enter desired temperature\")\n\n \"\"\"\n\n response_type = float\n validate_error_message = \"[prompt.invalid]Please enter a number\"\n\n\nclass Confirm(PromptBase[bool]):\n \"\"\"A yes / no confirmation prompt.\n\n Example:\n >>> if Confirm.ask(\"Continue\"):\n run_job()\n\n \"\"\"\n\n response_type = bool\n validate_error_message = \"[prompt.invalid]Please enter Y or N\"\n choices: List[str] = [\"y\", \"n\"]\n\n def render_default(self, default: DefaultType) -> Text:\n \"\"\"Render the default as (y) or (n) rather than True/False.\"\"\"\n yes, no = self.choices\n return Text(f\"({yes})\" if default else f\"({no})\", style=\"prompt.default\")\n\n def process_response(self, value: str) -> bool:\n \"\"\"Convert choices to a bool.\"\"\"\n value = value.strip().lower()\n if value not in self.choices:\n raise InvalidResponse(self.validate_error_message)\n return value == self.choices[0]\n\n\nif __name__ == \"__main__\": # pragma: no cover\n from pip._vendor.rich import print\n\n if Confirm.ask(\"Run [i]prompt[/i] tests?\", default=True):\n while True:\n result = IntPrompt.ask(\n \":rocket: Enter a number between [b]1[/b] and [b]10[/b]\", default=5\n )\n if result >= 1 and result <= 10:\n break\n print(\":pile_of_poo: [prompt.invalid]Number must be between 1 and 10\")\n print(f\"number={result}\")\n\n while True:\n password = Prompt.ask(\n \"Please enter a password [cyan](must be at least 5 characters)\",\n password=True,\n )\n if len(password) >= 5:\n break\n print(\"[prompt.invalid]password too short\")\n print(f\"password={password!r}\")\n\n fruit = Prompt.ask(\"Enter a fruit\", choices=[\"apple\", \"orange\", \"pear\"])\n print(f\"fruit={fruit!r}\")\n\n doggie = Prompt.ask(\n \"What's the best Dog? (Case INSENSITIVE)\",\n choices=[\"Border Terrier\", \"Collie\", \"Labradoodle\"],\n case_sensitive=False,\n )\n print(f\"doggie={doggie!r}\")\n\n else:\n print(\"[b]OK :loudly_crying_face:\")\n",[],[213,919,920,921,1016,1050,1511,1657],"0c1f973c-67fc-11f0-aedf-0224a6c84d84","progress_bar.py","0c1f97dc-67fc-11f0-aedf-0224a6c84d84",447,["D",1753299268112],"import math\nfrom functools import lru_cache\nfrom time import monotonic\nfrom typing import Iterable, List, Optional\n\nfrom .color import Color, blend_rgb\nfrom .color_triplet import ColorTriplet\nfrom .console import Console, ConsoleOptions, RenderResult\nfrom .jupyter import JupyterMixin\nfrom .measure import Measurement\nfrom .segment import Segment\nfrom .style import Style, StyleType\n\n# Number of characters before 'pulse' animation repeats\nPULSE_SIZE = 20\n\n\nclass ProgressBar(JupyterMixin):\n \"\"\"Renders a (progress) bar. Used by rich.progress.\n\n Args:\n total (float, optional): Number of steps in the bar. Defaults to 100. Set to None to render a pulsing animation.\n completed (float, optional): Number of steps completed. Defaults to 0.\n width (int, optional): Width of the bar, or ``None`` for maximum width. Defaults to None.\n pulse (bool, optional): Enable pulse effect. Defaults to False. Will pulse if a None total was passed.\n style (StyleType, optional): Style for the bar background. Defaults to \"bar.back\".\n complete_style (StyleType, optional): Style for the completed bar. Defaults to \"bar.complete\".\n finished_style (StyleType, optional): Style for a finished bar. Defaults to \"bar.finished\".\n pulse_style (StyleType, optional): Style for pulsing bars. Defaults to \"bar.pulse\".\n animation_time (Optional[float], optional): Time in seconds to use for animation, or None to use system time.\n \"\"\"\n\n def __init__(\n self,\n total: Optional[float] = 100.0,\n completed: float = 0,\n width: Optional[int] = None,\n pulse: bool = False,\n style: StyleType = \"bar.back\",\n complete_style: StyleType = \"bar.complete\",\n finished_style: StyleType = \"bar.finished\",\n pulse_style: StyleType = \"bar.pulse\",\n animation_time: Optional[float] = None,\n ):\n self.total = total\n self.completed = completed\n self.width = width\n self.pulse = pulse\n self.style = style\n self.complete_style = complete_style\n self.finished_style = finished_style\n self.pulse_style = pulse_style\n self.animation_time = animation_time\n\n self._pulse_segments: Optional[List[Segment]] = None\n\n def __repr__(self) -> str:\n return f\"\"\n\n @property\n def percentage_completed(self) -> Optional[float]:\n \"\"\"Calculate percentage complete.\"\"\"\n if self.total is None:\n return None\n completed = (self.completed / self.total) * 100.0\n completed = min(100, max(0.0, completed))\n return completed\n\n @lru_cache(maxsize=16)\n def _get_pulse_segments(\n self,\n fore_style: Style,\n back_style: Style,\n color_system: str,\n no_color: bool,\n ascii: bool = False,\n ) -> List[Segment]:\n \"\"\"Get a list of segments to render a pulse animation.\n\n Returns:\n List[Segment]: A list of segments, one segment per character.\n \"\"\"\n bar = \"-\" if ascii else \"━\"\n segments: List[Segment] = []\n if color_system not in (\"standard\", \"eight_bit\", \"truecolor\") or no_color:\n segments += [Segment(bar, fore_style)] * (PULSE_SIZE // 2)\n segments += [Segment(\" \" if no_color else bar, back_style)] * (\n PULSE_SIZE - (PULSE_SIZE // 2)\n )\n return segments\n\n append = segments.append\n fore_color = (\n fore_style.color.get_truecolor()\n if fore_style.color\n else ColorTriplet(255, 0, 255)\n )\n back_color = (\n back_style.color.get_truecolor()\n if back_style.color\n else ColorTriplet(0, 0, 0)\n )\n cos = math.cos\n pi = math.pi\n _Segment = Segment\n _Style = Style\n from_triplet = Color.from_triplet\n\n for index in range(PULSE_SIZE):\n position = index / PULSE_SIZE\n fade = 0.5 + cos(position * pi * 2) / 2.0\n color = blend_rgb(fore_color, back_color, cross_fade=fade)\n append(_Segment(bar, _Style(color=from_triplet(color))))\n return segments\n\n def update(self, completed: float, total: Optional[float] = None) -> None:\n \"\"\"Update progress with new values.\n\n Args:\n completed (float): Number of steps completed.\n total (float, optional): Total number of steps, or ``None`` to not change. Defaults to None.\n \"\"\"\n self.completed = completed\n self.total = total if total is not None else self.total\n\n def _render_pulse(\n self, console: Console, width: int, ascii: bool = False\n ) -> Iterable[Segment]:\n \"\"\"Renders the pulse animation.\n\n Args:\n console (Console): Console instance.\n width (int): Width in characters of pulse animation.\n\n Returns:\n RenderResult: [description]\n\n Yields:\n Iterator[Segment]: Segments to render pulse\n \"\"\"\n fore_style = console.get_style(self.pulse_style, default=\"white\")\n back_style = console.get_style(self.style, default=\"black\")\n\n pulse_segments = self._get_pulse_segments(\n fore_style, back_style, console.color_system, console.no_color, ascii=ascii\n )\n segment_count = len(pulse_segments)\n current_time = (\n monotonic() if self.animation_time is None else self.animation_time\n )\n segments = pulse_segments * (int(width / segment_count) + 2)\n offset = int(-current_time * 15) % segment_count\n segments = segments[offset : offset + width]\n yield from segments\n\n def __rich_console__(\n self, console: Console, options: ConsoleOptions\n ) -> RenderResult:\n width = min(self.width or options.max_width, options.max_width)\n ascii = options.legacy_windows or options.ascii_only\n should_pulse = self.pulse or self.total is None\n if should_pulse:\n yield from self._render_pulse(console, width, ascii=ascii)\n return\n\n completed: Optional[float] = (\n min(self.total, max(0, self.completed)) if self.total is not None else None\n )\n\n bar = \"-\" if ascii else \"━\"\n half_bar_right = \" \" if ascii else \"╸\"\n half_bar_left = \" \" if ascii else \"╺\"\n complete_halves = (\n int(width * 2 * completed / self.total)\n if self.total and completed is not None\n else width * 2\n )\n bar_count = complete_halves // 2\n half_bar_count = complete_halves % 2\n style = console.get_style(self.style)\n is_finished = self.total is None or self.completed >= self.total\n complete_style = console.get_style(\n self.finished_style if is_finished else self.complete_style\n )\n _Segment = Segment\n if bar_count:\n yield _Segment(bar * bar_count, complete_style)\n if half_bar_count:\n yield _Segment(half_bar_right * half_bar_count, complete_style)\n\n if not console.no_color:\n remaining_bars = width - bar_count - half_bar_count\n if remaining_bars and console.color_system is not None:\n if not half_bar_count and bar_count:\n yield _Segment(half_bar_left, style)\n remaining_bars -= 1\n if remaining_bars:\n yield _Segment(bar * remaining_bars, style)\n\n def __rich_measure__(\n self, console: Console, options: ConsoleOptions\n ) -> Measurement:\n return (\n Measurement(self.width, self.width)\n if self.width is not None\n else Measurement(4, options.max_width)\n )\n\n\nif __name__ == \"__main__\": # pragma: no cover\n console = Console()\n bar = ProgressBar(width=50, total=100)\n\n import time\n\n console.show_cursor(False)\n for n in range(0, 101, 1):\n bar.update(n)\n console.print(bar)\n console.file.write(\"\\r\")\n time.sleep(0.05)\n console.show_cursor(True)\n console.print()\n",[],[213,919,920,921,1016,1050,1511,1665],"0c44ecd0-67fc-11f0-bcbe-0224a6c84d84","progress.py","0c44ed84-67fc-11f0-bcbe-0224a6c84d84",453,["D",1753299268348],"import io\nimport sys\nimport typing\nimport warnings\nfrom abc import ABC, abstractmethod\nfrom collections import deque\nfrom dataclasses import dataclass, field\nfrom datetime import timedelta\nfrom io import RawIOBase, UnsupportedOperation\nfrom math import ceil\nfrom mmap import mmap\nfrom operator import length_hint\nfrom os import PathLike, stat\nfrom threading import Event, RLock, Thread\nfrom types import TracebackType\nfrom typing import (\n Any,\n BinaryIO,\n Callable,\n ContextManager,\n Deque,\n Dict,\n Generic,\n Iterable,\n List,\n NamedTuple,\n NewType,\n Optional,\n Sequence,\n TextIO,\n Tuple,\n Type,\n TypeVar,\n Union,\n)\n\nif sys.version_info >= (3, 8):\n from typing import Literal\nelse:\n from pip._vendor.typing_extensions import Literal # pragma: no cover\n\nif sys.version_info >= (3, 11):\n from typing import Self\nelse:\n from pip._vendor.typing_extensions import Self # pragma: no cover\n\nfrom . import filesize, get_console\nfrom .console import Console, Group, JustifyMethod, RenderableType\nfrom .highlighter import Highlighter\nfrom .jupyter import JupyterMixin\nfrom .live import Live\nfrom .progress_bar import ProgressBar\nfrom .spinner import Spinner\nfrom .style import StyleType\nfrom .table import Column, Table\nfrom .text import Text, TextType\n\nTaskID = NewType(\"TaskID\", int)\n\nProgressType = TypeVar(\"ProgressType\")\n\nGetTimeCallable = Callable[[], float]\n\n\n_I = typing.TypeVar(\"_I\", TextIO, BinaryIO)\n\n\nclass _TrackThread(Thread):\n \"\"\"A thread to periodically update progress.\"\"\"\n\n def __init__(self, progress: \"Progress\", task_id: \"TaskID\", update_period: float):\n self.progress = progress\n self.task_id = task_id\n self.update_period = update_period\n self.done = Event()\n\n self.completed = 0\n super().__init__(daemon=True)\n\n def run(self) -> None:\n task_id = self.task_id\n advance = self.progress.advance\n update_period = self.update_period\n last_completed = 0\n wait = self.done.wait\n while not wait(update_period) and self.progress.live.is_started:\n completed = self.completed\n if last_completed != completed:\n advance(task_id, completed - last_completed)\n last_completed = completed\n\n self.progress.update(self.task_id, completed=self.completed, refresh=True)\n\n def __enter__(self) -> \"_TrackThread\":\n self.start()\n return self\n\n def __exit__(\n self,\n exc_type: Optional[Type[BaseException]],\n exc_val: Optional[BaseException],\n exc_tb: Optional[TracebackType],\n ) -> None:\n self.done.set()\n self.join()\n\n\ndef track(\n sequence: Union[Sequence[ProgressType], Iterable[ProgressType]],\n description: str = \"Working...\",\n total: Optional[float] = None,\n completed: int = 0,\n auto_refresh: bool = True,\n console: Optional[Console] = None,\n transient: bool = False,\n get_time: Optional[Callable[[], float]] = None,\n refresh_per_second: float = 10,\n style: StyleType = \"bar.back\",\n complete_style: StyleType = \"bar.complete\",\n finished_style: StyleType = \"bar.finished\",\n pulse_style: StyleType = \"bar.pulse\",\n update_period: float = 0.1,\n disable: bool = False,\n show_speed: bool = True,\n) -> Iterable[ProgressType]:\n \"\"\"Track progress by iterating over a sequence.\n\n Args:\n sequence (Iterable[ProgressType]): A sequence (must support \"len\") you wish to iterate over.\n description (str, optional): Description of task show next to progress bar. Defaults to \"Working\".\n total: (float, optional): Total number of steps. Default is len(sequence).\n completed (int, optional): Number of steps completed so far. Defaults to 0.\n auto_refresh (bool, optional): Automatic refresh, disable to force a refresh after each iteration. Default is True.\n transient: (bool, optional): Clear the progress on exit. Defaults to False.\n console (Console, optional): Console to write to. Default creates internal Console instance.\n refresh_per_second (float): Number of times per second to refresh the progress information. Defaults to 10.\n style (StyleType, optional): Style for the bar background. Defaults to \"bar.back\".\n complete_style (StyleType, optional): Style for the completed bar. Defaults to \"bar.complete\".\n finished_style (StyleType, optional): Style for a finished bar. Defaults to \"bar.finished\".\n pulse_style (StyleType, optional): Style for pulsing bars. Defaults to \"bar.pulse\".\n update_period (float, optional): Minimum time (in seconds) between calls to update(). Defaults to 0.1.\n disable (bool, optional): Disable display of progress.\n show_speed (bool, optional): Show speed if total isn't known. Defaults to True.\n Returns:\n Iterable[ProgressType]: An iterable of the values in the sequence.\n\n \"\"\"\n\n columns: List[\"ProgressColumn\"] = (\n [TextColumn(\"[progress.description]{task.description}\")] if description else []\n )\n columns.extend(\n (\n BarColumn(\n style=style,\n complete_style=complete_style,\n finished_style=finished_style,\n pulse_style=pulse_style,\n ),\n TaskProgressColumn(show_speed=show_speed),\n TimeRemainingColumn(elapsed_when_finished=True),\n )\n )\n progress = Progress(\n *columns,\n auto_refresh=auto_refresh,\n console=console,\n transient=transient,\n get_time=get_time,\n refresh_per_second=refresh_per_second or 10,\n disable=disable,\n )\n\n with progress:\n yield from progress.track(\n sequence,\n total=total,\n completed=completed,\n description=description,\n update_period=update_period,\n )\n\n\nclass _Reader(RawIOBase, BinaryIO):\n \"\"\"A reader that tracks progress while it's being read from.\"\"\"\n\n def __init__(\n self,\n handle: BinaryIO,\n progress: \"Progress\",\n task: TaskID,\n close_handle: bool = True,\n ) -> None:\n self.handle = handle\n self.progress = progress\n self.task = task\n self.close_handle = close_handle\n self._closed = False\n\n def __enter__(self) -> \"_Reader\":\n self.handle.__enter__()\n return self\n\n def __exit__(\n self,\n exc_type: Optional[Type[BaseException]],\n exc_val: Optional[BaseException],\n exc_tb: Optional[TracebackType],\n ) -> None:\n self.close()\n\n def __iter__(self) -> BinaryIO:\n return self\n\n def __next__(self) -> bytes:\n line = next(self.handle)\n self.progress.advance(self.task, advance=len(line))\n return line\n\n @property\n def closed(self) -> bool:\n return self._closed\n\n def fileno(self) -> int:\n return self.handle.fileno()\n\n def isatty(self) -> bool:\n return self.handle.isatty()\n\n @property\n def mode(self) -> str:\n return self.handle.mode\n\n @property\n def name(self) -> str:\n return self.handle.name\n\n def readable(self) -> bool:\n return self.handle.readable()\n\n def seekable(self) -> bool:\n return self.handle.seekable()\n\n def writable(self) -> bool:\n return False\n\n def read(self, size: int = -1) -> bytes:\n block = self.handle.read(size)\n self.progress.advance(self.task, advance=len(block))\n return block\n\n def readinto(self, b: Union[bytearray, memoryview, mmap]): # type: ignore[no-untyped-def, override]\n n = self.handle.readinto(b) # type: ignore[attr-defined]\n self.progress.advance(self.task, advance=n)\n return n\n\n def readline(self, size: int = -1) -> bytes: # type: ignore[override]\n line = self.handle.readline(size)\n self.progress.advance(self.task, advance=len(line))\n return line\n\n def readlines(self, hint: int = -1) -> List[bytes]:\n lines = self.handle.readlines(hint)\n self.progress.advance(self.task, advance=sum(map(len, lines)))\n return lines\n\n def close(self) -> None:\n if self.close_handle:\n self.handle.close()\n self._closed = True\n\n def seek(self, offset: int, whence: int = 0) -> int:\n pos = self.handle.seek(offset, whence)\n self.progress.update(self.task, completed=pos)\n return pos\n\n def tell(self) -> int:\n return self.handle.tell()\n\n def write(self, s: Any) -> int:\n raise UnsupportedOperation(\"write\")\n\n def writelines(self, lines: Iterable[Any]) -> None:\n raise UnsupportedOperation(\"writelines\")\n\n\nclass _ReadContext(ContextManager[_I], Generic[_I]):\n \"\"\"A utility class to handle a context for both a reader and a progress.\"\"\"\n\n def __init__(self, progress: \"Progress\", reader: _I) -> None:\n self.progress = progress\n self.reader: _I = reader\n\n def __enter__(self) -> _I:\n self.progress.start()\n return self.reader.__enter__()\n\n def __exit__(\n self,\n exc_type: Optional[Type[BaseException]],\n exc_val: Optional[BaseException],\n exc_tb: Optional[TracebackType],\n ) -> None:\n self.progress.stop()\n self.reader.__exit__(exc_type, exc_val, exc_tb)\n\n\ndef wrap_file(\n file: BinaryIO,\n total: int,\n *,\n description: str = \"Reading...\",\n auto_refresh: bool = True,\n console: Optional[Console] = None,\n transient: bool = False,\n get_time: Optional[Callable[[], float]] = None,\n refresh_per_second: float = 10,\n style: StyleType = \"bar.back\",\n complete_style: StyleType = \"bar.complete\",\n finished_style: StyleType = \"bar.finished\",\n pulse_style: StyleType = \"bar.pulse\",\n disable: bool = False,\n) -> ContextManager[BinaryIO]:\n \"\"\"Read bytes from a file while tracking progress.\n\n Args:\n file (Union[str, PathLike[str], BinaryIO]): The path to the file to read, or a file-like object in binary mode.\n total (int): Total number of bytes to read.\n description (str, optional): Description of task show next to progress bar. Defaults to \"Reading\".\n auto_refresh (bool, optional): Automatic refresh, disable to force a refresh after each iteration. Default is True.\n transient: (bool, optional): Clear the progress on exit. Defaults to False.\n console (Console, optional): Console to write to. Default creates internal Console instance.\n refresh_per_second (float): Number of times per second to refresh the progress information. Defaults to 10.\n style (StyleType, optional): Style for the bar background. Defaults to \"bar.back\".\n complete_style (StyleType, optional): Style for the completed bar. Defaults to \"bar.complete\".\n finished_style (StyleType, optional): Style for a finished bar. Defaults to \"bar.finished\".\n pulse_style (StyleType, optional): Style for pulsing bars. Defaults to \"bar.pulse\".\n disable (bool, optional): Disable display of progress.\n Returns:\n ContextManager[BinaryIO]: A context manager yielding a progress reader.\n\n \"\"\"\n\n columns: List[\"ProgressColumn\"] = (\n [TextColumn(\"[progress.description]{task.description}\")] if description else []\n )\n columns.extend(\n (\n BarColumn(\n style=style,\n complete_style=complete_style,\n finished_style=finished_style,\n pulse_style=pulse_style,\n ),\n DownloadColumn(),\n TimeRemainingColumn(),\n )\n )\n progress = Progress(\n *columns,\n auto_refresh=auto_refresh,\n console=console,\n transient=transient,\n get_time=get_time,\n refresh_per_second=refresh_per_second or 10,\n disable=disable,\n )\n\n reader = progress.wrap_file(file, total=total, description=description)\n return _ReadContext(progress, reader)\n\n\n@typing.overload\ndef open(\n file: Union[str, \"PathLike[str]\", bytes],\n mode: Union[Literal[\"rt\"], Literal[\"r\"]],\n buffering: int = -1,\n encoding: Optional[str] = None,\n errors: Optional[str] = None,\n newline: Optional[str] = None,\n *,\n total: Optional[int] = None,\n description: str = \"Reading...\",\n auto_refresh: bool = True,\n console: Optional[Console] = None,\n transient: bool = False,\n get_time: Optional[Callable[[], float]] = None,\n refresh_per_second: float = 10,\n style: StyleType = \"bar.back\",\n complete_style: StyleType = \"bar.complete\",\n finished_style: StyleType = \"bar.finished\",\n pulse_style: StyleType = \"bar.pulse\",\n disable: bool = False,\n) -> ContextManager[TextIO]:\n pass\n\n\n@typing.overload\ndef open(\n file: Union[str, \"PathLike[str]\", bytes],\n mode: Literal[\"rb\"],\n buffering: int = -1,\n encoding: Optional[str] = None,\n errors: Optional[str] = None,\n newline: Optional[str] = None,\n *,\n total: Optional[int] = None,\n description: str = \"Reading...\",\n auto_refresh: bool = True,\n console: Optional[Console] = None,\n transient: bool = False,\n get_time: Optional[Callable[[], float]] = None,\n refresh_per_second: float = 10,\n style: StyleType = \"bar.back\",\n complete_style: StyleType = \"bar.complete\",\n finished_style: StyleType = \"bar.finished\",\n pulse_style: StyleType = \"bar.pulse\",\n disable: bool = False,\n) -> ContextManager[BinaryIO]:\n pass\n\n\ndef open(\n file: Union[str, \"PathLike[str]\", bytes],\n mode: Union[Literal[\"rb\"], Literal[\"rt\"], Literal[\"r\"]] = \"r\",\n buffering: int = -1,\n encoding: Optional[str] = None,\n errors: Optional[str] = None,\n newline: Optional[str] = None,\n *,\n total: Optional[int] = None,\n description: str = \"Reading...\",\n auto_refresh: bool = True,\n console: Optional[Console] = None,\n transient: bool = False,\n get_time: Optional[Callable[[], float]] = None,\n refresh_per_second: float = 10,\n style: StyleType = \"bar.back\",\n complete_style: StyleType = \"bar.complete\",\n finished_style: StyleType = \"bar.finished\",\n pulse_style: StyleType = \"bar.pulse\",\n disable: bool = False,\n) -> Union[ContextManager[BinaryIO], ContextManager[TextIO]]:\n \"\"\"Read bytes from a file while tracking progress.\n\n Args:\n path (Union[str, PathLike[str], BinaryIO]): The path to the file to read, or a file-like object in binary mode.\n mode (str): The mode to use to open the file. Only supports \"r\", \"rb\" or \"rt\".\n buffering (int): The buffering strategy to use, see :func:`io.open`.\n encoding (str, optional): The encoding to use when reading in text mode, see :func:`io.open`.\n errors (str, optional): The error handling strategy for decoding errors, see :func:`io.open`.\n newline (str, optional): The strategy for handling newlines in text mode, see :func:`io.open`\n total: (int, optional): Total number of bytes to read. Must be provided if reading from a file handle. Default for a path is os.stat(file).st_size.\n description (str, optional): Description of task show next to progress bar. Defaults to \"Reading\".\n auto_refresh (bool, optional): Automatic refresh, disable to force a refresh after each iteration. Default is True.\n transient: (bool, optional): Clear the progress on exit. Defaults to False.\n console (Console, optional): Console to write to. Default creates internal Console instance.\n refresh_per_second (float): Number of times per second to refresh the progress information. Defaults to 10.\n style (StyleType, optional): Style for the bar background. Defaults to \"bar.back\".\n complete_style (StyleType, optional): Style for the completed bar. Defaults to \"bar.complete\".\n finished_style (StyleType, optional): Style for a finished bar. Defaults to \"bar.finished\".\n pulse_style (StyleType, optional): Style for pulsing bars. Defaults to \"bar.pulse\".\n disable (bool, optional): Disable display of progress.\n encoding (str, optional): The encoding to use when reading in text mode.\n\n Returns:\n ContextManager[BinaryIO]: A context manager yielding a progress reader.\n\n \"\"\"\n\n columns: List[\"ProgressColumn\"] = (\n [TextColumn(\"[progress.description]{task.description}\")] if description else []\n )\n columns.extend(\n (\n BarColumn(\n style=style,\n complete_style=complete_style,\n finished_style=finished_style,\n pulse_style=pulse_style,\n ),\n DownloadColumn(),\n TimeRemainingColumn(),\n )\n )\n progress = Progress(\n *columns,\n auto_refresh=auto_refresh,\n console=console,\n transient=transient,\n get_time=get_time,\n refresh_per_second=refresh_per_second or 10,\n disable=disable,\n )\n\n reader = progress.open(\n file,\n mode=mode,\n buffering=buffering,\n encoding=encoding,\n errors=errors,\n newline=newline,\n total=total,\n description=description,\n )\n return _ReadContext(progress, reader) # type: ignore[return-value, type-var]\n\n\nclass ProgressColumn(ABC):\n \"\"\"Base class for a widget to use in progress display.\"\"\"\n\n max_refresh: Optional[float] = None\n\n def __init__(self, table_column: Optional[Column] = None) -> None:\n self._table_column = table_column\n self._renderable_cache: Dict[TaskID, Tuple[float, RenderableType]] = {}\n self._update_time: Optional[float] = None\n\n def get_table_column(self) -> Column:\n \"\"\"Get a table column, used to build tasks table.\"\"\"\n return self._table_column or Column()\n\n def __call__(self, task: \"Task\") -> RenderableType:\n \"\"\"Called by the Progress object to return a renderable for the given task.\n\n Args:\n task (Task): An object containing information regarding the task.\n\n Returns:\n RenderableType: Anything renderable (including str).\n \"\"\"\n current_time = task.get_time()\n if self.max_refresh is not None and not task.completed:\n try:\n timestamp, renderable = self._renderable_cache[task.id]\n except KeyError:\n pass\n else:\n if timestamp + self.max_refresh > current_time:\n return renderable\n\n renderable = self.render(task)\n self._renderable_cache[task.id] = (current_time, renderable)\n return renderable\n\n @abstractmethod\n def render(self, task: \"Task\") -> RenderableType:\n \"\"\"Should return a renderable object.\"\"\"\n\n\nclass RenderableColumn(ProgressColumn):\n \"\"\"A column to insert an arbitrary column.\n\n Args:\n renderable (RenderableType, optional): Any renderable. Defaults to empty string.\n \"\"\"\n\n def __init__(\n self, renderable: RenderableType = \"\", *, table_column: Optional[Column] = None\n ):\n self.renderable = renderable\n super().__init__(table_column=table_column)\n\n def render(self, task: \"Task\") -> RenderableType:\n return self.renderable\n\n\nclass SpinnerColumn(ProgressColumn):\n \"\"\"A column with a 'spinner' animation.\n\n Args:\n spinner_name (str, optional): Name of spinner animation. Defaults to \"dots\".\n style (StyleType, optional): Style of spinner. Defaults to \"progress.spinner\".\n speed (float, optional): Speed factor of spinner. Defaults to 1.0.\n finished_text (TextType, optional): Text used when task is finished. Defaults to \" \".\n \"\"\"\n\n def __init__(\n self,\n spinner_name: str = \"dots\",\n style: Optional[StyleType] = \"progress.spinner\",\n speed: float = 1.0,\n finished_text: TextType = \" \",\n table_column: Optional[Column] = None,\n ):\n self.spinner = Spinner(spinner_name, style=style, speed=speed)\n self.finished_text = (\n Text.from_markup(finished_text)\n if isinstance(finished_text, str)\n else finished_text\n )\n super().__init__(table_column=table_column)\n\n def set_spinner(\n self,\n spinner_name: str,\n spinner_style: Optional[StyleType] = \"progress.spinner\",\n speed: float = 1.0,\n ) -> None:\n \"\"\"Set a new spinner.\n\n Args:\n spinner_name (str): Spinner name, see python -m rich.spinner.\n spinner_style (Optional[StyleType], optional): Spinner style. Defaults to \"progress.spinner\".\n speed (float, optional): Speed factor of spinner. Defaults to 1.0.\n \"\"\"\n self.spinner = Spinner(spinner_name, style=spinner_style, speed=speed)\n\n def render(self, task: \"Task\") -> RenderableType:\n text = (\n self.finished_text\n if task.finished\n else self.spinner.render(task.get_time())\n )\n return text\n\n\nclass TextColumn(ProgressColumn):\n \"\"\"A column containing text.\"\"\"\n\n def __init__(\n self,\n text_format: str,\n style: StyleType = \"none\",\n justify: JustifyMethod = \"left\",\n markup: bool = True,\n highlighter: Optional[Highlighter] = None,\n table_column: Optional[Column] = None,\n ) -> None:\n self.text_format = text_format\n self.justify: JustifyMethod = justify\n self.style = style\n self.markup = markup\n self.highlighter = highlighter\n super().__init__(table_column=table_column or Column(no_wrap=True))\n\n def render(self, task: \"Task\") -> Text:\n _text = self.text_format.format(task=task)\n if self.markup:\n text = Text.from_markup(_text, style=self.style, justify=self.justify)\n else:\n text = Text(_text, style=self.style, justify=self.justify)\n if self.highlighter:\n self.highlighter.highlight(text)\n return text\n\n\nclass BarColumn(ProgressColumn):\n \"\"\"Renders a visual progress bar.\n\n Args:\n bar_width (Optional[int], optional): Width of bar or None for full width. Defaults to 40.\n style (StyleType, optional): Style for the bar background. Defaults to \"bar.back\".\n complete_style (StyleType, optional): Style for the completed bar. Defaults to \"bar.complete\".\n finished_style (StyleType, optional): Style for a finished bar. Defaults to \"bar.finished\".\n pulse_style (StyleType, optional): Style for pulsing bars. Defaults to \"bar.pulse\".\n \"\"\"\n\n def __init__(\n self,\n bar_width: Optional[int] = 40,\n style: StyleType = \"bar.back\",\n complete_style: StyleType = \"bar.complete\",\n finished_style: StyleType = \"bar.finished\",\n pulse_style: StyleType = \"bar.pulse\",\n table_column: Optional[Column] = None,\n ) -> None:\n self.bar_width = bar_width\n self.style = style\n self.complete_style = complete_style\n self.finished_style = finished_style\n self.pulse_style = pulse_style\n super().__init__(table_column=table_column)\n\n def render(self, task: \"Task\") -> ProgressBar:\n \"\"\"Gets a progress bar widget for a task.\"\"\"\n return ProgressBar(\n total=max(0, task.total) if task.total is not None else None,\n completed=max(0, task.completed),\n width=None if self.bar_width is None else max(1, self.bar_width),\n pulse=not task.started,\n animation_time=task.get_time(),\n style=self.style,\n complete_style=self.complete_style,\n finished_style=self.finished_style,\n pulse_style=self.pulse_style,\n )\n\n\nclass TimeElapsedColumn(ProgressColumn):\n \"\"\"Renders time elapsed.\"\"\"\n\n def render(self, task: \"Task\") -> Text:\n \"\"\"Show time elapsed.\"\"\"\n elapsed = task.finished_time if task.finished else task.elapsed\n if elapsed is None:\n return Text(\"-:--:--\", style=\"progress.elapsed\")\n delta = timedelta(seconds=max(0, int(elapsed)))\n return Text(str(delta), style=\"progress.elapsed\")\n\n\nclass TaskProgressColumn(TextColumn):\n \"\"\"Show task progress as a percentage.\n\n Args:\n text_format (str, optional): Format for percentage display. Defaults to \"[progress.percentage]{task.percentage:>3.0f}%\".\n text_format_no_percentage (str, optional): Format if percentage is unknown. Defaults to \"\".\n style (StyleType, optional): Style of output. Defaults to \"none\".\n justify (JustifyMethod, optional): Text justification. Defaults to \"left\".\n markup (bool, optional): Enable markup. Defaults to True.\n highlighter (Optional[Highlighter], optional): Highlighter to apply to output. Defaults to None.\n table_column (Optional[Column], optional): Table Column to use. Defaults to None.\n show_speed (bool, optional): Show speed if total is unknown. Defaults to False.\n \"\"\"\n\n def __init__(\n self,\n text_format: str = \"[progress.percentage]{task.percentage:>3.0f}%\",\n text_format_no_percentage: str = \"\",\n style: StyleType = \"none\",\n justify: JustifyMethod = \"left\",\n markup: bool = True,\n highlighter: Optional[Highlighter] = None,\n table_column: Optional[Column] = None,\n show_speed: bool = False,\n ) -> None:\n self.text_format_no_percentage = text_format_no_percentage\n self.show_speed = show_speed\n super().__init__(\n text_format=text_format,\n style=style,\n justify=justify,\n markup=markup,\n highlighter=highlighter,\n table_column=table_column,\n )\n\n @classmethod\n def render_speed(cls, speed: Optional[float]) -> Text:\n \"\"\"Render the speed in iterations per second.\n\n Args:\n task (Task): A Task object.\n\n Returns:\n Text: Text object containing the task speed.\n \"\"\"\n if speed is None:\n return Text(\"\", style=\"progress.percentage\")\n unit, suffix = filesize.pick_unit_and_suffix(\n int(speed),\n [\"\", \"×10³\", \"×10⁶\", \"×10⁹\", \"×10¹²\"],\n 1000,\n )\n data_speed = speed / unit\n return Text(f\"{data_speed:.1f}{suffix} it/s\", style=\"progress.percentage\")\n\n def render(self, task: \"Task\") -> Text:\n if task.total is None and self.show_speed:\n return self.render_speed(task.finished_speed or task.speed)\n text_format = (\n self.text_format_no_percentage if task.total is None else self.text_format\n )\n _text = text_format.format(task=task)\n if self.markup:\n text = Text.from_markup(_text, style=self.style, justify=self.justify)\n else:\n text = Text(_text, style=self.style, justify=self.justify)\n if self.highlighter:\n self.highlighter.highlight(text)\n return text\n\n\nclass TimeRemainingColumn(ProgressColumn):\n \"\"\"Renders estimated time remaining.\n\n Args:\n compact (bool, optional): Render MM:SS when time remaining is less than an hour. Defaults to False.\n elapsed_when_finished (bool, optional): Render time elapsed when the task is finished. Defaults to False.\n \"\"\"\n\n # Only refresh twice a second to prevent jitter\n max_refresh = 0.5\n\n def __init__(\n self,\n compact: bool = False,\n elapsed_when_finished: bool = False,\n table_column: Optional[Column] = None,\n ):\n self.compact = compact\n self.elapsed_when_finished = elapsed_when_finished\n super().__init__(table_column=table_column)\n\n def render(self, task: \"Task\") -> Text:\n \"\"\"Show time remaining.\"\"\"\n if self.elapsed_when_finished and task.finished:\n task_time = task.finished_time\n style = \"progress.elapsed\"\n else:\n task_time = task.time_remaining\n style = \"progress.remaining\"\n\n if task.total is None:\n return Text(\"\", style=style)\n\n if task_time is None:\n return Text(\"--:--\" if self.compact else \"-:--:--\", style=style)\n\n # Based on https://github.com/tqdm/tqdm/blob/master/tqdm/std.py\n minutes, seconds = divmod(int(task_time), 60)\n hours, minutes = divmod(minutes, 60)\n\n if self.compact and not hours:\n formatted = f\"{minutes:02d}:{seconds:02d}\"\n else:\n formatted = f\"{hours:d}:{minutes:02d}:{seconds:02d}\"\n\n return Text(formatted, style=style)\n\n\nclass FileSizeColumn(ProgressColumn):\n \"\"\"Renders completed filesize.\"\"\"\n\n def render(self, task: \"Task\") -> Text:\n \"\"\"Show data completed.\"\"\"\n data_size = filesize.decimal(int(task.completed))\n return Text(data_size, style=\"progress.filesize\")\n\n\nclass TotalFileSizeColumn(ProgressColumn):\n \"\"\"Renders total filesize.\"\"\"\n\n def render(self, task: \"Task\") -> Text:\n \"\"\"Show data completed.\"\"\"\n data_size = filesize.decimal(int(task.total)) if task.total is not None else \"\"\n return Text(data_size, style=\"progress.filesize.total\")\n\n\nclass MofNCompleteColumn(ProgressColumn):\n \"\"\"Renders completed count/total, e.g. ' 10/1000'.\n\n Best for bounded tasks with int quantities.\n\n Space pads the completed count so that progress length does not change as task progresses\n past powers of 10.\n\n Args:\n separator (str, optional): Text to separate completed and total values. Defaults to \"/\".\n \"\"\"\n\n def __init__(self, separator: str = \"/\", table_column: Optional[Column] = None):\n self.separator = separator\n super().__init__(table_column=table_column)\n\n def render(self, task: \"Task\") -> Text:\n \"\"\"Show completed/total.\"\"\"\n completed = int(task.completed)\n total = int(task.total) if task.total is not None else \"?\"\n total_width = len(str(total))\n return Text(\n f\"{completed:{total_width}d}{self.separator}{total}\",\n style=\"progress.download\",\n )\n\n\nclass DownloadColumn(ProgressColumn):\n \"\"\"Renders file size downloaded and total, e.g. '0.5/2.3 GB'.\n\n Args:\n binary_units (bool, optional): Use binary units, KiB, MiB etc. Defaults to False.\n \"\"\"\n\n def __init__(\n self, binary_units: bool = False, table_column: Optional[Column] = None\n ) -> None:\n self.binary_units = binary_units\n super().__init__(table_column=table_column)\n\n def render(self, task: \"Task\") -> Text:\n \"\"\"Calculate common unit for completed and total.\"\"\"\n completed = int(task.completed)\n\n unit_and_suffix_calculation_base = (\n int(task.total) if task.total is not None else completed\n )\n if self.binary_units:\n unit, suffix = filesize.pick_unit_and_suffix(\n unit_and_suffix_calculation_base,\n [\"bytes\", \"KiB\", \"MiB\", \"GiB\", \"TiB\", \"PiB\", \"EiB\", \"ZiB\", \"YiB\"],\n 1024,\n )\n else:\n unit, suffix = filesize.pick_unit_and_suffix(\n unit_and_suffix_calculation_base,\n [\"bytes\", \"kB\", \"MB\", \"GB\", \"TB\", \"PB\", \"EB\", \"ZB\", \"YB\"],\n 1000,\n )\n precision = 0 if unit == 1 else 1\n\n completed_ratio = completed / unit\n completed_str = f\"{completed_ratio:,.{precision}f}\"\n\n if task.total is not None:\n total = int(task.total)\n total_ratio = total / unit\n total_str = f\"{total_ratio:,.{precision}f}\"\n else:\n total_str = \"?\"\n\n download_status = f\"{completed_str}/{total_str} {suffix}\"\n download_text = Text(download_status, style=\"progress.download\")\n return download_text\n\n\nclass TransferSpeedColumn(ProgressColumn):\n \"\"\"Renders human readable transfer speed.\"\"\"\n\n def render(self, task: \"Task\") -> Text:\n \"\"\"Show data transfer speed.\"\"\"\n speed = task.finished_speed or task.speed\n if speed is None:\n return Text(\"?\", style=\"progress.data.speed\")\n data_speed = filesize.decimal(int(speed))\n return Text(f\"{data_speed}/s\", style=\"progress.data.speed\")\n\n\nclass ProgressSample(NamedTuple):\n \"\"\"Sample of progress for a given time.\"\"\"\n\n timestamp: float\n \"\"\"Timestamp of sample.\"\"\"\n completed: float\n \"\"\"Number of steps completed.\"\"\"\n\n\n@dataclass\nclass Task:\n \"\"\"Information regarding a progress task.\n\n This object should be considered read-only outside of the :class:`~Progress` class.\n\n \"\"\"\n\n id: TaskID\n \"\"\"Task ID associated with this task (used in Progress methods).\"\"\"\n\n description: str\n \"\"\"str: Description of the task.\"\"\"\n\n total: Optional[float]\n \"\"\"Optional[float]: Total number of steps in this task.\"\"\"\n\n completed: float\n \"\"\"float: Number of steps completed\"\"\"\n\n _get_time: GetTimeCallable\n \"\"\"Callable to get the current time.\"\"\"\n\n finished_time: Optional[float] = None\n \"\"\"float: Time task was finished.\"\"\"\n\n visible: bool = True\n \"\"\"bool: Indicates if this task is visible in the progress display.\"\"\"\n\n fields: Dict[str, Any] = field(default_factory=dict)\n \"\"\"dict: Arbitrary fields passed in via Progress.update.\"\"\"\n\n start_time: Optional[float] = field(default=None, init=False, repr=False)\n \"\"\"Optional[float]: Time this task was started, or None if not started.\"\"\"\n\n stop_time: Optional[float] = field(default=None, init=False, repr=False)\n \"\"\"Optional[float]: Time this task was stopped, or None if not stopped.\"\"\"\n\n finished_speed: Optional[float] = None\n \"\"\"Optional[float]: The last speed for a finished task.\"\"\"\n\n _progress: Deque[ProgressSample] = field(\n default_factory=lambda: deque(maxlen=1000), init=False, repr=False\n )\n\n _lock: RLock = field(repr=False, default_factory=RLock)\n \"\"\"Thread lock.\"\"\"\n\n def get_time(self) -> float:\n \"\"\"float: Get the current time, in seconds.\"\"\"\n return self._get_time()\n\n @property\n def started(self) -> bool:\n \"\"\"bool: Check if the task as started.\"\"\"\n return self.start_time is not None\n\n @property\n def remaining(self) -> Optional[float]:\n \"\"\"Optional[float]: Get the number of steps remaining, if a non-None total was set.\"\"\"\n if self.total is None:\n return None\n return self.total - self.completed\n\n @property\n def elapsed(self) -> Optional[float]:\n \"\"\"Optional[float]: Time elapsed since task was started, or ``None`` if the task hasn't started.\"\"\"\n if self.start_time is None:\n return None\n if self.stop_time is not None:\n return self.stop_time - self.start_time\n return self.get_time() - self.start_time\n\n @property\n def finished(self) -> bool:\n \"\"\"Check if the task has finished.\"\"\"\n return self.finished_time is not None\n\n @property\n def percentage(self) -> float:\n \"\"\"float: Get progress of task as a percentage. If a None total was set, returns 0\"\"\"\n if not self.total:\n return 0.0\n completed = (self.completed / self.total) * 100.0\n completed = min(100.0, max(0.0, completed))\n return completed\n\n @property\n def speed(self) -> Optional[float]:\n \"\"\"Optional[float]: Get the estimated speed in steps per second.\"\"\"\n if self.start_time is None:\n return None\n with self._lock:\n progress = self._progress\n if not progress:\n return None\n total_time = progress[-1].timestamp - progress[0].timestamp\n if total_time == 0:\n return None\n iter_progress = iter(progress)\n next(iter_progress)\n total_completed = sum(sample.completed for sample in iter_progress)\n speed = total_completed / total_time\n return speed\n\n @property\n def time_remaining(self) -> Optional[float]:\n \"\"\"Optional[float]: Get estimated time to completion, or ``None`` if no data.\"\"\"\n if self.finished:\n return 0.0\n speed = self.speed\n if not speed:\n return None\n remaining = self.remaining\n if remaining is None:\n return None\n estimate = ceil(remaining / speed)\n return estimate\n\n def _reset(self) -> None:\n \"\"\"Reset progress.\"\"\"\n self._progress.clear()\n self.finished_time = None\n self.finished_speed = None\n\n\nclass Progress(JupyterMixin):\n \"\"\"Renders an auto-updating progress bar(s).\n\n Args:\n console (Console, optional): Optional Console instance. Defaults to an internal Console instance writing to stdout.\n auto_refresh (bool, optional): Enable auto refresh. If disabled, you will need to call `refresh()`.\n refresh_per_second (Optional[float], optional): Number of times per second to refresh the progress information or None to use default (10). Defaults to None.\n speed_estimate_period: (float, optional): Period (in seconds) used to calculate the speed estimate. Defaults to 30.\n transient: (bool, optional): Clear the progress on exit. Defaults to False.\n redirect_stdout: (bool, optional): Enable redirection of stdout, so ``print`` may be used. Defaults to True.\n redirect_stderr: (bool, optional): Enable redirection of stderr. Defaults to True.\n get_time: (Callable, optional): A callable that gets the current time, or None to use Console.get_time. Defaults to None.\n disable (bool, optional): Disable progress display. Defaults to False\n expand (bool, optional): Expand tasks table to fit width. Defaults to False.\n \"\"\"\n\n def __init__(\n self,\n *columns: Union[str, ProgressColumn],\n console: Optional[Console] = None,\n auto_refresh: bool = True,\n refresh_per_second: float = 10,\n speed_estimate_period: float = 30.0,\n transient: bool = False,\n redirect_stdout: bool = True,\n redirect_stderr: bool = True,\n get_time: Optional[GetTimeCallable] = None,\n disable: bool = False,\n expand: bool = False,\n ) -> None:\n assert refresh_per_second > 0, \"refresh_per_second must be > 0\"\n self._lock = RLock()\n self.columns = columns or self.get_default_columns()\n self.speed_estimate_period = speed_estimate_period\n\n self.disable = disable\n self.expand = expand\n self._tasks: Dict[TaskID, Task] = {}\n self._task_index: TaskID = TaskID(0)\n self.live = Live(\n console=console or get_console(),\n auto_refresh=auto_refresh,\n refresh_per_second=refresh_per_second,\n transient=transient,\n redirect_stdout=redirect_stdout,\n redirect_stderr=redirect_stderr,\n get_renderable=self.get_renderable,\n )\n self.get_time = get_time or self.console.get_time\n self.print = self.console.print\n self.log = self.console.log\n\n @classmethod\n def get_default_columns(cls) -> Tuple[ProgressColumn, ...]:\n \"\"\"Get the default columns used for a new Progress instance:\n - a text column for the description (TextColumn)\n - the bar itself (BarColumn)\n - a text column showing completion percentage (TextColumn)\n - an estimated-time-remaining column (TimeRemainingColumn)\n If the Progress instance is created without passing a columns argument,\n the default columns defined here will be used.\n\n You can also create a Progress instance using custom columns before\n and/or after the defaults, as in this example:\n\n progress = Progress(\n SpinnerColumn(),\n *Progress.get_default_columns(),\n \"Elapsed:\",\n TimeElapsedColumn(),\n )\n\n This code shows the creation of a Progress display, containing\n a spinner to the left, the default columns, and a labeled elapsed\n time column.\n \"\"\"\n return (\n TextColumn(\"[progress.description]{task.description}\"),\n BarColumn(),\n TaskProgressColumn(),\n TimeRemainingColumn(),\n )\n\n @property\n def console(self) -> Console:\n return self.live.console\n\n @property\n def tasks(self) -> List[Task]:\n \"\"\"Get a list of Task instances.\"\"\"\n with self._lock:\n return list(self._tasks.values())\n\n @property\n def task_ids(self) -> List[TaskID]:\n \"\"\"A list of task IDs.\"\"\"\n with self._lock:\n return list(self._tasks.keys())\n\n @property\n def finished(self) -> bool:\n \"\"\"Check if all tasks have been completed.\"\"\"\n with self._lock:\n if not self._tasks:\n return True\n return all(task.finished for task in self._tasks.values())\n\n def start(self) -> None:\n \"\"\"Start the progress display.\"\"\"\n if not self.disable:\n self.live.start(refresh=True)\n\n def stop(self) -> None:\n \"\"\"Stop the progress display.\"\"\"\n self.live.stop()\n if not self.console.is_interactive and not self.console.is_jupyter:\n self.console.print()\n\n def __enter__(self) -> Self:\n self.start()\n return self\n\n def __exit__(\n self,\n exc_type: Optional[Type[BaseException]],\n exc_val: Optional[BaseException],\n exc_tb: Optional[TracebackType],\n ) -> None:\n self.stop()\n\n def track(\n self,\n sequence: Union[Iterable[ProgressType], Sequence[ProgressType]],\n total: Optional[float] = None,\n completed: int = 0,\n task_id: Optional[TaskID] = None,\n description: str = \"Working...\",\n update_period: float = 0.1,\n ) -> Iterable[ProgressType]:\n \"\"\"Track progress by iterating over a sequence.\n\n Args:\n sequence (Sequence[ProgressType]): A sequence of values you want to iterate over and track progress.\n total: (float, optional): Total number of steps. Default is len(sequence).\n completed (int, optional): Number of steps completed so far. Defaults to 0.\n task_id: (TaskID): Task to track. Default is new task.\n description: (str, optional): Description of task, if new task is created.\n update_period (float, optional): Minimum time (in seconds) between calls to update(). Defaults to 0.1.\n\n Returns:\n Iterable[ProgressType]: An iterable of values taken from the provided sequence.\n \"\"\"\n if total is None:\n total = float(length_hint(sequence)) or None\n\n if task_id is None:\n task_id = self.add_task(description, total=total, completed=completed)\n else:\n self.update(task_id, total=total, completed=completed)\n\n if self.live.auto_refresh:\n with _TrackThread(self, task_id, update_period) as track_thread:\n for value in sequence:\n yield value\n track_thread.completed += 1\n else:\n advance = self.advance\n refresh = self.refresh\n for value in sequence:\n yield value\n advance(task_id, 1)\n refresh()\n\n def wrap_file(\n self,\n file: BinaryIO,\n total: Optional[int] = None,\n *,\n task_id: Optional[TaskID] = None,\n description: str = \"Reading...\",\n ) -> BinaryIO:\n \"\"\"Track progress file reading from a binary file.\n\n Args:\n file (BinaryIO): A file-like object opened in binary mode.\n total (int, optional): Total number of bytes to read. This must be provided unless a task with a total is also given.\n task_id (TaskID): Task to track. Default is new task.\n description (str, optional): Description of task, if new task is created.\n\n Returns:\n BinaryIO: A readable file-like object in binary mode.\n\n Raises:\n ValueError: When no total value can be extracted from the arguments or the task.\n \"\"\"\n # attempt to recover the total from the task\n total_bytes: Optional[float] = None\n if total is not None:\n total_bytes = total\n elif task_id is not None:\n with self._lock:\n total_bytes = self._tasks[task_id].total\n if total_bytes is None:\n raise ValueError(\n f\"unable to get the total number of bytes, please specify 'total'\"\n )\n\n # update total of task or create new task\n if task_id is None:\n task_id = self.add_task(description, total=total_bytes)\n else:\n self.update(task_id, total=total_bytes)\n\n return _Reader(file, self, task_id, close_handle=False)\n\n @typing.overload\n def open(\n self,\n file: Union[str, \"PathLike[str]\", bytes],\n mode: Literal[\"rb\"],\n buffering: int = -1,\n encoding: Optional[str] = None,\n errors: Optional[str] = None,\n newline: Optional[str] = None,\n *,\n total: Optional[int] = None,\n task_id: Optional[TaskID] = None,\n description: str = \"Reading...\",\n ) -> BinaryIO:\n pass\n\n @typing.overload\n def open(\n self,\n file: Union[str, \"PathLike[str]\", bytes],\n mode: Union[Literal[\"r\"], Literal[\"rt\"]],\n buffering: int = -1,\n encoding: Optional[str] = None,\n errors: Optional[str] = None,\n newline: Optional[str] = None,\n *,\n total: Optional[int] = None,\n task_id: Optional[TaskID] = None,\n description: str = \"Reading...\",\n ) -> TextIO:\n pass\n\n def open(\n self,\n file: Union[str, \"PathLike[str]\", bytes],\n mode: Union[Literal[\"rb\"], Literal[\"rt\"], Literal[\"r\"]] = \"r\",\n buffering: int = -1,\n encoding: Optional[str] = None,\n errors: Optional[str] = None,\n newline: Optional[str] = None,\n *,\n total: Optional[int] = None,\n task_id: Optional[TaskID] = None,\n description: str = \"Reading...\",\n ) -> Union[BinaryIO, TextIO]:\n \"\"\"Track progress while reading from a binary file.\n\n Args:\n path (Union[str, PathLike[str]]): The path to the file to read.\n mode (str): The mode to use to open the file. Only supports \"r\", \"rb\" or \"rt\".\n buffering (int): The buffering strategy to use, see :func:`io.open`.\n encoding (str, optional): The encoding to use when reading in text mode, see :func:`io.open`.\n errors (str, optional): The error handling strategy for decoding errors, see :func:`io.open`.\n newline (str, optional): The strategy for handling newlines in text mode, see :func:`io.open`.\n total (int, optional): Total number of bytes to read. If none given, os.stat(path).st_size is used.\n task_id (TaskID): Task to track. Default is new task.\n description (str, optional): Description of task, if new task is created.\n\n Returns:\n BinaryIO: A readable file-like object in binary mode.\n\n Raises:\n ValueError: When an invalid mode is given.\n \"\"\"\n # normalize the mode (always rb, rt)\n _mode = \"\".join(sorted(mode, reverse=False))\n if _mode not in (\"br\", \"rt\", \"r\"):\n raise ValueError(f\"invalid mode {mode!r}\")\n\n # patch buffering to provide the same behaviour as the builtin `open`\n line_buffering = buffering == 1\n if _mode == \"br\" and buffering == 1:\n warnings.warn(\n \"line buffering (buffering=1) isn't supported in binary mode, the default buffer size will be used\",\n RuntimeWarning,\n )\n buffering = -1\n elif _mode in (\"rt\", \"r\"):\n if buffering == 0:\n raise ValueError(\"can't have unbuffered text I/O\")\n elif buffering == 1:\n buffering = -1\n\n # attempt to get the total with `os.stat`\n if total is None:\n total = stat(file).st_size\n\n # update total of task or create new task\n if task_id is None:\n task_id = self.add_task(description, total=total)\n else:\n self.update(task_id, total=total)\n\n # open the file in binary mode,\n handle = io.open(file, \"rb\", buffering=buffering)\n reader = _Reader(handle, self, task_id, close_handle=True)\n\n # wrap the reader in a `TextIOWrapper` if text mode\n if mode in (\"r\", \"rt\"):\n return io.TextIOWrapper(\n reader,\n encoding=encoding,\n errors=errors,\n newline=newline,\n line_buffering=line_buffering,\n )\n\n return reader\n\n def start_task(self, task_id: TaskID) -> None:\n \"\"\"Start a task.\n\n Starts a task (used when calculating elapsed time). You may need to call this manually,\n if you called ``add_task`` with ``start=False``.\n\n Args:\n task_id (TaskID): ID of task.\n \"\"\"\n with self._lock:\n task = self._tasks[task_id]\n if task.start_time is None:\n task.start_time = self.get_time()\n\n def stop_task(self, task_id: TaskID) -> None:\n \"\"\"Stop a task.\n\n This will freeze the elapsed time on the task.\n\n Args:\n task_id (TaskID): ID of task.\n \"\"\"\n with self._lock:\n task = self._tasks[task_id]\n current_time = self.get_time()\n if task.start_time is None:\n task.start_time = current_time\n task.stop_time = current_time\n\n def update(\n self,\n task_id: TaskID,\n *,\n total: Optional[float] = None,\n completed: Optional[float] = None,\n advance: Optional[float] = None,\n description: Optional[str] = None,\n visible: Optional[bool] = None,\n refresh: bool = False,\n **fields: Any,\n ) -> None:\n \"\"\"Update information associated with a task.\n\n Args:\n task_id (TaskID): Task id (returned by add_task).\n total (float, optional): Updates task.total if not None.\n completed (float, optional): Updates task.completed if not None.\n advance (float, optional): Add a value to task.completed if not None.\n description (str, optional): Change task description if not None.\n visible (bool, optional): Set visible flag if not None.\n refresh (bool): Force a refresh of progress information. Default is False.\n **fields (Any): Additional data fields required for rendering.\n \"\"\"\n with self._lock:\n task = self._tasks[task_id]\n completed_start = task.completed\n\n if total is not None and total != task.total:\n task.total = total\n task._reset()\n if advance is not None:\n task.completed += advance\n if completed is not None:\n task.completed = completed\n if description is not None:\n task.description = description\n if visible is not None:\n task.visible = visible\n task.fields.update(fields)\n update_completed = task.completed - completed_start\n\n current_time = self.get_time()\n old_sample_time = current_time - self.speed_estimate_period\n _progress = task._progress\n\n popleft = _progress.popleft\n while _progress and _progress[0].timestamp < old_sample_time:\n popleft()\n if update_completed > 0:\n _progress.append(ProgressSample(current_time, update_completed))\n if (\n task.total is not None\n and task.completed >= task.total\n and task.finished_time is None\n ):\n task.finished_time = task.elapsed\n\n if refresh:\n self.refresh()\n\n def reset(\n self,\n task_id: TaskID,\n *,\n start: bool = True,\n total: Optional[float] = None,\n completed: int = 0,\n visible: Optional[bool] = None,\n description: Optional[str] = None,\n **fields: Any,\n ) -> None:\n \"\"\"Reset a task so completed is 0 and the clock is reset.\n\n Args:\n task_id (TaskID): ID of task.\n start (bool, optional): Start the task after reset. Defaults to True.\n total (float, optional): New total steps in task, or None to use current total. Defaults to None.\n completed (int, optional): Number of steps completed. Defaults to 0.\n visible (bool, optional): Enable display of the task. Defaults to True.\n description (str, optional): Change task description if not None. Defaults to None.\n **fields (str): Additional data fields required for rendering.\n \"\"\"\n current_time = self.get_time()\n with self._lock:\n task = self._tasks[task_id]\n task._reset()\n task.start_time = current_time if start else None\n if total is not None:\n task.total = total\n task.completed = completed\n if visible is not None:\n task.visible = visible\n if fields:\n task.fields = fields\n if description is not None:\n task.description = description\n task.finished_time = None\n self.refresh()\n\n def advance(self, task_id: TaskID, advance: float = 1) -> None:\n \"\"\"Advance task by a number of steps.\n\n Args:\n task_id (TaskID): ID of task.\n advance (float): Number of steps to advance. Default is 1.\n \"\"\"\n current_time = self.get_time()\n with self._lock:\n task = self._tasks[task_id]\n completed_start = task.completed\n task.completed += advance\n update_completed = task.completed - completed_start\n old_sample_time = current_time - self.speed_estimate_period\n _progress = task._progress\n\n popleft = _progress.popleft\n while _progress and _progress[0].timestamp < old_sample_time:\n popleft()\n while len(_progress) > 1000:\n popleft()\n _progress.append(ProgressSample(current_time, update_completed))\n if (\n task.total is not None\n and task.completed >= task.total\n and task.finished_time is None\n ):\n task.finished_time = task.elapsed\n task.finished_speed = task.speed\n\n def refresh(self) -> None:\n \"\"\"Refresh (render) the progress information.\"\"\"\n if not self.disable and self.live.is_started:\n self.live.refresh()\n\n def get_renderable(self) -> RenderableType:\n \"\"\"Get a renderable for the progress display.\"\"\"\n renderable = Group(*self.get_renderables())\n return renderable\n\n def get_renderables(self) -> Iterable[RenderableType]:\n \"\"\"Get a number of renderables for the progress display.\"\"\"\n table = self.make_tasks_table(self.tasks)\n yield table\n\n def make_tasks_table(self, tasks: Iterable[Task]) -> Table:\n \"\"\"Get a table to render the Progress display.\n\n Args:\n tasks (Iterable[Task]): An iterable of Task instances, one per row of the table.\n\n Returns:\n Table: A table instance.\n \"\"\"\n table_columns = (\n (\n Column(no_wrap=True)\n if isinstance(_column, str)\n else _column.get_table_column().copy()\n )\n for _column in self.columns\n )\n table = Table.grid(*table_columns, padding=(0, 1), expand=self.expand)\n\n for task in tasks:\n if task.visible:\n table.add_row(\n *(\n (\n column.format(task=task)\n if isinstance(column, str)\n else column(task)\n )\n for column in self.columns\n )\n )\n return table\n\n def __rich__(self) -> RenderableType:\n \"\"\"Makes the Progress class itself renderable.\"\"\"\n with self._lock:\n return self.get_renderable()\n\n def add_task(\n self,\n description: str,\n start: bool = True,\n total: Optional[float] = 100.0,\n completed: int = 0,\n visible: bool = True,\n **fields: Any,\n ) -> TaskID:\n \"\"\"Add a new 'task' to the Progress display.\n\n Args:\n description (str): A description of the task.\n start (bool, optional): Start the task immediately (to calculate elapsed time). If set to False,\n you will need to call `start` manually. Defaults to True.\n total (float, optional): Number of total steps in the progress if known.\n Set to None to render a pulsing animation. Defaults to 100.\n completed (int, optional): Number of steps completed so far. Defaults to 0.\n visible (bool, optional): Enable display of the task. Defaults to True.\n **fields (str): Additional data fields required for rendering.\n\n Returns:\n TaskID: An ID you can use when calling `update`.\n \"\"\"\n with self._lock:\n task = Task(\n self._task_index,\n description,\n total,\n completed,\n visible=visible,\n fields=fields,\n _get_time=self.get_time,\n _lock=self._lock,\n )\n self._tasks[self._task_index] = task\n if start:\n self.start_task(self._task_index)\n new_task_index = self._task_index\n self._task_index = TaskID(int(self._task_index) + 1)\n self.refresh()\n return new_task_index\n\n def remove_task(self, task_id: TaskID) -> None:\n \"\"\"Delete a task if it exists.\n\n Args:\n task_id (TaskID): A task ID.\n\n \"\"\"\n with self._lock:\n del self._tasks[task_id]\n\n\nif __name__ == \"__main__\": # pragma: no coverage\n import random\n import time\n\n from .panel import Panel\n from .rule import Rule\n from .syntax import Syntax\n from .table import Table\n\n syntax = Syntax(\n '''def loop_last(values: Iterable[T]) -> Iterable[Tuple[bool, T]]:\n \"\"\"Iterate and generate a tuple with a flag for last value.\"\"\"\n iter_values = iter(values)\n try:\n previous_value = next(iter_values)\n except StopIteration:\n return\n for value in iter_values:\n yield False, previous_value\n previous_value = value\n yield True, previous_value''',\n \"python\",\n line_numbers=True,\n )\n\n table = Table(\"foo\", \"bar\", \"baz\")\n table.add_row(\"1\", \"2\", \"3\")\n\n progress_renderables = [\n \"Text may be printed while the progress bars are rendering.\",\n Panel(\"In fact, [i]any[/i] renderable will work\"),\n \"Such as [magenta]tables[/]...\",\n table,\n \"Pretty printed structures...\",\n {\"type\": \"example\", \"text\": \"Pretty printed\"},\n \"Syntax...\",\n syntax,\n Rule(\"Give it a try!\"),\n ]\n\n from itertools import cycle\n\n examples = cycle(progress_renderables)\n\n console = Console(record=True)\n\n with Progress(\n SpinnerColumn(),\n *Progress.get_default_columns(),\n TimeElapsedColumn(),\n console=console,\n transient=False,\n ) as progress:\n task1 = progress.add_task(\"[red]Downloading\", total=1000)\n task2 = progress.add_task(\"[green]Processing\", total=1000)\n task3 = progress.add_task(\"[yellow]Thinking\", total=None)\n\n while not progress.finished:\n progress.update(task1, advance=0.5)\n progress.update(task2, advance=0.3)\n time.sleep(0.01)\n if random.randint(0, 100) < 1:\n progress.log(next(examples))\n",[],[213,919,920,921,1016,1050,1511,1673],"0bc25824-67fc-11f0-84bb-0224a6c84d84","pretty.py","0bc25928-67fc-11f0-84bb-0224a6c84d84",433,["D",1753299267509],"import builtins\nimport collections\nimport dataclasses\nimport inspect\nimport os\nimport reprlib\nimport sys\nfrom array import array\nfrom collections import Counter, UserDict, UserList, defaultdict, deque\nfrom dataclasses import dataclass, fields, is_dataclass\nfrom inspect import isclass\nfrom itertools import islice\nfrom types import MappingProxyType\nfrom typing import (\n TYPE_CHECKING,\n Any,\n Callable,\n DefaultDict,\n Deque,\n Dict,\n Iterable,\n List,\n Optional,\n Sequence,\n Set,\n Tuple,\n Union,\n)\n\nfrom pip._vendor.rich.repr import RichReprResult\n\ntry:\n import attr as _attr_module\n\n _has_attrs = hasattr(_attr_module, \"ib\")\nexcept ImportError: # pragma: no cover\n _has_attrs = False\n\nfrom . import get_console\nfrom ._loop import loop_last\nfrom ._pick import pick_bool\nfrom .abc import RichRenderable\nfrom .cells import cell_len\nfrom .highlighter import ReprHighlighter\nfrom .jupyter import JupyterMixin, JupyterRenderable\nfrom .measure import Measurement\nfrom .text import Text\n\nif TYPE_CHECKING:\n from .console import (\n Console,\n ConsoleOptions,\n HighlighterType,\n JustifyMethod,\n OverflowMethod,\n RenderResult,\n )\n\n\ndef _is_attr_object(obj: Any) -> bool:\n \"\"\"Check if an object was created with attrs module.\"\"\"\n return _has_attrs and _attr_module.has(type(obj))\n\n\ndef _get_attr_fields(obj: Any) -> Sequence[\"_attr_module.Attribute[Any]\"]:\n \"\"\"Get fields for an attrs object.\"\"\"\n return _attr_module.fields(type(obj)) if _has_attrs else []\n\n\ndef _is_dataclass_repr(obj: object) -> bool:\n \"\"\"Check if an instance of a dataclass contains the default repr.\n\n Args:\n obj (object): A dataclass instance.\n\n Returns:\n bool: True if the default repr is used, False if there is a custom repr.\n \"\"\"\n # Digging in to a lot of internals here\n # Catching all exceptions in case something is missing on a non CPython implementation\n try:\n return obj.__repr__.__code__.co_filename in (\n dataclasses.__file__,\n reprlib.__file__,\n )\n except Exception: # pragma: no coverage\n return False\n\n\n_dummy_namedtuple = collections.namedtuple(\"_dummy_namedtuple\", [])\n\n\ndef _has_default_namedtuple_repr(obj: object) -> bool:\n \"\"\"Check if an instance of namedtuple contains the default repr\n\n Args:\n obj (object): A namedtuple\n\n Returns:\n bool: True if the default repr is used, False if there's a custom repr.\n \"\"\"\n obj_file = None\n try:\n obj_file = inspect.getfile(obj.__repr__)\n except (OSError, TypeError):\n # OSError handles case where object is defined in __main__ scope, e.g. REPL - no filename available.\n # TypeError trapped defensively, in case of object without filename slips through.\n pass\n default_repr_file = inspect.getfile(_dummy_namedtuple.__repr__)\n return obj_file == default_repr_file\n\n\ndef _ipy_display_hook(\n value: Any,\n console: Optional[\"Console\"] = None,\n overflow: \"OverflowMethod\" = \"ignore\",\n crop: bool = False,\n indent_guides: bool = False,\n max_length: Optional[int] = None,\n max_string: Optional[int] = None,\n max_depth: Optional[int] = None,\n expand_all: bool = False,\n) -> Union[str, None]:\n # needed here to prevent circular import:\n from .console import ConsoleRenderable\n\n # always skip rich generated jupyter renderables or None values\n if _safe_isinstance(value, JupyterRenderable) or value is None:\n return None\n\n console = console or get_console()\n\n with console.capture() as capture:\n # certain renderables should start on a new line\n if _safe_isinstance(value, ConsoleRenderable):\n console.line()\n console.print(\n (\n value\n if _safe_isinstance(value, RichRenderable)\n else Pretty(\n value,\n overflow=overflow,\n indent_guides=indent_guides,\n max_length=max_length,\n max_string=max_string,\n max_depth=max_depth,\n expand_all=expand_all,\n margin=12,\n )\n ),\n crop=crop,\n new_line_start=True,\n end=\"\",\n )\n # strip trailing newline, not usually part of a text repr\n # I'm not sure if this should be prevented at a lower level\n return capture.get().rstrip(\"\\n\")\n\n\ndef _safe_isinstance(\n obj: object, class_or_tuple: Union[type, Tuple[type, ...]]\n) -> bool:\n \"\"\"isinstance can fail in rare cases, for example types with no __class__\"\"\"\n try:\n return isinstance(obj, class_or_tuple)\n except Exception:\n return False\n\n\ndef install(\n console: Optional[\"Console\"] = None,\n overflow: \"OverflowMethod\" = \"ignore\",\n crop: bool = False,\n indent_guides: bool = False,\n max_length: Optional[int] = None,\n max_string: Optional[int] = None,\n max_depth: Optional[int] = None,\n expand_all: bool = False,\n) -> None:\n \"\"\"Install automatic pretty printing in the Python REPL.\n\n Args:\n console (Console, optional): Console instance or ``None`` to use global console. Defaults to None.\n overflow (Optional[OverflowMethod], optional): Overflow method. Defaults to \"ignore\".\n crop (Optional[bool], optional): Enable cropping of long lines. Defaults to False.\n indent_guides (bool, optional): Enable indentation guides. Defaults to False.\n max_length (int, optional): Maximum length of containers before abbreviating, or None for no abbreviation.\n Defaults to None.\n max_string (int, optional): Maximum length of string before truncating, or None to disable. Defaults to None.\n max_depth (int, optional): Maximum depth of nested data structures, or None for no maximum. Defaults to None.\n expand_all (bool, optional): Expand all containers. Defaults to False.\n max_frames (int): Maximum number of frames to show in a traceback, 0 for no maximum. Defaults to 100.\n \"\"\"\n from pip._vendor.rich import get_console\n\n console = console or get_console()\n assert console is not None\n\n def display_hook(value: Any) -> None:\n \"\"\"Replacement sys.displayhook which prettifies objects with Rich.\"\"\"\n if value is not None:\n assert console is not None\n builtins._ = None # type: ignore[attr-defined]\n console.print(\n (\n value\n if _safe_isinstance(value, RichRenderable)\n else Pretty(\n value,\n overflow=overflow,\n indent_guides=indent_guides,\n max_length=max_length,\n max_string=max_string,\n max_depth=max_depth,\n expand_all=expand_all,\n )\n ),\n crop=crop,\n )\n builtins._ = value # type: ignore[attr-defined]\n\n try:\n ip = get_ipython() # type: ignore[name-defined]\n except NameError:\n sys.displayhook = display_hook\n else:\n from IPython.core.formatters import BaseFormatter\n\n class RichFormatter(BaseFormatter): # type: ignore[misc]\n pprint: bool = True\n\n def __call__(self, value: Any) -> Any:\n if self.pprint:\n return _ipy_display_hook(\n value,\n console=get_console(),\n overflow=overflow,\n indent_guides=indent_guides,\n max_length=max_length,\n max_string=max_string,\n max_depth=max_depth,\n expand_all=expand_all,\n )\n else:\n return repr(value)\n\n # replace plain text formatter with rich formatter\n rich_formatter = RichFormatter()\n ip.display_formatter.formatters[\"text/plain\"] = rich_formatter\n\n\nclass Pretty(JupyterMixin):\n \"\"\"A rich renderable that pretty prints an object.\n\n Args:\n _object (Any): An object to pretty print.\n highlighter (HighlighterType, optional): Highlighter object to apply to result, or None for ReprHighlighter. Defaults to None.\n indent_size (int, optional): Number of spaces in indent. Defaults to 4.\n justify (JustifyMethod, optional): Justify method, or None for default. Defaults to None.\n overflow (OverflowMethod, optional): Overflow method, or None for default. Defaults to None.\n no_wrap (Optional[bool], optional): Disable word wrapping. Defaults to False.\n indent_guides (bool, optional): Enable indentation guides. Defaults to False.\n max_length (int, optional): Maximum length of containers before abbreviating, or None for no abbreviation.\n Defaults to None.\n max_string (int, optional): Maximum length of string before truncating, or None to disable. Defaults to None.\n max_depth (int, optional): Maximum depth of nested data structures, or None for no maximum. Defaults to None.\n expand_all (bool, optional): Expand all containers. Defaults to False.\n margin (int, optional): Subtrace a margin from width to force containers to expand earlier. Defaults to 0.\n insert_line (bool, optional): Insert a new line if the output has multiple new lines. Defaults to False.\n \"\"\"\n\n def __init__(\n self,\n _object: Any,\n highlighter: Optional[\"HighlighterType\"] = None,\n *,\n indent_size: int = 4,\n justify: Optional[\"JustifyMethod\"] = None,\n overflow: Optional[\"OverflowMethod\"] = None,\n no_wrap: Optional[bool] = False,\n indent_guides: bool = False,\n max_length: Optional[int] = None,\n max_string: Optional[int] = None,\n max_depth: Optional[int] = None,\n expand_all: bool = False,\n margin: int = 0,\n insert_line: bool = False,\n ) -> None:\n self._object = _object\n self.highlighter = highlighter or ReprHighlighter()\n self.indent_size = indent_size\n self.justify: Optional[\"JustifyMethod\"] = justify\n self.overflow: Optional[\"OverflowMethod\"] = overflow\n self.no_wrap = no_wrap\n self.indent_guides = indent_guides\n self.max_length = max_length\n self.max_string = max_string\n self.max_depth = max_depth\n self.expand_all = expand_all\n self.margin = margin\n self.insert_line = insert_line\n\n def __rich_console__(\n self, console: \"Console\", options: \"ConsoleOptions\"\n ) -> \"RenderResult\":\n pretty_str = pretty_repr(\n self._object,\n max_width=options.max_width - self.margin,\n indent_size=self.indent_size,\n max_length=self.max_length,\n max_string=self.max_string,\n max_depth=self.max_depth,\n expand_all=self.expand_all,\n )\n pretty_text = Text.from_ansi(\n pretty_str,\n justify=self.justify or options.justify,\n overflow=self.overflow or options.overflow,\n no_wrap=pick_bool(self.no_wrap, options.no_wrap),\n style=\"pretty\",\n )\n pretty_text = (\n self.highlighter(pretty_text)\n if pretty_text\n else Text(\n f\"{type(self._object)}.__repr__ returned empty string\",\n style=\"dim italic\",\n )\n )\n if self.indent_guides and not options.ascii_only:\n pretty_text = pretty_text.with_indent_guides(\n self.indent_size, style=\"repr.indent\"\n )\n if self.insert_line and \"\\n\" in pretty_text:\n yield \"\"\n yield pretty_text\n\n def __rich_measure__(\n self, console: \"Console\", options: \"ConsoleOptions\"\n ) -> \"Measurement\":\n pretty_str = pretty_repr(\n self._object,\n max_width=options.max_width,\n indent_size=self.indent_size,\n max_length=self.max_length,\n max_string=self.max_string,\n max_depth=self.max_depth,\n expand_all=self.expand_all,\n )\n text_width = (\n max(cell_len(line) for line in pretty_str.splitlines()) if pretty_str else 0\n )\n return Measurement(text_width, text_width)\n\n\ndef _get_braces_for_defaultdict(_object: DefaultDict[Any, Any]) -> Tuple[str, str, str]:\n return (\n f\"defaultdict({_object.default_factory!r}, {{\",\n \"})\",\n f\"defaultdict({_object.default_factory!r}, {{}})\",\n )\n\n\ndef _get_braces_for_deque(_object: Deque[Any]) -> Tuple[str, str, str]:\n if _object.maxlen is None:\n return (\"deque([\", \"])\", \"deque()\")\n return (\n \"deque([\",\n f\"], maxlen={_object.maxlen})\",\n f\"deque(maxlen={_object.maxlen})\",\n )\n\n\ndef _get_braces_for_array(_object: \"array[Any]\") -> Tuple[str, str, str]:\n return (f\"array({_object.typecode!r}, [\", \"])\", f\"array({_object.typecode!r})\")\n\n\n_BRACES: Dict[type, Callable[[Any], Tuple[str, str, str]]] = {\n os._Environ: lambda _object: (\"environ({\", \"})\", \"environ({})\"),\n array: _get_braces_for_array,\n defaultdict: _get_braces_for_defaultdict,\n Counter: lambda _object: (\"Counter({\", \"})\", \"Counter()\"),\n deque: _get_braces_for_deque,\n dict: lambda _object: (\"{\", \"}\", \"{}\"),\n UserDict: lambda _object: (\"{\", \"}\", \"{}\"),\n frozenset: lambda _object: (\"frozenset({\", \"})\", \"frozenset()\"),\n list: lambda _object: (\"[\", \"]\", \"[]\"),\n UserList: lambda _object: (\"[\", \"]\", \"[]\"),\n set: lambda _object: (\"{\", \"}\", \"set()\"),\n tuple: lambda _object: (\"(\", \")\", \"()\"),\n MappingProxyType: lambda _object: (\"mappingproxy({\", \"})\", \"mappingproxy({})\"),\n}\n_CONTAINERS = tuple(_BRACES.keys())\n_MAPPING_CONTAINERS = (dict, os._Environ, MappingProxyType, UserDict)\n\n\ndef is_expandable(obj: Any) -> bool:\n \"\"\"Check if an object may be expanded by pretty print.\"\"\"\n return (\n _safe_isinstance(obj, _CONTAINERS)\n or (is_dataclass(obj))\n or (hasattr(obj, \"__rich_repr__\"))\n or _is_attr_object(obj)\n ) and not isclass(obj)\n\n\n@dataclass\nclass Node:\n \"\"\"A node in a repr tree. May be atomic or a container.\"\"\"\n\n key_repr: str = \"\"\n value_repr: str = \"\"\n open_brace: str = \"\"\n close_brace: str = \"\"\n empty: str = \"\"\n last: bool = False\n is_tuple: bool = False\n is_namedtuple: bool = False\n children: Optional[List[\"Node\"]] = None\n key_separator: str = \": \"\n separator: str = \", \"\n\n def iter_tokens(self) -> Iterable[str]:\n \"\"\"Generate tokens for this node.\"\"\"\n if self.key_repr:\n yield self.key_repr\n yield self.key_separator\n if self.value_repr:\n yield self.value_repr\n elif self.children is not None:\n if self.children:\n yield self.open_brace\n if self.is_tuple and not self.is_namedtuple and len(self.children) == 1:\n yield from self.children[0].iter_tokens()\n yield \",\"\n else:\n for child in self.children:\n yield from child.iter_tokens()\n if not child.last:\n yield self.separator\n yield self.close_brace\n else:\n yield self.empty\n\n def check_length(self, start_length: int, max_length: int) -> bool:\n \"\"\"Check the length fits within a limit.\n\n Args:\n start_length (int): Starting length of the line (indent, prefix, suffix).\n max_length (int): Maximum length.\n\n Returns:\n bool: True if the node can be rendered within max length, otherwise False.\n \"\"\"\n total_length = start_length\n for token in self.iter_tokens():\n total_length += cell_len(token)\n if total_length > max_length:\n return False\n return True\n\n def __str__(self) -> str:\n repr_text = \"\".join(self.iter_tokens())\n return repr_text\n\n def render(\n self, max_width: int = 80, indent_size: int = 4, expand_all: bool = False\n ) -> str:\n \"\"\"Render the node to a pretty repr.\n\n Args:\n max_width (int, optional): Maximum width of the repr. Defaults to 80.\n indent_size (int, optional): Size of indents. Defaults to 4.\n expand_all (bool, optional): Expand all levels. Defaults to False.\n\n Returns:\n str: A repr string of the original object.\n \"\"\"\n lines = [_Line(node=self, is_root=True)]\n line_no = 0\n while line_no < len(lines):\n line = lines[line_no]\n if line.expandable and not line.expanded:\n if expand_all or not line.check_length(max_width):\n lines[line_no : line_no + 1] = line.expand(indent_size)\n line_no += 1\n\n repr_str = \"\\n\".join(str(line) for line in lines)\n return repr_str\n\n\n@dataclass\nclass _Line:\n \"\"\"A line in repr output.\"\"\"\n\n parent: Optional[\"_Line\"] = None\n is_root: bool = False\n node: Optional[Node] = None\n text: str = \"\"\n suffix: str = \"\"\n whitespace: str = \"\"\n expanded: bool = False\n last: bool = False\n\n @property\n def expandable(self) -> bool:\n \"\"\"Check if the line may be expanded.\"\"\"\n return bool(self.node is not None and self.node.children)\n\n def check_length(self, max_length: int) -> bool:\n \"\"\"Check this line fits within a given number of cells.\"\"\"\n start_length = (\n len(self.whitespace) + cell_len(self.text) + cell_len(self.suffix)\n )\n assert self.node is not None\n return self.node.check_length(start_length, max_length)\n\n def expand(self, indent_size: int) -> Iterable[\"_Line\"]:\n \"\"\"Expand this line by adding children on their own line.\"\"\"\n node = self.node\n assert node is not None\n whitespace = self.whitespace\n assert node.children\n if node.key_repr:\n new_line = yield _Line(\n text=f\"{node.key_repr}{node.key_separator}{node.open_brace}\",\n whitespace=whitespace,\n )\n else:\n new_line = yield _Line(text=node.open_brace, whitespace=whitespace)\n child_whitespace = self.whitespace + \" \" * indent_size\n tuple_of_one = node.is_tuple and len(node.children) == 1\n for last, child in loop_last(node.children):\n separator = \",\" if tuple_of_one else node.separator\n line = _Line(\n parent=new_line,\n node=child,\n whitespace=child_whitespace,\n suffix=separator,\n last=last and not tuple_of_one,\n )\n yield line\n\n yield _Line(\n text=node.close_brace,\n whitespace=whitespace,\n suffix=self.suffix,\n last=self.last,\n )\n\n def __str__(self) -> str:\n if self.last:\n return f\"{self.whitespace}{self.text}{self.node or ''}\"\n else:\n return (\n f\"{self.whitespace}{self.text}{self.node or ''}{self.suffix.rstrip()}\"\n )\n\n\ndef _is_namedtuple(obj: Any) -> bool:\n \"\"\"Checks if an object is most likely a namedtuple. It is possible\n to craft an object that passes this check and isn't a namedtuple, but\n there is only a minuscule chance of this happening unintentionally.\n\n Args:\n obj (Any): The object to test\n\n Returns:\n bool: True if the object is a namedtuple. False otherwise.\n \"\"\"\n try:\n fields = getattr(obj, \"_fields\", None)\n except Exception:\n # Being very defensive - if we cannot get the attr then its not a namedtuple\n return False\n return isinstance(obj, tuple) and isinstance(fields, tuple)\n\n\ndef traverse(\n _object: Any,\n max_length: Optional[int] = None,\n max_string: Optional[int] = None,\n max_depth: Optional[int] = None,\n) -> Node:\n \"\"\"Traverse object and generate a tree.\n\n Args:\n _object (Any): Object to be traversed.\n max_length (int, optional): Maximum length of containers before abbreviating, or None for no abbreviation.\n Defaults to None.\n max_string (int, optional): Maximum length of string before truncating, or None to disable truncating.\n Defaults to None.\n max_depth (int, optional): Maximum depth of data structures, or None for no maximum.\n Defaults to None.\n\n Returns:\n Node: The root of a tree structure which can be used to render a pretty repr.\n \"\"\"\n\n def to_repr(obj: Any) -> str:\n \"\"\"Get repr string for an object, but catch errors.\"\"\"\n if (\n max_string is not None\n and _safe_isinstance(obj, (bytes, str))\n and len(obj) > max_string\n ):\n truncated = len(obj) - max_string\n obj_repr = f\"{obj[:max_string]!r}+{truncated}\"\n else:\n try:\n obj_repr = repr(obj)\n except Exception as error:\n obj_repr = f\"\"\n return obj_repr\n\n visited_ids: Set[int] = set()\n push_visited = visited_ids.add\n pop_visited = visited_ids.remove\n\n def _traverse(obj: Any, root: bool = False, depth: int = 0) -> Node:\n \"\"\"Walk the object depth first.\"\"\"\n\n obj_id = id(obj)\n if obj_id in visited_ids:\n # Recursion detected\n return Node(value_repr=\"...\")\n\n obj_type = type(obj)\n children: List[Node]\n reached_max_depth = max_depth is not None and depth >= max_depth\n\n def iter_rich_args(rich_args: Any) -> Iterable[Union[Any, Tuple[str, Any]]]:\n for arg in rich_args:\n if _safe_isinstance(arg, tuple):\n if len(arg) == 3:\n key, child, default = arg\n if default == child:\n continue\n yield key, child\n elif len(arg) == 2:\n key, child = arg\n yield key, child\n elif len(arg) == 1:\n yield arg[0]\n else:\n yield arg\n\n try:\n fake_attributes = hasattr(\n obj, \"awehoi234_wdfjwljet234_234wdfoijsdfmmnxpi492\"\n )\n except Exception:\n fake_attributes = False\n\n rich_repr_result: Optional[RichReprResult] = None\n if not fake_attributes:\n try:\n if hasattr(obj, \"__rich_repr__\") and not isclass(obj):\n rich_repr_result = obj.__rich_repr__()\n except Exception:\n pass\n\n if rich_repr_result is not None:\n push_visited(obj_id)\n angular = getattr(obj.__rich_repr__, \"angular\", False)\n args = list(iter_rich_args(rich_repr_result))\n class_name = obj.__class__.__name__\n\n if args:\n children = []\n append = children.append\n\n if reached_max_depth:\n if angular:\n node = Node(value_repr=f\"<{class_name}...>\")\n else:\n node = Node(value_repr=f\"{class_name}(...)\")\n else:\n if angular:\n node = Node(\n open_brace=f\"<{class_name} \",\n close_brace=\">\",\n children=children,\n last=root,\n separator=\" \",\n )\n else:\n node = Node(\n open_brace=f\"{class_name}(\",\n close_brace=\")\",\n children=children,\n last=root,\n )\n for last, arg in loop_last(args):\n if _safe_isinstance(arg, tuple):\n key, child = arg\n child_node = _traverse(child, depth=depth + 1)\n child_node.last = last\n child_node.key_repr = key\n child_node.key_separator = \"=\"\n append(child_node)\n else:\n child_node = _traverse(arg, depth=depth + 1)\n child_node.last = last\n append(child_node)\n else:\n node = Node(\n value_repr=f\"<{class_name}>\" if angular else f\"{class_name}()\",\n children=[],\n last=root,\n )\n pop_visited(obj_id)\n elif _is_attr_object(obj) and not fake_attributes:\n push_visited(obj_id)\n children = []\n append = children.append\n\n attr_fields = _get_attr_fields(obj)\n if attr_fields:\n if reached_max_depth:\n node = Node(value_repr=f\"{obj.__class__.__name__}(...)\")\n else:\n node = Node(\n open_brace=f\"{obj.__class__.__name__}(\",\n close_brace=\")\",\n children=children,\n last=root,\n )\n\n def iter_attrs() -> (\n Iterable[Tuple[str, Any, Optional[Callable[[Any], str]]]]\n ):\n \"\"\"Iterate over attr fields and values.\"\"\"\n for attr in attr_fields:\n if attr.repr:\n try:\n value = getattr(obj, attr.name)\n except Exception as error:\n # Can happen, albeit rarely\n yield (attr.name, error, None)\n else:\n yield (\n attr.name,\n value,\n attr.repr if callable(attr.repr) else None,\n )\n\n for last, (name, value, repr_callable) in loop_last(iter_attrs()):\n if repr_callable:\n child_node = Node(value_repr=str(repr_callable(value)))\n else:\n child_node = _traverse(value, depth=depth + 1)\n child_node.last = last\n child_node.key_repr = name\n child_node.key_separator = \"=\"\n append(child_node)\n else:\n node = Node(\n value_repr=f\"{obj.__class__.__name__}()\", children=[], last=root\n )\n pop_visited(obj_id)\n elif (\n is_dataclass(obj)\n and not _safe_isinstance(obj, type)\n and not fake_attributes\n and _is_dataclass_repr(obj)\n ):\n push_visited(obj_id)\n children = []\n append = children.append\n if reached_max_depth:\n node = Node(value_repr=f\"{obj.__class__.__name__}(...)\")\n else:\n node = Node(\n open_brace=f\"{obj.__class__.__name__}(\",\n close_brace=\")\",\n children=children,\n last=root,\n empty=f\"{obj.__class__.__name__}()\",\n )\n\n for last, field in loop_last(\n field\n for field in fields(obj)\n if field.repr and hasattr(obj, field.name)\n ):\n child_node = _traverse(getattr(obj, field.name), depth=depth + 1)\n child_node.key_repr = field.name\n child_node.last = last\n child_node.key_separator = \"=\"\n append(child_node)\n\n pop_visited(obj_id)\n elif _is_namedtuple(obj) and _has_default_namedtuple_repr(obj):\n push_visited(obj_id)\n class_name = obj.__class__.__name__\n if reached_max_depth:\n # If we've reached the max depth, we still show the class name, but not its contents\n node = Node(\n value_repr=f\"{class_name}(...)\",\n )\n else:\n children = []\n append = children.append\n node = Node(\n open_brace=f\"{class_name}(\",\n close_brace=\")\",\n children=children,\n empty=f\"{class_name}()\",\n )\n for last, (key, value) in loop_last(obj._asdict().items()):\n child_node = _traverse(value, depth=depth + 1)\n child_node.key_repr = key\n child_node.last = last\n child_node.key_separator = \"=\"\n append(child_node)\n pop_visited(obj_id)\n elif _safe_isinstance(obj, _CONTAINERS):\n for container_type in _CONTAINERS:\n if _safe_isinstance(obj, container_type):\n obj_type = container_type\n break\n\n push_visited(obj_id)\n\n open_brace, close_brace, empty = _BRACES[obj_type](obj)\n\n if reached_max_depth:\n node = Node(value_repr=f\"{open_brace}...{close_brace}\")\n elif obj_type.__repr__ != type(obj).__repr__:\n node = Node(value_repr=to_repr(obj), last=root)\n elif obj:\n children = []\n node = Node(\n open_brace=open_brace,\n close_brace=close_brace,\n children=children,\n last=root,\n )\n append = children.append\n num_items = len(obj)\n last_item_index = num_items - 1\n\n if _safe_isinstance(obj, _MAPPING_CONTAINERS):\n iter_items = iter(obj.items())\n if max_length is not None:\n iter_items = islice(iter_items, max_length)\n for index, (key, child) in enumerate(iter_items):\n child_node = _traverse(child, depth=depth + 1)\n child_node.key_repr = to_repr(key)\n child_node.last = index == last_item_index\n append(child_node)\n else:\n iter_values = iter(obj)\n if max_length is not None:\n iter_values = islice(iter_values, max_length)\n for index, child in enumerate(iter_values):\n child_node = _traverse(child, depth=depth + 1)\n child_node.last = index == last_item_index\n append(child_node)\n if max_length is not None and num_items > max_length:\n append(Node(value_repr=f\"... +{num_items - max_length}\", last=True))\n else:\n node = Node(empty=empty, children=[], last=root)\n\n pop_visited(obj_id)\n else:\n node = Node(value_repr=to_repr(obj), last=root)\n node.is_tuple = type(obj) == tuple\n node.is_namedtuple = _is_namedtuple(obj)\n return node\n\n node = _traverse(_object, root=True)\n return node\n\n\ndef pretty_repr(\n _object: Any,\n *,\n max_width: int = 80,\n indent_size: int = 4,\n max_length: Optional[int] = None,\n max_string: Optional[int] = None,\n max_depth: Optional[int] = None,\n expand_all: bool = False,\n) -> str:\n \"\"\"Prettify repr string by expanding on to new lines to fit within a given width.\n\n Args:\n _object (Any): Object to repr.\n max_width (int, optional): Desired maximum width of repr string. Defaults to 80.\n indent_size (int, optional): Number of spaces to indent. Defaults to 4.\n max_length (int, optional): Maximum length of containers before abbreviating, or None for no abbreviation.\n Defaults to None.\n max_string (int, optional): Maximum length of string before truncating, or None to disable truncating.\n Defaults to None.\n max_depth (int, optional): Maximum depth of nested data structure, or None for no depth.\n Defaults to None.\n expand_all (bool, optional): Expand all containers regardless of available width. Defaults to False.\n\n Returns:\n str: A possibly multi-line representation of the object.\n \"\"\"\n\n if _safe_isinstance(_object, Node):\n node = _object\n else:\n node = traverse(\n _object, max_length=max_length, max_string=max_string, max_depth=max_depth\n )\n repr_str: str = node.render(\n max_width=max_width, indent_size=indent_size, expand_all=expand_all\n )\n return repr_str\n\n\ndef pprint(\n _object: Any,\n *,\n console: Optional[\"Console\"] = None,\n indent_guides: bool = True,\n max_length: Optional[int] = None,\n max_string: Optional[int] = None,\n max_depth: Optional[int] = None,\n expand_all: bool = False,\n) -> None:\n \"\"\"A convenience function for pretty printing.\n\n Args:\n _object (Any): Object to pretty print.\n console (Console, optional): Console instance, or None to use default. Defaults to None.\n max_length (int, optional): Maximum length of containers before abbreviating, or None for no abbreviation.\n Defaults to None.\n max_string (int, optional): Maximum length of strings before truncating, or None to disable. Defaults to None.\n max_depth (int, optional): Maximum depth for nested data structures, or None for unlimited depth. Defaults to None.\n indent_guides (bool, optional): Enable indentation guides. Defaults to True.\n expand_all (bool, optional): Expand all containers. Defaults to False.\n \"\"\"\n _console = get_console() if console is None else console\n _console.print(\n Pretty(\n _object,\n max_length=max_length,\n max_string=max_string,\n max_depth=max_depth,\n indent_guides=indent_guides,\n expand_all=expand_all,\n overflow=\"ignore\",\n ),\n soft_wrap=True,\n )\n\n\nif __name__ == \"__main__\": # pragma: no cover\n\n class BrokenRepr:\n def __repr__(self) -> str:\n 1 / 0\n return \"this will fail\"\n\n from typing import NamedTuple\n\n class StockKeepingUnit(NamedTuple):\n name: str\n description: str\n price: float\n category: str\n reviews: List[str]\n\n d = defaultdict(int)\n d[\"foo\"] = 5\n data = {\n \"foo\": [\n 1,\n \"Hello World!\",\n 100.123,\n 323.232,\n 432324.0,\n {5, 6, 7, (1, 2, 3, 4), 8},\n ],\n \"bar\": frozenset({1, 2, 3}),\n \"defaultdict\": defaultdict(\n list, {\"crumble\": [\"apple\", \"rhubarb\", \"butter\", \"sugar\", \"flour\"]}\n ),\n \"counter\": Counter(\n [\n \"apple\",\n \"orange\",\n \"pear\",\n \"kumquat\",\n \"kumquat\",\n \"durian\" * 100,\n ]\n ),\n \"atomic\": (False, True, None),\n \"namedtuple\": StockKeepingUnit(\n \"Sparkling British Spring Water\",\n \"Carbonated spring water\",\n 0.9,\n \"water\",\n [\"its amazing!\", \"its terrible!\"],\n ),\n \"Broken\": BrokenRepr(),\n }\n data[\"foo\"].append(data) # type: ignore[attr-defined]\n\n from pip._vendor.rich import print\n\n print(Pretty(data, indent_guides=True, max_string=20))\n\n class Thing:\n def __repr__(self) -> str:\n return \"Hello\\x1b[38;5;239m World!\"\n\n print(Pretty(Thing()))\n",[],[213,919,920,921,1016,1050,1511,1681],"0c66d854-67fc-11f0-bcbe-0224a6c84d84","panel.py","0c66d930-67fc-11f0-bcbe-0224a6c84d84",459,["D",1753299268578],"from typing import TYPE_CHECKING, Optional\n\nfrom .align import AlignMethod\nfrom .box import ROUNDED, Box\nfrom .cells import cell_len\nfrom .jupyter import JupyterMixin\nfrom .measure import Measurement, measure_renderables\nfrom .padding import Padding, PaddingDimensions\nfrom .segment import Segment\nfrom .style import Style, StyleType\nfrom .text import Text, TextType\n\nif TYPE_CHECKING:\n from .console import Console, ConsoleOptions, RenderableType, RenderResult\n\n\nclass Panel(JupyterMixin):\n \"\"\"A console renderable that draws a border around its contents.\n\n Example:\n >>> console.print(Panel(\"Hello, World!\"))\n\n Args:\n renderable (RenderableType): A console renderable object.\n box (Box): A Box instance that defines the look of the border (see :ref:`appendix_box`. Defaults to box.ROUNDED.\n title (Optional[TextType], optional): Optional title displayed in panel header. Defaults to None.\n title_align (AlignMethod, optional): Alignment of title. Defaults to \"center\".\n subtitle (Optional[TextType], optional): Optional subtitle displayed in panel footer. Defaults to None.\n subtitle_align (AlignMethod, optional): Alignment of subtitle. Defaults to \"center\".\n safe_box (bool, optional): Disable box characters that don't display on windows legacy terminal with *raster* fonts. Defaults to True.\n expand (bool, optional): If True the panel will stretch to fill the console width, otherwise it will be sized to fit the contents. Defaults to True.\n style (str, optional): The style of the panel (border and contents). Defaults to \"none\".\n border_style (str, optional): The style of the border. Defaults to \"none\".\n width (Optional[int], optional): Optional width of panel. Defaults to None to auto-detect.\n height (Optional[int], optional): Optional height of panel. Defaults to None to auto-detect.\n padding (Optional[PaddingDimensions]): Optional padding around renderable. Defaults to 0.\n highlight (bool, optional): Enable automatic highlighting of panel title (if str). Defaults to False.\n \"\"\"\n\n def __init__(\n self,\n renderable: \"RenderableType\",\n box: Box = ROUNDED,\n *,\n title: Optional[TextType] = None,\n title_align: AlignMethod = \"center\",\n subtitle: Optional[TextType] = None,\n subtitle_align: AlignMethod = \"center\",\n safe_box: Optional[bool] = None,\n expand: bool = True,\n style: StyleType = \"none\",\n border_style: StyleType = \"none\",\n width: Optional[int] = None,\n height: Optional[int] = None,\n padding: PaddingDimensions = (0, 1),\n highlight: bool = False,\n ) -> None:\n self.renderable = renderable\n self.box = box\n self.title = title\n self.title_align: AlignMethod = title_align\n self.subtitle = subtitle\n self.subtitle_align = subtitle_align\n self.safe_box = safe_box\n self.expand = expand\n self.style = style\n self.border_style = border_style\n self.width = width\n self.height = height\n self.padding = padding\n self.highlight = highlight\n\n @classmethod\n def fit(\n cls,\n renderable: \"RenderableType\",\n box: Box = ROUNDED,\n *,\n title: Optional[TextType] = None,\n title_align: AlignMethod = \"center\",\n subtitle: Optional[TextType] = None,\n subtitle_align: AlignMethod = \"center\",\n safe_box: Optional[bool] = None,\n style: StyleType = \"none\",\n border_style: StyleType = \"none\",\n width: Optional[int] = None,\n height: Optional[int] = None,\n padding: PaddingDimensions = (0, 1),\n highlight: bool = False,\n ) -> \"Panel\":\n \"\"\"An alternative constructor that sets expand=False.\"\"\"\n return cls(\n renderable,\n box,\n title=title,\n title_align=title_align,\n subtitle=subtitle,\n subtitle_align=subtitle_align,\n safe_box=safe_box,\n style=style,\n border_style=border_style,\n width=width,\n height=height,\n padding=padding,\n highlight=highlight,\n expand=False,\n )\n\n @property\n def _title(self) -> Optional[Text]:\n if self.title:\n title_text = (\n Text.from_markup(self.title)\n if isinstance(self.title, str)\n else self.title.copy()\n )\n title_text.end = \"\"\n title_text.plain = title_text.plain.replace(\"\\n\", \" \")\n title_text.no_wrap = True\n title_text.expand_tabs()\n title_text.pad(1)\n return title_text\n return None\n\n @property\n def _subtitle(self) -> Optional[Text]:\n if self.subtitle:\n subtitle_text = (\n Text.from_markup(self.subtitle)\n if isinstance(self.subtitle, str)\n else self.subtitle.copy()\n )\n subtitle_text.end = \"\"\n subtitle_text.plain = subtitle_text.plain.replace(\"\\n\", \" \")\n subtitle_text.no_wrap = True\n subtitle_text.expand_tabs()\n subtitle_text.pad(1)\n return subtitle_text\n return None\n\n def __rich_console__(\n self, console: \"Console\", options: \"ConsoleOptions\"\n ) -> \"RenderResult\":\n _padding = Padding.unpack(self.padding)\n renderable = (\n Padding(self.renderable, _padding) if any(_padding) else self.renderable\n )\n style = console.get_style(self.style)\n partial_border_style = console.get_style(self.border_style)\n border_style = style + partial_border_style\n width = (\n options.max_width\n if self.width is None\n else min(options.max_width, self.width)\n )\n\n safe_box: bool = console.safe_box if self.safe_box is None else self.safe_box\n box = self.box.substitute(options, safe=safe_box)\n\n def align_text(\n text: Text, width: int, align: str, character: str, style: Style\n ) -> Text:\n \"\"\"Gets new aligned text.\n\n Args:\n text (Text): Title or subtitle text.\n width (int): Desired width.\n align (str): Alignment.\n character (str): Character for alignment.\n style (Style): Border style\n\n Returns:\n Text: New text instance\n \"\"\"\n text = text.copy()\n text.truncate(width)\n excess_space = width - cell_len(text.plain)\n if text.style:\n text.stylize(console.get_style(text.style))\n\n if excess_space:\n if align == \"left\":\n return Text.assemble(\n text,\n (character * excess_space, style),\n no_wrap=True,\n end=\"\",\n )\n elif align == \"center\":\n left = excess_space // 2\n return Text.assemble(\n (character * left, style),\n text,\n (character * (excess_space - left), style),\n no_wrap=True,\n end=\"\",\n )\n else:\n return Text.assemble(\n (character * excess_space, style),\n text,\n no_wrap=True,\n end=\"\",\n )\n return text\n\n title_text = self._title\n if title_text is not None:\n title_text.stylize_before(partial_border_style)\n\n child_width = (\n width - 2\n if self.expand\n else console.measure(\n renderable, options=options.update_width(width - 2)\n ).maximum\n )\n child_height = self.height or options.height or None\n if child_height:\n child_height -= 2\n if title_text is not None:\n child_width = min(\n options.max_width - 2, max(child_width, title_text.cell_len + 2)\n )\n\n width = child_width + 2\n child_options = options.update(\n width=child_width, height=child_height, highlight=self.highlight\n )\n lines = console.render_lines(renderable, child_options, style=style)\n\n line_start = Segment(box.mid_left, border_style)\n line_end = Segment(f\"{box.mid_right}\", border_style)\n new_line = Segment.line()\n if title_text is None or width <= 4:\n yield Segment(box.get_top([width - 2]), border_style)\n else:\n title_text = align_text(\n title_text,\n width - 4,\n self.title_align,\n box.top,\n border_style,\n )\n yield Segment(box.top_left + box.top, border_style)\n yield from console.render(title_text, child_options.update_width(width - 4))\n yield Segment(box.top + box.top_right, border_style)\n\n yield new_line\n for line in lines:\n yield line_start\n yield from line\n yield line_end\n yield new_line\n\n subtitle_text = self._subtitle\n if subtitle_text is not None:\n subtitle_text.stylize_before(partial_border_style)\n\n if subtitle_text is None or width <= 4:\n yield Segment(box.get_bottom([width - 2]), border_style)\n else:\n subtitle_text = align_text(\n subtitle_text,\n width - 4,\n self.subtitle_align,\n box.bottom,\n border_style,\n )\n yield Segment(box.bottom_left + box.bottom, border_style)\n yield from console.render(\n subtitle_text, child_options.update_width(width - 4)\n )\n yield Segment(box.bottom + box.bottom_right, border_style)\n\n yield new_line\n\n def __rich_measure__(\n self, console: \"Console\", options: \"ConsoleOptions\"\n ) -> \"Measurement\":\n _title = self._title\n _, right, _, left = Padding.unpack(self.padding)\n padding = left + right\n renderables = [self.renderable, _title] if _title else [self.renderable]\n\n if self.width is None:\n width = (\n measure_renderables(\n console,\n options.update_width(options.max_width - padding - 2),\n renderables,\n ).maximum\n + padding\n + 2\n )\n else:\n width = self.width\n return Measurement(width, width)\n\n\nif __name__ == \"__main__\": # pragma: no cover\n from .console import Console\n\n c = Console()\n\n from .box import DOUBLE, ROUNDED\n from .padding import Padding\n\n p = Panel(\n \"Hello, World!\",\n title=\"rich.Panel\",\n style=\"white on blue\",\n box=DOUBLE,\n padding=1,\n )\n\n c.print()\n c.print(p)\n",[],[213,919,920,921,1016,1050,1511,1689],"0ba4045a-67fc-11f0-9454-0224a6c84d84","palette.py","0ba4063a-67fc-11f0-9454-0224a6c84d84",428,["D",1753299267309],"from math import sqrt\nfrom functools import lru_cache\nfrom typing import Sequence, Tuple, TYPE_CHECKING\n\nfrom .color_triplet import ColorTriplet\n\nif TYPE_CHECKING:\n from pip._vendor.rich.table import Table\n\n\nclass Palette:\n \"\"\"A palette of available colors.\"\"\"\n\n def __init__(self, colors: Sequence[Tuple[int, int, int]]):\n self._colors = colors\n\n def __getitem__(self, number: int) -> ColorTriplet:\n return ColorTriplet(*self._colors[number])\n\n def __rich__(self) -> \"Table\":\n from pip._vendor.rich.color import Color\n from pip._vendor.rich.style import Style\n from pip._vendor.rich.text import Text\n from pip._vendor.rich.table import Table\n\n table = Table(\n \"index\",\n \"RGB\",\n \"Color\",\n title=\"Palette\",\n caption=f\"{len(self._colors)} colors\",\n highlight=True,\n caption_justify=\"right\",\n )\n for index, color in enumerate(self._colors):\n table.add_row(\n str(index),\n repr(color),\n Text(\" \" * 16, style=Style(bgcolor=Color.from_rgb(*color))),\n )\n return table\n\n # This is somewhat inefficient and needs caching\n @lru_cache(maxsize=1024)\n def match(self, color: Tuple[int, int, int]) -> int:\n \"\"\"Find a color from a palette that most closely matches a given color.\n\n Args:\n color (Tuple[int, int, int]): RGB components in range 0 > 255.\n\n Returns:\n int: Index of closes matching color.\n \"\"\"\n red1, green1, blue1 = color\n _sqrt = sqrt\n get_color = self._colors.__getitem__\n\n def get_color_distance(index: int) -> float:\n \"\"\"Get the distance to a color.\"\"\"\n red2, green2, blue2 = get_color(index)\n red_mean = (red1 + red2) // 2\n red = red1 - red2\n green = green1 - green2\n blue = blue1 - blue2\n return _sqrt(\n (((512 + red_mean) * red * red) >> 8)\n + 4 * green * green\n + (((767 - red_mean) * blue * blue) >> 8)\n )\n\n min_index = min(range(len(self._colors)), key=get_color_distance)\n return min_index\n\n\nif __name__ == \"__main__\": # pragma: no cover\n import colorsys\n from typing import Iterable\n from pip._vendor.rich.color import Color\n from pip._vendor.rich.console import Console, ConsoleOptions\n from pip._vendor.rich.segment import Segment\n from pip._vendor.rich.style import Style\n\n class ColorBox:\n def __rich_console__(\n self, console: Console, options: ConsoleOptions\n ) -> Iterable[Segment]:\n height = console.size.height - 3\n for y in range(0, height):\n for x in range(options.max_width):\n h = x / options.max_width\n l = y / (height + 1)\n r1, g1, b1 = colorsys.hls_to_rgb(h, l, 1.0)\n r2, g2, b2 = colorsys.hls_to_rgb(h, l + (1 / height / 2), 1.0)\n bgcolor = Color.from_rgb(r1 * 255, g1 * 255, b1 * 255)\n color = Color.from_rgb(r2 * 255, g2 * 255, b2 * 255)\n yield Segment(\"▄\", Style(color=color, bgcolor=bgcolor))\n yield Segment.line()\n\n console = Console()\n console.print(ColorBox())\n",[],[213,919,920,921,1016,1050,1511,1697],"0bf07aa6-67fc-11f0-9454-0224a6c84d84","pager.py","0bf07b50-67fc-11f0-9454-0224a6c84d84",441,["D",1753299267734],"from abc import ABC, abstractmethod\nfrom typing import Any\n\n\nclass Pager(ABC):\n \"\"\"Base class for a pager.\"\"\"\n\n @abstractmethod\n def show(self, content: str) -> None:\n \"\"\"Show content in pager.\n\n Args:\n content (str): Content to be displayed.\n \"\"\"\n\n\nclass SystemPager(Pager):\n \"\"\"Uses the pager installed on the system.\"\"\"\n\n def _pager(self, content: str) -> Any: # pragma: no cover\n return __import__(\"pydoc\").pager(content)\n\n def show(self, content: str) -> None:\n \"\"\"Use the same pager used by pydoc.\"\"\"\n self._pager(content)\n\n\nif __name__ == \"__main__\": # pragma: no cover\n from .__main__ import make_test_card\n from .console import Console\n\n console = Console()\n with console.pager(styles=True):\n console.print(make_test_card())\n",[],[213,919,920,921,1016,1050,1511,1705],"0c8b4982-67fc-11f0-aca6-0224a6c84d84","padding.py","0c8b4a2c-67fc-11f0-aca6-0224a6c84d84",464,["D",1753299268793],"from typing import TYPE_CHECKING, List, Optional, Tuple, Union\n\nif TYPE_CHECKING:\n from .console import (\n Console,\n ConsoleOptions,\n RenderableType,\n RenderResult,\n )\n\nfrom .jupyter import JupyterMixin\nfrom .measure import Measurement\nfrom .segment import Segment\nfrom .style import Style\n\nPaddingDimensions = Union[int, Tuple[int], Tuple[int, int], Tuple[int, int, int, int]]\n\n\nclass Padding(JupyterMixin):\n \"\"\"Draw space around content.\n\n Example:\n >>> print(Padding(\"Hello\", (2, 4), style=\"on blue\"))\n\n Args:\n renderable (RenderableType): String or other renderable.\n pad (Union[int, Tuple[int]]): Padding for top, right, bottom, and left borders.\n May be specified with 1, 2, or 4 integers (CSS style).\n style (Union[str, Style], optional): Style for padding characters. Defaults to \"none\".\n expand (bool, optional): Expand padding to fit available width. Defaults to True.\n \"\"\"\n\n def __init__(\n self,\n renderable: \"RenderableType\",\n pad: \"PaddingDimensions\" = (0, 0, 0, 0),\n *,\n style: Union[str, Style] = \"none\",\n expand: bool = True,\n ):\n self.renderable = renderable\n self.top, self.right, self.bottom, self.left = self.unpack(pad)\n self.style = style\n self.expand = expand\n\n @classmethod\n def indent(cls, renderable: \"RenderableType\", level: int) -> \"Padding\":\n \"\"\"Make padding instance to render an indent.\n\n Args:\n renderable (RenderableType): String or other renderable.\n level (int): Number of characters to indent.\n\n Returns:\n Padding: A Padding instance.\n \"\"\"\n\n return Padding(renderable, pad=(0, 0, 0, level), expand=False)\n\n @staticmethod\n def unpack(pad: \"PaddingDimensions\") -> Tuple[int, int, int, int]:\n \"\"\"Unpack padding specified in CSS style.\"\"\"\n if isinstance(pad, int):\n return (pad, pad, pad, pad)\n if len(pad) == 1:\n _pad = pad[0]\n return (_pad, _pad, _pad, _pad)\n if len(pad) == 2:\n pad_top, pad_right = pad\n return (pad_top, pad_right, pad_top, pad_right)\n if len(pad) == 4:\n top, right, bottom, left = pad\n return (top, right, bottom, left)\n raise ValueError(f\"1, 2 or 4 integers required for padding; {len(pad)} given\")\n\n def __repr__(self) -> str:\n return f\"Padding({self.renderable!r}, ({self.top},{self.right},{self.bottom},{self.left}))\"\n\n def __rich_console__(\n self, console: \"Console\", options: \"ConsoleOptions\"\n ) -> \"RenderResult\":\n style = console.get_style(self.style)\n if self.expand:\n width = options.max_width\n else:\n width = min(\n Measurement.get(console, options, self.renderable).maximum\n + self.left\n + self.right,\n options.max_width,\n )\n render_options = options.update_width(width - self.left - self.right)\n if render_options.height is not None:\n render_options = render_options.update_height(\n height=render_options.height - self.top - self.bottom\n )\n lines = console.render_lines(\n self.renderable, render_options, style=style, pad=True\n )\n _Segment = Segment\n\n left = _Segment(\" \" * self.left, style) if self.left else None\n right = (\n [_Segment(f'{\" \" * self.right}', style), _Segment.line()]\n if self.right\n else [_Segment.line()]\n )\n blank_line: Optional[List[Segment]] = None\n if self.top:\n blank_line = [_Segment(f'{\" \" * width}\\n', style)]\n yield from blank_line * self.top\n if left:\n for line in lines:\n yield left\n yield from line\n yield from right\n else:\n for line in lines:\n yield from line\n yield from right\n if self.bottom:\n blank_line = blank_line or [_Segment(f'{\" \" * width}\\n', style)]\n yield from blank_line * self.bottom\n\n def __rich_measure__(\n self, console: \"Console\", options: \"ConsoleOptions\"\n ) -> \"Measurement\":\n max_width = options.max_width\n extra_width = self.left + self.right\n if max_width - extra_width < 1:\n return Measurement(max_width, max_width)\n measure_min, measure_max = Measurement.get(console, options, self.renderable)\n measurement = Measurement(measure_min + extra_width, measure_max + extra_width)\n measurement = measurement.with_maximum(max_width)\n return measurement\n\n\nif __name__ == \"__main__\": # pragma: no cover\n from pip._vendor.rich import print\n\n print(Padding(\"Hello, World\", (2, 4), style=\"on blue\"))\n",[],[213,919,920,921,1016,1050,1511,1713],"0aff1850-67fc-11f0-9b65-0224a6c84d84","measure.py","0aff1a4e-67fc-11f0-9b65-0224a6c84d84",401,["D",1753299266141],"from operator import itemgetter\nfrom typing import TYPE_CHECKING, Callable, NamedTuple, Optional, Sequence\n\nfrom . import errors\nfrom .protocol import is_renderable, rich_cast\n\nif TYPE_CHECKING:\n from .console import Console, ConsoleOptions, RenderableType\n\n\nclass Measurement(NamedTuple):\n \"\"\"Stores the minimum and maximum widths (in characters) required to render an object.\"\"\"\n\n minimum: int\n \"\"\"Minimum number of cells required to render.\"\"\"\n maximum: int\n \"\"\"Maximum number of cells required to render.\"\"\"\n\n @property\n def span(self) -> int:\n \"\"\"Get difference between maximum and minimum.\"\"\"\n return self.maximum - self.minimum\n\n def normalize(self) -> \"Measurement\":\n \"\"\"Get measurement that ensures that minimum <= maximum and minimum >= 0\n\n Returns:\n Measurement: A normalized measurement.\n \"\"\"\n minimum, maximum = self\n minimum = min(max(0, minimum), maximum)\n return Measurement(max(0, minimum), max(0, max(minimum, maximum)))\n\n def with_maximum(self, width: int) -> \"Measurement\":\n \"\"\"Get a RenderableWith where the widths are <= width.\n\n Args:\n width (int): Maximum desired width.\n\n Returns:\n Measurement: New Measurement object.\n \"\"\"\n minimum, maximum = self\n return Measurement(min(minimum, width), min(maximum, width))\n\n def with_minimum(self, width: int) -> \"Measurement\":\n \"\"\"Get a RenderableWith where the widths are >= width.\n\n Args:\n width (int): Minimum desired width.\n\n Returns:\n Measurement: New Measurement object.\n \"\"\"\n minimum, maximum = self\n width = max(0, width)\n return Measurement(max(minimum, width), max(maximum, width))\n\n def clamp(\n self, min_width: Optional[int] = None, max_width: Optional[int] = None\n ) -> \"Measurement\":\n \"\"\"Clamp a measurement within the specified range.\n\n Args:\n min_width (int): Minimum desired width, or ``None`` for no minimum. Defaults to None.\n max_width (int): Maximum desired width, or ``None`` for no maximum. Defaults to None.\n\n Returns:\n Measurement: New Measurement object.\n \"\"\"\n measurement = self\n if min_width is not None:\n measurement = measurement.with_minimum(min_width)\n if max_width is not None:\n measurement = measurement.with_maximum(max_width)\n return measurement\n\n @classmethod\n def get(\n cls, console: \"Console\", options: \"ConsoleOptions\", renderable: \"RenderableType\"\n ) -> \"Measurement\":\n \"\"\"Get a measurement for a renderable.\n\n Args:\n console (~rich.console.Console): Console instance.\n options (~rich.console.ConsoleOptions): Console options.\n renderable (RenderableType): An object that may be rendered with Rich.\n\n Raises:\n errors.NotRenderableError: If the object is not renderable.\n\n Returns:\n Measurement: Measurement object containing range of character widths required to render the object.\n \"\"\"\n _max_width = options.max_width\n if _max_width < 1:\n return Measurement(0, 0)\n if isinstance(renderable, str):\n renderable = console.render_str(\n renderable, markup=options.markup, highlight=False\n )\n renderable = rich_cast(renderable)\n if is_renderable(renderable):\n get_console_width: Optional[\n Callable[[\"Console\", \"ConsoleOptions\"], \"Measurement\"]\n ] = getattr(renderable, \"__rich_measure__\", None)\n if get_console_width is not None:\n render_width = (\n get_console_width(console, options)\n .normalize()\n .with_maximum(_max_width)\n )\n if render_width.maximum < 1:\n return Measurement(0, 0)\n return render_width.normalize()\n else:\n return Measurement(0, _max_width)\n else:\n raise errors.NotRenderableError(\n f\"Unable to get render width for {renderable!r}; \"\n \"a str, Segment, or object with __rich_console__ method is required\"\n )\n\n\ndef measure_renderables(\n console: \"Console\",\n options: \"ConsoleOptions\",\n renderables: Sequence[\"RenderableType\"],\n) -> \"Measurement\":\n \"\"\"Get a measurement that would fit a number of renderables.\n\n Args:\n console (~rich.console.Console): Console instance.\n options (~rich.console.ConsoleOptions): Console options.\n renderables (Iterable[RenderableType]): One or more renderable objects.\n\n Returns:\n Measurement: Measurement object containing range of character widths required to\n contain all given renderables.\n \"\"\"\n if not renderables:\n return Measurement(0, 0)\n get_measurement = Measurement.get\n measurements = [\n get_measurement(console, options, renderable) for renderable in renderables\n ]\n measured_width = Measurement(\n max(measurements, key=itemgetter(0)).minimum,\n max(measurements, key=itemgetter(1)).maximum,\n )\n return measured_width\n",[],[213,919,920,921,1016,1050,1511,1721],"0ba954b4-67fc-11f0-b666-0224a6c84d84","markup.py","0ba95554-67fc-11f0-b666-0224a6c84d84",429,["D",1753299267314],"import re\nfrom ast import literal_eval\nfrom operator import attrgetter\nfrom typing import Callable, Iterable, List, Match, NamedTuple, Optional, Tuple, Union\n\nfrom ._emoji_replace import _emoji_replace\nfrom .emoji import EmojiVariant\nfrom .errors import MarkupError\nfrom .style import Style\nfrom .text import Span, Text\n\nRE_TAGS = re.compile(\n r\"\"\"((\\\\*)\\[([a-z#/@][^[]*?)])\"\"\",\n re.VERBOSE,\n)\n\nRE_HANDLER = re.compile(r\"^([\\w.]*?)(\$.*?\$)?$\")\n\n\nclass Tag(NamedTuple):\n \"\"\"A tag in console markup.\"\"\"\n\n name: str\n \"\"\"The tag name. e.g. 'bold'.\"\"\"\n parameters: Optional[str]\n \"\"\"Any additional parameters after the name.\"\"\"\n\n def __str__(self) -> str:\n return (\n self.name if self.parameters is None else f\"{self.name} {self.parameters}\"\n )\n\n @property\n def markup(self) -> str:\n \"\"\"Get the string representation of this tag.\"\"\"\n return (\n f\"[{self.name}]\"\n if self.parameters is None\n else f\"[{self.name}={self.parameters}]\"\n )\n\n\n_ReStringMatch = Match[str] # regex match object\n_ReSubCallable = Callable[[_ReStringMatch], str] # Callable invoked by re.sub\n_EscapeSubMethod = Callable[[_ReSubCallable, str], str] # Sub method of a compiled re\n\n\ndef escape(\n markup: str,\n _escape: _EscapeSubMethod = re.compile(r\"(\\\\*)(\\[[a-z#/@][^[]*?])\").sub,\n) -> str:\n \"\"\"Escapes text so that it won't be interpreted as markup.\n\n Args:\n markup (str): Content to be inserted in to markup.\n\n Returns:\n str: Markup with square brackets escaped.\n \"\"\"\n\n def escape_backslashes(match: Match[str]) -> str:\n \"\"\"Called by re.sub replace matches.\"\"\"\n backslashes, text = match.groups()\n return f\"{backslashes}{backslashes}\\\\{text}\"\n\n markup = _escape(escape_backslashes, markup)\n if markup.endswith(\"\\\\\") and not markup.endswith(\"\\\\\\\\\"):\n return markup + \"\\\\\"\n\n return markup\n\n\ndef _parse(markup: str) -> Iterable[Tuple[int, Optional[str], Optional[Tag]]]:\n \"\"\"Parse markup in to an iterable of tuples of (position, text, tag).\n\n Args:\n markup (str): A string containing console markup\n\n \"\"\"\n position = 0\n _divmod = divmod\n _Tag = Tag\n for match in RE_TAGS.finditer(markup):\n full_text, escapes, tag_text = match.groups()\n start, end = match.span()\n if start > position:\n yield start, markup[position:start], None\n if escapes:\n backslashes, escaped = _divmod(len(escapes), 2)\n if backslashes:\n # Literal backslashes\n yield start, \"\\\\\" * backslashes, None\n start += backslashes * 2\n if escaped:\n # Escape of tag\n yield start, full_text[len(escapes) :], None\n position = end\n continue\n text, equals, parameters = tag_text.partition(\"=\")\n yield start, None, _Tag(text, parameters if equals else None)\n position = end\n if position < len(markup):\n yield position, markup[position:], None\n\n\ndef render(\n markup: str,\n style: Union[str, Style] = \"\",\n emoji: bool = True,\n emoji_variant: Optional[EmojiVariant] = None,\n) -> Text:\n \"\"\"Render console markup in to a Text instance.\n\n Args:\n markup (str): A string containing console markup.\n style: (Union[str, Style]): The style to use.\n emoji (bool, optional): Also render emoji code. Defaults to True.\n emoji_variant (str, optional): Optional emoji variant, either \"text\" or \"emoji\". Defaults to None.\n\n\n Raises:\n MarkupError: If there is a syntax error in the markup.\n\n Returns:\n Text: A test instance.\n \"\"\"\n emoji_replace = _emoji_replace\n if \"[\" not in markup:\n return Text(\n emoji_replace(markup, default_variant=emoji_variant) if emoji else markup,\n style=style,\n )\n text = Text(style=style)\n append = text.append\n normalize = Style.normalize\n\n style_stack: List[Tuple[int, Tag]] = []\n pop = style_stack.pop\n\n spans: List[Span] = []\n append_span = spans.append\n\n _Span = Span\n _Tag = Tag\n\n def pop_style(style_name: str) -> Tuple[int, Tag]:\n \"\"\"Pop tag matching given style name.\"\"\"\n for index, (_, tag) in enumerate(reversed(style_stack), 1):\n if tag.name == style_name:\n return pop(-index)\n raise KeyError(style_name)\n\n for position, plain_text, tag in _parse(markup):\n if plain_text is not None:\n # Handle open brace escapes, where the brace is not part of a tag.\n plain_text = plain_text.replace(\"\\\\[\", \"[\")\n append(emoji_replace(plain_text) if emoji else plain_text)\n elif tag is not None:\n if tag.name.startswith(\"/\"): # Closing tag\n style_name = tag.name[1:].strip()\n\n if style_name: # explicit close\n style_name = normalize(style_name)\n try:\n start, open_tag = pop_style(style_name)\n except KeyError:\n raise MarkupError(\n f\"closing tag '{tag.markup}' at position {position} doesn't match any open tag\"\n ) from None\n else: # implicit close\n try:\n start, open_tag = pop()\n except IndexError:\n raise MarkupError(\n f\"closing tag '[/]' at position {position} has nothing to close\"\n ) from None\n\n if open_tag.name.startswith(\"@\"):\n if open_tag.parameters:\n handler_name = \"\"\n parameters = open_tag.parameters.strip()\n handler_match = RE_HANDLER.match(parameters)\n if handler_match is not None:\n handler_name, match_parameters = handler_match.groups()\n parameters = (\n \"()\" if match_parameters is None else match_parameters\n )\n\n try:\n meta_params = literal_eval(parameters)\n except SyntaxError as error:\n raise MarkupError(\n f\"error parsing {parameters!r} in {open_tag.parameters!r}; {error.msg}\"\n )\n except Exception as error:\n raise MarkupError(\n f\"error parsing {open_tag.parameters!r}; {error}\"\n ) from None\n\n if handler_name:\n meta_params = (\n handler_name,\n meta_params\n if isinstance(meta_params, tuple)\n else (meta_params,),\n )\n\n else:\n meta_params = ()\n\n append_span(\n _Span(\n start, len(text), Style(meta={open_tag.name: meta_params})\n )\n )\n else:\n append_span(_Span(start, len(text), str(open_tag)))\n\n else: # Opening tag\n normalized_tag = _Tag(normalize(tag.name), tag.parameters)\n style_stack.append((len(text), normalized_tag))\n\n text_length = len(text)\n while style_stack:\n start, tag = style_stack.pop()\n style = str(tag)\n if style:\n append_span(_Span(start, text_length, style))\n\n text.spans = sorted(spans[::-1], key=attrgetter(\"start\"))\n return text\n\n\nif __name__ == \"__main__\": # pragma: no cover\n MARKUP = [\n \"[red]Hello World[/red]\",\n \"[magenta]Hello [b]World[/b]\",\n \"[bold]Bold[italic] bold and italic [/bold]italic[/italic]\",\n \"Click [link=https://www.willmcgugan.com]here[/link] to visit my Blog\",\n \":warning-emoji: [bold red blink] DANGER![/]\",\n ]\n\n from pip._vendor.rich import print\n from pip._vendor.rich.table import Table\n\n grid = Table(\"Markup\", \"Result\", padding=(0, 1))\n\n for markup in MARKUP:\n grid.add_row(Text(markup), markup)\n\n print(grid)\n",[],[213,919,920,921,1016,1050,1511,1729],"0aeac36e-67fc-11f0-9f6f-0224a6c84d84","logging.py","0aeac422-67fc-11f0-9f6f-0224a6c84d84",398,["D",1753299266083],"import logging\nfrom datetime import datetime\nfrom logging import Handler, LogRecord\nfrom pathlib import Path\nfrom types import ModuleType\nfrom typing import ClassVar, Iterable, List, Optional, Type, Union\n\nfrom pip._vendor.rich._null_file import NullFile\n\nfrom . import get_console\nfrom ._log_render import FormatTimeCallable, LogRender\nfrom .console import Console, ConsoleRenderable\nfrom .highlighter import Highlighter, ReprHighlighter\nfrom .text import Text\nfrom .traceback import Traceback\n\n\nclass RichHandler(Handler):\n \"\"\"A logging handler that renders output with Rich. The time / level / message and file are displayed in columns.\n The level is color coded, and the message is syntax highlighted.\n\n Note:\n Be careful when enabling console markup in log messages if you have configured logging for libraries not\n under your control. If a dependency writes messages containing square brackets, it may not produce the intended output.\n\n Args:\n level (Union[int, str], optional): Log level. Defaults to logging.NOTSET.\n console (:class:`~rich.console.Console`, optional): Optional console instance to write logs.\n Default will use a global console instance writing to stdout.\n show_time (bool, optional): Show a column for the time. Defaults to True.\n omit_repeated_times (bool, optional): Omit repetition of the same time. Defaults to True.\n show_level (bool, optional): Show a column for the level. Defaults to True.\n show_path (bool, optional): Show the path to the original log call. Defaults to True.\n enable_link_path (bool, optional): Enable terminal link of path column to file. Defaults to True.\n highlighter (Highlighter, optional): Highlighter to style log messages, or None to use ReprHighlighter. Defaults to None.\n markup (bool, optional): Enable console markup in log messages. Defaults to False.\n rich_tracebacks (bool, optional): Enable rich tracebacks with syntax highlighting and formatting. Defaults to False.\n tracebacks_width (Optional[int], optional): Number of characters used to render tracebacks, or None for full width. Defaults to None.\n tracebacks_code_width (int, optional): Number of code characters used to render tracebacks, or None for full width. Defaults to 88.\n tracebacks_extra_lines (int, optional): Additional lines of code to render tracebacks, or None for full width. Defaults to None.\n tracebacks_theme (str, optional): Override pygments theme used in traceback.\n tracebacks_word_wrap (bool, optional): Enable word wrapping of long tracebacks lines. Defaults to True.\n tracebacks_show_locals (bool, optional): Enable display of locals in tracebacks. Defaults to False.\n tracebacks_suppress (Sequence[Union[str, ModuleType]]): Optional sequence of modules or paths to exclude from traceback.\n tracebacks_max_frames (int, optional): Optional maximum number of frames returned by traceback.\n locals_max_length (int, optional): Maximum length of containers before abbreviating, or None for no abbreviation.\n Defaults to 10.\n locals_max_string (int, optional): Maximum length of string before truncating, or None to disable. Defaults to 80.\n log_time_format (Union[str, TimeFormatterCallable], optional): If ``log_time`` is enabled, either string for strftime or callable that formats the time. Defaults to \"[%x %X] \".\n keywords (List[str], optional): List of words to highlight instead of ``RichHandler.KEYWORDS``.\n \"\"\"\n\n KEYWORDS: ClassVar[Optional[List[str]]] = [\n \"GET\",\n \"POST\",\n \"HEAD\",\n \"PUT\",\n \"DELETE\",\n \"OPTIONS\",\n \"TRACE\",\n \"PATCH\",\n ]\n HIGHLIGHTER_CLASS: ClassVar[Type[Highlighter]] = ReprHighlighter\n\n def __init__(\n self,\n level: Union[int, str] = logging.NOTSET,\n console: Optional[Console] = None,\n *,\n show_time: bool = True,\n omit_repeated_times: bool = True,\n show_level: bool = True,\n show_path: bool = True,\n enable_link_path: bool = True,\n highlighter: Optional[Highlighter] = None,\n markup: bool = False,\n rich_tracebacks: bool = False,\n tracebacks_width: Optional[int] = None,\n tracebacks_code_width: int = 88,\n tracebacks_extra_lines: int = 3,\n tracebacks_theme: Optional[str] = None,\n tracebacks_word_wrap: bool = True,\n tracebacks_show_locals: bool = False,\n tracebacks_suppress: Iterable[Union[str, ModuleType]] = (),\n tracebacks_max_frames: int = 100,\n locals_max_length: int = 10,\n locals_max_string: int = 80,\n log_time_format: Union[str, FormatTimeCallable] = \"[%x %X]\",\n keywords: Optional[List[str]] = None,\n ) -> None:\n super().__init__(level=level)\n self.console = console or get_console()\n self.highlighter = highlighter or self.HIGHLIGHTER_CLASS()\n self._log_render = LogRender(\n show_time=show_time,\n show_level=show_level,\n show_path=show_path,\n time_format=log_time_format,\n omit_repeated_times=omit_repeated_times,\n level_width=None,\n )\n self.enable_link_path = enable_link_path\n self.markup = markup\n self.rich_tracebacks = rich_tracebacks\n self.tracebacks_width = tracebacks_width\n self.tracebacks_extra_lines = tracebacks_extra_lines\n self.tracebacks_theme = tracebacks_theme\n self.tracebacks_word_wrap = tracebacks_word_wrap\n self.tracebacks_show_locals = tracebacks_show_locals\n self.tracebacks_suppress = tracebacks_suppress\n self.tracebacks_max_frames = tracebacks_max_frames\n self.tracebacks_code_width = tracebacks_code_width\n self.locals_max_length = locals_max_length\n self.locals_max_string = locals_max_string\n self.keywords = keywords\n\n def get_level_text(self, record: LogRecord) -> Text:\n \"\"\"Get the level name from the record.\n\n Args:\n record (LogRecord): LogRecord instance.\n\n Returns:\n Text: A tuple of the style and level name.\n \"\"\"\n level_name = record.levelname\n level_text = Text.styled(\n level_name.ljust(8), f\"logging.level.{level_name.lower()}\"\n )\n return level_text\n\n def emit(self, record: LogRecord) -> None:\n \"\"\"Invoked by logging.\"\"\"\n message = self.format(record)\n traceback = None\n if (\n self.rich_tracebacks\n and record.exc_info\n and record.exc_info != (None, None, None)\n ):\n exc_type, exc_value, exc_traceback = record.exc_info\n assert exc_type is not None\n assert exc_value is not None\n traceback = Traceback.from_exception(\n exc_type,\n exc_value,\n exc_traceback,\n width=self.tracebacks_width,\n code_width=self.tracebacks_code_width,\n extra_lines=self.tracebacks_extra_lines,\n theme=self.tracebacks_theme,\n word_wrap=self.tracebacks_word_wrap,\n show_locals=self.tracebacks_show_locals,\n locals_max_length=self.locals_max_length,\n locals_max_string=self.locals_max_string,\n suppress=self.tracebacks_suppress,\n max_frames=self.tracebacks_max_frames,\n )\n message = record.getMessage()\n if self.formatter:\n record.message = record.getMessage()\n formatter = self.formatter\n if hasattr(formatter, \"usesTime\") and formatter.usesTime():\n record.asctime = formatter.formatTime(record, formatter.datefmt)\n message = formatter.formatMessage(record)\n\n message_renderable = self.render_message(record, message)\n log_renderable = self.render(\n record=record, traceback=traceback, message_renderable=message_renderable\n )\n if isinstance(self.console.file, NullFile):\n # Handles pythonw, where stdout/stderr are null, and we return NullFile\n # instance from Console.file. In this case, we still want to make a log record\n # even though we won't be writing anything to a file.\n self.handleError(record)\n else:\n try:\n self.console.print(log_renderable)\n except Exception:\n self.handleError(record)\n\n def render_message(self, record: LogRecord, message: str) -> \"ConsoleRenderable\":\n \"\"\"Render message text in to Text.\n\n Args:\n record (LogRecord): logging Record.\n message (str): String containing log message.\n\n Returns:\n ConsoleRenderable: Renderable to display log message.\n \"\"\"\n use_markup = getattr(record, \"markup\", self.markup)\n message_text = Text.from_markup(message) if use_markup else Text(message)\n\n highlighter = getattr(record, \"highlighter\", self.highlighter)\n if highlighter:\n message_text = highlighter(message_text)\n\n if self.keywords is None:\n self.keywords = self.KEYWORDS\n\n if self.keywords:\n message_text.highlight_words(self.keywords, \"logging.keyword\")\n\n return message_text\n\n def render(\n self,\n *,\n record: LogRecord,\n traceback: Optional[Traceback],\n message_renderable: \"ConsoleRenderable\",\n ) -> \"ConsoleRenderable\":\n \"\"\"Render log for display.\n\n Args:\n record (LogRecord): logging Record.\n traceback (Optional[Traceback]): Traceback instance or None for no Traceback.\n message_renderable (ConsoleRenderable): Renderable (typically Text) containing log message contents.\n\n Returns:\n ConsoleRenderable: Renderable to display log.\n \"\"\"\n path = Path(record.pathname).name\n level = self.get_level_text(record)\n time_format = None if self.formatter is None else self.formatter.datefmt\n log_time = datetime.fromtimestamp(record.created)\n\n log_renderable = self._log_render(\n self.console,\n [message_renderable] if not traceback else [message_renderable, traceback],\n log_time=log_time,\n time_format=time_format,\n level=level,\n path=path,\n line_no=record.lineno,\n link_path=record.pathname if self.enable_link_path else None,\n )\n return log_renderable\n\n\nif __name__ == \"__main__\": # pragma: no cover\n from time import sleep\n\n FORMAT = \"%(message)s\"\n # FORMAT = \"%(asctime)-15s - %(levelname)s - %(message)s\"\n logging.basicConfig(\n level=\"NOTSET\",\n format=FORMAT,\n datefmt=\"[%X]\",\n handlers=[RichHandler(rich_tracebacks=True, tracebacks_show_locals=True)],\n )\n log = logging.getLogger(\"rich\")\n\n log.info(\"Server starting...\")\n log.info(\"Listening on http://127.0.0.1:8080\")\n sleep(1)\n\n log.info(\"GET /index.html 200 1298\")\n log.info(\"GET /imgs/backgrounds/back1.jpg 200 54386\")\n log.info(\"GET /css/styles.css 200 54386\")\n log.warning(\"GET /favicon.ico 404 242\")\n sleep(1)\n\n log.debug(\n \"JSONRPC request\\n--> %r\\n<-- %r\",\n {\n \"version\": \"1.1\",\n \"method\": \"confirmFruitPurchase\",\n \"params\": [[\"apple\", \"orange\", \"mangoes\", \"pomelo\"], 1.123],\n \"id\": \"194521489\",\n },\n {\"version\": \"1.1\", \"result\": True, \"error\": None, \"id\": \"194521489\"},\n )\n log.debug(\n \"Loading configuration file /adasd/asdasd/qeqwe/qwrqwrqwr/sdgsdgsdg/werwerwer/dfgerert/ertertert/ertetert/werwerwer\"\n )\n log.error(\"Unable to find 'pomelo' in database!\")\n log.info(\"POST /jsonrpc/ 200 65532\")\n log.info(\"POST /admin/ 401 42234\")\n log.warning(\"password was rejected for admin site.\")\n\n def divide() -> None:\n number = 1\n divisor = 0\n foos = [\"foo\"] * 100\n log.debug(\"in divide\")\n try:\n number / divisor\n except:\n log.exception(\"An error of some kind occurred!\")\n\n divide()\n sleep(1)\n log.critical(\"Out of memory!\")\n log.info(\"Server exited with code=-1\")\n log.info(\"[bold]EXITING...[/bold]\", extra=dict(markup=True))\n",[],[213,919,920,921,1016,1050,1511,1737],"0b037de6-67fc-11f0-95df-0224a6c84d84","live_render.py","0b037fe4-67fc-11f0-95df-0224a6c84d84",402,["D",1753299266249],"import sys\nfrom typing import Optional, Tuple\n\nif sys.version_info >= (3, 8):\n from typing import Literal\nelse:\n from pip._vendor.typing_extensions import Literal # pragma: no cover\n\n\nfrom ._loop import loop_last\nfrom .console import Console, ConsoleOptions, RenderableType, RenderResult\nfrom .control import Control\nfrom .segment import ControlType, Segment\nfrom .style import StyleType\nfrom .text import Text\n\nVerticalOverflowMethod = Literal[\"crop\", \"ellipsis\", \"visible\"]\n\n\nclass LiveRender:\n \"\"\"Creates a renderable that may be updated.\n\n Args:\n renderable (RenderableType): Any renderable object.\n style (StyleType, optional): An optional style to apply to the renderable. Defaults to \"\".\n \"\"\"\n\n def __init__(\n self,\n renderable: RenderableType,\n style: StyleType = \"\",\n vertical_overflow: VerticalOverflowMethod = \"ellipsis\",\n ) -> None:\n self.renderable = renderable\n self.style = style\n self.vertical_overflow = vertical_overflow\n self._shape: Optional[Tuple[int, int]] = None\n\n def set_renderable(self, renderable: RenderableType) -> None:\n \"\"\"Set a new renderable.\n\n Args:\n renderable (RenderableType): Any renderable object, including str.\n \"\"\"\n self.renderable = renderable\n\n def position_cursor(self) -> Control:\n \"\"\"Get control codes to move cursor to beginning of live render.\n\n Returns:\n Control: A control instance that may be printed.\n \"\"\"\n if self._shape is not None:\n _, height = self._shape\n return Control(\n ControlType.CARRIAGE_RETURN,\n (ControlType.ERASE_IN_LINE, 2),\n *(\n (\n (ControlType.CURSOR_UP, 1),\n (ControlType.ERASE_IN_LINE, 2),\n )\n * (height - 1)\n )\n )\n return Control()\n\n def restore_cursor(self) -> Control:\n \"\"\"Get control codes to clear the render and restore the cursor to its previous position.\n\n Returns:\n Control: A Control instance that may be printed.\n \"\"\"\n if self._shape is not None:\n _, height = self._shape\n return Control(\n ControlType.CARRIAGE_RETURN,\n *((ControlType.CURSOR_UP, 1), (ControlType.ERASE_IN_LINE, 2)) * height\n )\n return Control()\n\n def __rich_console__(\n self, console: Console, options: ConsoleOptions\n ) -> RenderResult:\n renderable = self.renderable\n style = console.get_style(self.style)\n lines = console.render_lines(renderable, options, style=style, pad=False)\n shape = Segment.get_shape(lines)\n\n _, height = shape\n if height > options.size.height:\n if self.vertical_overflow == \"crop\":\n lines = lines[: options.size.height]\n shape = Segment.get_shape(lines)\n elif self.vertical_overflow == \"ellipsis\":\n lines = lines[: (options.size.height - 1)]\n overflow_text = Text(\n \"...\",\n overflow=\"crop\",\n justify=\"center\",\n end=\"\",\n style=\"live.ellipsis\",\n )\n lines.append(list(console.render(overflow_text)))\n shape = Segment.get_shape(lines)\n self._shape = shape\n\n new_line = Segment.line()\n for last, line in loop_last(lines):\n yield from line\n if not last:\n yield new_line\n",[],[213,919,920,921,1016,1050,1511,1745],"0c045e4a-67fc-11f0-a7d9-0224a6c84d84","live.py","0c045f12-67fc-11f0-a7d9-0224a6c84d84",444,["D",1753299267945],"import sys\nfrom threading import Event, RLock, Thread\nfrom types import TracebackType\nfrom typing import IO, Any, Callable, List, Optional, TextIO, Type, cast\n\nfrom . import get_console\nfrom .console import Console, ConsoleRenderable, RenderableType, RenderHook\nfrom .control import Control\nfrom .file_proxy import FileProxy\nfrom .jupyter import JupyterMixin\nfrom .live_render import LiveRender, VerticalOverflowMethod\nfrom .screen import Screen\nfrom .text import Text\n\n\nclass _RefreshThread(Thread):\n \"\"\"A thread that calls refresh() at regular intervals.\"\"\"\n\n def __init__(self, live: \"Live\", refresh_per_second: float) -> None:\n self.live = live\n self.refresh_per_second = refresh_per_second\n self.done = Event()\n super().__init__(daemon=True)\n\n def stop(self) -> None:\n self.done.set()\n\n def run(self) -> None:\n while not self.done.wait(1 / self.refresh_per_second):\n with self.live._lock:\n if not self.done.is_set():\n self.live.refresh()\n\n\nclass Live(JupyterMixin, RenderHook):\n \"\"\"Renders an auto-updating live display of any given renderable.\n\n Args:\n renderable (RenderableType, optional): The renderable to live display. Defaults to displaying nothing.\n console (Console, optional): Optional Console instance. Defaults to an internal Console instance writing to stdout.\n screen (bool, optional): Enable alternate screen mode. Defaults to False.\n auto_refresh (bool, optional): Enable auto refresh. If disabled, you will need to call `refresh()` or `update()` with refresh flag. Defaults to True\n refresh_per_second (float, optional): Number of times per second to refresh the live display. Defaults to 4.\n transient (bool, optional): Clear the renderable on exit (has no effect when screen=True). Defaults to False.\n redirect_stdout (bool, optional): Enable redirection of stdout, so ``print`` may be used. Defaults to True.\n redirect_stderr (bool, optional): Enable redirection of stderr. Defaults to True.\n vertical_overflow (VerticalOverflowMethod, optional): How to handle renderable when it is too tall for the console. Defaults to \"ellipsis\".\n get_renderable (Callable[[], RenderableType], optional): Optional callable to get renderable. Defaults to None.\n \"\"\"\n\n def __init__(\n self,\n renderable: Optional[RenderableType] = None,\n *,\n console: Optional[Console] = None,\n screen: bool = False,\n auto_refresh: bool = True,\n refresh_per_second: float = 4,\n transient: bool = False,\n redirect_stdout: bool = True,\n redirect_stderr: bool = True,\n vertical_overflow: VerticalOverflowMethod = \"ellipsis\",\n get_renderable: Optional[Callable[[], RenderableType]] = None,\n ) -> None:\n assert refresh_per_second > 0, \"refresh_per_second must be > 0\"\n self._renderable = renderable\n self.console = console if console is not None else get_console()\n self._screen = screen\n self._alt_screen = False\n\n self._redirect_stdout = redirect_stdout\n self._redirect_stderr = redirect_stderr\n self._restore_stdout: Optional[IO[str]] = None\n self._restore_stderr: Optional[IO[str]] = None\n\n self._lock = RLock()\n self.ipy_widget: Optional[Any] = None\n self.auto_refresh = auto_refresh\n self._started: bool = False\n self.transient = True if screen else transient\n\n self._refresh_thread: Optional[_RefreshThread] = None\n self.refresh_per_second = refresh_per_second\n\n self.vertical_overflow = vertical_overflow\n self._get_renderable = get_renderable\n self._live_render = LiveRender(\n self.get_renderable(), vertical_overflow=vertical_overflow\n )\n\n @property\n def is_started(self) -> bool:\n \"\"\"Check if live display has been started.\"\"\"\n return self._started\n\n def get_renderable(self) -> RenderableType:\n renderable = (\n self._get_renderable()\n if self._get_renderable is not None\n else self._renderable\n )\n return renderable or \"\"\n\n def start(self, refresh: bool = False) -> None:\n \"\"\"Start live rendering display.\n\n Args:\n refresh (bool, optional): Also refresh. Defaults to False.\n \"\"\"\n with self._lock:\n if self._started:\n return\n self.console.set_live(self)\n self._started = True\n if self._screen:\n self._alt_screen = self.console.set_alt_screen(True)\n self.console.show_cursor(False)\n self._enable_redirect_io()\n self.console.push_render_hook(self)\n if refresh:\n try:\n self.refresh()\n except Exception:\n # If refresh fails, we want to stop the redirection of sys.stderr,\n # so the error stacktrace is properly displayed in the terminal.\n # (or, if the code that calls Rich captures the exception and wants to display something,\n # let this be displayed in the terminal).\n self.stop()\n raise\n if self.auto_refresh:\n self._refresh_thread = _RefreshThread(self, self.refresh_per_second)\n self._refresh_thread.start()\n\n def stop(self) -> None:\n \"\"\"Stop live rendering display.\"\"\"\n with self._lock:\n if not self._started:\n return\n self.console.clear_live()\n self._started = False\n\n if self.auto_refresh and self._refresh_thread is not None:\n self._refresh_thread.stop()\n self._refresh_thread = None\n # allow it to fully render on the last even if overflow\n self.vertical_overflow = \"visible\"\n with self.console:\n try:\n if not self._alt_screen and not self.console.is_jupyter:\n self.refresh()\n finally:\n self._disable_redirect_io()\n self.console.pop_render_hook()\n if not self._alt_screen and self.console.is_terminal:\n self.console.line()\n self.console.show_cursor(True)\n if self._alt_screen:\n self.console.set_alt_screen(False)\n\n if self.transient and not self._alt_screen:\n self.console.control(self._live_render.restore_cursor())\n if self.ipy_widget is not None and self.transient:\n self.ipy_widget.close() # pragma: no cover\n\n def __enter__(self) -> \"Live\":\n self.start(refresh=self._renderable is not None)\n return self\n\n def __exit__(\n self,\n exc_type: Optional[Type[BaseException]],\n exc_val: Optional[BaseException],\n exc_tb: Optional[TracebackType],\n ) -> None:\n self.stop()\n\n def _enable_redirect_io(self) -> None:\n \"\"\"Enable redirecting of stdout / stderr.\"\"\"\n if self.console.is_terminal or self.console.is_jupyter:\n if self._redirect_stdout and not isinstance(sys.stdout, FileProxy):\n self._restore_stdout = sys.stdout\n sys.stdout = cast(\"TextIO\", FileProxy(self.console, sys.stdout))\n if self._redirect_stderr and not isinstance(sys.stderr, FileProxy):\n self._restore_stderr = sys.stderr\n sys.stderr = cast(\"TextIO\", FileProxy(self.console, sys.stderr))\n\n def _disable_redirect_io(self) -> None:\n \"\"\"Disable redirecting of stdout / stderr.\"\"\"\n if self._restore_stdout:\n sys.stdout = cast(\"TextIO\", self._restore_stdout)\n self._restore_stdout = None\n if self._restore_stderr:\n sys.stderr = cast(\"TextIO\", self._restore_stderr)\n self._restore_stderr = None\n\n @property\n def renderable(self) -> RenderableType:\n \"\"\"Get the renderable that is being displayed\n\n Returns:\n RenderableType: Displayed renderable.\n \"\"\"\n renderable = self.get_renderable()\n return Screen(renderable) if self._alt_screen else renderable\n\n def update(self, renderable: RenderableType, *, refresh: bool = False) -> None:\n \"\"\"Update the renderable that is being displayed\n\n Args:\n renderable (RenderableType): New renderable to use.\n refresh (bool, optional): Refresh the display. Defaults to False.\n \"\"\"\n if isinstance(renderable, str):\n renderable = self.console.render_str(renderable)\n with self._lock:\n self._renderable = renderable\n if refresh:\n self.refresh()\n\n def refresh(self) -> None:\n \"\"\"Update the display of the Live Render.\"\"\"\n with self._lock:\n self._live_render.set_renderable(self.renderable)\n if self.console.is_jupyter: # pragma: no cover\n try:\n from IPython.display import display\n from ipywidgets import Output\n except ImportError:\n import warnings\n\n warnings.warn('install \"ipywidgets\" for Jupyter support')\n else:\n if self.ipy_widget is None:\n self.ipy_widget = Output()\n display(self.ipy_widget)\n\n with self.ipy_widget:\n self.ipy_widget.clear_output(wait=True)\n self.console.print(self._live_render.renderable)\n elif self.console.is_terminal and not self.console.is_dumb_terminal:\n with self.console:\n self.console.print(Control())\n elif (\n not self._started and not self.transient\n ): # if it is finished allow files or dumb-terminals to see final result\n with self.console:\n self.console.print(Control())\n\n def process_renderables(\n self, renderables: List[ConsoleRenderable]\n ) -> List[ConsoleRenderable]:\n \"\"\"Process renderables to restore cursor and display progress.\"\"\"\n self._live_render.vertical_overflow = self.vertical_overflow\n if self.console.is_interactive:\n # lock needs acquiring as user can modify live_render renderable at any time unlike in Progress.\n with self._lock:\n reset = (\n Control.home()\n if self._alt_screen\n else self._live_render.position_cursor()\n )\n renderables = [reset, *renderables, self._live_render]\n elif (\n not self._started and not self.transient\n ): # if it is finished render the final output for files or dumb_terminals\n renderables = [*renderables, self._live_render]\n\n return renderables\n\n\nif __name__ == \"__main__\": # pragma: no cover\n import random\n import time\n from itertools import cycle\n from typing import Dict, List, Tuple\n\n from .align import Align\n from .console import Console\n from .live import Live as Live\n from .panel import Panel\n from .rule import Rule\n from .syntax import Syntax\n from .table import Table\n\n console = Console()\n\n syntax = Syntax(\n '''def loop_last(values: Iterable[T]) -> Iterable[Tuple[bool, T]]:\n \"\"\"Iterate and generate a tuple with a flag for last value.\"\"\"\n iter_values = iter(values)\n try:\n previous_value = next(iter_values)\n except StopIteration:\n return\n for value in iter_values:\n yield False, previous_value\n previous_value = value\n yield True, previous_value''',\n \"python\",\n line_numbers=True,\n )\n\n table = Table(\"foo\", \"bar\", \"baz\")\n table.add_row(\"1\", \"2\", \"3\")\n\n progress_renderables = [\n \"You can make the terminal shorter and taller to see the live table hide\"\n \"Text may be printed while the progress bars are rendering.\",\n Panel(\"In fact, [i]any[/i] renderable will work\"),\n \"Such as [magenta]tables[/]...\",\n table,\n \"Pretty printed structures...\",\n {\"type\": \"example\", \"text\": \"Pretty printed\"},\n \"Syntax...\",\n syntax,\n Rule(\"Give it a try!\"),\n ]\n\n examples = cycle(progress_renderables)\n\n exchanges = [\n \"SGD\",\n \"MYR\",\n \"EUR\",\n \"USD\",\n \"AUD\",\n \"JPY\",\n \"CNH\",\n \"HKD\",\n \"CAD\",\n \"INR\",\n \"DKK\",\n \"GBP\",\n \"RUB\",\n \"NZD\",\n \"MXN\",\n \"IDR\",\n \"TWD\",\n \"THB\",\n \"VND\",\n ]\n with Live(console=console) as live_table:\n exchange_rate_dict: Dict[Tuple[str, str], float] = {}\n\n for index in range(100):\n select_exchange = exchanges[index % len(exchanges)]\n\n for exchange in exchanges:\n if exchange == select_exchange:\n continue\n time.sleep(0.4)\n if random.randint(0, 10) < 1:\n console.log(next(examples))\n exchange_rate_dict[(select_exchange, exchange)] = 200 / (\n (random.random() * 320) + 1\n )\n if len(exchange_rate_dict) > len(exchanges) - 1:\n exchange_rate_dict.pop(list(exchange_rate_dict.keys())[0])\n table = Table(title=\"Exchange Rates\")\n\n table.add_column(\"Source Currency\")\n table.add_column(\"Destination Currency\")\n table.add_column(\"Exchange Rate\")\n\n for (source, dest), exchange_rate in exchange_rate_dict.items():\n table.add_row(\n source,\n dest,\n Text(\n f\"{exchange_rate:.4f}\",\n style=\"red\" if exchange_rate < 1.0 else \"green\",\n ),\n )\n\n live_table.update(Align.center(table))\n",[],[213,919,920,921,1016,1050,1511,1753],"0b4fafe0-67fc-11f0-a7d9-0224a6c84d84","layout.py","0b4fb0b2-67fc-11f0-a7d9-0224a6c84d84",414,["D",1753299266760],"from abc import ABC, abstractmethod\nfrom itertools import islice\nfrom operator import itemgetter\nfrom threading import RLock\nfrom typing import (\n TYPE_CHECKING,\n Dict,\n Iterable,\n List,\n NamedTuple,\n Optional,\n Sequence,\n Tuple,\n Union,\n)\n\nfrom ._ratio import ratio_resolve\nfrom .align import Align\nfrom .console import Console, ConsoleOptions, RenderableType, RenderResult\nfrom .highlighter import ReprHighlighter\nfrom .panel import Panel\nfrom .pretty import Pretty\nfrom .region import Region\nfrom .repr import Result, rich_repr\nfrom .segment import Segment\nfrom .style import StyleType\n\nif TYPE_CHECKING:\n from pip._vendor.rich.tree import Tree\n\n\nclass LayoutRender(NamedTuple):\n \"\"\"An individual layout render.\"\"\"\n\n region: Region\n render: List[List[Segment]]\n\n\nRegionMap = Dict[\"Layout\", Region]\nRenderMap = Dict[\"Layout\", LayoutRender]\n\n\nclass LayoutError(Exception):\n \"\"\"Layout related error.\"\"\"\n\n\nclass NoSplitter(LayoutError):\n \"\"\"Requested splitter does not exist.\"\"\"\n\n\nclass _Placeholder:\n \"\"\"An internal renderable used as a Layout placeholder.\"\"\"\n\n highlighter = ReprHighlighter()\n\n def __init__(self, layout: \"Layout\", style: StyleType = \"\") -> None:\n self.layout = layout\n self.style = style\n\n def __rich_console__(\n self, console: Console, options: ConsoleOptions\n ) -> RenderResult:\n width = options.max_width\n height = options.height or options.size.height\n layout = self.layout\n title = (\n f\"{layout.name!r} ({width} x {height})\"\n if layout.name\n else f\"({width} x {height})\"\n )\n yield Panel(\n Align.center(Pretty(layout), vertical=\"middle\"),\n style=self.style,\n title=self.highlighter(title),\n border_style=\"blue\",\n height=height,\n )\n\n\nclass Splitter(ABC):\n \"\"\"Base class for a splitter.\"\"\"\n\n name: str = \"\"\n\n @abstractmethod\n def get_tree_icon(self) -> str:\n \"\"\"Get the icon (emoji) used in layout.tree\"\"\"\n\n @abstractmethod\n def divide(\n self, children: Sequence[\"Layout\"], region: Region\n ) -> Iterable[Tuple[\"Layout\", Region]]:\n \"\"\"Divide a region amongst several child layouts.\n\n Args:\n children (Sequence(Layout)): A number of child layouts.\n region (Region): A rectangular region to divide.\n \"\"\"\n\n\nclass RowSplitter(Splitter):\n \"\"\"Split a layout region in to rows.\"\"\"\n\n name = \"row\"\n\n def get_tree_icon(self) -> str:\n return \"[layout.tree.row]⬌\"\n\n def divide(\n self, children: Sequence[\"Layout\"], region: Region\n ) -> Iterable[Tuple[\"Layout\", Region]]:\n x, y, width, height = region\n render_widths = ratio_resolve(width, children)\n offset = 0\n _Region = Region\n for child, child_width in zip(children, render_widths):\n yield child, _Region(x + offset, y, child_width, height)\n offset += child_width\n\n\nclass ColumnSplitter(Splitter):\n \"\"\"Split a layout region in to columns.\"\"\"\n\n name = \"column\"\n\n def get_tree_icon(self) -> str:\n return \"[layout.tree.column]⬍\"\n\n def divide(\n self, children: Sequence[\"Layout\"], region: Region\n ) -> Iterable[Tuple[\"Layout\", Region]]:\n x, y, width, height = region\n render_heights = ratio_resolve(height, children)\n offset = 0\n _Region = Region\n for child, child_height in zip(children, render_heights):\n yield child, _Region(x, y + offset, width, child_height)\n offset += child_height\n\n\n@rich_repr\nclass Layout:\n \"\"\"A renderable to divide a fixed height in to rows or columns.\n\n Args:\n renderable (RenderableType, optional): Renderable content, or None for placeholder. Defaults to None.\n name (str, optional): Optional identifier for Layout. Defaults to None.\n size (int, optional): Optional fixed size of layout. Defaults to None.\n minimum_size (int, optional): Minimum size of layout. Defaults to 1.\n ratio (int, optional): Optional ratio for flexible layout. Defaults to 1.\n visible (bool, optional): Visibility of layout. Defaults to True.\n \"\"\"\n\n splitters = {\"row\": RowSplitter, \"column\": ColumnSplitter}\n\n def __init__(\n self,\n renderable: Optional[RenderableType] = None,\n *,\n name: Optional[str] = None,\n size: Optional[int] = None,\n minimum_size: int = 1,\n ratio: int = 1,\n visible: bool = True,\n ) -> None:\n self._renderable = renderable or _Placeholder(self)\n self.size = size\n self.minimum_size = minimum_size\n self.ratio = ratio\n self.name = name\n self.visible = visible\n self.splitter: Splitter = self.splitters[\"column\"]()\n self._children: List[Layout] = []\n self._render_map: RenderMap = {}\n self._lock = RLock()\n\n def __rich_repr__(self) -> Result:\n yield \"name\", self.name, None\n yield \"size\", self.size, None\n yield \"minimum_size\", self.minimum_size, 1\n yield \"ratio\", self.ratio, 1\n\n @property\n def renderable(self) -> RenderableType:\n \"\"\"Layout renderable.\"\"\"\n return self if self._children else self._renderable\n\n @property\n def children(self) -> List[\"Layout\"]:\n \"\"\"Gets (visible) layout children.\"\"\"\n return [child for child in self._children if child.visible]\n\n @property\n def map(self) -> RenderMap:\n \"\"\"Get a map of the last render.\"\"\"\n return self._render_map\n\n def get(self, name: str) -> Optional[\"Layout\"]:\n \"\"\"Get a named layout, or None if it doesn't exist.\n\n Args:\n name (str): Name of layout.\n\n Returns:\n Optional[Layout]: Layout instance or None if no layout was found.\n \"\"\"\n if self.name == name:\n return self\n else:\n for child in self._children:\n named_layout = child.get(name)\n if named_layout is not None:\n return named_layout\n return None\n\n def __getitem__(self, name: str) -> \"Layout\":\n layout = self.get(name)\n if layout is None:\n raise KeyError(f\"No layout with name {name!r}\")\n return layout\n\n @property\n def tree(self) -> \"Tree\":\n \"\"\"Get a tree renderable to show layout structure.\"\"\"\n from pip._vendor.rich.styled import Styled\n from pip._vendor.rich.table import Table\n from pip._vendor.rich.tree import Tree\n\n def summary(layout: \"Layout\") -> Table:\n icon = layout.splitter.get_tree_icon()\n\n table = Table.grid(padding=(0, 1, 0, 0))\n\n text: RenderableType = (\n Pretty(layout) if layout.visible else Styled(Pretty(layout), \"dim\")\n )\n table.add_row(icon, text)\n _summary = table\n return _summary\n\n layout = self\n tree = Tree(\n summary(layout),\n guide_style=f\"layout.tree.{layout.splitter.name}\",\n highlight=True,\n )\n\n def recurse(tree: \"Tree\", layout: \"Layout\") -> None:\n for child in layout._children:\n recurse(\n tree.add(\n summary(child),\n guide_style=f\"layout.tree.{child.splitter.name}\",\n ),\n child,\n )\n\n recurse(tree, self)\n return tree\n\n def split(\n self,\n *layouts: Union[\"Layout\", RenderableType],\n splitter: Union[Splitter, str] = \"column\",\n ) -> None:\n \"\"\"Split the layout in to multiple sub-layouts.\n\n Args:\n *layouts (Layout): Positional arguments should be (sub) Layout instances.\n splitter (Union[Splitter, str]): Splitter instance or name of splitter.\n \"\"\"\n _layouts = [\n layout if isinstance(layout, Layout) else Layout(layout)\n for layout in layouts\n ]\n try:\n self.splitter = (\n splitter\n if isinstance(splitter, Splitter)\n else self.splitters[splitter]()\n )\n except KeyError:\n raise NoSplitter(f\"No splitter called {splitter!r}\")\n self._children[:] = _layouts\n\n def add_split(self, *layouts: Union[\"Layout\", RenderableType]) -> None:\n \"\"\"Add a new layout(s) to existing split.\n\n Args:\n *layouts (Union[Layout, RenderableType]): Positional arguments should be renderables or (sub) Layout instances.\n\n \"\"\"\n _layouts = (\n layout if isinstance(layout, Layout) else Layout(layout)\n for layout in layouts\n )\n self._children.extend(_layouts)\n\n def split_row(self, *layouts: Union[\"Layout\", RenderableType]) -> None:\n \"\"\"Split the layout in to a row (layouts side by side).\n\n Args:\n *layouts (Layout): Positional arguments should be (sub) Layout instances.\n \"\"\"\n self.split(*layouts, splitter=\"row\")\n\n def split_column(self, *layouts: Union[\"Layout\", RenderableType]) -> None:\n \"\"\"Split the layout in to a column (layouts stacked on top of each other).\n\n Args:\n *layouts (Layout): Positional arguments should be (sub) Layout instances.\n \"\"\"\n self.split(*layouts, splitter=\"column\")\n\n def unsplit(self) -> None:\n \"\"\"Reset splits to initial state.\"\"\"\n del self._children[:]\n\n def update(self, renderable: RenderableType) -> None:\n \"\"\"Update renderable.\n\n Args:\n renderable (RenderableType): New renderable object.\n \"\"\"\n with self._lock:\n self._renderable = renderable\n\n def refresh_screen(self, console: \"Console\", layout_name: str) -> None:\n \"\"\"Refresh a sub-layout.\n\n Args:\n console (Console): Console instance where Layout is to be rendered.\n layout_name (str): Name of layout.\n \"\"\"\n with self._lock:\n layout = self[layout_name]\n region, _lines = self._render_map[layout]\n (x, y, width, height) = region\n lines = console.render_lines(\n layout, console.options.update_dimensions(width, height)\n )\n self._render_map[layout] = LayoutRender(region, lines)\n console.update_screen_lines(lines, x, y)\n\n def _make_region_map(self, width: int, height: int) -> RegionMap:\n \"\"\"Create a dict that maps layout on to Region.\"\"\"\n stack: List[Tuple[Layout, Region]] = [(self, Region(0, 0, width, height))]\n push = stack.append\n pop = stack.pop\n layout_regions: List[Tuple[Layout, Region]] = []\n append_layout_region = layout_regions.append\n while stack:\n append_layout_region(pop())\n layout, region = layout_regions[-1]\n children = layout.children\n if children:\n for child_and_region in layout.splitter.divide(children, region):\n push(child_and_region)\n\n region_map = {\n layout: region\n for layout, region in sorted(layout_regions, key=itemgetter(1))\n }\n return region_map\n\n def render(self, console: Console, options: ConsoleOptions) -> RenderMap:\n \"\"\"Render the sub_layouts.\n\n Args:\n console (Console): Console instance.\n options (ConsoleOptions): Console options.\n\n Returns:\n RenderMap: A dict that maps Layout on to a tuple of Region, lines\n \"\"\"\n render_width = options.max_width\n render_height = options.height or console.height\n region_map = self._make_region_map(render_width, render_height)\n layout_regions = [\n (layout, region)\n for layout, region in region_map.items()\n if not layout.children\n ]\n render_map: Dict[\"Layout\", \"LayoutRender\"] = {}\n render_lines = console.render_lines\n update_dimensions = options.update_dimensions\n\n for layout, region in layout_regions:\n lines = render_lines(\n layout.renderable, update_dimensions(region.width, region.height)\n )\n render_map[layout] = LayoutRender(region, lines)\n return render_map\n\n def __rich_console__(\n self, console: Console, options: ConsoleOptions\n ) -> RenderResult:\n with self._lock:\n width = options.max_width or console.width\n height = options.height or console.height\n render_map = self.render(console, options.update_dimensions(width, height))\n self._render_map = render_map\n layout_lines: List[List[Segment]] = [[] for _ in range(height)]\n _islice = islice\n for region, lines in render_map.values():\n _x, y, _layout_width, layout_height = region\n for row, line in zip(\n _islice(layout_lines, y, y + layout_height), lines\n ):\n row.extend(line)\n\n new_line = Segment.line()\n for layout_row in layout_lines:\n yield from layout_row\n yield new_line\n\n\nif __name__ == \"__main__\":\n from pip._vendor.rich.console import Console\n\n console = Console()\n layout = Layout()\n\n layout.split_column(\n Layout(name=\"header\", size=3),\n Layout(ratio=1, name=\"main\"),\n Layout(size=10, name=\"footer\"),\n )\n\n layout[\"main\"].split_row(Layout(name=\"side\"), Layout(name=\"body\", ratio=2))\n\n layout[\"body\"].split_row(Layout(name=\"content\", ratio=2), Layout(name=\"s2\"))\n\n layout[\"s2\"].split_column(\n Layout(name=\"top\"), Layout(name=\"middle\"), Layout(name=\"bottom\")\n )\n\n layout[\"side\"].split_column(Layout(layout.tree, name=\"left1\"), Layout(name=\"left2\"))\n\n layout[\"content\"].update(\"foo\")\n\n console.print(layout)\n",[],[213,919,920,921,1016,1050,1511,1761],"0cb7cdc2-67fc-11f0-bfb3-0224a6c84d84","jupyter.py","0cb7ce9e-67fc-11f0-bfb3-0224a6c84d84",470,["D",1753299269119],"from typing import TYPE_CHECKING, Any, Dict, Iterable, List, Sequence\n\nif TYPE_CHECKING:\n from pip._vendor.rich.console import ConsoleRenderable\n\nfrom . import get_console\nfrom .segment import Segment\nfrom .terminal_theme import DEFAULT_TERMINAL_THEME\n\nif TYPE_CHECKING:\n from pip._vendor.rich.console import ConsoleRenderable\n\nJUPYTER_HTML_FORMAT = \"\"\"\\\n

{code}

\n\"\"\"\n\n\nclass JupyterRenderable:\n \"\"\"A shim to write html to Jupyter notebook.\"\"\"\n\n def __init__(self, html: str, text: str) -> None:\n self.html = html\n self.text = text\n\n def _repr_mimebundle_(\n self, include: Sequence[str], exclude: Sequence[str], **kwargs: Any\n ) -> Dict[str, str]:\n data = {\"text/plain\": self.text, \"text/html\": self.html}\n if include:\n data = {k: v for (k, v) in data.items() if k in include}\n if exclude:\n data = {k: v for (k, v) in data.items() if k not in exclude}\n return data\n\n\nclass JupyterMixin:\n \"\"\"Add to an Rich renderable to make it render in Jupyter notebook.\"\"\"\n\n __slots__ = ()\n\n def _repr_mimebundle_(\n self: \"ConsoleRenderable\",\n include: Sequence[str],\n exclude: Sequence[str],\n **kwargs: Any,\n ) -> Dict[str, str]:\n console = get_console()\n segments = list(console.render(self, console.options))\n html = _render_segments(segments)\n text = console._render_buffer(segments)\n data = {\"text/plain\": text, \"text/html\": html}\n if include:\n data = {k: v for (k, v) in data.items() if k in include}\n if exclude:\n data = {k: v for (k, v) in data.items() if k not in exclude}\n return data\n\n\ndef _render_segments(segments: Iterable[Segment]) -> str:\n def escape(text: str) -> str:\n \"\"\"Escape html.\"\"\"\n return text.replace(\"&\", \"&\").replace(\"<\", \"<\").replace(\">\", \">\")\n\n fragments: List[str] = []\n append_fragment = fragments.append\n theme = DEFAULT_TERMINAL_THEME\n for text, style, control in Segment.simplify(segments):\n if control:\n continue\n text = escape(text)\n if style:\n rule = style.get_html_style(theme)\n text = f'{text}' if rule else text\n if style.link:\n text = f'{text}'\n append_fragment(text)\n\n code = \"\".join(fragments)\n html = JUPYTER_HTML_FORMAT.format(code=code)\n\n return html\n\n\ndef display(segments: Iterable[Segment], text: str) -> None:\n \"\"\"Render segments to Jupyter.\"\"\"\n html = _render_segments(segments)\n jupyter_renderable = JupyterRenderable(html, text)\n try:\n from IPython.display import display as ipython_display\n\n ipython_display(jupyter_renderable)\n except ModuleNotFoundError:\n # Handle the case where the Console has force_jupyter=True,\n # but IPython is not installed.\n pass\n\n\ndef print(*args: Any, **kwargs: Any) -> None:\n \"\"\"Proxy for Console print.\"\"\"\n console = get_console()\n return console.print(*args, **kwargs)\n",[],[213,919,920,921,1016,1050,1511,1769],"0c7e1d02-67fc-11f0-bcbe-0224a6c84d84","json.py","0c7e1df2-67fc-11f0-bcbe-0224a6c84d84",463,["D",1753299268743],"from pathlib import Path\nfrom json import loads, dumps\nfrom typing import Any, Callable, Optional, Union\n\nfrom .text import Text\nfrom .highlighter import JSONHighlighter, NullHighlighter\n\n\nclass JSON:\n \"\"\"A renderable which pretty prints JSON.\n\n Args:\n json (str): JSON encoded data.\n indent (Union[None, int, str], optional): Number of characters to indent by. Defaults to 2.\n highlight (bool, optional): Enable highlighting. Defaults to True.\n skip_keys (bool, optional): Skip keys not of a basic type. Defaults to False.\n ensure_ascii (bool, optional): Escape all non-ascii characters. Defaults to False.\n check_circular (bool, optional): Check for circular references. Defaults to True.\n allow_nan (bool, optional): Allow NaN and Infinity values. Defaults to True.\n default (Callable, optional): A callable that converts values that can not be encoded\n in to something that can be JSON encoded. Defaults to None.\n sort_keys (bool, optional): Sort dictionary keys. Defaults to False.\n \"\"\"\n\n def __init__(\n self,\n json: str,\n indent: Union[None, int, str] = 2,\n highlight: bool = True,\n skip_keys: bool = False,\n ensure_ascii: bool = False,\n check_circular: bool = True,\n allow_nan: bool = True,\n default: Optional[Callable[[Any], Any]] = None,\n sort_keys: bool = False,\n ) -> None:\n data = loads(json)\n json = dumps(\n data,\n indent=indent,\n skipkeys=skip_keys,\n ensure_ascii=ensure_ascii,\n check_circular=check_circular,\n allow_nan=allow_nan,\n default=default,\n sort_keys=sort_keys,\n )\n highlighter = JSONHighlighter() if highlight else NullHighlighter()\n self.text = highlighter(json)\n self.text.no_wrap = True\n self.text.overflow = None\n\n @classmethod\n def from_data(\n cls,\n data: Any,\n indent: Union[None, int, str] = 2,\n highlight: bool = True,\n skip_keys: bool = False,\n ensure_ascii: bool = False,\n check_circular: bool = True,\n allow_nan: bool = True,\n default: Optional[Callable[[Any], Any]] = None,\n sort_keys: bool = False,\n ) -> \"JSON\":\n \"\"\"Encodes a JSON object from arbitrary data.\n\n Args:\n data (Any): An object that may be encoded in to JSON\n indent (Union[None, int, str], optional): Number of characters to indent by. Defaults to 2.\n highlight (bool, optional): Enable highlighting. Defaults to True.\n default (Callable, optional): Optional callable which will be called for objects that cannot be serialized. Defaults to None.\n skip_keys (bool, optional): Skip keys not of a basic type. Defaults to False.\n ensure_ascii (bool, optional): Escape all non-ascii characters. Defaults to False.\n check_circular (bool, optional): Check for circular references. Defaults to True.\n allow_nan (bool, optional): Allow NaN and Infinity values. Defaults to True.\n default (Callable, optional): A callable that converts values that can not be encoded\n in to something that can be JSON encoded. Defaults to None.\n sort_keys (bool, optional): Sort dictionary keys. Defaults to False.\n\n Returns:\n JSON: New JSON object from the given data.\n \"\"\"\n json_instance: \"JSON\" = cls.__new__(cls)\n json = dumps(\n data,\n indent=indent,\n skipkeys=skip_keys,\n ensure_ascii=ensure_ascii,\n check_circular=check_circular,\n allow_nan=allow_nan,\n default=default,\n sort_keys=sort_keys,\n )\n highlighter = JSONHighlighter() if highlight else NullHighlighter()\n json_instance.text = highlighter(json)\n json_instance.text.no_wrap = True\n json_instance.text.overflow = None\n return json_instance\n\n def __rich__(self) -> Text:\n return self.text\n\n\nif __name__ == \"__main__\":\n import argparse\n import sys\n\n parser = argparse.ArgumentParser(description=\"Pretty print json\")\n parser.add_argument(\n \"path\",\n metavar=\"PATH\",\n help=\"path to file, or - for stdin\",\n )\n parser.add_argument(\n \"-i\",\n \"--indent\",\n metavar=\"SPACES\",\n type=int,\n help=\"Number of spaces in an indent\",\n default=2,\n )\n args = parser.parse_args()\n\n from pip._vendor.rich.console import Console\n\n console = Console()\n error_console = Console(stderr=True)\n\n try:\n if args.path == \"-\":\n json_data = sys.stdin.read()\n else:\n json_data = Path(args.path).read_text()\n except Exception as error:\n error_console.print(f\"Unable to read {args.path!r}; {error}\")\n sys.exit(-1)\n\n console.print(JSON(json_data, indent=args.indent), soft_wrap=True)\n",[],[213,919,920,921,1016,1050,1511,1777],"0be90906-67fc-11f0-b666-0224a6c84d84","highlighter.py","0be909b0-67fc-11f0-b666-0224a6c84d84",439,["D",1753299267764],"import re\nfrom abc import ABC, abstractmethod\nfrom typing import List, Union\n\nfrom .text import Span, Text\n\n\ndef _combine_regex(*regexes: str) -> str:\n \"\"\"Combine a number of regexes in to a single regex.\n\n Returns:\n str: New regex with all regexes ORed together.\n \"\"\"\n return \"|\".join(regexes)\n\n\nclass Highlighter(ABC):\n \"\"\"Abstract base class for highlighters.\"\"\"\n\n def __call__(self, text: Union[str, Text]) -> Text:\n \"\"\"Highlight a str or Text instance.\n\n Args:\n text (Union[str, ~Text]): Text to highlight.\n\n Raises:\n TypeError: If not called with text or str.\n\n Returns:\n Text: A test instance with highlighting applied.\n \"\"\"\n if isinstance(text, str):\n highlight_text = Text(text)\n elif isinstance(text, Text):\n highlight_text = text.copy()\n else:\n raise TypeError(f\"str or Text instance required, not {text!r}\")\n self.highlight(highlight_text)\n return highlight_text\n\n @abstractmethod\n def highlight(self, text: Text) -> None:\n \"\"\"Apply highlighting in place to text.\n\n Args:\n text (~Text): A text object highlight.\n \"\"\"\n\n\nclass NullHighlighter(Highlighter):\n \"\"\"A highlighter object that doesn't highlight.\n\n May be used to disable highlighting entirely.\n\n \"\"\"\n\n def highlight(self, text: Text) -> None:\n \"\"\"Nothing to do\"\"\"\n\n\nclass RegexHighlighter(Highlighter):\n \"\"\"Applies highlighting from a list of regular expressions.\"\"\"\n\n highlights: List[str] = []\n base_style: str = \"\"\n\n def highlight(self, text: Text) -> None:\n \"\"\"Highlight :class:`rich.text.Text` using regular expressions.\n\n Args:\n text (~Text): Text to highlighted.\n\n \"\"\"\n\n highlight_regex = text.highlight_regex\n for re_highlight in self.highlights:\n highlight_regex(re_highlight, style_prefix=self.base_style)\n\n\nclass ReprHighlighter(RegexHighlighter):\n \"\"\"Highlights the text typically produced from ``__repr__`` methods.\"\"\"\n\n base_style = \"repr.\"\n highlights = [\n r\"(?P<)(?P[-\\w.:|]*)(?P[\\w\\W]*)(?P>)\",\n r'(?P[\\w_]{1,50})=(?P\"?[\\w_]+\"?)?',\n r\"(?P[][{}()])\",\n _combine_regex(\n r\"(?P[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3})\",\n r\"(?P([A-Fa-f0-9]{1,4}::?){1,7}[A-Fa-f0-9]{1,4})\",\n r\"(?P(?:[0-9A-Fa-f]{1,2}-){7}[0-9A-Fa-f]{1,2}|(?:[0-9A-Fa-f]{1,2}:){7}[0-9A-Fa-f]{1,2}|(?:[0-9A-Fa-f]{4}\\.){3}[0-9A-Fa-f]{4})\",\n r\"(?P(?:[0-9A-Fa-f]{1,2}-){5}[0-9A-Fa-f]{1,2}|(?:[0-9A-Fa-f]{1,2}:){5}[0-9A-Fa-f]{1,2}|(?:[0-9A-Fa-f]{4}\\.){2}[0-9A-Fa-f]{4})\",\n r\"(?P[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12})\",\n r\"(?P[\\w.]*?)\$\",\n r\"\\b(?PTrue)\\b|\\b(?PFalse)\\b|\\b(?PNone)\\b\",\n r\"(?P\\.\\.\\.)\",\n r\"(?P(?(?\\B(/[-\\w._+]+)*\\/)(?P[-\\w._+]*)?\",\n r\"(?b?'''.*?(?(file|https|http|ws|wss)://[-0-9a-zA-Z$_+!`(),.?/;:&=%#~@]*)\",\n ),\n ]\n\n\nclass JSONHighlighter(RegexHighlighter):\n \"\"\"Highlights JSON\"\"\"\n\n # Captures the start and end of JSON strings, handling escaped quotes\n JSON_STR = r\"(?b?\\\".*?(?[\\{\\[\\(\$\\]\\}])\",\n r\"\\b(?Ptrue)\\b|\\b(?Pfalse)\\b|\\b(?Pnull)\\b\",\n r\"(?P(? None:\n super().highlight(text)\n\n # Additional work to handle highlighting JSON keys\n plain = text.plain\n append = text.spans.append\n whitespace = self.JSON_WHITESPACE\n for match in re.finditer(self.JSON_STR, plain):\n start, end = match.span()\n cursor = end\n while cursor < len(plain):\n char = plain[cursor]\n cursor += 1\n if char == \":\":\n append(Span(start, end, \"json.key\"))\n elif char in whitespace:\n continue\n break\n\n\nclass ISO8601Highlighter(RegexHighlighter):\n \"\"\"Highlights the ISO8601 date time strings.\n Regex reference: https://www.oreilly.com/library/view/regular-expressions-cookbook/9781449327453/ch04s07.html\n \"\"\"\n\n base_style = \"iso8601.\"\n highlights = [\n #\n # Dates\n #\n # Calendar month (e.g. 2008-08). The hyphen is required\n r\"^(?P[0-9]{4})-(?P1[0-2]|0[1-9])$\",\n # Calendar date w/o hyphens (e.g. 20080830)\n r\"^(?P(?P[0-9]{4})(?P1[0-2]|0[1-9])(?P3[01]|0[1-9]|[12][0-9]))$\",\n # Ordinal date (e.g. 2008-243). The hyphen is optional\n r\"^(?P(?P[0-9]{4})-?(?P36[0-6]|3[0-5][0-9]|[12][0-9]{2}|0[1-9][0-9]|00[1-9]))$\",\n #\n # Weeks\n #\n # Week of the year (e.g., 2008-W35). The hyphen is optional\n r\"^(?P(?P[0-9]{4})-?W(?P5[0-3]|[1-4][0-9]|0[1-9]))$\",\n # Week date (e.g., 2008-W35-6). The hyphens are optional\n r\"^(?P(?P[0-9]{4})-?W(?P5[0-3]|[1-4][0-9]|0[1-9])-?(?P[1-7]))$\",\n #\n # Times\n #\n # Hours and minutes (e.g., 17:21). The colon is optional\n r\"^(?P(?P2[0-3]|[01][0-9]):?(?P[0-5][0-9]))$\",\n # Hours, minutes, and seconds w/o colons (e.g., 172159)\n r\"^(?P(?P2[0-3]|[01][0-9])(?P[0-5][0-9])(?P[0-5][0-9]))$\",\n # Time zone designator (e.g., Z, +07 or +07:00). The colons and the minutes are optional\n r\"^(?P(Z|[+-](?:2[0-3]|[01][0-9])(?::?(?:[0-5][0-9]))?))$\",\n # Hours, minutes, and seconds with time zone designator (e.g., 17:21:59+07:00).\n # All the colons are optional. The minutes in the time zone designator are also optional\n r\"^(?P(?P2[0-3]|[01][0-9])(?P[0-5][0-9])(?P[0-5][0-9]))(?PZ|[+-](?:2[0-3]|[01][0-9])(?::?(?:[0-5][0-9]))?)$\",\n #\n # Date and Time\n #\n # Calendar date with hours, minutes, and seconds (e.g., 2008-08-30 17:21:59 or 20080830 172159).\n # A space is required between the date and the time. The hyphens and colons are optional.\n # This regex matches dates and times that specify some hyphens or colons but omit others.\n # This does not follow ISO 8601\n r\"^(?P(?P[0-9]{4})(?P-)?(?P1[0-2]|0[1-9])(?(hyphen)-)(?P3[01]|0[1-9]|[12][0-9])) (?P(?P2[0-3]|[01][0-9])(?(hyphen):)(?P[0-5][0-9])(?(hyphen):)(?P[0-5][0-9]))$\",\n #\n # XML Schema dates and times\n #\n # Date, with optional time zone (e.g., 2008-08-30 or 2008-08-30+07:00).\n # Hyphens are required. This is the XML Schema 'date' type\n r\"^(?P(?P-?(?:[1-9][0-9]*)?[0-9]{4})-(?P1[0-2]|0[1-9])-(?P3[01]|0[1-9]|[12][0-9]))(?PZ|[+-](?:2[0-3]|[01][0-9]):[0-5][0-9])?$\",\n # Time, with optional fractional seconds and time zone (e.g., 01:45:36 or 01:45:36.123+07:00).\n # There is no limit on the number of digits for the fractional seconds. This is the XML Schema 'time' type\n r\"^(?P(?P2[0-3]|[01][0-9]):(?P[0-5][0-9]):(?P[0-5][0-9])(?P\\.[0-9]+)?)(?PZ|[+-](?:2[0-3]|[01][0-9]):[0-5][0-9])?$\",\n # Date and time, with optional fractional seconds and time zone (e.g., 2008-08-30T01:45:36 or 2008-08-30T01:45:36.123Z).\n # This is the XML Schema 'dateTime' type\n r\"^(?P(?P-?(?:[1-9][0-9]*)?[0-9]{4})-(?P1[0-2]|0[1-9])-(?P3[01]|0[1-9]|[12][0-9]))T(?P(?P2[0-3]|[01][0-9]):(?P[0-5][0-9]):(?P[0-5][0-9])(?P\\.[0-9]+)?)(?PZ|[+-](?:2[0-3]|[01][0-9]):[0-5][0-9])?$\",\n ]\n\n\nif __name__ == \"__main__\": # pragma: no cover\n from .console import Console\n\n console = Console()\n console.print(\"[bold green]hello world![/bold green]\")\n console.print(\"'[bold green]hello world![/bold green]'\")\n\n console.print(\" /foo\")\n console.print(\"/foo/\")\n console.print(\"/foo/bar\")\n console.print(\"foo/bar/baz\")\n\n console.print(\"/foo/bar/baz?foo=bar+egg&egg=baz\")\n console.print(\"/foo/bar/baz/\")\n console.print(\"/foo/bar/baz/egg\")\n console.print(\"/foo/bar/baz/egg.py\")\n console.print(\"/foo/bar/baz/egg.py word\")\n console.print(\" /foo/bar/baz/egg.py word\")\n console.print(\"foo /foo/bar/baz/egg.py word\")\n console.print(\"foo /foo/bar/ba._++z/egg+.py word\")\n console.print(\"https://example.org?foo=bar#header\")\n\n console.print(1234567.34)\n console.print(1 / 2)\n console.print(-1 / 123123123123)\n\n console.print(\n \"127.0.1.1 bar 192.168.1.4 2001:0db8:85a3:0000:0000:8a2e:0370:7334 foo\"\n )\n import json\n\n console.print_json(json.dumps(obj={\"name\": \"apple\", \"count\": 1}), indent=None)\n",[],[213,919,920,921,1016,1050,1511,1785],"0b7df652-67fc-11f0-aad3-0224a6c84d84","filesize.py","0b7df6de-67fc-11f0-aad3-0224a6c84d84",422,["D",1753299267052],"\"\"\"Functions for reporting filesizes. Borrowed from https://github.com/PyFilesystem/pyfilesystem2\n\nThe functions declared in this module should cover the different\nuse cases needed to generate a string representation of a file size\nusing several different units. Since there are many standards regarding\nfile size units, three different functions have been implemented.\n\nSee Also:\n * `Wikipedia: Binary prefix `_\n\n\"\"\"\n\n__all__ = [\"decimal\"]\n\nfrom typing import Iterable, List, Optional, Tuple\n\n\ndef _to_str(\n size: int,\n suffixes: Iterable[str],\n base: int,\n *,\n precision: Optional[int] = 1,\n separator: Optional[str] = \" \",\n) -> str:\n if size == 1:\n return \"1 byte\"\n elif size < base:\n return f\"{size:,} bytes\"\n\n for i, suffix in enumerate(suffixes, 2): # noqa: B007\n unit = base**i\n if size < unit:\n break\n return \"{:,.{precision}f}{separator}{}\".format(\n (base * size / unit),\n suffix,\n precision=precision,\n separator=separator,\n )\n\n\ndef pick_unit_and_suffix(size: int, suffixes: List[str], base: int) -> Tuple[int, str]:\n \"\"\"Pick a suffix and base for the given size.\"\"\"\n for i, suffix in enumerate(suffixes):\n unit = base**i\n if size < unit * base:\n break\n return unit, suffix\n\n\ndef decimal(\n size: int,\n *,\n precision: Optional[int] = 1,\n separator: Optional[str] = \" \",\n) -> str:\n \"\"\"Convert a filesize in to a string (powers of 1000, SI prefixes).\n\n In this convention, ``1000 B = 1 kB``.\n\n This is typically the format used to advertise the storage\n capacity of USB flash drives and the like (*256 MB* meaning\n actually a storage capacity of more than *256 000 000 B*),\n or used by **Mac OS X** since v10.6 to report file sizes.\n\n Arguments:\n int (size): A file size.\n int (precision): The number of decimal places to include (default = 1).\n str (separator): The string to separate the value from the units (default = \" \").\n\n Returns:\n `str`: A string containing a abbreviated file size and units.\n\n Example:\n >>> filesize.decimal(30000)\n '30.0 kB'\n >>> filesize.decimal(30000, precision=2, separator=\"\")\n '30.00kB'\n\n \"\"\"\n return _to_str(\n size,\n (\"kB\", \"MB\", \"GB\", \"TB\", \"PB\", \"EB\", \"ZB\", \"YB\"),\n 1000,\n precision=precision,\n separator=separator,\n )\n",[],[213,919,920,921,1016,1050,1511,1793],"0b9c2aaa-67fc-11f0-a319-0224a6c84d84","file_proxy.py","0b9c2ba4-67fc-11f0-a319-0224a6c84d84",427,["D",1753299267248],"import io\nfrom typing import IO, TYPE_CHECKING, Any, List\n\nfrom .ansi import AnsiDecoder\nfrom .text import Text\n\nif TYPE_CHECKING:\n from .console import Console\n\n\nclass FileProxy(io.TextIOBase):\n \"\"\"Wraps a file (e.g. sys.stdout) and redirects writes to a console.\"\"\"\n\n def __init__(self, console: \"Console\", file: IO[str]) -> None:\n self.__console = console\n self.__file = file\n self.__buffer: List[str] = []\n self.__ansi_decoder = AnsiDecoder()\n\n @property\n def rich_proxied_file(self) -> IO[str]:\n \"\"\"Get proxied file.\"\"\"\n return self.__file\n\n def __getattr__(self, name: str) -> Any:\n return getattr(self.__file, name)\n\n def write(self, text: str) -> int:\n if not isinstance(text, str):\n raise TypeError(f\"write() argument must be str, not {type(text).__name__}\")\n buffer = self.__buffer\n lines: List[str] = []\n while text:\n line, new_line, text = text.partition(\"\\n\")\n if new_line:\n lines.append(\"\".join(buffer) + line)\n buffer.clear()\n else:\n buffer.append(line)\n break\n if lines:\n console = self.__console\n with console:\n output = Text(\"\\n\").join(\n self.__ansi_decoder.decode_line(line) for line in lines\n )\n console.print(output)\n return len(text)\n\n def flush(self) -> None:\n output = \"\".join(self.__buffer)\n if output:\n self.__console.print(output)\n del self.__buffer[:]\n\n def fileno(self) -> int:\n return self.__file.fileno()\n",[],[213,919,920,921,1016,1050,1511,1801],"0c2257a6-67fc-11f0-befa-0224a6c84d84","errors.py","0c225878-67fc-11f0-befa-0224a6c84d84",448,["D",1753299268131],"class ConsoleError(Exception):\n \"\"\"An error in console operation.\"\"\"\n\n\nclass StyleError(Exception):\n \"\"\"An error in styles.\"\"\"\n\n\nclass StyleSyntaxError(ConsoleError):\n \"\"\"Style was badly formatted.\"\"\"\n\n\nclass MissingStyle(StyleError):\n \"\"\"No such style.\"\"\"\n\n\nclass StyleStackError(ConsoleError):\n \"\"\"Style stack is invalid.\"\"\"\n\n\nclass NotRenderableError(ConsoleError):\n \"\"\"Object is not renderable.\"\"\"\n\n\nclass MarkupError(ConsoleError):\n \"\"\"Markup was badly formatted.\"\"\"\n\n\nclass LiveError(ConsoleError):\n \"\"\"Error related to Live display.\"\"\"\n\n\nclass NoAltScreen(ConsoleError):\n \"\"\"Alt screen mode was required.\"\"\"\n",[],[213,919,920,921,1016,1050,1511,1809],"0b484d9a-67fc-11f0-bcbe-0224a6c84d84","emoji.py","0b484e3a-67fc-11f0-bcbe-0224a6c84d84",413,["D",1753299266698],"import sys\nfrom typing import TYPE_CHECKING, Optional, Union\n\nfrom .jupyter import JupyterMixin\nfrom .segment import Segment\nfrom .style import Style\nfrom ._emoji_codes import EMOJI\nfrom ._emoji_replace import _emoji_replace\n\nif sys.version_info >= (3, 8):\n from typing import Literal\nelse:\n from pip._vendor.typing_extensions import Literal # pragma: no cover\n\n\nif TYPE_CHECKING:\n from .console import Console, ConsoleOptions, RenderResult\n\n\nEmojiVariant = Literal[\"emoji\", \"text\"]\n\n\nclass NoEmoji(Exception):\n \"\"\"No emoji by that name.\"\"\"\n\n\nclass Emoji(JupyterMixin):\n __slots__ = [\"name\", \"style\", \"_char\", \"variant\"]\n\n VARIANTS = {\"text\": \"\\uFE0E\", \"emoji\": \"\\uFE0F\"}\n\n def __init__(\n self,\n name: str,\n style: Union[str, Style] = \"none\",\n variant: Optional[EmojiVariant] = None,\n ) -> None:\n \"\"\"A single emoji character.\n\n Args:\n name (str): Name of emoji.\n style (Union[str, Style], optional): Optional style. Defaults to None.\n\n Raises:\n NoEmoji: If the emoji doesn't exist.\n \"\"\"\n self.name = name\n self.style = style\n self.variant = variant\n try:\n self._char = EMOJI[name]\n except KeyError:\n raise NoEmoji(f\"No emoji called {name!r}\")\n if variant is not None:\n self._char += self.VARIANTS.get(variant, \"\")\n\n @classmethod\n def replace(cls, text: str) -> str:\n \"\"\"Replace emoji markup with corresponding unicode characters.\n\n Args:\n text (str): A string with emojis codes, e.g. \"Hello :smiley:!\"\n\n Returns:\n str: A string with emoji codes replaces with actual emoji.\n \"\"\"\n return _emoji_replace(text)\n\n def __repr__(self) -> str:\n return f\"\"\n\n def __str__(self) -> str:\n return self._char\n\n def __rich_console__(\n self, console: \"Console\", options: \"ConsoleOptions\"\n ) -> \"RenderResult\":\n yield Segment(self._char, console.get_style(self.style))\n\n\nif __name__ == \"__main__\": # pragma: no cover\n import sys\n\n from pip._vendor.rich.columns import Columns\n from pip._vendor.rich.console import Console\n\n console = Console(record=True)\n\n columns = Columns(\n (f\":{name}: {name}\" for name in sorted(EMOJI.keys()) if \"\\u200D\" not in name),\n column_first=True,\n )\n\n console.print(columns)\n if len(sys.argv) > 1:\n console.save_html(sys.argv[1])\n",[],[213,919,920,921,1016,1050,1511,1817],"0bc5f8c6-67fc-11f0-a319-0224a6c84d84","diagnose.py","0bc5f984-67fc-11f0-a319-0224a6c84d84",434,["D",1753299267533],"import os\nimport platform\n\nfrom pip._vendor.rich import inspect\nfrom pip._vendor.rich.console import Console, get_windows_console_features\nfrom pip._vendor.rich.panel import Panel\nfrom pip._vendor.rich.pretty import Pretty\n\n\ndef report() -> None: # pragma: no cover\n \"\"\"Print a report to the terminal with debugging information\"\"\"\n console = Console()\n inspect(console)\n features = get_windows_console_features()\n inspect(features)\n\n env_names = (\n \"CLICOLOR\",\n \"COLORTERM\",\n \"COLUMNS\",\n \"JPY_PARENT_PID\",\n \"JUPYTER_COLUMNS\",\n \"JUPYTER_LINES\",\n \"LINES\",\n \"NO_COLOR\",\n \"TERM_PROGRAM\",\n \"TERM\",\n \"TTY_COMPATIBLE\",\n \"VSCODE_VERBOSE_LOGGING\",\n )\n env = {name: os.getenv(name) for name in env_names}\n console.print(Panel.fit((Pretty(env)), title=\"[b]Environment Variables\"))\n\n console.print(f'platform=\"{platform.system()}\"')\n\n\nif __name__ == \"__main__\": # pragma: no cover\n report()\n",[],[213,919,920,921,1016,1050,1511,1825],"0b349e26-67fc-11f0-aedf-0224a6c84d84","default_styles.py","0b349eee-67fc-11f0-aedf-0224a6c84d84",409,["D",1753299266584],"from typing import Dict\n\nfrom .style import Style\n\nDEFAULT_STYLES: Dict[str, Style] = {\n \"none\": Style.null(),\n \"reset\": Style(\n color=\"default\",\n bgcolor=\"default\",\n dim=False,\n bold=False,\n italic=False,\n underline=False,\n blink=False,\n blink2=False,\n reverse=False,\n conceal=False,\n strike=False,\n ),\n \"dim\": Style(dim=True),\n \"bright\": Style(dim=False),\n \"bold\": Style(bold=True),\n \"strong\": Style(bold=True),\n \"code\": Style(reverse=True, bold=True),\n \"italic\": Style(italic=True),\n \"emphasize\": Style(italic=True),\n \"underline\": Style(underline=True),\n \"blink\": Style(blink=True),\n \"blink2\": Style(blink2=True),\n \"reverse\": Style(reverse=True),\n \"strike\": Style(strike=True),\n \"black\": Style(color=\"black\"),\n \"red\": Style(color=\"red\"),\n \"green\": Style(color=\"green\"),\n \"yellow\": Style(color=\"yellow\"),\n \"magenta\": Style(color=\"magenta\"),\n \"cyan\": Style(color=\"cyan\"),\n \"white\": Style(color=\"white\"),\n \"inspect.attr\": Style(color=\"yellow\", italic=True),\n \"inspect.attr.dunder\": Style(color=\"yellow\", italic=True, dim=True),\n \"inspect.callable\": Style(bold=True, color=\"red\"),\n \"inspect.async_def\": Style(italic=True, color=\"bright_cyan\"),\n \"inspect.def\": Style(italic=True, color=\"bright_cyan\"),\n \"inspect.class\": Style(italic=True, color=\"bright_cyan\"),\n \"inspect.error\": Style(bold=True, color=\"red\"),\n \"inspect.equals\": Style(),\n \"inspect.help\": Style(color=\"cyan\"),\n \"inspect.doc\": Style(dim=True),\n \"inspect.value.border\": Style(color=\"green\"),\n \"live.ellipsis\": Style(bold=True, color=\"red\"),\n \"layout.tree.row\": Style(dim=False, color=\"red\"),\n \"layout.tree.column\": Style(dim=False, color=\"blue\"),\n \"logging.keyword\": Style(bold=True, color=\"yellow\"),\n \"logging.level.notset\": Style(dim=True),\n \"logging.level.debug\": Style(color=\"green\"),\n \"logging.level.info\": Style(color=\"blue\"),\n \"logging.level.warning\": Style(color=\"yellow\"),\n \"logging.level.error\": Style(color=\"red\", bold=True),\n \"logging.level.critical\": Style(color=\"red\", bold=True, reverse=True),\n \"log.level\": Style.null(),\n \"log.time\": Style(color=\"cyan\", dim=True),\n \"log.message\": Style.null(),\n \"log.path\": Style(dim=True),\n \"repr.ellipsis\": Style(color=\"yellow\"),\n \"repr.indent\": Style(color=\"green\", dim=True),\n \"repr.error\": Style(color=\"red\", bold=True),\n \"repr.str\": Style(color=\"green\", italic=False, bold=False),\n \"repr.brace\": Style(bold=True),\n \"repr.comma\": Style(bold=True),\n \"repr.ipv4\": Style(bold=True, color=\"bright_green\"),\n \"repr.ipv6\": Style(bold=True, color=\"bright_green\"),\n \"repr.eui48\": Style(bold=True, color=\"bright_green\"),\n \"repr.eui64\": Style(bold=True, color=\"bright_green\"),\n \"repr.tag_start\": Style(bold=True),\n \"repr.tag_name\": Style(color=\"bright_magenta\", bold=True),\n \"repr.tag_contents\": Style(color=\"default\"),\n \"repr.tag_end\": Style(bold=True),\n \"repr.attrib_name\": Style(color=\"yellow\", italic=False),\n \"repr.attrib_equal\": Style(bold=True),\n \"repr.attrib_value\": Style(color=\"magenta\", italic=False),\n \"repr.number\": Style(color=\"cyan\", bold=True, italic=False),\n \"repr.number_complex\": Style(color=\"cyan\", bold=True, italic=False), # same\n \"repr.bool_true\": Style(color=\"bright_green\", italic=True),\n \"repr.bool_false\": Style(color=\"bright_red\", italic=True),\n \"repr.none\": Style(color=\"magenta\", italic=True),\n \"repr.url\": Style(underline=True, color=\"bright_blue\", italic=False, bold=False),\n \"repr.uuid\": Style(color=\"bright_yellow\", bold=False),\n \"repr.call\": Style(color=\"magenta\", bold=True),\n \"repr.path\": Style(color=\"magenta\"),\n \"repr.filename\": Style(color=\"bright_magenta\"),\n \"rule.line\": Style(color=\"bright_green\"),\n \"rule.text\": Style.null(),\n \"json.brace\": Style(bold=True),\n \"json.bool_true\": Style(color=\"bright_green\", italic=True),\n \"json.bool_false\": Style(color=\"bright_red\", italic=True),\n \"json.null\": Style(color=\"magenta\", italic=True),\n \"json.number\": Style(color=\"cyan\", bold=True, italic=False),\n \"json.str\": Style(color=\"green\", italic=False, bold=False),\n \"json.key\": Style(color=\"blue\", bold=True),\n \"prompt\": Style.null(),\n \"prompt.choices\": Style(color=\"magenta\", bold=True),\n \"prompt.default\": Style(color=\"cyan\", bold=True),\n \"prompt.invalid\": Style(color=\"red\"),\n \"prompt.invalid.choice\": Style(color=\"red\"),\n \"pretty\": Style.null(),\n \"scope.border\": Style(color=\"blue\"),\n \"scope.key\": Style(color=\"yellow\", italic=True),\n \"scope.key.special\": Style(color=\"yellow\", italic=True, dim=True),\n \"scope.equals\": Style(color=\"red\"),\n \"table.header\": Style(bold=True),\n \"table.footer\": Style(bold=True),\n \"table.cell\": Style.null(),\n \"table.title\": Style(italic=True),\n \"table.caption\": Style(italic=True, dim=True),\n \"traceback.error\": Style(color=\"red\", italic=True),\n \"traceback.border.syntax_error\": Style(color=\"bright_red\"),\n \"traceback.border\": Style(color=\"red\"),\n \"traceback.text\": Style.null(),\n \"traceback.title\": Style(color=\"red\", bold=True),\n \"traceback.exc_type\": Style(color=\"bright_red\", bold=True),\n \"traceback.exc_value\": Style.null(),\n \"traceback.offset\": Style(color=\"bright_red\", bold=True),\n \"traceback.error_range\": Style(underline=True, bold=True),\n \"traceback.note\": Style(color=\"green\", bold=True),\n \"traceback.group.border\": Style(color=\"magenta\"),\n \"bar.back\": Style(color=\"grey23\"),\n \"bar.complete\": Style(color=\"rgb(249,38,114)\"),\n \"bar.finished\": Style(color=\"rgb(114,156,31)\"),\n \"bar.pulse\": Style(color=\"rgb(249,38,114)\"),\n \"progress.description\": Style.null(),\n \"progress.filesize\": Style(color=\"green\"),\n \"progress.filesize.total\": Style(color=\"green\"),\n \"progress.download\": Style(color=\"green\"),\n \"progress.elapsed\": Style(color=\"yellow\"),\n \"progress.percentage\": Style(color=\"magenta\"),\n \"progress.remaining\": Style(color=\"cyan\"),\n \"progress.data.speed\": Style(color=\"red\"),\n \"progress.spinner\": Style(color=\"green\"),\n \"status.spinner\": Style(color=\"green\"),\n \"tree\": Style(),\n \"tree.line\": Style(),\n \"markdown.paragraph\": Style(),\n \"markdown.text\": Style(),\n \"markdown.em\": Style(italic=True),\n \"markdown.emph\": Style(italic=True), # For commonmark backwards compatibility\n \"markdown.strong\": Style(bold=True),\n \"markdown.code\": Style(bold=True, color=\"cyan\", bgcolor=\"black\"),\n \"markdown.code_block\": Style(color=\"cyan\", bgcolor=\"black\"),\n \"markdown.block_quote\": Style(color=\"magenta\"),\n \"markdown.list\": Style(color=\"cyan\"),\n \"markdown.item\": Style(),\n \"markdown.item.bullet\": Style(color=\"yellow\", bold=True),\n \"markdown.item.number\": Style(color=\"yellow\", bold=True),\n \"markdown.hr\": Style(color=\"yellow\"),\n \"markdown.h1.border\": Style(),\n \"markdown.h1\": Style(bold=True),\n \"markdown.h2\": Style(bold=True, underline=True),\n \"markdown.h3\": Style(bold=True),\n \"markdown.h4\": Style(bold=True, dim=True),\n \"markdown.h5\": Style(underline=True),\n \"markdown.h6\": Style(italic=True),\n \"markdown.h7\": Style(italic=True, dim=True),\n \"markdown.link\": Style(color=\"bright_blue\"),\n \"markdown.link_url\": Style(color=\"blue\", underline=True),\n \"markdown.s\": Style(strike=True),\n \"iso8601.date\": Style(color=\"blue\"),\n \"iso8601.time\": Style(color=\"magenta\"),\n \"iso8601.timezone\": Style(color=\"yellow\"),\n}\n\n\nif __name__ == \"__main__\": # pragma: no cover\n import argparse\n import io\n\n from pip._vendor.rich.console import Console\n from pip._vendor.rich.table import Table\n from pip._vendor.rich.text import Text\n\n parser = argparse.ArgumentParser()\n parser.add_argument(\"--html\", action=\"store_true\", help=\"Export as HTML table\")\n args = parser.parse_args()\n html: bool = args.html\n console = Console(record=True, width=70, file=io.StringIO()) if html else Console()\n\n table = Table(\"Name\", \"Styling\")\n\n for style_name, style in DEFAULT_STYLES.items():\n table.add_row(Text(style_name, style=style), str(style))\n\n console.print(table)\n if html:\n print(console.export_html(inline_styles=True))\n",[],[213,919,920,921,1016,1050,1511,1833],"0b7a13fc-67fc-11f0-bcbe-0224a6c84d84","control.py","0b7a149c-67fc-11f0-bcbe-0224a6c84d84",421,["D",1753299267039],"import sys\nimport time\nfrom typing import TYPE_CHECKING, Callable, Dict, Iterable, List, Union\n\nif sys.version_info >= (3, 8):\n from typing import Final\nelse:\n from pip._vendor.typing_extensions import Final # pragma: no cover\n\nfrom .segment import ControlCode, ControlType, Segment\n\nif TYPE_CHECKING:\n from .console import Console, ConsoleOptions, RenderResult\n\nSTRIP_CONTROL_CODES: Final = [\n 7, # Bell\n 8, # Backspace\n 11, # Vertical tab\n 12, # Form feed\n 13, # Carriage return\n]\n_CONTROL_STRIP_TRANSLATE: Final = {\n _codepoint: None for _codepoint in STRIP_CONTROL_CODES\n}\n\nCONTROL_ESCAPE: Final = {\n 7: \"\\\\a\",\n 8: \"\\\\b\",\n 11: \"\\\\v\",\n 12: \"\\\\f\",\n 13: \"\\\\r\",\n}\n\nCONTROL_CODES_FORMAT: Dict[int, Callable[..., str]] = {\n ControlType.BELL: lambda: \"\\x07\",\n ControlType.CARRIAGE_RETURN: lambda: \"\\r\",\n ControlType.HOME: lambda: \"\\x1b[H\",\n ControlType.CLEAR: lambda: \"\\x1b[2J\",\n ControlType.ENABLE_ALT_SCREEN: lambda: \"\\x1b[?1049h\",\n ControlType.DISABLE_ALT_SCREEN: lambda: \"\\x1b[?1049l\",\n ControlType.SHOW_CURSOR: lambda: \"\\x1b[?25h\",\n ControlType.HIDE_CURSOR: lambda: \"\\x1b[?25l\",\n ControlType.CURSOR_UP: lambda param: f\"\\x1b[{param}A\",\n ControlType.CURSOR_DOWN: lambda param: f\"\\x1b[{param}B\",\n ControlType.CURSOR_FORWARD: lambda param: f\"\\x1b[{param}C\",\n ControlType.CURSOR_BACKWARD: lambda param: f\"\\x1b[{param}D\",\n ControlType.CURSOR_MOVE_TO_COLUMN: lambda param: f\"\\x1b[{param+1}G\",\n ControlType.ERASE_IN_LINE: lambda param: f\"\\x1b[{param}K\",\n ControlType.CURSOR_MOVE_TO: lambda x, y: f\"\\x1b[{y+1};{x+1}H\",\n ControlType.SET_WINDOW_TITLE: lambda title: f\"\\x1b]0;{title}\\x07\",\n}\n\n\nclass Control:\n \"\"\"A renderable that inserts a control code (non printable but may move cursor).\n\n Args:\n *codes (str): Positional arguments are either a :class:`~rich.segment.ControlType` enum or a\n tuple of ControlType and an integer parameter\n \"\"\"\n\n __slots__ = [\"segment\"]\n\n def __init__(self, *codes: Union[ControlType, ControlCode]) -> None:\n control_codes: List[ControlCode] = [\n (code,) if isinstance(code, ControlType) else code for code in codes\n ]\n _format_map = CONTROL_CODES_FORMAT\n rendered_codes = \"\".join(\n _format_map[code](*parameters) for code, *parameters in control_codes\n )\n self.segment = Segment(rendered_codes, None, control_codes)\n\n @classmethod\n def bell(cls) -> \"Control\":\n \"\"\"Ring the 'bell'.\"\"\"\n return cls(ControlType.BELL)\n\n @classmethod\n def home(cls) -> \"Control\":\n \"\"\"Move cursor to 'home' position.\"\"\"\n return cls(ControlType.HOME)\n\n @classmethod\n def move(cls, x: int = 0, y: int = 0) -> \"Control\":\n \"\"\"Move cursor relative to current position.\n\n Args:\n x (int): X offset.\n y (int): Y offset.\n\n Returns:\n ~Control: Control object.\n\n \"\"\"\n\n def get_codes() -> Iterable[ControlCode]:\n control = ControlType\n if x:\n yield (\n control.CURSOR_FORWARD if x > 0 else control.CURSOR_BACKWARD,\n abs(x),\n )\n if y:\n yield (\n control.CURSOR_DOWN if y > 0 else control.CURSOR_UP,\n abs(y),\n )\n\n control = cls(*get_codes())\n return control\n\n @classmethod\n def move_to_column(cls, x: int, y: int = 0) -> \"Control\":\n \"\"\"Move to the given column, optionally add offset to row.\n\n Returns:\n x (int): absolute x (column)\n y (int): optional y offset (row)\n\n Returns:\n ~Control: Control object.\n \"\"\"\n\n return (\n cls(\n (ControlType.CURSOR_MOVE_TO_COLUMN, x),\n (\n ControlType.CURSOR_DOWN if y > 0 else ControlType.CURSOR_UP,\n abs(y),\n ),\n )\n if y\n else cls((ControlType.CURSOR_MOVE_TO_COLUMN, x))\n )\n\n @classmethod\n def move_to(cls, x: int, y: int) -> \"Control\":\n \"\"\"Move cursor to absolute position.\n\n Args:\n x (int): x offset (column)\n y (int): y offset (row)\n\n Returns:\n ~Control: Control object.\n \"\"\"\n return cls((ControlType.CURSOR_MOVE_TO, x, y))\n\n @classmethod\n def clear(cls) -> \"Control\":\n \"\"\"Clear the screen.\"\"\"\n return cls(ControlType.CLEAR)\n\n @classmethod\n def show_cursor(cls, show: bool) -> \"Control\":\n \"\"\"Show or hide the cursor.\"\"\"\n return cls(ControlType.SHOW_CURSOR if show else ControlType.HIDE_CURSOR)\n\n @classmethod\n def alt_screen(cls, enable: bool) -> \"Control\":\n \"\"\"Enable or disable alt screen.\"\"\"\n if enable:\n return cls(ControlType.ENABLE_ALT_SCREEN, ControlType.HOME)\n else:\n return cls(ControlType.DISABLE_ALT_SCREEN)\n\n @classmethod\n def title(cls, title: str) -> \"Control\":\n \"\"\"Set the terminal window title\n\n Args:\n title (str): The new terminal window title\n \"\"\"\n return cls((ControlType.SET_WINDOW_TITLE, title))\n\n def __str__(self) -> str:\n return self.segment.text\n\n def __rich_console__(\n self, console: \"Console\", options: \"ConsoleOptions\"\n ) -> \"RenderResult\":\n if self.segment.text:\n yield self.segment\n\n\ndef strip_control_codes(\n text: str, _translate_table: Dict[int, None] = _CONTROL_STRIP_TRANSLATE\n) -> str:\n \"\"\"Remove control codes from text.\n\n Args:\n text (str): A string possibly contain control codes.\n\n Returns:\n str: String with control codes removed.\n \"\"\"\n return text.translate(_translate_table)\n\n\ndef escape_control_codes(\n text: str,\n _translate_table: Dict[int, str] = CONTROL_ESCAPE,\n) -> str:\n \"\"\"Replace control codes with their \"escaped\" equivalent in the given text.\n (e.g. \"\\b\" becomes \"\\\\b\")\n\n Args:\n text (str): A string possibly containing control codes.\n\n Returns:\n str: String with control codes replaced with their escaped version.\n \"\"\"\n return text.translate(_translate_table)\n\n\nif __name__ == \"__main__\": # pragma: no cover\n from pip._vendor.rich.console import Console\n\n console = Console()\n console.print(\"Look at the title of your terminal window ^\")\n # console.print(Control((ControlType.SET_WINDOW_TITLE, \"Hello, world!\")))\n for i in range(10):\n console.set_window_title(\"🚀 Loading\" + \".\" * i)\n time.sleep(0.5)\n",[],[213,919,920,921,1016,1050,1511,1841],"0b54fff4-67fc-11f0-9bd1-0224a6c84d84","containers.py","0b5500a8-67fc-11f0-9bd1-0224a6c84d84",415,["D",1753299266796],"from itertools import zip_longest\nfrom typing import (\n TYPE_CHECKING,\n Iterable,\n Iterator,\n List,\n Optional,\n TypeVar,\n Union,\n overload,\n)\n\nif TYPE_CHECKING:\n from .console import (\n Console,\n ConsoleOptions,\n JustifyMethod,\n OverflowMethod,\n RenderResult,\n RenderableType,\n )\n from .text import Text\n\nfrom .cells import cell_len\nfrom .measure import Measurement\n\nT = TypeVar(\"T\")\n\n\nclass Renderables:\n \"\"\"A list subclass which renders its contents to the console.\"\"\"\n\n def __init__(\n self, renderables: Optional[Iterable[\"RenderableType\"]] = None\n ) -> None:\n self._renderables: List[\"RenderableType\"] = (\n list(renderables) if renderables is not None else []\n )\n\n def __rich_console__(\n self, console: \"Console\", options: \"ConsoleOptions\"\n ) -> \"RenderResult\":\n \"\"\"Console render method to insert line-breaks.\"\"\"\n yield from self._renderables\n\n def __rich_measure__(\n self, console: \"Console\", options: \"ConsoleOptions\"\n ) -> \"Measurement\":\n dimensions = [\n Measurement.get(console, options, renderable)\n for renderable in self._renderables\n ]\n if not dimensions:\n return Measurement(1, 1)\n _min = max(dimension.minimum for dimension in dimensions)\n _max = max(dimension.maximum for dimension in dimensions)\n return Measurement(_min, _max)\n\n def append(self, renderable: \"RenderableType\") -> None:\n self._renderables.append(renderable)\n\n def __iter__(self) -> Iterable[\"RenderableType\"]:\n return iter(self._renderables)\n\n\nclass Lines:\n \"\"\"A list subclass which can render to the console.\"\"\"\n\n def __init__(self, lines: Iterable[\"Text\"] = ()) -> None:\n self._lines: List[\"Text\"] = list(lines)\n\n def __repr__(self) -> str:\n return f\"Lines({self._lines!r})\"\n\n def __iter__(self) -> Iterator[\"Text\"]:\n return iter(self._lines)\n\n @overload\n def __getitem__(self, index: int) -> \"Text\":\n ...\n\n @overload\n def __getitem__(self, index: slice) -> List[\"Text\"]:\n ...\n\n def __getitem__(self, index: Union[slice, int]) -> Union[\"Text\", List[\"Text\"]]:\n return self._lines[index]\n\n def __setitem__(self, index: int, value: \"Text\") -> \"Lines\":\n self._lines[index] = value\n return self\n\n def __len__(self) -> int:\n return self._lines.__len__()\n\n def __rich_console__(\n self, console: \"Console\", options: \"ConsoleOptions\"\n ) -> \"RenderResult\":\n \"\"\"Console render method to insert line-breaks.\"\"\"\n yield from self._lines\n\n def append(self, line: \"Text\") -> None:\n self._lines.append(line)\n\n def extend(self, lines: Iterable[\"Text\"]) -> None:\n self._lines.extend(lines)\n\n def pop(self, index: int = -1) -> \"Text\":\n return self._lines.pop(index)\n\n def justify(\n self,\n console: \"Console\",\n width: int,\n justify: \"JustifyMethod\" = \"left\",\n overflow: \"OverflowMethod\" = \"fold\",\n ) -> None:\n \"\"\"Justify and overflow text to a given width.\n\n Args:\n console (Console): Console instance.\n width (int): Number of cells available per line.\n justify (str, optional): Default justify method for text: \"left\", \"center\", \"full\" or \"right\". Defaults to \"left\".\n overflow (str, optional): Default overflow for text: \"crop\", \"fold\", or \"ellipsis\". Defaults to \"fold\".\n\n \"\"\"\n from .text import Text\n\n if justify == \"left\":\n for line in self._lines:\n line.truncate(width, overflow=overflow, pad=True)\n elif justify == \"center\":\n for line in self._lines:\n line.rstrip()\n line.truncate(width, overflow=overflow)\n line.pad_left((width - cell_len(line.plain)) // 2)\n line.pad_right(width - cell_len(line.plain))\n elif justify == \"right\":\n for line in self._lines:\n line.rstrip()\n line.truncate(width, overflow=overflow)\n line.pad_left(width - cell_len(line.plain))\n elif justify == \"full\":\n for line_index, line in enumerate(self._lines):\n if line_index == len(self._lines) - 1:\n break\n words = line.split(\" \")\n words_size = sum(cell_len(word.plain) for word in words)\n num_spaces = len(words) - 1\n spaces = [1 for _ in range(num_spaces)]\n index = 0\n if spaces:\n while words_size + num_spaces < width:\n spaces[len(spaces) - index - 1] += 1\n num_spaces += 1\n index = (index + 1) % len(spaces)\n tokens: List[Text] = []\n for index, (word, next_word) in enumerate(\n zip_longest(words, words[1:])\n ):\n tokens.append(word)\n if index < len(spaces):\n style = word.get_style_at_offset(console, -1)\n next_style = next_word.get_style_at_offset(console, 0)\n space_style = style if style == next_style else line.style\n tokens.append(Text(\" \" * spaces[index], style=space_style))\n self[line_index] = Text(\"\").join(tokens)\n",[],[213,919,920,921,1016,1050,1511,1849],"0bb91e4e-67fc-11f0-a99a-0224a6c84d84","constrain.py","0bb91f0c-67fc-11f0-a99a-0224a6c84d84",432,["D",1753299267450],"from typing import Optional, TYPE_CHECKING\n\nfrom .jupyter import JupyterMixin\nfrom .measure import Measurement\n\nif TYPE_CHECKING:\n from .console import Console, ConsoleOptions, RenderableType, RenderResult\n\n\nclass Constrain(JupyterMixin):\n \"\"\"Constrain the width of a renderable to a given number of characters.\n\n Args:\n renderable (RenderableType): A renderable object.\n width (int, optional): The maximum width (in characters) to render. Defaults to 80.\n \"\"\"\n\n def __init__(self, renderable: \"RenderableType\", width: Optional[int] = 80) -> None:\n self.renderable = renderable\n self.width = width\n\n def __rich_console__(\n self, console: \"Console\", options: \"ConsoleOptions\"\n ) -> \"RenderResult\":\n if self.width is None:\n yield self.renderable\n else:\n child_options = options.update_width(min(self.width, options.max_width))\n yield from console.render(self.renderable, child_options)\n\n def __rich_measure__(\n self, console: \"Console\", options: \"ConsoleOptions\"\n ) -> \"Measurement\":\n if self.width is not None:\n options = options.update_width(self.width)\n measurement = Measurement.get(console, options, self.renderable)\n return measurement\n",[],[213,919,920,921,1016,1050,1511,1857],"0bcc75ac-67fc-11f0-9bd1-0224a6c84d84","columns.py","0bcc7656-67fc-11f0-9bd1-0224a6c84d84",435,["D",1753299267546],"from collections import defaultdict\nfrom itertools import chain\nfrom operator import itemgetter\nfrom typing import Dict, Iterable, List, Optional, Tuple\n\nfrom .align import Align, AlignMethod\nfrom .console import Console, ConsoleOptions, RenderableType, RenderResult\nfrom .constrain import Constrain\nfrom .measure import Measurement\nfrom .padding import Padding, PaddingDimensions\nfrom .table import Table\nfrom .text import TextType\nfrom .jupyter import JupyterMixin\n\n\nclass Columns(JupyterMixin):\n \"\"\"Display renderables in neat columns.\n\n Args:\n renderables (Iterable[RenderableType]): Any number of Rich renderables (including str).\n width (int, optional): The desired width of the columns, or None to auto detect. Defaults to None.\n padding (PaddingDimensions, optional): Optional padding around cells. Defaults to (0, 1).\n expand (bool, optional): Expand columns to full width. Defaults to False.\n equal (bool, optional): Arrange in to equal sized columns. Defaults to False.\n column_first (bool, optional): Align items from top to bottom (rather than left to right). Defaults to False.\n right_to_left (bool, optional): Start column from right hand side. Defaults to False.\n align (str, optional): Align value (\"left\", \"right\", or \"center\") or None for default. Defaults to None.\n title (TextType, optional): Optional title for Columns.\n \"\"\"\n\n def __init__(\n self,\n renderables: Optional[Iterable[RenderableType]] = None,\n padding: PaddingDimensions = (0, 1),\n *,\n width: Optional[int] = None,\n expand: bool = False,\n equal: bool = False,\n column_first: bool = False,\n right_to_left: bool = False,\n align: Optional[AlignMethod] = None,\n title: Optional[TextType] = None,\n ) -> None:\n self.renderables = list(renderables or [])\n self.width = width\n self.padding = padding\n self.expand = expand\n self.equal = equal\n self.column_first = column_first\n self.right_to_left = right_to_left\n self.align: Optional[AlignMethod] = align\n self.title = title\n\n def add_renderable(self, renderable: RenderableType) -> None:\n \"\"\"Add a renderable to the columns.\n\n Args:\n renderable (RenderableType): Any renderable object.\n \"\"\"\n self.renderables.append(renderable)\n\n def __rich_console__(\n self, console: Console, options: ConsoleOptions\n ) -> RenderResult:\n render_str = console.render_str\n renderables = [\n render_str(renderable) if isinstance(renderable, str) else renderable\n for renderable in self.renderables\n ]\n if not renderables:\n return\n _top, right, _bottom, left = Padding.unpack(self.padding)\n width_padding = max(left, right)\n max_width = options.max_width\n widths: Dict[int, int] = defaultdict(int)\n column_count = len(renderables)\n\n get_measurement = Measurement.get\n renderable_widths = [\n get_measurement(console, options, renderable).maximum\n for renderable in renderables\n ]\n if self.equal:\n renderable_widths = [max(renderable_widths)] * len(renderable_widths)\n\n def iter_renderables(\n column_count: int,\n ) -> Iterable[Tuple[int, Optional[RenderableType]]]:\n item_count = len(renderables)\n if self.column_first:\n width_renderables = list(zip(renderable_widths, renderables))\n\n column_lengths: List[int] = [item_count // column_count] * column_count\n for col_no in range(item_count % column_count):\n column_lengths[col_no] += 1\n\n row_count = (item_count + column_count - 1) // column_count\n cells = [[-1] * column_count for _ in range(row_count)]\n row = col = 0\n for index in range(item_count):\n cells[row][col] = index\n column_lengths[col] -= 1\n if column_lengths[col]:\n row += 1\n else:\n col += 1\n row = 0\n for index in chain.from_iterable(cells):\n if index == -1:\n break\n yield width_renderables[index]\n else:\n yield from zip(renderable_widths, renderables)\n # Pad odd elements with spaces\n if item_count % column_count:\n for _ in range(column_count - (item_count % column_count)):\n yield 0, None\n\n table = Table.grid(padding=self.padding, collapse_padding=True, pad_edge=False)\n table.expand = self.expand\n table.title = self.title\n\n if self.width is not None:\n column_count = (max_width) // (self.width + width_padding)\n for _ in range(column_count):\n table.add_column(width=self.width)\n else:\n while column_count > 1:\n widths.clear()\n column_no = 0\n for renderable_width, _ in iter_renderables(column_count):\n widths[column_no] = max(widths[column_no], renderable_width)\n total_width = sum(widths.values()) + width_padding * (\n len(widths) - 1\n )\n if total_width > max_width:\n column_count = len(widths) - 1\n break\n else:\n column_no = (column_no + 1) % column_count\n else:\n break\n\n get_renderable = itemgetter(1)\n _renderables = [\n get_renderable(_renderable)\n for _renderable in iter_renderables(column_count)\n ]\n if self.equal:\n _renderables = [\n None\n if renderable is None\n else Constrain(renderable, renderable_widths[0])\n for renderable in _renderables\n ]\n if self.align:\n align = self.align\n _Align = Align\n _renderables = [\n None if renderable is None else _Align(renderable, align)\n for renderable in _renderables\n ]\n\n right_to_left = self.right_to_left\n add_row = table.add_row\n for start in range(0, len(_renderables), column_count):\n row = _renderables[start : start + column_count]\n if right_to_left:\n row = row[::-1]\n add_row(*row)\n yield table\n\n\nif __name__ == \"__main__\": # pragma: no cover\n import os\n\n console = Console()\n\n files = [f\"{i} {s}\" for i, s in enumerate(sorted(os.listdir()))]\n columns = Columns(files, padding=(0, 1), expand=False, equal=False)\n console.print(columns)\n console.rule()\n columns.column_first = True\n console.print(columns)\n columns.right_to_left = True\n console.rule()\n console.print(columns)\n",[],[213,919,920,921,1016,1050,1511,1865],"0cc0e47a-67fc-11f0-847e-0224a6c84d84","color_triplet.py","0cc0e510-67fc-11f0-847e-0224a6c84d84",472,["D",1753299269167],"from typing import NamedTuple, Tuple\n\n\nclass ColorTriplet(NamedTuple):\n \"\"\"The red, green, and blue components of a color.\"\"\"\n\n red: int\n \"\"\"Red component in 0 to 255 range.\"\"\"\n green: int\n \"\"\"Green component in 0 to 255 range.\"\"\"\n blue: int\n \"\"\"Blue component in 0 to 255 range.\"\"\"\n\n @property\n def hex(self) -> str:\n \"\"\"get the color triplet in CSS style.\"\"\"\n red, green, blue = self\n return f\"#{red:02x}{green:02x}{blue:02x}\"\n\n @property\n def rgb(self) -> str:\n \"\"\"The color in RGB format.\n\n Returns:\n str: An rgb color, e.g. ``\"rgb(100,23,255)\"``.\n \"\"\"\n red, green, blue = self\n return f\"rgb({red},{green},{blue})\"\n\n @property\n def normalized(self) -> Tuple[float, float, float]:\n \"\"\"Convert components into floats between 0 and 1.\n\n Returns:\n Tuple[float, float, float]: A tuple of three normalized colour components.\n \"\"\"\n red, green, blue = self\n return red / 255.0, green / 255.0, blue / 255.0\n",[],[213,919,920,921,1016,1050,1511,1873],"0b0cf218-67fc-11f0-b6cd-0224a6c84d84","color.py","0b0cf2cc-67fc-11f0-b6cd-0224a6c84d84",404,["D",1753299266320],"import re\nimport sys\nfrom colorsys import rgb_to_hls\nfrom enum import IntEnum\nfrom functools import lru_cache\nfrom typing import TYPE_CHECKING, NamedTuple, Optional, Tuple\n\nfrom ._palettes import EIGHT_BIT_PALETTE, STANDARD_PALETTE, WINDOWS_PALETTE\nfrom .color_triplet import ColorTriplet\nfrom .repr import Result, rich_repr\nfrom .terminal_theme import DEFAULT_TERMINAL_THEME\n\nif TYPE_CHECKING: # pragma: no cover\n from .terminal_theme import TerminalTheme\n from .text import Text\n\n\nWINDOWS = sys.platform == \"win32\"\n\n\nclass ColorSystem(IntEnum):\n \"\"\"One of the 3 color system supported by terminals.\"\"\"\n\n STANDARD = 1\n EIGHT_BIT = 2\n TRUECOLOR = 3\n WINDOWS = 4\n\n def __repr__(self) -> str:\n return f\"ColorSystem.{self.name}\"\n\n def __str__(self) -> str:\n return repr(self)\n\n\nclass ColorType(IntEnum):\n \"\"\"Type of color stored in Color class.\"\"\"\n\n DEFAULT = 0\n STANDARD = 1\n EIGHT_BIT = 2\n TRUECOLOR = 3\n WINDOWS = 4\n\n def __repr__(self) -> str:\n return f\"ColorType.{self.name}\"\n\n\nANSI_COLOR_NAMES = {\n \"black\": 0,\n \"red\": 1,\n \"green\": 2,\n \"yellow\": 3,\n \"blue\": 4,\n \"magenta\": 5,\n \"cyan\": 6,\n \"white\": 7,\n \"bright_black\": 8,\n \"bright_red\": 9,\n \"bright_green\": 10,\n \"bright_yellow\": 11,\n \"bright_blue\": 12,\n \"bright_magenta\": 13,\n \"bright_cyan\": 14,\n \"bright_white\": 15,\n \"grey0\": 16,\n \"gray0\": 16,\n \"navy_blue\": 17,\n \"dark_blue\": 18,\n \"blue3\": 20,\n \"blue1\": 21,\n \"dark_green\": 22,\n \"deep_sky_blue4\": 25,\n \"dodger_blue3\": 26,\n \"dodger_blue2\": 27,\n \"green4\": 28,\n \"spring_green4\": 29,\n \"turquoise4\": 30,\n \"deep_sky_blue3\": 32,\n \"dodger_blue1\": 33,\n \"green3\": 40,\n \"spring_green3\": 41,\n \"dark_cyan\": 36,\n \"light_sea_green\": 37,\n \"deep_sky_blue2\": 38,\n \"deep_sky_blue1\": 39,\n \"spring_green2\": 47,\n \"cyan3\": 43,\n \"dark_turquoise\": 44,\n \"turquoise2\": 45,\n \"green1\": 46,\n \"spring_green1\": 48,\n \"medium_spring_green\": 49,\n \"cyan2\": 50,\n \"cyan1\": 51,\n \"dark_red\": 88,\n \"deep_pink4\": 125,\n \"purple4\": 55,\n \"purple3\": 56,\n \"blue_violet\": 57,\n \"orange4\": 94,\n \"grey37\": 59,\n \"gray37\": 59,\n \"medium_purple4\": 60,\n \"slate_blue3\": 62,\n \"royal_blue1\": 63,\n \"chartreuse4\": 64,\n \"dark_sea_green4\": 71,\n \"pale_turquoise4\": 66,\n \"steel_blue\": 67,\n \"steel_blue3\": 68,\n \"cornflower_blue\": 69,\n \"chartreuse3\": 76,\n \"cadet_blue\": 73,\n \"sky_blue3\": 74,\n \"steel_blue1\": 81,\n \"pale_green3\": 114,\n \"sea_green3\": 78,\n \"aquamarine3\": 79,\n \"medium_turquoise\": 80,\n \"chartreuse2\": 112,\n \"sea_green2\": 83,\n \"sea_green1\": 85,\n \"aquamarine1\": 122,\n \"dark_slate_gray2\": 87,\n \"dark_magenta\": 91,\n \"dark_violet\": 128,\n \"purple\": 129,\n \"light_pink4\": 95,\n \"plum4\": 96,\n \"medium_purple3\": 98,\n \"slate_blue1\": 99,\n \"yellow4\": 106,\n \"wheat4\": 101,\n \"grey53\": 102,\n \"gray53\": 102,\n \"light_slate_grey\": 103,\n \"light_slate_gray\": 103,\n \"medium_purple\": 104,\n \"light_slate_blue\": 105,\n \"dark_olive_green3\": 149,\n \"dark_sea_green\": 108,\n \"light_sky_blue3\": 110,\n \"sky_blue2\": 111,\n \"dark_sea_green3\": 150,\n \"dark_slate_gray3\": 116,\n \"sky_blue1\": 117,\n \"chartreuse1\": 118,\n \"light_green\": 120,\n \"pale_green1\": 156,\n \"dark_slate_gray1\": 123,\n \"red3\": 160,\n \"medium_violet_red\": 126,\n \"magenta3\": 164,\n \"dark_orange3\": 166,\n \"indian_red\": 167,\n \"hot_pink3\": 168,\n \"medium_orchid3\": 133,\n \"medium_orchid\": 134,\n \"medium_purple2\": 140,\n \"dark_goldenrod\": 136,\n \"light_salmon3\": 173,\n \"rosy_brown\": 138,\n \"grey63\": 139,\n \"gray63\": 139,\n \"medium_purple1\": 141,\n \"gold3\": 178,\n \"dark_khaki\": 143,\n \"navajo_white3\": 144,\n \"grey69\": 145,\n \"gray69\": 145,\n \"light_steel_blue3\": 146,\n \"light_steel_blue\": 147,\n \"yellow3\": 184,\n \"dark_sea_green2\": 157,\n \"light_cyan3\": 152,\n \"light_sky_blue1\": 153,\n \"green_yellow\": 154,\n \"dark_olive_green2\": 155,\n \"dark_sea_green1\": 193,\n \"pale_turquoise1\": 159,\n \"deep_pink3\": 162,\n \"magenta2\": 200,\n \"hot_pink2\": 169,\n \"orchid\": 170,\n \"medium_orchid1\": 207,\n \"orange3\": 172,\n \"light_pink3\": 174,\n \"pink3\": 175,\n \"plum3\": 176,\n \"violet\": 177,\n \"light_goldenrod3\": 179,\n \"tan\": 180,\n \"misty_rose3\": 181,\n \"thistle3\": 182,\n \"plum2\": 183,\n \"khaki3\": 185,\n \"light_goldenrod2\": 222,\n \"light_yellow3\": 187,\n \"grey84\": 188,\n \"gray84\": 188,\n \"light_steel_blue1\": 189,\n \"yellow2\": 190,\n \"dark_olive_green1\": 192,\n \"honeydew2\": 194,\n \"light_cyan1\": 195,\n \"red1\": 196,\n \"deep_pink2\": 197,\n \"deep_pink1\": 199,\n \"magenta1\": 201,\n \"orange_red1\": 202,\n \"indian_red1\": 204,\n \"hot_pink\": 206,\n \"dark_orange\": 208,\n \"salmon1\": 209,\n \"light_coral\": 210,\n \"pale_violet_red1\": 211,\n \"orchid2\": 212,\n \"orchid1\": 213,\n \"orange1\": 214,\n \"sandy_brown\": 215,\n \"light_salmon1\": 216,\n \"light_pink1\": 217,\n \"pink1\": 218,\n \"plum1\": 219,\n \"gold1\": 220,\n \"navajo_white1\": 223,\n \"misty_rose1\": 224,\n \"thistle1\": 225,\n \"yellow1\": 226,\n \"light_goldenrod1\": 227,\n \"khaki1\": 228,\n \"wheat1\": 229,\n \"cornsilk1\": 230,\n \"grey100\": 231,\n \"gray100\": 231,\n \"grey3\": 232,\n \"gray3\": 232,\n \"grey7\": 233,\n \"gray7\": 233,\n \"grey11\": 234,\n \"gray11\": 234,\n \"grey15\": 235,\n \"gray15\": 235,\n \"grey19\": 236,\n \"gray19\": 236,\n \"grey23\": 237,\n \"gray23\": 237,\n \"grey27\": 238,\n \"gray27\": 238,\n \"grey30\": 239,\n \"gray30\": 239,\n \"grey35\": 240,\n \"gray35\": 240,\n \"grey39\": 241,\n \"gray39\": 241,\n \"grey42\": 242,\n \"gray42\": 242,\n \"grey46\": 243,\n \"gray46\": 243,\n \"grey50\": 244,\n \"gray50\": 244,\n \"grey54\": 245,\n \"gray54\": 245,\n \"grey58\": 246,\n \"gray58\": 246,\n \"grey62\": 247,\n \"gray62\": 247,\n \"grey66\": 248,\n \"gray66\": 248,\n \"grey70\": 249,\n \"gray70\": 249,\n \"grey74\": 250,\n \"gray74\": 250,\n \"grey78\": 251,\n \"gray78\": 251,\n \"grey82\": 252,\n \"gray82\": 252,\n \"grey85\": 253,\n \"gray85\": 253,\n \"grey89\": 254,\n \"gray89\": 254,\n \"grey93\": 255,\n \"gray93\": 255,\n}\n\n\nclass ColorParseError(Exception):\n \"\"\"The color could not be parsed.\"\"\"\n\n\nRE_COLOR = re.compile(\n r\"\"\"^\n\\#([0-9a-f]{6})$|\ncolor\$([0-9]{1,3})\$$|\nrgb\$([\\d\\s,]+)\$$\n\"\"\",\n re.VERBOSE,\n)\n\n\n@rich_repr\nclass Color(NamedTuple):\n \"\"\"Terminal color definition.\"\"\"\n\n name: str\n \"\"\"The name of the color (typically the input to Color.parse).\"\"\"\n type: ColorType\n \"\"\"The type of the color.\"\"\"\n number: Optional[int] = None\n \"\"\"The color number, if a standard color, or None.\"\"\"\n triplet: Optional[ColorTriplet] = None\n \"\"\"A triplet of color components, if an RGB color.\"\"\"\n\n def __rich__(self) -> \"Text\":\n \"\"\"Displays the actual color if Rich printed.\"\"\"\n from .style import Style\n from .text import Text\n\n return Text.assemble(\n f\"\",\n )\n\n def __rich_repr__(self) -> Result:\n yield self.name\n yield self.type\n yield \"number\", self.number, None\n yield \"triplet\", self.triplet, None\n\n @property\n def system(self) -> ColorSystem:\n \"\"\"Get the native color system for this color.\"\"\"\n if self.type == ColorType.DEFAULT:\n return ColorSystem.STANDARD\n return ColorSystem(int(self.type))\n\n @property\n def is_system_defined(self) -> bool:\n \"\"\"Check if the color is ultimately defined by the system.\"\"\"\n return self.system not in (ColorSystem.EIGHT_BIT, ColorSystem.TRUECOLOR)\n\n @property\n def is_default(self) -> bool:\n \"\"\"Check if the color is a default color.\"\"\"\n return self.type == ColorType.DEFAULT\n\n def get_truecolor(\n self, theme: Optional[\"TerminalTheme\"] = None, foreground: bool = True\n ) -> ColorTriplet:\n \"\"\"Get an equivalent color triplet for this color.\n\n Args:\n theme (TerminalTheme, optional): Optional terminal theme, or None to use default. Defaults to None.\n foreground (bool, optional): True for a foreground color, or False for background. Defaults to True.\n\n Returns:\n ColorTriplet: A color triplet containing RGB components.\n \"\"\"\n\n if theme is None:\n theme = DEFAULT_TERMINAL_THEME\n if self.type == ColorType.TRUECOLOR:\n assert self.triplet is not None\n return self.triplet\n elif self.type == ColorType.EIGHT_BIT:\n assert self.number is not None\n return EIGHT_BIT_PALETTE[self.number]\n elif self.type == ColorType.STANDARD:\n assert self.number is not None\n return theme.ansi_colors[self.number]\n elif self.type == ColorType.WINDOWS:\n assert self.number is not None\n return WINDOWS_PALETTE[self.number]\n else: # self.type == ColorType.DEFAULT:\n assert self.number is None\n return theme.foreground_color if foreground else theme.background_color\n\n @classmethod\n def from_ansi(cls, number: int) -> \"Color\":\n \"\"\"Create a Color number from it's 8-bit ansi number.\n\n Args:\n number (int): A number between 0-255 inclusive.\n\n Returns:\n Color: A new Color instance.\n \"\"\"\n return cls(\n name=f\"color({number})\",\n type=(ColorType.STANDARD if number < 16 else ColorType.EIGHT_BIT),\n number=number,\n )\n\n @classmethod\n def from_triplet(cls, triplet: \"ColorTriplet\") -> \"Color\":\n \"\"\"Create a truecolor RGB color from a triplet of values.\n\n Args:\n triplet (ColorTriplet): A color triplet containing red, green and blue components.\n\n Returns:\n Color: A new color object.\n \"\"\"\n return cls(name=triplet.hex, type=ColorType.TRUECOLOR, triplet=triplet)\n\n @classmethod\n def from_rgb(cls, red: float, green: float, blue: float) -> \"Color\":\n \"\"\"Create a truecolor from three color components in the range(0->255).\n\n Args:\n red (float): Red component in range 0-255.\n green (float): Green component in range 0-255.\n blue (float): Blue component in range 0-255.\n\n Returns:\n Color: A new color object.\n \"\"\"\n return cls.from_triplet(ColorTriplet(int(red), int(green), int(blue)))\n\n @classmethod\n def default(cls) -> \"Color\":\n \"\"\"Get a Color instance representing the default color.\n\n Returns:\n Color: Default color.\n \"\"\"\n return cls(name=\"default\", type=ColorType.DEFAULT)\n\n @classmethod\n @lru_cache(maxsize=1024)\n def parse(cls, color: str) -> \"Color\":\n \"\"\"Parse a color definition.\"\"\"\n original_color = color\n color = color.lower().strip()\n\n if color == \"default\":\n return cls(color, type=ColorType.DEFAULT)\n\n color_number = ANSI_COLOR_NAMES.get(color)\n if color_number is not None:\n return cls(\n color,\n type=(ColorType.STANDARD if color_number < 16 else ColorType.EIGHT_BIT),\n number=color_number,\n )\n\n color_match = RE_COLOR.match(color)\n if color_match is None:\n raise ColorParseError(f\"{original_color!r} is not a valid color\")\n\n color_24, color_8, color_rgb = color_match.groups()\n if color_24:\n triplet = ColorTriplet(\n int(color_24[0:2], 16), int(color_24[2:4], 16), int(color_24[4:6], 16)\n )\n return cls(color, ColorType.TRUECOLOR, triplet=triplet)\n\n elif color_8:\n number = int(color_8)\n if number > 255:\n raise ColorParseError(f\"color number must be <= 255 in {color!r}\")\n return cls(\n color,\n type=(ColorType.STANDARD if number < 16 else ColorType.EIGHT_BIT),\n number=number,\n )\n\n else: # color_rgb:\n components = color_rgb.split(\",\")\n if len(components) != 3:\n raise ColorParseError(\n f\"expected three components in {original_color!r}\"\n )\n red, green, blue = components\n triplet = ColorTriplet(int(red), int(green), int(blue))\n if not all(component <= 255 for component in triplet):\n raise ColorParseError(\n f\"color components must be <= 255 in {original_color!r}\"\n )\n return cls(color, ColorType.TRUECOLOR, triplet=triplet)\n\n @lru_cache(maxsize=1024)\n def get_ansi_codes(self, foreground: bool = True) -> Tuple[str, ...]:\n \"\"\"Get the ANSI escape codes for this color.\"\"\"\n _type = self.type\n if _type == ColorType.DEFAULT:\n return (\"39\" if foreground else \"49\",)\n\n elif _type == ColorType.WINDOWS:\n number = self.number\n assert number is not None\n fore, back = (30, 40) if number < 8 else (82, 92)\n return (str(fore + number if foreground else back + number),)\n\n elif _type == ColorType.STANDARD:\n number = self.number\n assert number is not None\n fore, back = (30, 40) if number < 8 else (82, 92)\n return (str(fore + number if foreground else back + number),)\n\n elif _type == ColorType.EIGHT_BIT:\n assert self.number is not None\n return (\"38\" if foreground else \"48\", \"5\", str(self.number))\n\n else: # self.standard == ColorStandard.TRUECOLOR:\n assert self.triplet is not None\n red, green, blue = self.triplet\n return (\"38\" if foreground else \"48\", \"2\", str(red), str(green), str(blue))\n\n @lru_cache(maxsize=1024)\n def downgrade(self, system: ColorSystem) -> \"Color\":\n \"\"\"Downgrade a color system to a system with fewer colors.\"\"\"\n\n if self.type in (ColorType.DEFAULT, system):\n return self\n # Convert to 8-bit color from truecolor color\n if system == ColorSystem.EIGHT_BIT and self.system == ColorSystem.TRUECOLOR:\n assert self.triplet is not None\n _h, l, s = rgb_to_hls(*self.triplet.normalized)\n # If saturation is under 15% assume it is grayscale\n if s < 0.15:\n gray = round(l * 25.0)\n if gray == 0:\n color_number = 16\n elif gray == 25:\n color_number = 231\n else:\n color_number = 231 + gray\n return Color(self.name, ColorType.EIGHT_BIT, number=color_number)\n\n red, green, blue = self.triplet\n six_red = red / 95 if red < 95 else 1 + (red - 95) / 40\n six_green = green / 95 if green < 95 else 1 + (green - 95) / 40\n six_blue = blue / 95 if blue < 95 else 1 + (blue - 95) / 40\n\n color_number = (\n 16 + 36 * round(six_red) + 6 * round(six_green) + round(six_blue)\n )\n return Color(self.name, ColorType.EIGHT_BIT, number=color_number)\n\n # Convert to standard from truecolor or 8-bit\n elif system == ColorSystem.STANDARD:\n if self.system == ColorSystem.TRUECOLOR:\n assert self.triplet is not None\n triplet = self.triplet\n else: # self.system == ColorSystem.EIGHT_BIT\n assert self.number is not None\n triplet = ColorTriplet(*EIGHT_BIT_PALETTE[self.number])\n\n color_number = STANDARD_PALETTE.match(triplet)\n return Color(self.name, ColorType.STANDARD, number=color_number)\n\n elif system == ColorSystem.WINDOWS:\n if self.system == ColorSystem.TRUECOLOR:\n assert self.triplet is not None\n triplet = self.triplet\n else: # self.system == ColorSystem.EIGHT_BIT\n assert self.number is not None\n if self.number < 16:\n return Color(self.name, ColorType.WINDOWS, number=self.number)\n triplet = ColorTriplet(*EIGHT_BIT_PALETTE[self.number])\n\n color_number = WINDOWS_PALETTE.match(triplet)\n return Color(self.name, ColorType.WINDOWS, number=color_number)\n\n return self\n\n\ndef parse_rgb_hex(hex_color: str) -> ColorTriplet:\n \"\"\"Parse six hex characters in to RGB triplet.\"\"\"\n assert len(hex_color) == 6, \"must be 6 characters\"\n color = ColorTriplet(\n int(hex_color[0:2], 16), int(hex_color[2:4], 16), int(hex_color[4:6], 16)\n )\n return color\n\n\ndef blend_rgb(\n color1: ColorTriplet, color2: ColorTriplet, cross_fade: float = 0.5\n) -> ColorTriplet:\n \"\"\"Blend one RGB color in to another.\"\"\"\n r1, g1, b1 = color1\n r2, g2, b2 = color2\n new_color = ColorTriplet(\n int(r1 + (r2 - r1) * cross_fade),\n int(g1 + (g2 - g1) * cross_fade),\n int(b1 + (b2 - b1) * cross_fade),\n )\n return new_color\n\n\nif __name__ == \"__main__\": # pragma: no cover\n from .console import Console\n from .table import Table\n from .text import Text\n\n console = Console()\n\n table = Table(show_footer=False, show_edge=True)\n table.add_column(\"Color\", width=10, overflow=\"ellipsis\")\n table.add_column(\"Number\", justify=\"right\", style=\"yellow\")\n table.add_column(\"Name\", style=\"green\")\n table.add_column(\"Hex\", style=\"blue\")\n table.add_column(\"RGB\", style=\"magenta\")\n\n colors = sorted((v, k) for k, v in ANSI_COLOR_NAMES.items())\n for color_number, name in colors:\n if \"grey\" in name:\n continue\n color_cell = Text(\" \" * 10, style=f\"on {name}\")\n if color_number < 16:\n table.add_row(color_cell, f\"{color_number}\", Text(f'\"{name}\"'))\n else:\n color = EIGHT_BIT_PALETTE[color_number] # type: ignore[has-type]\n table.add_row(\n color_cell, str(color_number), Text(f'\"{name}\"'), color.hex, color.rgb\n )\n\n console.print(table)\n",[],[213,919,920,921,1016,1050,1511,1881],"0c5b9714-67fc-11f0-aca6-0224a6c84d84","cells.py","0c5b9804-67fc-11f0-aca6-0224a6c84d84",457,["D",1753299268510],"from __future__ import annotations\n\nfrom functools import lru_cache\nfrom typing import Callable\n\nfrom ._cell_widths import CELL_WIDTHS\n\n# Ranges of unicode ordinals that produce a 1-cell wide character\n# This is non-exhaustive, but covers most common Western characters\n_SINGLE_CELL_UNICODE_RANGES: list[tuple[int, int]] = [\n (0x20, 0x7E), # Latin (excluding non-printable)\n (0xA0, 0xAC),\n (0xAE, 0x002FF),\n (0x00370, 0x00482), # Greek / Cyrillic\n (0x02500, 0x025FC), # Box drawing, box elements, geometric shapes\n (0x02800, 0x028FF), # Braille\n]\n\n# A set of characters that are a single cell wide\n_SINGLE_CELLS = frozenset(\n [\n character\n for _start, _end in _SINGLE_CELL_UNICODE_RANGES\n for character in map(chr, range(_start, _end + 1))\n ]\n)\n\n# When called with a string this will return True if all\n# characters are single-cell, otherwise False\n_is_single_cell_widths: Callable[[str], bool] = _SINGLE_CELLS.issuperset\n\n\n@lru_cache(4096)\ndef cached_cell_len(text: str) -> int:\n \"\"\"Get the number of cells required to display text.\n\n This method always caches, which may use up a lot of memory. It is recommended to use\n `cell_len` over this method.\n\n Args:\n text (str): Text to display.\n\n Returns:\n int: Get the number of cells required to display text.\n \"\"\"\n if _is_single_cell_widths(text):\n return len(text)\n return sum(map(get_character_cell_size, text))\n\n\ndef cell_len(text: str, _cell_len: Callable[[str], int] = cached_cell_len) -> int:\n \"\"\"Get the number of cells required to display text.\n\n Args:\n text (str): Text to display.\n\n Returns:\n int: Get the number of cells required to display text.\n \"\"\"\n if len(text) < 512:\n return _cell_len(text)\n if _is_single_cell_widths(text):\n return len(text)\n return sum(map(get_character_cell_size, text))\n\n\n@lru_cache(maxsize=4096)\ndef get_character_cell_size(character: str) -> int:\n \"\"\"Get the cell size of a character.\n\n Args:\n character (str): A single character.\n\n Returns:\n int: Number of cells (0, 1 or 2) occupied by that character.\n \"\"\"\n codepoint = ord(character)\n _table = CELL_WIDTHS\n lower_bound = 0\n upper_bound = len(_table) - 1\n index = (lower_bound + upper_bound) // 2\n while True:\n start, end, width = _table[index]\n if codepoint < start:\n upper_bound = index - 1\n elif codepoint > end:\n lower_bound = index + 1\n else:\n return 0 if width == -1 else width\n if upper_bound < lower_bound:\n break\n index = (lower_bound + upper_bound) // 2\n return 1\n\n\ndef set_cell_size(text: str, total: int) -> str:\n \"\"\"Set the length of a string to fit within given number of cells.\"\"\"\n\n if _is_single_cell_widths(text):\n size = len(text)\n if size < total:\n return text + \" \" * (total - size)\n return text[:total]\n\n if total <= 0:\n return \"\"\n cell_size = cell_len(text)\n if cell_size == total:\n return text\n if cell_size < total:\n return text + \" \" * (total - cell_size)\n\n start = 0\n end = len(text)\n\n # Binary search until we find the right size\n while True:\n pos = (start + end) // 2\n before = text[: pos + 1]\n before_len = cell_len(before)\n if before_len == total + 1 and cell_len(before[-1]) == 2:\n return before[:-1] + \" \"\n if before_len == total:\n return before\n if before_len > total:\n end = pos\n else:\n start = pos\n\n\ndef chop_cells(\n text: str,\n width: int,\n) -> list[str]:\n \"\"\"Split text into lines such that each line fits within the available (cell) width.\n\n Args:\n text: The text to fold such that it fits in the given width.\n width: The width available (number of cells).\n\n Returns:\n A list of strings such that each string in the list has cell width\n less than or equal to the available width.\n \"\"\"\n _get_character_cell_size = get_character_cell_size\n lines: list[list[str]] = [[]]\n\n append_new_line = lines.append\n append_to_last_line = lines[-1].append\n\n total_width = 0\n\n for character in text:\n cell_width = _get_character_cell_size(character)\n char_doesnt_fit = total_width + cell_width > width\n\n if char_doesnt_fit:\n append_new_line([character])\n append_to_last_line = lines[-1].append\n total_width = cell_width\n else:\n append_to_last_line(character)\n total_width += cell_width\n\n return [\"\".join(line) for line in lines]\n\n\nif __name__ == \"__main__\": # pragma: no cover\n print(get_character_cell_size(\"😽\"))\n for line in chop_cells(\"\"\"这是对亚洲语言支持的测试。面对模棱两可的想法，拒绝猜测的诱惑。\"\"\", 8):\n print(line)\n for n in range(80, 1, -1):\n print(set_cell_size(\"\"\"这是对亚洲语言支持的测试。面对模棱两可的想法，拒绝猜测的诱惑。\"\"\", n) + \"|\")\n print(\"x\" * n)\n",[],[213,919,920,921,1016,1050,1511,1889],"0b074c46-67fc-11f0-b666-0224a6c84d84","box.py","0b074d18-67fc-11f0-b666-0224a6c84d84",403,["D",1753299266275],"import sys\nfrom typing import TYPE_CHECKING, Iterable, List\n\nif sys.version_info >= (3, 8):\n from typing import Literal\nelse:\n from pip._vendor.typing_extensions import Literal # pragma: no cover\n\n\nfrom ._loop import loop_last\n\nif TYPE_CHECKING:\n from pip._vendor.rich.console import ConsoleOptions\n\n\nclass Box:\n \"\"\"Defines characters to render boxes.\n\n ┌─┬┐ top\n │ ││ head\n ├─┼┤ head_row\n │ ││ mid\n ├─┼┤ row\n ├─┼┤ foot_row\n │ ││ foot\n └─┴┘ bottom\n\n Args:\n box (str): Characters making up box.\n ascii (bool, optional): True if this box uses ascii characters only. Default is False.\n \"\"\"\n\n def __init__(self, box: str, *, ascii: bool = False) -> None:\n self._box = box\n self.ascii = ascii\n line1, line2, line3, line4, line5, line6, line7, line8 = box.splitlines()\n # top\n self.top_left, self.top, self.top_divider, self.top_right = iter(line1)\n # head\n self.head_left, _, self.head_vertical, self.head_right = iter(line2)\n # head_row\n (\n self.head_row_left,\n self.head_row_horizontal,\n self.head_row_cross,\n self.head_row_right,\n ) = iter(line3)\n\n # mid\n self.mid_left, _, self.mid_vertical, self.mid_right = iter(line4)\n # row\n self.row_left, self.row_horizontal, self.row_cross, self.row_right = iter(line5)\n # foot_row\n (\n self.foot_row_left,\n self.foot_row_horizontal,\n self.foot_row_cross,\n self.foot_row_right,\n ) = iter(line6)\n # foot\n self.foot_left, _, self.foot_vertical, self.foot_right = iter(line7)\n # bottom\n self.bottom_left, self.bottom, self.bottom_divider, self.bottom_right = iter(\n line8\n )\n\n def __repr__(self) -> str:\n return \"Box(...)\"\n\n def __str__(self) -> str:\n return self._box\n\n def substitute(self, options: \"ConsoleOptions\", safe: bool = True) -> \"Box\":\n \"\"\"Substitute this box for another if it won't render due to platform issues.\n\n Args:\n options (ConsoleOptions): Console options used in rendering.\n safe (bool, optional): Substitute this for another Box if there are known problems\n displaying on the platform (currently only relevant on Windows). Default is True.\n\n Returns:\n Box: A different Box or the same Box.\n \"\"\"\n box = self\n if options.legacy_windows and safe:\n box = LEGACY_WINDOWS_SUBSTITUTIONS.get(box, box)\n if options.ascii_only and not box.ascii:\n box = ASCII\n return box\n\n def get_plain_headed_box(self) -> \"Box\":\n \"\"\"If this box uses special characters for the borders of the header, then\n return the equivalent box that does not.\n\n Returns:\n Box: The most similar Box that doesn't use header-specific box characters.\n If the current Box already satisfies this criterion, then it's returned.\n \"\"\"\n return PLAIN_HEADED_SUBSTITUTIONS.get(self, self)\n\n def get_top(self, widths: Iterable[int]) -> str:\n \"\"\"Get the top of a simple box.\n\n Args:\n widths (List[int]): Widths of columns.\n\n Returns:\n str: A string of box characters.\n \"\"\"\n\n parts: List[str] = []\n append = parts.append\n append(self.top_left)\n for last, width in loop_last(widths):\n append(self.top * width)\n if not last:\n append(self.top_divider)\n append(self.top_right)\n return \"\".join(parts)\n\n def get_row(\n self,\n widths: Iterable[int],\n level: Literal[\"head\", \"row\", \"foot\", \"mid\"] = \"row\",\n edge: bool = True,\n ) -> str:\n \"\"\"Get the top of a simple box.\n\n Args:\n width (List[int]): Widths of columns.\n\n Returns:\n str: A string of box characters.\n \"\"\"\n if level == \"head\":\n left = self.head_row_left\n horizontal = self.head_row_horizontal\n cross = self.head_row_cross\n right = self.head_row_right\n elif level == \"row\":\n left = self.row_left\n horizontal = self.row_horizontal\n cross = self.row_cross\n right = self.row_right\n elif level == \"mid\":\n left = self.mid_left\n horizontal = \" \"\n cross = self.mid_vertical\n right = self.mid_right\n elif level == \"foot\":\n left = self.foot_row_left\n horizontal = self.foot_row_horizontal\n cross = self.foot_row_cross\n right = self.foot_row_right\n else:\n raise ValueError(\"level must be 'head', 'row' or 'foot'\")\n\n parts: List[str] = []\n append = parts.append\n if edge:\n append(left)\n for last, width in loop_last(widths):\n append(horizontal * width)\n if not last:\n append(cross)\n if edge:\n append(right)\n return \"\".join(parts)\n\n def get_bottom(self, widths: Iterable[int]) -> str:\n \"\"\"Get the bottom of a simple box.\n\n Args:\n widths (List[int]): Widths of columns.\n\n Returns:\n str: A string of box characters.\n \"\"\"\n\n parts: List[str] = []\n append = parts.append\n append(self.bottom_left)\n for last, width in loop_last(widths):\n append(self.bottom * width)\n if not last:\n append(self.bottom_divider)\n append(self.bottom_right)\n return \"\".join(parts)\n\n\n# fmt: off\nASCII: Box = Box(\n \"+--+\\n\"\n \"| ||\\n\"\n \"|-+|\\n\"\n \"| ||\\n\"\n \"|-+|\\n\"\n \"|-+|\\n\"\n \"| ||\\n\"\n \"+--+\\n\",\n ascii=True,\n)\n\nASCII2: Box = Box(\n \"+-++\\n\"\n \"| ||\\n\"\n \"+-++\\n\"\n \"| ||\\n\"\n \"+-++\\n\"\n \"+-++\\n\"\n \"| ||\\n\"\n \"+-++\\n\",\n ascii=True,\n)\n\nASCII_DOUBLE_HEAD: Box = Box(\n \"+-++\\n\"\n \"| ||\\n\"\n \"+=++\\n\"\n \"| ||\\n\"\n \"+-++\\n\"\n \"+-++\\n\"\n \"| ||\\n\"\n \"+-++\\n\",\n ascii=True,\n)\n\nSQUARE: Box = Box(\n \"┌─┬┐\\n\"\n \"│ ││\\n\"\n \"├─┼┤\\n\"\n \"│ ││\\n\"\n \"├─┼┤\\n\"\n \"├─┼┤\\n\"\n \"│ ││\\n\"\n \"└─┴┘\\n\"\n)\n\nSQUARE_DOUBLE_HEAD: Box = Box(\n \"┌─┬┐\\n\"\n \"│ ││\\n\"\n \"╞═╪╡\\n\"\n \"│ ││\\n\"\n \"├─┼┤\\n\"\n \"├─┼┤\\n\"\n \"│ ││\\n\"\n \"└─┴┘\\n\"\n)\n\nMINIMAL: Box = Box(\n \" ╷ \\n\"\n \" │ \\n\"\n \"╶─┼╴\\n\"\n \" │ \\n\"\n \"╶─┼╴\\n\"\n \"╶─┼╴\\n\"\n \" │ \\n\"\n \" ╵ \\n\"\n)\n\n\nMINIMAL_HEAVY_HEAD: Box = Box(\n \" ╷ \\n\"\n \" │ \\n\"\n \"╺━┿╸\\n\"\n \" │ \\n\"\n \"╶─┼╴\\n\"\n \"╶─┼╴\\n\"\n \" │ \\n\"\n \" ╵ \\n\"\n)\n\nMINIMAL_DOUBLE_HEAD: Box = Box(\n \" ╷ \\n\"\n \" │ \\n\"\n \" ═╪ \\n\"\n \" │ \\n\"\n \" ─┼ \\n\"\n \" ─┼ \\n\"\n \" │ \\n\"\n \" ╵ \\n\"\n)\n\n\nSIMPLE: Box = Box(\n \" \\n\"\n \" \\n\"\n \" ── \\n\"\n \" \\n\"\n \" \\n\"\n \" ── \\n\"\n \" \\n\"\n \" \\n\"\n)\n\nSIMPLE_HEAD: Box = Box(\n \" \\n\"\n \" \\n\"\n \" ── \\n\"\n \" \\n\"\n \" \\n\"\n \" \\n\"\n \" \\n\"\n \" \\n\"\n)\n\n\nSIMPLE_HEAVY: Box = Box(\n \" \\n\"\n \" \\n\"\n \" ━━ \\n\"\n \" \\n\"\n \" \\n\"\n \" ━━ \\n\"\n \" \\n\"\n \" \\n\"\n)\n\n\nHORIZONTALS: Box = Box(\n \" ── \\n\"\n \" \\n\"\n \" ── \\n\"\n \" \\n\"\n \" ── \\n\"\n \" ── \\n\"\n \" \\n\"\n \" ── \\n\"\n)\n\nROUNDED: Box = Box(\n \"╭─┬╮\\n\"\n \"│ ││\\n\"\n \"├─┼┤\\n\"\n \"│ ││\\n\"\n \"├─┼┤\\n\"\n \"├─┼┤\\n\"\n \"│ ││\\n\"\n \"╰─┴╯\\n\"\n)\n\nHEAVY: Box = Box(\n \"┏━┳┓\\n\"\n \"┃ ┃┃\\n\"\n \"┣━╋┫\\n\"\n \"┃ ┃┃\\n\"\n \"┣━╋┫\\n\"\n \"┣━╋┫\\n\"\n \"┃ ┃┃\\n\"\n \"┗━┻┛\\n\"\n)\n\nHEAVY_EDGE: Box = Box(\n \"┏━┯┓\\n\"\n \"┃ │┃\\n\"\n \"┠─┼┨\\n\"\n \"┃ │┃\\n\"\n \"┠─┼┨\\n\"\n \"┠─┼┨\\n\"\n \"┃ │┃\\n\"\n \"┗━┷┛\\n\"\n)\n\nHEAVY_HEAD: Box = Box(\n \"┏━┳┓\\n\"\n \"┃ ┃┃\\n\"\n \"┡━╇┩\\n\"\n \"│ ││\\n\"\n \"├─┼┤\\n\"\n \"├─┼┤\\n\"\n \"│ ││\\n\"\n \"└─┴┘\\n\"\n)\n\nDOUBLE: Box = Box(\n \"╔═╦╗\\n\"\n \"║ ║║\\n\"\n \"╠═╬╣\\n\"\n \"║ ║║\\n\"\n \"╠═╬╣\\n\"\n \"╠═╬╣\\n\"\n \"║ ║║\\n\"\n \"╚═╩╝\\n\"\n)\n\nDOUBLE_EDGE: Box = Box(\n \"╔═╤╗\\n\"\n \"║ │║\\n\"\n \"╟─┼╢\\n\"\n \"║ │║\\n\"\n \"╟─┼╢\\n\"\n \"╟─┼╢\\n\"\n \"║ │║\\n\"\n \"╚═╧╝\\n\"\n)\n\nMARKDOWN: Box = Box(\n \" \\n\"\n \"| ||\\n\"\n \"|-||\\n\"\n \"| ||\\n\"\n \"|-||\\n\"\n \"|-||\\n\"\n \"| ||\\n\"\n \" \\n\",\n ascii=True,\n)\n# fmt: on\n\n# Map Boxes that don't render with raster fonts on to equivalent that do\nLEGACY_WINDOWS_SUBSTITUTIONS = {\n ROUNDED: SQUARE,\n MINIMAL_HEAVY_HEAD: MINIMAL,\n SIMPLE_HEAVY: SIMPLE,\n HEAVY: SQUARE,\n HEAVY_EDGE: SQUARE,\n HEAVY_HEAD: SQUARE,\n}\n\n# Map headed boxes to their headerless equivalents\nPLAIN_HEADED_SUBSTITUTIONS = {\n HEAVY_HEAD: SQUARE,\n SQUARE_DOUBLE_HEAD: SQUARE,\n MINIMAL_DOUBLE_HEAD: MINIMAL,\n MINIMAL_HEAVY_HEAD: MINIMAL,\n ASCII_DOUBLE_HEAD: ASCII2,\n}\n\n\nif __name__ == \"__main__\": # pragma: no cover\n from pip._vendor.rich.columns import Columns\n from pip._vendor.rich.panel import Panel\n\n from . import box as box\n from .console import Console\n from .table import Table\n from .text import Text\n\n console = Console(record=True)\n\n BOXES = [\n \"ASCII\",\n \"ASCII2\",\n \"ASCII_DOUBLE_HEAD\",\n \"SQUARE\",\n \"SQUARE_DOUBLE_HEAD\",\n \"MINIMAL\",\n \"MINIMAL_HEAVY_HEAD\",\n \"MINIMAL_DOUBLE_HEAD\",\n \"SIMPLE\",\n \"SIMPLE_HEAD\",\n \"SIMPLE_HEAVY\",\n \"HORIZONTALS\",\n \"ROUNDED\",\n \"HEAVY\",\n \"HEAVY_EDGE\",\n \"HEAVY_HEAD\",\n \"DOUBLE\",\n \"DOUBLE_EDGE\",\n \"MARKDOWN\",\n ]\n\n console.print(Panel(\"[bold green]Box Constants\", style=\"green\"), justify=\"center\")\n console.print()\n\n columns = Columns(expand=True, padding=2)\n for box_name in sorted(BOXES):\n table = Table(\n show_footer=True, style=\"dim\", border_style=\"not dim\", expand=True\n )\n table.add_column(\"Header 1\", \"Footer 1\")\n table.add_column(\"Header 2\", \"Footer 2\")\n table.add_row(\"Cell\", \"Cell\")\n table.add_row(\"Cell\", \"Cell\")\n table.box = getattr(box, box_name)\n table.title = Text(f\"box.{box_name}\", style=\"magenta\")\n columns.add_renderable(table)\n console.print(columns)\n\n # console.save_svg(\"box.svg\")\n",[],[213,919,920,921,1016,1050,1511,1897],"0c004c9c-67fc-11f0-84bb-0224a6c84d84","bar.py","0c004d3c-67fc-11f0-84bb-0224a6c84d84",443,["D",1753299267918],"from typing import Optional, Union\n\nfrom .color import Color\nfrom .console import Console, ConsoleOptions, RenderResult\nfrom .jupyter import JupyterMixin\nfrom .measure import Measurement\nfrom .segment import Segment\nfrom .style import Style\n\n# There are left-aligned characters for 1/8 to 7/8, but\n# the right-aligned characters exist only for 1/8 and 4/8.\nBEGIN_BLOCK_ELEMENTS = [\"█\", \"█\", \"█\", \"▐\", \"▐\", \"▐\", \"▕\", \"▕\"]\nEND_BLOCK_ELEMENTS = [\" \", \"▏\", \"▎\", \"▍\", \"▌\", \"▋\", \"▊\", \"▉\"]\nFULL_BLOCK = \"█\"\n\n\nclass Bar(JupyterMixin):\n \"\"\"Renders a solid block bar.\n\n Args:\n size (float): Value for the end of the bar.\n begin (float): Begin point (between 0 and size, inclusive).\n end (float): End point (between 0 and size, inclusive).\n width (int, optional): Width of the bar, or ``None`` for maximum width. Defaults to None.\n color (Union[Color, str], optional): Color of the bar. Defaults to \"default\".\n bgcolor (Union[Color, str], optional): Color of bar background. Defaults to \"default\".\n \"\"\"\n\n def __init__(\n self,\n size: float,\n begin: float,\n end: float,\n *,\n width: Optional[int] = None,\n color: Union[Color, str] = \"default\",\n bgcolor: Union[Color, str] = \"default\",\n ):\n self.size = size\n self.begin = max(begin, 0)\n self.end = min(end, size)\n self.width = width\n self.style = Style(color=color, bgcolor=bgcolor)\n\n def __repr__(self) -> str:\n return f\"Bar({self.size}, {self.begin}, {self.end})\"\n\n def __rich_console__(\n self, console: Console, options: ConsoleOptions\n ) -> RenderResult:\n width = min(\n self.width if self.width is not None else options.max_width,\n options.max_width,\n )\n\n if self.begin >= self.end:\n yield Segment(\" \" * width, self.style)\n yield Segment.line()\n return\n\n prefix_complete_eights = int(width * 8 * self.begin / self.size)\n prefix_bar_count = prefix_complete_eights // 8\n prefix_eights_count = prefix_complete_eights % 8\n\n body_complete_eights = int(width * 8 * self.end / self.size)\n body_bar_count = body_complete_eights // 8\n body_eights_count = body_complete_eights % 8\n\n # When start and end fall into the same cell, we ideally should render\n # a symbol that's \"center-aligned\", but there is no good symbol in Unicode.\n # In this case, we fall back to right-aligned block symbol for simplicity.\n\n prefix = \" \" * prefix_bar_count\n if prefix_eights_count:\n prefix += BEGIN_BLOCK_ELEMENTS[prefix_eights_count]\n\n body = FULL_BLOCK * body_bar_count\n if body_eights_count:\n body += END_BLOCK_ELEMENTS[body_eights_count]\n\n suffix = \" \" * (width - len(body))\n\n yield Segment(prefix + body[len(prefix) :] + suffix, self.style)\n yield Segment.line()\n\n def __rich_measure__(\n self, console: Console, options: ConsoleOptions\n ) -> Measurement:\n return (\n Measurement(self.width, self.width)\n if self.width is not None\n else Measurement(4, options.max_width)\n )\n",[],[213,919,920,921,1016,1050,1511,1905],"0c3d93e0-67fc-11f0-aedf-0224a6c84d84","ansi.py","0c3d949e-67fc-11f0-aedf-0224a6c84d84",452,["D",1753299268308],"import re\nimport sys\nfrom contextlib import suppress\nfrom typing import Iterable, NamedTuple, Optional\n\nfrom .color import Color\nfrom .style import Style\nfrom .text import Text\n\nre_ansi = re.compile(\n r\"\"\"\n(?:\\x1b[0-?])|\n(?:\\x1b\\](.*?)\\x1b\\\\)|\n(?:\\x1b([(@-Z\\\\-_]|\\[[0-?]*[ -/]*[@-~]))\n\"\"\",\n re.VERBOSE,\n)\n\n\nclass _AnsiToken(NamedTuple):\n \"\"\"Result of ansi tokenized string.\"\"\"\n\n plain: str = \"\"\n sgr: Optional[str] = \"\"\n osc: Optional[str] = \"\"\n\n\ndef _ansi_tokenize(ansi_text: str) -> Iterable[_AnsiToken]:\n \"\"\"Tokenize a string in to plain text and ANSI codes.\n\n Args:\n ansi_text (str): A String containing ANSI codes.\n\n Yields:\n AnsiToken: A named tuple of (plain, sgr, osc)\n \"\"\"\n\n position = 0\n sgr: Optional[str]\n osc: Optional[str]\n for match in re_ansi.finditer(ansi_text):\n start, end = match.span(0)\n osc, sgr = match.groups()\n if start > position:\n yield _AnsiToken(ansi_text[position:start])\n if sgr:\n if sgr == \"(\":\n position = end + 1\n continue\n if sgr.endswith(\"m\"):\n yield _AnsiToken(\"\", sgr[1:-1], osc)\n else:\n yield _AnsiToken(\"\", sgr, osc)\n position = end\n if position < len(ansi_text):\n yield _AnsiToken(ansi_text[position:])\n\n\nSGR_STYLE_MAP = {\n 1: \"bold\",\n 2: \"dim\",\n 3: \"italic\",\n 4: \"underline\",\n 5: \"blink\",\n 6: \"blink2\",\n 7: \"reverse\",\n 8: \"conceal\",\n 9: \"strike\",\n 21: \"underline2\",\n 22: \"not dim not bold\",\n 23: \"not italic\",\n 24: \"not underline\",\n 25: \"not blink\",\n 26: \"not blink2\",\n 27: \"not reverse\",\n 28: \"not conceal\",\n 29: \"not strike\",\n 30: \"color(0)\",\n 31: \"color(1)\",\n 32: \"color(2)\",\n 33: \"color(3)\",\n 34: \"color(4)\",\n 35: \"color(5)\",\n 36: \"color(6)\",\n 37: \"color(7)\",\n 39: \"default\",\n 40: \"on color(0)\",\n 41: \"on color(1)\",\n 42: \"on color(2)\",\n 43: \"on color(3)\",\n 44: \"on color(4)\",\n 45: \"on color(5)\",\n 46: \"on color(6)\",\n 47: \"on color(7)\",\n 49: \"on default\",\n 51: \"frame\",\n 52: \"encircle\",\n 53: \"overline\",\n 54: \"not frame not encircle\",\n 55: \"not overline\",\n 90: \"color(8)\",\n 91: \"color(9)\",\n 92: \"color(10)\",\n 93: \"color(11)\",\n 94: \"color(12)\",\n 95: \"color(13)\",\n 96: \"color(14)\",\n 97: \"color(15)\",\n 100: \"on color(8)\",\n 101: \"on color(9)\",\n 102: \"on color(10)\",\n 103: \"on color(11)\",\n 104: \"on color(12)\",\n 105: \"on color(13)\",\n 106: \"on color(14)\",\n 107: \"on color(15)\",\n}\n\n\nclass AnsiDecoder:\n \"\"\"Translate ANSI code in to styled Text.\"\"\"\n\n def __init__(self) -> None:\n self.style = Style.null()\n\n def decode(self, terminal_text: str) -> Iterable[Text]:\n \"\"\"Decode ANSI codes in an iterable of lines.\n\n Args:\n lines (Iterable[str]): An iterable of lines of terminal output.\n\n Yields:\n Text: Marked up Text.\n \"\"\"\n for line in terminal_text.splitlines():\n yield self.decode_line(line)\n\n def decode_line(self, line: str) -> Text:\n \"\"\"Decode a line containing ansi codes.\n\n Args:\n line (str): A line of terminal output.\n\n Returns:\n Text: A Text instance marked up according to ansi codes.\n \"\"\"\n from_ansi = Color.from_ansi\n from_rgb = Color.from_rgb\n _Style = Style\n text = Text()\n append = text.append\n line = line.rsplit(\"\\r\", 1)[-1]\n for plain_text, sgr, osc in _ansi_tokenize(line):\n if plain_text:\n append(plain_text, self.style or None)\n elif osc is not None:\n if osc.startswith(\"8;\"):\n _params, semicolon, link = osc[2:].partition(\";\")\n if semicolon:\n self.style = self.style.update_link(link or None)\n elif sgr is not None:\n # Translate in to semi-colon separated codes\n # Ignore invalid codes, because we want to be lenient\n codes = [\n min(255, int(_code) if _code else 0)\n for _code in sgr.split(\";\")\n if _code.isdigit() or _code == \"\"\n ]\n iter_codes = iter(codes)\n for code in iter_codes:\n if code == 0:\n # reset\n self.style = _Style.null()\n elif code in SGR_STYLE_MAP:\n # styles\n self.style += _Style.parse(SGR_STYLE_MAP[code])\n elif code == 38:\n # Foreground\n with suppress(StopIteration):\n color_type = next(iter_codes)\n if color_type == 5:\n self.style += _Style.from_color(\n from_ansi(next(iter_codes))\n )\n elif color_type == 2:\n self.style += _Style.from_color(\n from_rgb(\n next(iter_codes),\n next(iter_codes),\n next(iter_codes),\n )\n )\n elif code == 48:\n # Background\n with suppress(StopIteration):\n color_type = next(iter_codes)\n if color_type == 5:\n self.style += _Style.from_color(\n None, from_ansi(next(iter_codes))\n )\n elif color_type == 2:\n self.style += _Style.from_color(\n None,\n from_rgb(\n next(iter_codes),\n next(iter_codes),\n next(iter_codes),\n ),\n )\n\n return text\n\n\nif sys.platform != \"win32\" and __name__ == \"__main__\": # pragma: no cover\n import io\n import os\n import pty\n import sys\n\n decoder = AnsiDecoder()\n\n stdout = io.BytesIO()\n\n def read(fd: int) -> bytes:\n data = os.read(fd, 1024)\n stdout.write(data)\n return data\n\n pty.spawn(sys.argv[1:], read)\n\n from .console import Console\n\n console = Console(record=True)\n\n stdout_result = stdout.getvalue().decode(\"utf-8\")\n print(stdout_result)\n\n for line in decoder.decode(stdout_result):\n console.print(line)\n\n console.save_html(\"stdout.html\")\n",[],[213,919,920,921,1016,1050,1511,1913],"0b1f0c78-67fc-11f0-b666-0224a6c84d84","align.py","0b1f0d68-67fc-11f0-b666-0224a6c84d84",406,["D",1753299266441],"import sys\nfrom itertools import chain\nfrom typing import TYPE_CHECKING, Iterable, Optional\n\nif sys.version_info >= (3, 8):\n from typing import Literal\nelse:\n from pip._vendor.typing_extensions import Literal # pragma: no cover\n\nfrom .constrain import Constrain\nfrom .jupyter import JupyterMixin\nfrom .measure import Measurement\nfrom .segment import Segment\nfrom .style import StyleType\n\nif TYPE_CHECKING:\n from .console import Console, ConsoleOptions, RenderableType, RenderResult\n\nAlignMethod = Literal[\"left\", \"center\", \"right\"]\nVerticalAlignMethod = Literal[\"top\", \"middle\", \"bottom\"]\n\n\nclass Align(JupyterMixin):\n \"\"\"Align a renderable by adding spaces if necessary.\n\n Args:\n renderable (RenderableType): A console renderable.\n align (AlignMethod): One of \"left\", \"center\", or \"right\"\"\n style (StyleType, optional): An optional style to apply to the background.\n vertical (Optional[VerticalAlignMethod], optional): Optional vertical align, one of \"top\", \"middle\", or \"bottom\". Defaults to None.\n pad (bool, optional): Pad the right with spaces. Defaults to True.\n width (int, optional): Restrict contents to given width, or None to use default width. Defaults to None.\n height (int, optional): Set height of align renderable, or None to fit to contents. Defaults to None.\n\n Raises:\n ValueError: if ``align`` is not one of the expected values.\n \"\"\"\n\n def __init__(\n self,\n renderable: \"RenderableType\",\n align: AlignMethod = \"left\",\n style: Optional[StyleType] = None,\n *,\n vertical: Optional[VerticalAlignMethod] = None,\n pad: bool = True,\n width: Optional[int] = None,\n height: Optional[int] = None,\n ) -> None:\n if align not in (\"left\", \"center\", \"right\"):\n raise ValueError(\n f'invalid value for align, expected \"left\", \"center\", or \"right\" (not {align!r})'\n )\n if vertical is not None and vertical not in (\"top\", \"middle\", \"bottom\"):\n raise ValueError(\n f'invalid value for vertical, expected \"top\", \"middle\", or \"bottom\" (not {vertical!r})'\n )\n self.renderable = renderable\n self.align = align\n self.style = style\n self.vertical = vertical\n self.pad = pad\n self.width = width\n self.height = height\n\n def __repr__(self) -> str:\n return f\"Align({self.renderable!r}, {self.align!r})\"\n\n @classmethod\n def left(\n cls,\n renderable: \"RenderableType\",\n style: Optional[StyleType] = None,\n *,\n vertical: Optional[VerticalAlignMethod] = None,\n pad: bool = True,\n width: Optional[int] = None,\n height: Optional[int] = None,\n ) -> \"Align\":\n \"\"\"Align a renderable to the left.\"\"\"\n return cls(\n renderable,\n \"left\",\n style=style,\n vertical=vertical,\n pad=pad,\n width=width,\n height=height,\n )\n\n @classmethod\n def center(\n cls,\n renderable: \"RenderableType\",\n style: Optional[StyleType] = None,\n *,\n vertical: Optional[VerticalAlignMethod] = None,\n pad: bool = True,\n width: Optional[int] = None,\n height: Optional[int] = None,\n ) -> \"Align\":\n \"\"\"Align a renderable to the center.\"\"\"\n return cls(\n renderable,\n \"center\",\n style=style,\n vertical=vertical,\n pad=pad,\n width=width,\n height=height,\n )\n\n @classmethod\n def right(\n cls,\n renderable: \"RenderableType\",\n style: Optional[StyleType] = None,\n *,\n vertical: Optional[VerticalAlignMethod] = None,\n pad: bool = True,\n width: Optional[int] = None,\n height: Optional[int] = None,\n ) -> \"Align\":\n \"\"\"Align a renderable to the right.\"\"\"\n return cls(\n renderable,\n \"right\",\n style=style,\n vertical=vertical,\n pad=pad,\n width=width,\n height=height,\n )\n\n def __rich_console__(\n self, console: \"Console\", options: \"ConsoleOptions\"\n ) -> \"RenderResult\":\n align = self.align\n width = console.measure(self.renderable, options=options).maximum\n rendered = console.render(\n Constrain(\n self.renderable, width if self.width is None else min(width, self.width)\n ),\n options.update(height=None),\n )\n lines = list(Segment.split_lines(rendered))\n width, height = Segment.get_shape(lines)\n lines = Segment.set_shape(lines, width, height)\n new_line = Segment.line()\n excess_space = options.max_width - width\n style = console.get_style(self.style) if self.style is not None else None\n\n def generate_segments() -> Iterable[Segment]:\n if excess_space <= 0:\n # Exact fit\n for line in lines:\n yield from line\n yield new_line\n\n elif align == \"left\":\n # Pad on the right\n pad = Segment(\" \" * excess_space, style) if self.pad else None\n for line in lines:\n yield from line\n if pad:\n yield pad\n yield new_line\n\n elif align == \"center\":\n # Pad left and right\n left = excess_space // 2\n pad = Segment(\" \" * left, style)\n pad_right = (\n Segment(\" \" * (excess_space - left), style) if self.pad else None\n )\n for line in lines:\n if left:\n yield pad\n yield from line\n if pad_right:\n yield pad_right\n yield new_line\n\n elif align == \"right\":\n # Padding on left\n pad = Segment(\" \" * excess_space, style)\n for line in lines:\n yield pad\n yield from line\n yield new_line\n\n blank_line = (\n Segment(f\"{' ' * (self.width or options.max_width)}\\n\", style)\n if self.pad\n else Segment(\"\\n\")\n )\n\n def blank_lines(count: int) -> Iterable[Segment]:\n if count > 0:\n for _ in range(count):\n yield blank_line\n\n vertical_height = self.height or options.height\n iter_segments: Iterable[Segment]\n if self.vertical and vertical_height is not None:\n if self.vertical == \"top\":\n bottom_space = vertical_height - height\n iter_segments = chain(generate_segments(), blank_lines(bottom_space))\n elif self.vertical == \"middle\":\n top_space = (vertical_height - height) // 2\n bottom_space = vertical_height - top_space - height\n iter_segments = chain(\n blank_lines(top_space),\n generate_segments(),\n blank_lines(bottom_space),\n )\n else: # self.vertical == \"bottom\":\n top_space = vertical_height - height\n iter_segments = chain(blank_lines(top_space), generate_segments())\n else:\n iter_segments = generate_segments()\n if self.style:\n style = console.get_style(self.style)\n iter_segments = Segment.apply_style(iter_segments, style)\n yield from iter_segments\n\n def __rich_measure__(\n self, console: \"Console\", options: \"ConsoleOptions\"\n ) -> Measurement:\n measurement = Measurement.get(console, options, self.renderable)\n return measurement\n\n\nclass VerticalCenter(JupyterMixin):\n \"\"\"Vertically aligns a renderable.\n\n Warn:\n This class is deprecated and may be removed in a future version. Use Align class with\n `vertical=\"middle\"`.\n\n Args:\n renderable (RenderableType): A renderable object.\n style (StyleType, optional): An optional style to apply to the background. Defaults to None.\n \"\"\"\n\n def __init__(\n self,\n renderable: \"RenderableType\",\n style: Optional[StyleType] = None,\n ) -> None:\n self.renderable = renderable\n self.style = style\n\n def __repr__(self) -> str:\n return f\"VerticalCenter({self.renderable!r})\"\n\n def __rich_console__(\n self, console: \"Console\", options: \"ConsoleOptions\"\n ) -> \"RenderResult\":\n style = console.get_style(self.style) if self.style is not None else None\n lines = console.render_lines(\n self.renderable, options.update(height=None), pad=False\n )\n width, _height = Segment.get_shape(lines)\n new_line = Segment.line()\n height = options.height or options.size.height\n top_space = (height - len(lines)) // 2\n bottom_space = height - top_space - len(lines)\n blank_line = Segment(f\"{' ' * width}\", style)\n\n def blank_lines(count: int) -> Iterable[Segment]:\n for _ in range(count):\n yield blank_line\n yield new_line\n\n if top_space > 0:\n yield from blank_lines(top_space)\n for line in lines:\n yield from line\n yield new_line\n if bottom_space > 0:\n yield from blank_lines(bottom_space)\n\n def __rich_measure__(\n self, console: \"Console\", options: \"ConsoleOptions\"\n ) -> Measurement:\n measurement = Measurement.get(console, options, self.renderable)\n return measurement\n\n\nif __name__ == \"__main__\": # pragma: no cover\n from pip._vendor.rich.console import Console, Group\n from pip._vendor.rich.highlighter import ReprHighlighter\n from pip._vendor.rich.panel import Panel\n\n highlighter = ReprHighlighter()\n console = Console()\n\n panel = Panel(\n Group(\n Align.left(highlighter(\"align='left'\")),\n Align.center(highlighter(\"align='center'\")),\n Align.right(highlighter(\"align='right'\")),\n ),\n width=60,\n style=\"on dark_blue\",\n title=\"Align\",\n )\n\n console.print(\n Align.center(panel, vertical=\"middle\", style=\"on red\", height=console.height)\n )\n",[],[213,919,920,921,1016,1050,1511,1921],"0cae8c9e-67fc-11f0-aca6-0224a6c84d84","abc.py","0cae8d70-67fc-11f0-aca6-0224a6c84d84",469,["D",1753299269057],"from abc import ABC\n\n\nclass RichRenderable(ABC):\n \"\"\"An abstract base class for Rich renderables.\n\n Note that there is no need to extend this class, the intended use is to check if an\n object supports the Rich renderable protocol. For example::\n\n if isinstance(my_object, RichRenderable):\n console.print(my_object)\n\n \"\"\"\n\n @classmethod\n def __subclasshook__(cls, other: type) -> bool:\n \"\"\"Check if this class supports the rich render protocol.\"\"\"\n return hasattr(other, \"__rich_console__\") or hasattr(other, \"__rich__\")\n\n\nif __name__ == \"__main__\": # pragma: no cover\n from pip._vendor.rich.text import Text\n\n t = Text()\n print(isinstance(Text, RichRenderable))\n print(isinstance(t, RichRenderable))\n\n class Foo:\n pass\n\n f = Foo()\n print(isinstance(f, RichRenderable))\n print(isinstance(\"\", RichRenderable))\n",[],[213,919,920,921,1016,1050,1511,1929],"0b3e165e-67fc-11f0-9454-0224a6c84d84","_wrap.py","0b3e1708-67fc-11f0-9454-0224a6c84d84",411,["D",1753299266626],"from __future__ import annotations\n\nimport re\nfrom typing import Iterable\n\nfrom ._loop import loop_last\nfrom .cells import cell_len, chop_cells\n\nre_word = re.compile(r\"\\s*\\S+\\s*\")\n\n\ndef words(text: str) -> Iterable[tuple[int, int, str]]:\n \"\"\"Yields each word from the text as a tuple\n containing (start_index, end_index, word). A \"word\" in this context may\n include the actual word and any whitespace to the right.\n \"\"\"\n position = 0\n word_match = re_word.match(text, position)\n while word_match is not None:\n start, end = word_match.span()\n word = word_match.group(0)\n yield start, end, word\n word_match = re_word.match(text, end)\n\n\ndef divide_line(text: str, width: int, fold: bool = True) -> list[int]:\n \"\"\"Given a string of text, and a width (measured in cells), return a list\n of cell offsets which the string should be split at in order for it to fit\n within the given width.\n\n Args:\n text: The text to examine.\n width: The available cell width.\n fold: If True, words longer than `width` will be folded onto a new line.\n\n Returns:\n A list of indices to break the line at.\n \"\"\"\n break_positions: list[int] = [] # offsets to insert the breaks at\n append = break_positions.append\n cell_offset = 0\n _cell_len = cell_len\n\n for start, _end, word in words(text):\n word_length = _cell_len(word.rstrip())\n remaining_space = width - cell_offset\n word_fits_remaining_space = remaining_space >= word_length\n\n if word_fits_remaining_space:\n # Simplest case - the word fits within the remaining width for this line.\n cell_offset += _cell_len(word)\n else:\n # Not enough space remaining for this word on the current line.\n if word_length > width:\n # The word doesn't fit on any line, so we can't simply\n # place it on the next line...\n if fold:\n # Fold the word across multiple lines.\n folded_word = chop_cells(word, width=width)\n for last, line in loop_last(folded_word):\n if start:\n append(start)\n if last:\n cell_offset = _cell_len(line)\n else:\n start += len(line)\n else:\n # Folding isn't allowed, so crop the word.\n if start:\n append(start)\n cell_offset = _cell_len(word)\n elif cell_offset and start:\n # The word doesn't fit within the remaining space on the current\n # line, but it *can* fit on to the next (empty) line.\n append(start)\n cell_offset = _cell_len(word)\n\n return break_positions\n\n\nif __name__ == \"__main__\": # pragma: no cover\n from .console import Console\n\n console = Console(width=10)\n console.print(\"12345 abcdefghijklmnopqrstuvwyxzABCDEFGHIJKLMNOPQRSTUVWXYZ 12345\")\n print(chop_cells(\"abcdefghijklmnopqrstuvwxyz\", 10))\n\n console = Console(width=20)\n console.rule()\n console.print(\"TextualはPythonの高速アプリケーション開発フレームワークです\")\n\n console.rule()\n console.print(\"アプリケーションは1670万色を使用でき\")\n",[],[213,919,920,921,1016,1050,1511,1937],"0c77b7d2-67fc-11f0-8d4e-0224a6c84d84","_windows_renderer.py","0c77b8ea-67fc-11f0-8d4e-0224a6c84d84",462,["D",1753299268699],"from typing import Iterable, Sequence, Tuple, cast\n\nfrom pip._vendor.rich._win32_console import LegacyWindowsTerm, WindowsCoordinates\nfrom pip._vendor.rich.segment import ControlCode, ControlType, Segment\n\n\ndef legacy_windows_render(buffer: Iterable[Segment], term: LegacyWindowsTerm) -> None:\n \"\"\"Makes appropriate Windows Console API calls based on the segments in the buffer.\n\n Args:\n buffer (Iterable[Segment]): Iterable of Segments to convert to Win32 API calls.\n term (LegacyWindowsTerm): Used to call the Windows Console API.\n \"\"\"\n for text, style, control in buffer:\n if not control:\n if style:\n term.write_styled(text, style)\n else:\n term.write_text(text)\n else:\n control_codes: Sequence[ControlCode] = control\n for control_code in control_codes:\n control_type = control_code[0]\n if control_type == ControlType.CURSOR_MOVE_TO:\n _, x, y = cast(Tuple[ControlType, int, int], control_code)\n term.move_cursor_to(WindowsCoordinates(row=y - 1, col=x - 1))\n elif control_type == ControlType.CARRIAGE_RETURN:\n term.write_text(\"\\r\")\n elif control_type == ControlType.HOME:\n term.move_cursor_to(WindowsCoordinates(0, 0))\n elif control_type == ControlType.CURSOR_UP:\n term.move_cursor_up()\n elif control_type == ControlType.CURSOR_DOWN:\n term.move_cursor_down()\n elif control_type == ControlType.CURSOR_FORWARD:\n term.move_cursor_forward()\n elif control_type == ControlType.CURSOR_BACKWARD:\n term.move_cursor_backward()\n elif control_type == ControlType.CURSOR_MOVE_TO_COLUMN:\n _, column = cast(Tuple[ControlType, int], control_code)\n term.move_cursor_to_column(column - 1)\n elif control_type == ControlType.HIDE_CURSOR:\n term.hide_cursor()\n elif control_type == ControlType.SHOW_CURSOR:\n term.show_cursor()\n elif control_type == ControlType.ERASE_IN_LINE:\n _, mode = cast(Tuple[ControlType, int], control_code)\n if mode == 0:\n term.erase_end_of_line()\n elif mode == 1:\n term.erase_start_of_line()\n elif mode == 2:\n term.erase_line()\n elif control_type == ControlType.SET_WINDOW_TITLE:\n _, title = cast(Tuple[ControlType, str], control_code)\n term.set_title(title)\n",[],[213,919,920,921,1016,1050,1511,1945],"0c48e858-67fc-11f0-aca6-0224a6c84d84","0c48e90c-67fc-11f0-aca6-0224a6c84d84",454,["D",1753299268392],"import sys\nfrom dataclasses import dataclass\n\n\n@dataclass\nclass WindowsConsoleFeatures:\n \"\"\"Windows features available.\"\"\"\n\n vt: bool = False\n \"\"\"The console supports VT codes.\"\"\"\n truecolor: bool = False\n \"\"\"The console supports truecolor.\"\"\"\n\n\ntry:\n import ctypes\n from ctypes import LibraryLoader\n\n if sys.platform == \"win32\":\n windll = LibraryLoader(ctypes.WinDLL)\n else:\n windll = None\n raise ImportError(\"Not windows\")\n\n from pip._vendor.rich._win32_console import (\n ENABLE_VIRTUAL_TERMINAL_PROCESSING,\n GetConsoleMode,\n GetStdHandle,\n LegacyWindowsError,\n )\n\nexcept (AttributeError, ImportError, ValueError):\n # Fallback if we can't load the Windows DLL\n def get_windows_console_features() -> WindowsConsoleFeatures:\n features = WindowsConsoleFeatures()\n return features\n\nelse:\n\n def get_windows_console_features() -> WindowsConsoleFeatures:\n \"\"\"Get windows console features.\n\n Returns:\n WindowsConsoleFeatures: An instance of WindowsConsoleFeatures.\n \"\"\"\n handle = GetStdHandle()\n try:\n console_mode = GetConsoleMode(handle)\n success = True\n except LegacyWindowsError:\n console_mode = 0\n success = False\n vt = bool(success and console_mode & ENABLE_VIRTUAL_TERMINAL_PROCESSING)\n truecolor = False\n if vt:\n win_version = sys.getwindowsversion()\n truecolor = win_version.major > 10 or (\n win_version.major == 10 and win_version.build >= 15063\n )\n features = WindowsConsoleFeatures(vt=vt, truecolor=truecolor)\n return features\n\n\nif __name__ == \"__main__\":\n import platform\n\n features = get_windows_console_features()\n from pip._vendor.rich import print\n\n print(f'platform=\"{platform.system()}\"')\n print(repr(features))\n",[],[213,919,920,921,1016,1050,1511,1376],"0c62b12a-67fc-11f0-aedf-0224a6c84d84","_win32_console.py","0c62b238-67fc-11f0-aedf-0224a6c84d84",458,["D",1753299268561],"\"\"\"Light wrapper around the Win32 Console API - this module should only be imported on Windows\n\nThe API that this module wraps is documented at https://docs.microsoft.com/en-us/windows/console/console-functions\n\"\"\"\n\nimport ctypes\nimport sys\nfrom typing import Any\n\nwindll: Any = None\nif sys.platform == \"win32\":\n windll = ctypes.LibraryLoader(ctypes.WinDLL)\nelse:\n raise ImportError(f\"{__name__} can only be imported on Windows\")\n\nimport time\nfrom ctypes import Structure, byref, wintypes\nfrom typing import IO, NamedTuple, Type, cast\n\nfrom pip._vendor.rich.color import ColorSystem\nfrom pip._vendor.rich.style import Style\n\nSTDOUT = -11\nENABLE_VIRTUAL_TERMINAL_PROCESSING = 4\n\nCOORD = wintypes._COORD\n\n\nclass LegacyWindowsError(Exception):\n pass\n\n\nclass WindowsCoordinates(NamedTuple):\n \"\"\"Coordinates in the Windows Console API are (y, x), not (x, y).\n This class is intended to prevent that confusion.\n Rows and columns are indexed from 0.\n This class can be used in place of wintypes._COORD in arguments and argtypes.\n \"\"\"\n\n row: int\n col: int\n\n @classmethod\n def from_param(cls, value: \"WindowsCoordinates\") -> COORD:\n \"\"\"Converts a WindowsCoordinates into a wintypes _COORD structure.\n This classmethod is internally called by ctypes to perform the conversion.\n\n Args:\n value (WindowsCoordinates): The input coordinates to convert.\n\n Returns:\n wintypes._COORD: The converted coordinates struct.\n \"\"\"\n return COORD(value.col, value.row)\n\n\nclass CONSOLE_SCREEN_BUFFER_INFO(Structure):\n _fields_ = [\n (\"dwSize\", COORD),\n (\"dwCursorPosition\", COORD),\n (\"wAttributes\", wintypes.WORD),\n (\"srWindow\", wintypes.SMALL_RECT),\n (\"dwMaximumWindowSize\", COORD),\n ]\n\n\nclass CONSOLE_CURSOR_INFO(ctypes.Structure):\n _fields_ = [(\"dwSize\", wintypes.DWORD), (\"bVisible\", wintypes.BOOL)]\n\n\n_GetStdHandle = windll.kernel32.GetStdHandle\n_GetStdHandle.argtypes = [\n wintypes.DWORD,\n]\n_GetStdHandle.restype = wintypes.HANDLE\n\n\ndef GetStdHandle(handle: int = STDOUT) -> wintypes.HANDLE:\n \"\"\"Retrieves a handle to the specified standard device (standard input, standard output, or standard error).\n\n Args:\n handle (int): Integer identifier for the handle. Defaults to -11 (stdout).\n\n Returns:\n wintypes.HANDLE: The handle\n \"\"\"\n return cast(wintypes.HANDLE, _GetStdHandle(handle))\n\n\n_GetConsoleMode = windll.kernel32.GetConsoleMode\n_GetConsoleMode.argtypes = [wintypes.HANDLE, wintypes.LPDWORD]\n_GetConsoleMode.restype = wintypes.BOOL\n\n\ndef GetConsoleMode(std_handle: wintypes.HANDLE) -> int:\n \"\"\"Retrieves the current input mode of a console's input buffer\n or the current output mode of a console screen buffer.\n\n Args:\n std_handle (wintypes.HANDLE): A handle to the console input buffer or the console screen buffer.\n\n Raises:\n LegacyWindowsError: If any error occurs while calling the Windows console API.\n\n Returns:\n int: Value representing the current console mode as documented at\n https://docs.microsoft.com/en-us/windows/console/getconsolemode#parameters\n \"\"\"\n\n console_mode = wintypes.DWORD()\n success = bool(_GetConsoleMode(std_handle, console_mode))\n if not success:\n raise LegacyWindowsError(\"Unable to get legacy Windows Console Mode\")\n return console_mode.value\n\n\n_FillConsoleOutputCharacterW = windll.kernel32.FillConsoleOutputCharacterW\n_FillConsoleOutputCharacterW.argtypes = [\n wintypes.HANDLE,\n ctypes.c_char,\n wintypes.DWORD,\n cast(Type[COORD], WindowsCoordinates),\n ctypes.POINTER(wintypes.DWORD),\n]\n_FillConsoleOutputCharacterW.restype = wintypes.BOOL\n\n\ndef FillConsoleOutputCharacter(\n std_handle: wintypes.HANDLE,\n char: str,\n length: int,\n start: WindowsCoordinates,\n) -> int:\n \"\"\"Writes a character to the console screen buffer a specified number of times, beginning at the specified coordinates.\n\n Args:\n std_handle (wintypes.HANDLE): A handle to the console input buffer or the console screen buffer.\n char (str): The character to write. Must be a string of length 1.\n length (int): The number of times to write the character.\n start (WindowsCoordinates): The coordinates to start writing at.\n\n Returns:\n int: The number of characters written.\n \"\"\"\n character = ctypes.c_char(char.encode())\n num_characters = wintypes.DWORD(length)\n num_written = wintypes.DWORD(0)\n _FillConsoleOutputCharacterW(\n std_handle,\n character,\n num_characters,\n start,\n byref(num_written),\n )\n return num_written.value\n\n\n_FillConsoleOutputAttribute = windll.kernel32.FillConsoleOutputAttribute\n_FillConsoleOutputAttribute.argtypes = [\n wintypes.HANDLE,\n wintypes.WORD,\n wintypes.DWORD,\n cast(Type[COORD], WindowsCoordinates),\n ctypes.POINTER(wintypes.DWORD),\n]\n_FillConsoleOutputAttribute.restype = wintypes.BOOL\n\n\ndef FillConsoleOutputAttribute(\n std_handle: wintypes.HANDLE,\n attributes: int,\n length: int,\n start: WindowsCoordinates,\n) -> int:\n \"\"\"Sets the character attributes for a specified number of character cells,\n beginning at the specified coordinates in a screen buffer.\n\n Args:\n std_handle (wintypes.HANDLE): A handle to the console input buffer or the console screen buffer.\n attributes (int): Integer value representing the foreground and background colours of the cells.\n length (int): The number of cells to set the output attribute of.\n start (WindowsCoordinates): The coordinates of the first cell whose attributes are to be set.\n\n Returns:\n int: The number of cells whose attributes were actually set.\n \"\"\"\n num_cells = wintypes.DWORD(length)\n style_attrs = wintypes.WORD(attributes)\n num_written = wintypes.DWORD(0)\n _FillConsoleOutputAttribute(\n std_handle, style_attrs, num_cells, start, byref(num_written)\n )\n return num_written.value\n\n\n_SetConsoleTextAttribute = windll.kernel32.SetConsoleTextAttribute\n_SetConsoleTextAttribute.argtypes = [\n wintypes.HANDLE,\n wintypes.WORD,\n]\n_SetConsoleTextAttribute.restype = wintypes.BOOL\n\n\ndef SetConsoleTextAttribute(\n std_handle: wintypes.HANDLE, attributes: wintypes.WORD\n) -> bool:\n \"\"\"Set the colour attributes for all text written after this function is called.\n\n Args:\n std_handle (wintypes.HANDLE): A handle to the console input buffer or the console screen buffer.\n attributes (int): Integer value representing the foreground and background colours.\n\n\n Returns:\n bool: True if the attribute was set successfully, otherwise False.\n \"\"\"\n return bool(_SetConsoleTextAttribute(std_handle, attributes))\n\n\n_GetConsoleScreenBufferInfo = windll.kernel32.GetConsoleScreenBufferInfo\n_GetConsoleScreenBufferInfo.argtypes = [\n wintypes.HANDLE,\n ctypes.POINTER(CONSOLE_SCREEN_BUFFER_INFO),\n]\n_GetConsoleScreenBufferInfo.restype = wintypes.BOOL\n\n\ndef GetConsoleScreenBufferInfo(\n std_handle: wintypes.HANDLE,\n) -> CONSOLE_SCREEN_BUFFER_INFO:\n \"\"\"Retrieves information about the specified console screen buffer.\n\n Args:\n std_handle (wintypes.HANDLE): A handle to the console input buffer or the console screen buffer.\n\n Returns:\n CONSOLE_SCREEN_BUFFER_INFO: A CONSOLE_SCREEN_BUFFER_INFO ctype struct contain information about\n screen size, cursor position, colour attributes, and more.\"\"\"\n console_screen_buffer_info = CONSOLE_SCREEN_BUFFER_INFO()\n _GetConsoleScreenBufferInfo(std_handle, byref(console_screen_buffer_info))\n return console_screen_buffer_info\n\n\n_SetConsoleCursorPosition = windll.kernel32.SetConsoleCursorPosition\n_SetConsoleCursorPosition.argtypes = [\n wintypes.HANDLE,\n cast(Type[COORD], WindowsCoordinates),\n]\n_SetConsoleCursorPosition.restype = wintypes.BOOL\n\n\ndef SetConsoleCursorPosition(\n std_handle: wintypes.HANDLE, coords: WindowsCoordinates\n) -> bool:\n \"\"\"Set the position of the cursor in the console screen\n\n Args:\n std_handle (wintypes.HANDLE): A handle to the console input buffer or the console screen buffer.\n coords (WindowsCoordinates): The coordinates to move the cursor to.\n\n Returns:\n bool: True if the function succeeds, otherwise False.\n \"\"\"\n return bool(_SetConsoleCursorPosition(std_handle, coords))\n\n\n_GetConsoleCursorInfo = windll.kernel32.GetConsoleCursorInfo\n_GetConsoleCursorInfo.argtypes = [\n wintypes.HANDLE,\n ctypes.POINTER(CONSOLE_CURSOR_INFO),\n]\n_GetConsoleCursorInfo.restype = wintypes.BOOL\n\n\ndef GetConsoleCursorInfo(\n std_handle: wintypes.HANDLE, cursor_info: CONSOLE_CURSOR_INFO\n) -> bool:\n \"\"\"Get the cursor info - used to get cursor visibility and width\n\n Args:\n std_handle (wintypes.HANDLE): A handle to the console input buffer or the console screen buffer.\n cursor_info (CONSOLE_CURSOR_INFO): CONSOLE_CURSOR_INFO ctype struct that receives information\n about the console's cursor.\n\n Returns:\n bool: True if the function succeeds, otherwise False.\n \"\"\"\n return bool(_GetConsoleCursorInfo(std_handle, byref(cursor_info)))\n\n\n_SetConsoleCursorInfo = windll.kernel32.SetConsoleCursorInfo\n_SetConsoleCursorInfo.argtypes = [\n wintypes.HANDLE,\n ctypes.POINTER(CONSOLE_CURSOR_INFO),\n]\n_SetConsoleCursorInfo.restype = wintypes.BOOL\n\n\ndef SetConsoleCursorInfo(\n std_handle: wintypes.HANDLE, cursor_info: CONSOLE_CURSOR_INFO\n) -> bool:\n \"\"\"Set the cursor info - used for adjusting cursor visibility and width\n\n Args:\n std_handle (wintypes.HANDLE): A handle to the console input buffer or the console screen buffer.\n cursor_info (CONSOLE_CURSOR_INFO): CONSOLE_CURSOR_INFO ctype struct containing the new cursor info.\n\n Returns:\n bool: True if the function succeeds, otherwise False.\n \"\"\"\n return bool(_SetConsoleCursorInfo(std_handle, byref(cursor_info)))\n\n\n_SetConsoleTitle = windll.kernel32.SetConsoleTitleW\n_SetConsoleTitle.argtypes = [wintypes.LPCWSTR]\n_SetConsoleTitle.restype = wintypes.BOOL\n\n\ndef SetConsoleTitle(title: str) -> bool:\n \"\"\"Sets the title of the current console window\n\n Args:\n title (str): The new title of the console window.\n\n Returns:\n bool: True if the function succeeds, otherwise False.\n \"\"\"\n return bool(_SetConsoleTitle(title))\n\n\nclass LegacyWindowsTerm:\n \"\"\"This class allows interaction with the legacy Windows Console API. It should only be used in the context\n of environments where virtual terminal processing is not available. However, if it is used in a Windows environment,\n the entire API should work.\n\n Args:\n file (IO[str]): The file which the Windows Console API HANDLE is retrieved from, defaults to sys.stdout.\n \"\"\"\n\n BRIGHT_BIT = 8\n\n # Indices are ANSI color numbers, values are the corresponding Windows Console API color numbers\n ANSI_TO_WINDOWS = [\n 0, # black The Windows colours are defined in wincon.h as follows:\n 4, # red define FOREGROUND_BLUE 0x0001 -- 0000 0001\n 2, # green define FOREGROUND_GREEN 0x0002 -- 0000 0010\n 6, # yellow define FOREGROUND_RED 0x0004 -- 0000 0100\n 1, # blue define FOREGROUND_INTENSITY 0x0008 -- 0000 1000\n 5, # magenta define BACKGROUND_BLUE 0x0010 -- 0001 0000\n 3, # cyan define BACKGROUND_GREEN 0x0020 -- 0010 0000\n 7, # white define BACKGROUND_RED 0x0040 -- 0100 0000\n 8, # bright black (grey) define BACKGROUND_INTENSITY 0x0080 -- 1000 0000\n 12, # bright red\n 10, # bright green\n 14, # bright yellow\n 9, # bright blue\n 13, # bright magenta\n 11, # bright cyan\n 15, # bright white\n ]\n\n def __init__(self, file: \"IO[str]\") -> None:\n handle = GetStdHandle(STDOUT)\n self._handle = handle\n default_text = GetConsoleScreenBufferInfo(handle).wAttributes\n self._default_text = default_text\n\n self._default_fore = default_text & 7\n self._default_back = (default_text >> 4) & 7\n self._default_attrs = self._default_fore | (self._default_back << 4)\n\n self._file = file\n self.write = file.write\n self.flush = file.flush\n\n @property\n def cursor_position(self) -> WindowsCoordinates:\n \"\"\"Returns the current position of the cursor (0-based)\n\n Returns:\n WindowsCoordinates: The current cursor position.\n \"\"\"\n coord: COORD = GetConsoleScreenBufferInfo(self._handle).dwCursorPosition\n return WindowsCoordinates(row=coord.Y, col=coord.X)\n\n @property\n def screen_size(self) -> WindowsCoordinates:\n \"\"\"Returns the current size of the console screen buffer, in character columns and rows\n\n Returns:\n WindowsCoordinates: The width and height of the screen as WindowsCoordinates.\n \"\"\"\n screen_size: COORD = GetConsoleScreenBufferInfo(self._handle).dwSize\n return WindowsCoordinates(row=screen_size.Y, col=screen_size.X)\n\n def write_text(self, text: str) -> None:\n \"\"\"Write text directly to the terminal without any modification of styles\n\n Args:\n text (str): The text to write to the console\n \"\"\"\n self.write(text)\n self.flush()\n\n def write_styled(self, text: str, style: Style) -> None:\n \"\"\"Write styled text to the terminal.\n\n Args:\n text (str): The text to write\n style (Style): The style of the text\n \"\"\"\n color = style.color\n bgcolor = style.bgcolor\n if style.reverse:\n color, bgcolor = bgcolor, color\n\n if color:\n fore = color.downgrade(ColorSystem.WINDOWS).number\n fore = fore if fore is not None else 7 # Default to ANSI 7: White\n if style.bold:\n fore = fore | self.BRIGHT_BIT\n if style.dim:\n fore = fore & ~self.BRIGHT_BIT\n fore = self.ANSI_TO_WINDOWS[fore]\n else:\n fore = self._default_fore\n\n if bgcolor:\n back = bgcolor.downgrade(ColorSystem.WINDOWS).number\n back = back if back is not None else 0 # Default to ANSI 0: Black\n back = self.ANSI_TO_WINDOWS[back]\n else:\n back = self._default_back\n\n assert fore is not None\n assert back is not None\n\n SetConsoleTextAttribute(\n self._handle, attributes=ctypes.c_ushort(fore | (back << 4))\n )\n self.write_text(text)\n SetConsoleTextAttribute(self._handle, attributes=self._default_text)\n\n def move_cursor_to(self, new_position: WindowsCoordinates) -> None:\n \"\"\"Set the position of the cursor\n\n Args:\n new_position (WindowsCoordinates): The WindowsCoordinates representing the new position of the cursor.\n \"\"\"\n if new_position.col < 0 or new_position.row < 0:\n return\n SetConsoleCursorPosition(self._handle, coords=new_position)\n\n def erase_line(self) -> None:\n \"\"\"Erase all content on the line the cursor is currently located at\"\"\"\n screen_size = self.screen_size\n cursor_position = self.cursor_position\n cells_to_erase = screen_size.col\n start_coordinates = WindowsCoordinates(row=cursor_position.row, col=0)\n FillConsoleOutputCharacter(\n self._handle, \" \", length=cells_to_erase, start=start_coordinates\n )\n FillConsoleOutputAttribute(\n self._handle,\n self._default_attrs,\n length=cells_to_erase,\n start=start_coordinates,\n )\n\n def erase_end_of_line(self) -> None:\n \"\"\"Erase all content from the cursor position to the end of that line\"\"\"\n cursor_position = self.cursor_position\n cells_to_erase = self.screen_size.col - cursor_position.col\n FillConsoleOutputCharacter(\n self._handle, \" \", length=cells_to_erase, start=cursor_position\n )\n FillConsoleOutputAttribute(\n self._handle,\n self._default_attrs,\n length=cells_to_erase,\n start=cursor_position,\n )\n\n def erase_start_of_line(self) -> None:\n \"\"\"Erase all content from the cursor position to the start of that line\"\"\"\n row, col = self.cursor_position\n start = WindowsCoordinates(row, 0)\n FillConsoleOutputCharacter(self._handle, \" \", length=col, start=start)\n FillConsoleOutputAttribute(\n self._handle, self._default_attrs, length=col, start=start\n )\n\n def move_cursor_up(self) -> None:\n \"\"\"Move the cursor up a single cell\"\"\"\n cursor_position = self.cursor_position\n SetConsoleCursorPosition(\n self._handle,\n coords=WindowsCoordinates(\n row=cursor_position.row - 1, col=cursor_position.col\n ),\n )\n\n def move_cursor_down(self) -> None:\n \"\"\"Move the cursor down a single cell\"\"\"\n cursor_position = self.cursor_position\n SetConsoleCursorPosition(\n self._handle,\n coords=WindowsCoordinates(\n row=cursor_position.row + 1,\n col=cursor_position.col,\n ),\n )\n\n def move_cursor_forward(self) -> None:\n \"\"\"Move the cursor forward a single cell. Wrap to the next line if required.\"\"\"\n row, col = self.cursor_position\n if col == self.screen_size.col - 1:\n row += 1\n col = 0\n else:\n col += 1\n SetConsoleCursorPosition(\n self._handle, coords=WindowsCoordinates(row=row, col=col)\n )\n\n def move_cursor_to_column(self, column: int) -> None:\n \"\"\"Move cursor to the column specified by the zero-based column index, staying on the same row\n\n Args:\n column (int): The zero-based column index to move the cursor to.\n \"\"\"\n row, _ = self.cursor_position\n SetConsoleCursorPosition(self._handle, coords=WindowsCoordinates(row, column))\n\n def move_cursor_backward(self) -> None:\n \"\"\"Move the cursor backward a single cell. Wrap to the previous line if required.\"\"\"\n row, col = self.cursor_position\n if col == 0:\n row -= 1\n col = self.screen_size.col - 1\n else:\n col -= 1\n SetConsoleCursorPosition(\n self._handle, coords=WindowsCoordinates(row=row, col=col)\n )\n\n def hide_cursor(self) -> None:\n \"\"\"Hide the cursor\"\"\"\n current_cursor_size = self._get_cursor_size()\n invisible_cursor = CONSOLE_CURSOR_INFO(dwSize=current_cursor_size, bVisible=0)\n SetConsoleCursorInfo(self._handle, cursor_info=invisible_cursor)\n\n def show_cursor(self) -> None:\n \"\"\"Show the cursor\"\"\"\n current_cursor_size = self._get_cursor_size()\n visible_cursor = CONSOLE_CURSOR_INFO(dwSize=current_cursor_size, bVisible=1)\n SetConsoleCursorInfo(self._handle, cursor_info=visible_cursor)\n\n def set_title(self, title: str) -> None:\n \"\"\"Set the title of the terminal window\n\n Args:\n title (str): The new title of the console window\n \"\"\"\n assert len(title) < 255, \"Console title must be less than 255 characters\"\n SetConsoleTitle(title)\n\n def _get_cursor_size(self) -> int:\n \"\"\"Get the percentage of the character cell that is filled by the cursor\"\"\"\n cursor_info = CONSOLE_CURSOR_INFO()\n GetConsoleCursorInfo(self._handle, cursor_info=cursor_info)\n return int(cursor_info.dwSize)\n\n\nif __name__ == \"__main__\":\n handle = GetStdHandle()\n\n from pip._vendor.rich.console import Console\n\n console = Console()\n\n term = LegacyWindowsTerm(sys.stdout)\n term.set_title(\"Win32 Console Examples\")\n\n style = Style(color=\"black\", bgcolor=\"red\")\n\n heading = Style.parse(\"black on green\")\n\n # Check colour output\n console.rule(\"Checking colour output\")\n console.print(\"[on red]on red!\")\n console.print(\"[blue]blue!\")\n console.print(\"[yellow]yellow!\")\n console.print(\"[bold yellow]bold yellow!\")\n console.print(\"[bright_yellow]bright_yellow!\")\n console.print(\"[dim bright_yellow]dim bright_yellow!\")\n console.print(\"[italic cyan]italic cyan!\")\n console.print(\"[bold white on blue]bold white on blue!\")\n console.print(\"[reverse bold white on blue]reverse bold white on blue!\")\n console.print(\"[bold black on cyan]bold black on cyan!\")\n console.print(\"[black on green]black on green!\")\n console.print(\"[blue on green]blue on green!\")\n console.print(\"[white on black]white on black!\")\n console.print(\"[black on white]black on white!\")\n console.print(\"[#1BB152 on #DA812D]#1BB152 on #DA812D!\")\n\n # Check cursor movement\n console.rule(\"Checking cursor movement\")\n console.print()\n term.move_cursor_backward()\n term.move_cursor_backward()\n term.write_text(\"went back and wrapped to prev line\")\n time.sleep(1)\n term.move_cursor_up()\n term.write_text(\"we go up\")\n time.sleep(1)\n term.move_cursor_down()\n term.write_text(\"and down\")\n time.sleep(1)\n term.move_cursor_up()\n term.move_cursor_backward()\n term.move_cursor_backward()\n term.write_text(\"we went up and back 2\")\n time.sleep(1)\n term.move_cursor_down()\n term.move_cursor_backward()\n term.move_cursor_backward()\n term.write_text(\"we went down and back 2\")\n time.sleep(1)\n\n # Check erasing of lines\n term.hide_cursor()\n console.print()\n console.rule(\"Checking line erasing\")\n console.print(\"\\n...Deleting to the start of the line...\")\n term.write_text(\"The red arrow shows the cursor location, and direction of erase\")\n time.sleep(1)\n term.move_cursor_to_column(16)\n term.write_styled(\"<\", Style.parse(\"black on red\"))\n term.move_cursor_backward()\n time.sleep(1)\n term.erase_start_of_line()\n time.sleep(1)\n\n console.print(\"\\n\\n...And to the end of the line...\")\n term.write_text(\"The red arrow shows the cursor location, and direction of erase\")\n time.sleep(1)\n\n term.move_cursor_to_column(16)\n term.write_styled(\">\", Style.parse(\"black on red\"))\n time.sleep(1)\n term.erase_end_of_line()\n time.sleep(1)\n\n console.print(\"\\n\\n...Now the whole line will be erased...\")\n term.write_styled(\"I'm going to disappear!\", style=Style.parse(\"black on cyan\"))\n time.sleep(1)\n term.erase_line()\n\n term.show_cursor()\n print(\"\\n\")\n",[],[213,919,920,921,1016,1050,1511,1960],"0b193898-67fc-11f0-b6cd-0224a6c84d84","_timer.py","0b19396a-67fc-11f0-b6cd-0224a6c84d84",405,["D",1753299266398],"\"\"\"\nTimer context manager, only used in debug.\n\n\"\"\"\n\nfrom time import time\n\nimport contextlib\nfrom typing import Generator\n\n\n@contextlib.contextmanager\ndef timer(subject: str = \"time\") -> Generator[None, None, None]:\n \"\"\"print the elapsed time. (only used in debugging)\"\"\"\n start = time()\n yield\n elapsed = time() - start\n elapsed_ms = elapsed * 1000\n print(f\"{subject} elapsed {elapsed_ms:.1f}ms\")\n",[],[213,919,920,921,1016,1050,1511,1968],"0c4c5696-67fc-11f0-a7d9-0224a6c84d84","_stack.py","0c4c5754-67fc-11f0-a7d9-0224a6c84d84",455,["D",1753299268383],"from typing import List, TypeVar\n\nT = TypeVar(\"T\")\n\n\nclass Stack(List[T]):\n \"\"\"A small shim over builtin list.\"\"\"\n\n @property\n def top(self) -> T:\n \"\"\"Get top of stack.\"\"\"\n return self[-1]\n\n def push(self, item: T) -> None:\n \"\"\"Push an item on to the stack (append in stack nomenclature).\"\"\"\n self.append(item)\n",[],[213,919,920,921,1016,1050,1511,1976],"0bec6a2e-67fc-11f0-aad3-0224a6c84d84","_spinners.py","0bec6aec-67fc-11f0-aad3-0224a6c84d84",440,["D",1753299267776],"\"\"\"\nSpinners are from:\n* cli-spinners:\n MIT License\n Copyright (c) Sindre Sorhus (sindresorhus.com)\n Permission is hereby granted, free of charge, to any person obtaining a copy\n of this software and associated documentation files (the \"Software\"), to deal\n in the Software without restriction, including without limitation the rights to\n use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\n the Software, and to permit persons to whom the Software is furnished to do so,\n subject to the following conditions:\n The above copyright notice and this permission notice shall be included\n in all copies or substantial portions of the Software.\n THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,\n INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR\n PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE\n FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,\n ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS\n IN THE SOFTWARE.\n\"\"\"\n\nSPINNERS = {\n \"dots\": {\n \"interval\": 80,\n \"frames\": \"⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏\",\n },\n \"dots2\": {\"interval\": 80, \"frames\": \"⣾⣽⣻⢿⡿⣟⣯⣷\"},\n \"dots3\": {\n \"interval\": 80,\n \"frames\": \"⠋⠙⠚⠞⠖⠦⠴⠲⠳⠓\",\n },\n \"dots4\": {\n \"interval\": 80,\n \"frames\": \"⠄⠆⠇⠋⠙⠸⠰⠠⠰⠸⠙⠋⠇⠆\",\n },\n \"dots5\": {\n \"interval\": 80,\n \"frames\": \"⠋⠙⠚⠒⠂⠂⠒⠲⠴⠦⠖⠒⠐⠐⠒⠓⠋\",\n },\n \"dots6\": {\n \"interval\": 80,\n \"frames\": \"⠁⠉⠙⠚⠒⠂⠂⠒⠲⠴⠤⠄⠄⠤⠴⠲⠒⠂⠂⠒⠚⠙⠉⠁\",\n },\n \"dots7\": {\n \"interval\": 80,\n \"frames\": \"⠈⠉⠋⠓⠒⠐⠐⠒⠖⠦⠤⠠⠠⠤⠦⠖⠒⠐⠐⠒⠓⠋⠉⠈\",\n },\n \"dots8\": {\n \"interval\": 80,\n \"frames\": \"⠁⠁⠉⠙⠚⠒⠂⠂⠒⠲⠴⠤⠄⠄⠤⠠⠠⠤⠦⠖⠒⠐⠐⠒⠓⠋⠉⠈⠈\",\n },\n \"dots9\": {\"interval\": 80, \"frames\": \"⢹⢺⢼⣸⣇⡧⡗⡏\"},\n \"dots10\": {\"interval\": 80, \"frames\": \"⢄⢂⢁⡁⡈⡐⡠\"},\n \"dots11\": {\"interval\": 100, \"frames\": \"⠁⠂⠄⡀⢀⠠⠐⠈\"},\n \"dots12\": {\n \"interval\": 80,\n \"frames\": [\n \"⢀⠀\",\n \"⡀⠀\",\n \"⠄⠀\",\n \"⢂⠀\",\n \"⡂⠀\",\n \"⠅⠀\",\n \"⢃⠀\",\n \"⡃⠀\",\n \"⠍⠀\",\n \"⢋⠀\",\n \"⡋⠀\",\n \"⠍⠁\",\n \"⢋⠁\",\n \"⡋⠁\",\n \"⠍⠉\",\n \"⠋⠉\",\n \"⠋⠉\",\n \"⠉⠙\",\n \"⠉⠙\",\n \"⠉⠩\",\n \"⠈⢙\",\n \"⠈⡙\",\n \"⢈⠩\",\n \"⡀⢙\",\n \"⠄⡙\",\n \"⢂⠩\",\n \"⡂⢘\",\n \"⠅⡘\",\n \"⢃⠨\",\n \"⡃⢐\",\n \"⠍⡐\",\n \"⢋⠠\",\n \"⡋⢀\",\n \"⠍⡁\",\n \"⢋⠁\",\n \"⡋⠁\",\n \"⠍⠉\",\n \"⠋⠉\",\n \"⠋⠉\",\n \"⠉⠙\",\n \"⠉⠙\",\n \"⠉⠩\",\n \"⠈⢙\",\n \"⠈⡙\",\n \"⠈⠩\",\n \"⠀⢙\",\n \"⠀⡙\",\n \"⠀⠩\",\n \"⠀⢘\",\n \"⠀⡘\",\n \"⠀⠨\",\n \"⠀⢐\",\n \"⠀⡐\",\n \"⠀⠠\",\n \"⠀⢀\",\n \"⠀⡀\",\n ],\n },\n \"dots8Bit\": {\n \"interval\": 80,\n \"frames\": \"⠀⠁⠂⠃⠄⠅⠆⠇⡀⡁⡂⡃⡄⡅⡆⡇⠈⠉⠊⠋⠌⠍⠎⠏⡈⡉⡊⡋⡌⡍⡎⡏⠐⠑⠒⠓⠔⠕⠖⠗⡐⡑⡒⡓⡔⡕⡖⡗⠘⠙⠚⠛⠜⠝⠞⠟⡘⡙\"\n \"⡚⡛⡜⡝⡞⡟⠠⠡⠢⠣⠤⠥⠦⠧⡠⡡⡢⡣⡤⡥⡦⡧⠨⠩⠪⠫⠬⠭⠮⠯⡨⡩⡪⡫⡬⡭⡮⡯⠰⠱⠲⠳⠴⠵⠶⠷⡰⡱⡲⡳⡴⡵⡶⡷⠸⠹⠺⠻\"\n \"⠼⠽⠾⠿⡸⡹⡺⡻⡼⡽⡾⡿⢀⢁⢂⢃⢄⢅⢆⢇⣀⣁⣂⣃⣄⣅⣆⣇⢈⢉⢊⢋⢌⢍⢎⢏⣈⣉⣊⣋⣌⣍⣎⣏⢐⢑⢒⢓⢔⢕⢖⢗⣐⣑⣒⣓⣔⣕\"\n \"⣖⣗⢘⢙⢚⢛⢜⢝⢞⢟⣘⣙⣚⣛⣜⣝⣞⣟⢠⢡⢢⢣⢤⢥⢦⢧⣠⣡⣢⣣⣤⣥⣦⣧⢨⢩⢪⢫⢬⢭⢮⢯⣨⣩⣪⣫⣬⣭⣮⣯⢰⢱⢲⢳⢴⢵⢶⢷\"\n \"⣰⣱⣲⣳⣴⣵⣶⣷⢸⢹⢺⢻⢼⢽⢾⢿⣸⣹⣺⣻⣼⣽⣾⣿\",\n },\n \"line\": {\"interval\": 130, \"frames\": [\"-\", \"\\\\\", \"|\", \"/\"]},\n \"line2\": {\"interval\": 100, \"frames\": \"⠂-–—–-\"},\n \"pipe\": {\"interval\": 100, \"frames\": \"┤┘┴└├┌┬┐\"},\n \"simpleDots\": {\"interval\": 400, \"frames\": [\". \", \".. \", \"...\", \" \"]},\n \"simpleDotsScrolling\": {\n \"interval\": 200,\n \"frames\": [\". \", \".. \", \"...\", \" ..\", \" .\", \" \"],\n },\n \"star\": {\"interval\": 70, \"frames\": \"✶✸✹✺✹✷\"},\n \"star2\": {\"interval\": 80, \"frames\": \"+x*\"},\n \"flip\": {\n \"interval\": 70,\n \"frames\": \"___-``'´-___\",\n },\n \"hamburger\": {\"interval\": 100, \"frames\": \"☱☲☴\"},\n \"growVertical\": {\n \"interval\": 120,\n \"frames\": \"▁▃▄▅▆▇▆▅▄▃\",\n },\n \"growHorizontal\": {\n \"interval\": 120,\n \"frames\": \"▏▎▍▌▋▊▉▊▋▌▍▎\",\n },\n \"balloon\": {\"interval\": 140, \"frames\": \" .oO@* \"},\n \"balloon2\": {\"interval\": 120, \"frames\": \".oO°Oo.\"},\n \"noise\": {\"interval\": 100, \"frames\": \"▓▒░\"},\n \"bounce\": {\"interval\": 120, \"frames\": \"⠁⠂⠄⠂\"},\n \"boxBounce\": {\"interval\": 120, \"frames\": \"▖▘▝▗\"},\n \"boxBounce2\": {\"interval\": 100, \"frames\": \"▌▀▐▄\"},\n \"triangle\": {\"interval\": 50, \"frames\": \"◢◣◤◥\"},\n \"arc\": {\"interval\": 100, \"frames\": \"◜◠◝◞◡◟\"},\n \"circle\": {\"interval\": 120, \"frames\": \"◡⊙◠\"},\n \"squareCorners\": {\"interval\": 180, \"frames\": \"◰◳◲◱\"},\n \"circleQuarters\": {\"interval\": 120, \"frames\": \"◴◷◶◵\"},\n \"circleHalves\": {\"interval\": 50, \"frames\": \"◐◓◑◒\"},\n \"squish\": {\"interval\": 100, \"frames\": \"╫╪\"},\n \"toggle\": {\"interval\": 250, \"frames\": \"⊶⊷\"},\n \"toggle2\": {\"interval\": 80, \"frames\": \"▫▪\"},\n \"toggle3\": {\"interval\": 120, \"frames\": \"□■\"},\n \"toggle4\": {\"interval\": 100, \"frames\": \"■□▪▫\"},\n \"toggle5\": {\"interval\": 100, \"frames\": \"▮▯\"},\n \"toggle6\": {\"interval\": 300, \"frames\": \"ဝ၀\"},\n \"toggle7\": {\"interval\": 80, \"frames\": \"⦾⦿\"},\n \"toggle8\": {\"interval\": 100, \"frames\": \"◍◌\"},\n \"toggle9\": {\"interval\": 100, \"frames\": \"◉◎\"},\n \"toggle10\": {\"interval\": 100, \"frames\": \"㊂㊀㊁\"},\n \"toggle11\": {\"interval\": 50, \"frames\": \"⧇⧆\"},\n \"toggle12\": {\"interval\": 120, \"frames\": \"☗☖\"},\n \"toggle13\": {\"interval\": 80, \"frames\": \"=*-\"},\n \"arrow\": {\"interval\": 100, \"frames\": \"←↖↑↗→↘↓↙\"},\n \"arrow2\": {\n \"interval\": 80,\n \"frames\": [\"⬆️ \", \"↗️ \", \"➡️ \", \"↘️ \", \"⬇️ \", \"↙️ \", \"⬅️ \", \"↖️ \"],\n },\n \"arrow3\": {\n \"interval\": 120,\n \"frames\": [\"▹▹▹▹▹\", \"▸▹▹▹▹\", \"▹▸▹▹▹\", \"▹▹▸▹▹\", \"▹▹▹▸▹\", \"▹▹▹▹▸\"],\n },\n \"bouncingBar\": {\n \"interval\": 80,\n \"frames\": [\n \"[ ]\",\n \"[= ]\",\n \"[== ]\",\n \"[=== ]\",\n \"[ ===]\",\n \"[ ==]\",\n \"[ =]\",\n \"[ ]\",\n \"[ =]\",\n \"[ ==]\",\n \"[ ===]\",\n \"[====]\",\n \"[=== ]\",\n \"[== ]\",\n \"[= ]\",\n ],\n },\n \"bouncingBall\": {\n \"interval\": 80,\n \"frames\": [\n \"( ● )\",\n \"( ● )\",\n \"( ● )\",\n \"( ● )\",\n \"( ●)\",\n \"( ● )\",\n \"( ● )\",\n \"( ● )\",\n \"( ● )\",\n \"(● )\",\n ],\n },\n \"smiley\": {\"interval\": 200, \"frames\": [\"😄 \", \"😝 \"]},\n \"monkey\": {\"interval\": 300, \"frames\": [\"🙈 \", \"🙈 \", \"🙉 \", \"🙊 \"]},\n \"hearts\": {\"interval\": 100, \"frames\": [\"💛 \", \"💙 \", \"💜 \", \"💚 \", \"❤️ \"]},\n \"clock\": {\n \"interval\": 100,\n \"frames\": [\n \"🕛 \",\n \"🕐 \",\n \"🕑 \",\n \"🕒 \",\n \"🕓 \",\n \"🕔 \",\n \"🕕 \",\n \"🕖 \",\n \"🕗 \",\n \"🕘 \",\n \"🕙 \",\n \"🕚 \",\n ],\n },\n \"earth\": {\"interval\": 180, \"frames\": [\"🌍 \", \"🌎 \", \"🌏 \"]},\n \"material\": {\n \"interval\": 17,\n \"frames\": [\n \"█▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁\",\n \"██▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁\",\n \"███▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁\",\n \"████▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁\",\n \"██████▁▁▁▁▁▁▁▁▁▁▁▁▁▁\",\n \"██████▁▁▁▁▁▁▁▁▁▁▁▁▁▁\",\n \"███████▁▁▁▁▁▁▁▁▁▁▁▁▁\",\n \"████████▁▁▁▁▁▁▁▁▁▁▁▁\",\n \"█████████▁▁▁▁▁▁▁▁▁▁▁\",\n \"█████████▁▁▁▁▁▁▁▁▁▁▁\",\n \"██████████▁▁▁▁▁▁▁▁▁▁\",\n \"███████████▁▁▁▁▁▁▁▁▁\",\n \"█████████████▁▁▁▁▁▁▁\",\n \"██████████████▁▁▁▁▁▁\",\n \"██████████████▁▁▁▁▁▁\",\n \"▁██████████████▁▁▁▁▁\",\n \"▁██████████████▁▁▁▁▁\",\n \"▁██████████████▁▁▁▁▁\",\n \"▁▁██████████████▁▁▁▁\",\n \"▁▁▁██████████████▁▁▁\",\n \"▁▁▁▁█████████████▁▁▁\",\n \"▁▁▁▁██████████████▁▁\",\n \"▁▁▁▁██████████████▁▁\",\n \"▁▁▁▁▁██████████████▁\",\n \"▁▁▁▁▁██████████████▁\",\n \"▁▁▁▁▁██████████████▁\",\n \"▁▁▁▁▁▁██████████████\",\n \"▁▁▁▁▁▁██████████████\",\n \"▁▁▁▁▁▁▁█████████████\",\n \"▁▁▁▁▁▁▁█████████████\",\n \"▁▁▁▁▁▁▁▁████████████\",\n \"▁▁▁▁▁▁▁▁████████████\",\n \"▁▁▁▁▁▁▁▁▁███████████\",\n \"▁▁▁▁▁▁▁▁▁███████████\",\n \"▁▁▁▁▁▁▁▁▁▁██████████\",\n \"▁▁▁▁▁▁▁▁▁▁██████████\",\n \"▁▁▁▁▁▁▁▁▁▁▁▁████████\",\n \"▁▁▁▁▁▁▁▁▁▁▁▁▁███████\",\n \"▁▁▁▁▁▁▁▁▁▁▁▁▁▁██████\",\n \"▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁█████\",\n \"▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁█████\",\n \"█▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁████\",\n \"██▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁███\",\n \"██▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁███\",\n \"███▁▁▁▁▁▁▁▁▁▁▁▁▁▁███\",\n \"████▁▁▁▁▁▁▁▁▁▁▁▁▁▁██\",\n \"█████▁▁▁▁▁▁▁▁▁▁▁▁▁▁█\",\n \"█████▁▁▁▁▁▁▁▁▁▁▁▁▁▁█\",\n \"██████▁▁▁▁▁▁▁▁▁▁▁▁▁█\",\n \"████████▁▁▁▁▁▁▁▁▁▁▁▁\",\n \"█████████▁▁▁▁▁▁▁▁▁▁▁\",\n \"█████████▁▁▁▁▁▁▁▁▁▁▁\",\n \"█████████▁▁▁▁▁▁▁▁▁▁▁\",\n \"█████████▁▁▁▁▁▁▁▁▁▁▁\",\n \"███████████▁▁▁▁▁▁▁▁▁\",\n \"████████████▁▁▁▁▁▁▁▁\",\n \"████████████▁▁▁▁▁▁▁▁\",\n \"██████████████▁▁▁▁▁▁\",\n \"██████████████▁▁▁▁▁▁\",\n \"▁██████████████▁▁▁▁▁\",\n \"▁██████████████▁▁▁▁▁\",\n \"▁▁▁█████████████▁▁▁▁\",\n \"▁▁▁▁▁████████████▁▁▁\",\n \"▁▁▁▁▁████████████▁▁▁\",\n \"▁▁▁▁▁▁███████████▁▁▁\",\n \"▁▁▁▁▁▁▁▁█████████▁▁▁\",\n \"▁▁▁▁▁▁▁▁█████████▁▁▁\",\n \"▁▁▁▁▁▁▁▁▁█████████▁▁\",\n \"▁▁▁▁▁▁▁▁▁█████████▁▁\",\n \"▁▁▁▁▁▁▁▁▁▁█████████▁\",\n \"▁▁▁▁▁▁▁▁▁▁▁████████▁\",\n \"▁▁▁▁▁▁▁▁▁▁▁████████▁\",\n \"▁▁▁▁▁▁▁▁▁▁▁▁███████▁\",\n \"▁▁▁▁▁▁▁▁▁▁▁▁███████▁\",\n \"▁▁▁▁▁▁▁▁▁▁▁▁▁███████\",\n \"▁▁▁▁▁▁▁▁▁▁▁▁▁███████\",\n \"▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁█████\",\n \"▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁████\",\n \"▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁████\",\n \"▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁████\",\n \"▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁███\",\n \"▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁███\",\n \"▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁██\",\n \"▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁██\",\n \"▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁██\",\n \"▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁█\",\n \"▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁█\",\n \"▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁█\",\n \"▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁\",\n \"▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁\",\n \"▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁\",\n \"▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁\",\n ],\n },\n \"moon\": {\n \"interval\": 80,\n \"frames\": [\"🌑 \", \"🌒 \", \"🌓 \", \"🌔 \", \"🌕 \", \"🌖 \", \"🌗 \", \"🌘 \"],\n },\n \"runner\": {\"interval\": 140, \"frames\": [\"🚶 \", \"🏃 \"]},\n \"pong\": {\n \"interval\": 80,\n \"frames\": [\n \"▐⠂ ▌\",\n \"▐⠈ ▌\",\n \"▐ ⠂ ▌\",\n \"▐ ⠠ ▌\",\n \"▐ ⡀ ▌\",\n \"▐ ⠠ ▌\",\n \"▐ ⠂ ▌\",\n \"▐ ⠈ ▌\",\n \"▐ ⠂ ▌\",\n \"▐ ⠠ ▌\",\n \"▐ ⡀ ▌\",\n \"▐ ⠠ ▌\",\n \"▐ ⠂ ▌\",\n \"▐ ⠈ ▌\",\n \"▐ ⠂▌\",\n \"▐ ⠠▌\",\n \"▐ ⡀▌\",\n \"▐ ⠠ ▌\",\n \"▐ ⠂ ▌\",\n \"▐ ⠈ ▌\",\n \"▐ ⠂ ▌\",\n \"▐ ⠠ ▌\",\n \"▐ ⡀ ▌\",\n \"▐ ⠠ ▌\",\n \"▐ ⠂ ▌\",\n \"▐ ⠈ ▌\",\n \"▐ ⠂ ▌\",\n \"▐ ⠠ ▌\",\n \"▐ ⡀ ▌\",\n \"▐⠠ ▌\",\n ],\n },\n \"shark\": {\n \"interval\": 120,\n \"frames\": [\n \"▐|\\\\____________▌\",\n \"▐_|\\\\___________▌\",\n \"▐__|\\\\__________▌\",\n \"▐___|\\\\_________▌\",\n \"▐____|\\\\________▌\",\n \"▐_____|\\\\_______▌\",\n \"▐______|\\\\______▌\",\n \"▐_______|\\\\_____▌\",\n \"▐________|\\\\____▌\",\n \"▐_________|\\\\___▌\",\n \"▐__________|\\\\__▌\",\n \"▐___________|\\\\_▌\",\n \"▐____________|\\\\▌\",\n \"▐____________/|▌\",\n \"▐___________/|_▌\",\n \"▐__________/|__▌\",\n \"▐_________/|___▌\",\n \"▐________/|____▌\",\n \"▐_______/|_____▌\",\n \"▐______/|______▌\",\n \"▐_____/|_______▌\",\n \"▐____/|________▌\",\n \"▐___/|_________▌\",\n \"▐__/|__________▌\",\n \"▐_/|___________▌\",\n \"▐/|____________▌\",\n ],\n },\n \"dqpb\": {\"interval\": 100, \"frames\": \"dqpb\"},\n \"weather\": {\n \"interval\": 100,\n \"frames\": [\n \"☀️ \",\n \"☀️ \",\n \"☀️ \",\n \"🌤 \",\n \"⛅️ \",\n \"🌥 \",\n \"☁️ \",\n \"🌧 \",\n \"🌨 \",\n \"🌧 \",\n \"🌨 \",\n \"🌧 \",\n \"🌨 \",\n \"⛈ \",\n \"🌨 \",\n \"🌧 \",\n \"🌨 \",\n \"☁️ \",\n \"🌥 \",\n \"⛅️ \",\n \"🌤 \",\n \"☀️ \",\n \"☀️ \",\n ],\n },\n \"christmas\": {\"interval\": 400, \"frames\": \"🌲🎄\"},\n \"grenade\": {\n \"interval\": 80,\n \"frames\": [\n \"، \",\n \"′ \",\n \" ´ \",\n \" ‾ \",\n \" ⸌\",\n \" ⸊\",\n \" |\",\n \" ⁎\",\n \" ⁕\",\n \" ෴ \",\n \" ⁓\",\n \" \",\n \" \",\n \" \",\n ],\n },\n \"point\": {\"interval\": 125, \"frames\": [\"∙∙∙\", \"●∙∙\", \"∙●∙\", \"∙∙●\", \"∙∙∙\"]},\n \"layer\": {\"interval\": 150, \"frames\": \"-=≡\"},\n \"betaWave\": {\n \"interval\": 80,\n \"frames\": [\n \"ρββββββ\",\n \"βρβββββ\",\n \"ββρββββ\",\n \"βββρβββ\",\n \"ββββρββ\",\n \"βββββρβ\",\n \"ββββββρ\",\n ],\n },\n \"aesthetic\": {\n \"interval\": 80,\n \"frames\": [\n \"▰▱▱▱▱▱▱\",\n \"▰▰▱▱▱▱▱\",\n \"▰▰▰▱▱▱▱\",\n \"▰▰▰▰▱▱▱\",\n \"▰▰▰▰▰▱▱\",\n \"▰▰▰▰▰▰▱\",\n \"▰▰▰▰▰▰▰\",\n \"▰▱▱▱▱▱▱\",\n ],\n },\n}\n",[],[213,919,920,921,1016,1050,1511,1984],"0bac1f6e-67fc-11f0-9bd1-0224a6c84d84","_ratio.py","0bac202c-67fc-11f0-9bd1-0224a6c84d84",430,["D",1753299267357],"import sys\nfrom fractions import Fraction\nfrom math import ceil\nfrom typing import cast, List, Optional, Sequence\n\nif sys.version_info >= (3, 8):\n from typing import Protocol\nelse:\n from pip._vendor.typing_extensions import Protocol # pragma: no cover\n\n\nclass Edge(Protocol):\n \"\"\"Any object that defines an edge (such as Layout).\"\"\"\n\n size: Optional[int] = None\n ratio: int = 1\n minimum_size: int = 1\n\n\ndef ratio_resolve(total: int, edges: Sequence[Edge]) -> List[int]:\n \"\"\"Divide total space to satisfy size, ratio, and minimum_size, constraints.\n\n The returned list of integers should add up to total in most cases, unless it is\n impossible to satisfy all the constraints. For instance, if there are two edges\n with a minimum size of 20 each and `total` is 30 then the returned list will be\n greater than total. In practice, this would mean that a Layout object would\n clip the rows that would overflow the screen height.\n\n Args:\n total (int): Total number of characters.\n edges (List[Edge]): Edges within total space.\n\n Returns:\n List[int]: Number of characters for each edge.\n \"\"\"\n # Size of edge or None for yet to be determined\n sizes = [(edge.size or None) for edge in edges]\n\n _Fraction = Fraction\n\n # While any edges haven't been calculated\n while None in sizes:\n # Get flexible edges and index to map these back on to sizes list\n flexible_edges = [\n (index, edge)\n for index, (size, edge) in enumerate(zip(sizes, edges))\n if size is None\n ]\n # Remaining space in total\n remaining = total - sum(size or 0 for size in sizes)\n if remaining <= 0:\n # No room for flexible edges\n return [\n ((edge.minimum_size or 1) if size is None else size)\n for size, edge in zip(sizes, edges)\n ]\n # Calculate number of characters in a ratio portion\n portion = _Fraction(\n remaining, sum((edge.ratio or 1) for _, edge in flexible_edges)\n )\n\n # If any edges will be less than their minimum, replace size with the minimum\n for index, edge in flexible_edges:\n if portion * edge.ratio <= edge.minimum_size:\n sizes[index] = edge.minimum_size\n # New fixed size will invalidate calculations, so we need to repeat the process\n break\n else:\n # Distribute flexible space and compensate for rounding error\n # Since edge sizes can only be integers we need to add the remainder\n # to the following line\n remainder = _Fraction(0)\n for index, edge in flexible_edges:\n size, remainder = divmod(portion * edge.ratio + remainder, 1)\n sizes[index] = size\n break\n # Sizes now contains integers only\n return cast(List[int], sizes)\n\n\ndef ratio_reduce(\n total: int, ratios: List[int], maximums: List[int], values: List[int]\n) -> List[int]:\n \"\"\"Divide an integer total in to parts based on ratios.\n\n Args:\n total (int): The total to divide.\n ratios (List[int]): A list of integer ratios.\n maximums (List[int]): List of maximums values for each slot.\n values (List[int]): List of values\n\n Returns:\n List[int]: A list of integers guaranteed to sum to total.\n \"\"\"\n ratios = [ratio if _max else 0 for ratio, _max in zip(ratios, maximums)]\n total_ratio = sum(ratios)\n if not total_ratio:\n return values[:]\n total_remaining = total\n result: List[int] = []\n append = result.append\n for ratio, maximum, value in zip(ratios, maximums, values):\n if ratio and total_ratio > 0:\n distributed = min(maximum, round(ratio * total_remaining / total_ratio))\n append(value - distributed)\n total_remaining -= distributed\n total_ratio -= ratio\n else:\n append(value)\n return result\n\n\ndef ratio_distribute(\n total: int, ratios: List[int], minimums: Optional[List[int]] = None\n) -> List[int]:\n \"\"\"Distribute an integer total in to parts based on ratios.\n\n Args:\n total (int): The total to divide.\n ratios (List[int]): A list of integer ratios.\n minimums (List[int]): List of minimum values for each slot.\n\n Returns:\n List[int]: A list of integers guaranteed to sum to total.\n \"\"\"\n if minimums:\n ratios = [ratio if _min else 0 for ratio, _min in zip(ratios, minimums)]\n total_ratio = sum(ratios)\n assert total_ratio > 0, \"Sum of ratios must be > 0\"\n\n total_remaining = total\n distributed_total: List[int] = []\n append = distributed_total.append\n if minimums is None:\n _minimums = [0] * len(ratios)\n else:\n _minimums = minimums\n for ratio, minimum in zip(ratios, _minimums):\n if total_ratio > 0:\n distributed = max(minimum, ceil(ratio * total_remaining / total_ratio))\n else:\n distributed = total_remaining\n append(distributed)\n total_ratio -= ratio\n total_remaining -= distributed\n return distributed_total\n\n\nif __name__ == \"__main__\":\n from dataclasses import dataclass\n\n @dataclass\n class E:\n size: Optional[int] = None\n ratio: int = 1\n minimum_size: int = 1\n\n resolved = ratio_resolve(110, [E(None, 1, 1), E(None, 1, 1), E(None, 1, 1)])\n print(sum(resolved))\n",[],[213,919,920,921,1016,1050,1511,1992],"0b985506-67fc-11f0-bcbe-0224a6c84d84","_pick.py","0b9855ba-67fc-11f0-bcbe-0224a6c84d84",426,["D",1753299267236],"from typing import Optional\n\n\ndef pick_bool(*values: Optional[bool]) -> bool:\n \"\"\"Pick the first non-none bool or return the last value.\n\n Args:\n *values (bool): Any number of boolean or None values.\n\n Returns:\n bool: First non-none boolean.\n \"\"\"\n assert values, \"1 or more values required\"\n for value in values:\n if value is not None:\n return value\n return bool(value)\n",[],[213,919,920,921,1016,1050,1511,2000],"0b89b686-67fc-11f0-9bd1-0224a6c84d84","_palettes.py","0b89b762-67fc-11f0-9bd1-0224a6c84d84",424,["D",1753299267143],"from .palette import Palette\n\n\n# Taken from https://en.wikipedia.org/wiki/ANSI_escape_code (Windows 10 column)\nWINDOWS_PALETTE = Palette(\n [\n (12, 12, 12),\n (197, 15, 31),\n (19, 161, 14),\n (193, 156, 0),\n (0, 55, 218),\n (136, 23, 152),\n (58, 150, 221),\n (204, 204, 204),\n (118, 118, 118),\n (231, 72, 86),\n (22, 198, 12),\n (249, 241, 165),\n (59, 120, 255),\n (180, 0, 158),\n (97, 214, 214),\n (242, 242, 242),\n ]\n)\n\n# # The standard ansi colors (including bright variants)\nSTANDARD_PALETTE = Palette(\n [\n (0, 0, 0),\n (170, 0, 0),\n (0, 170, 0),\n (170, 85, 0),\n (0, 0, 170),\n (170, 0, 170),\n (0, 170, 170),\n (170, 170, 170),\n (85, 85, 85),\n (255, 85, 85),\n (85, 255, 85),\n (255, 255, 85),\n (85, 85, 255),\n (255, 85, 255),\n (85, 255, 255),\n (255, 255, 255),\n ]\n)\n\n\n# The 256 color palette\nEIGHT_BIT_PALETTE = Palette(\n [\n (0, 0, 0),\n (128, 0, 0),\n (0, 128, 0),\n (128, 128, 0),\n (0, 0, 128),\n (128, 0, 128),\n (0, 128, 128),\n (192, 192, 192),\n (128, 128, 128),\n (255, 0, 0),\n (0, 255, 0),\n (255, 255, 0),\n (0, 0, 255),\n (255, 0, 255),\n (0, 255, 255),\n (255, 255, 255),\n (0, 0, 0),\n (0, 0, 95),\n (0, 0, 135),\n (0, 0, 175),\n (0, 0, 215),\n (0, 0, 255),\n (0, 95, 0),\n (0, 95, 95),\n (0, 95, 135),\n (0, 95, 175),\n (0, 95, 215),\n (0, 95, 255),\n (0, 135, 0),\n (0, 135, 95),\n (0, 135, 135),\n (0, 135, 175),\n (0, 135, 215),\n (0, 135, 255),\n (0, 175, 0),\n (0, 175, 95),\n (0, 175, 135),\n (0, 175, 175),\n (0, 175, 215),\n (0, 175, 255),\n (0, 215, 0),\n (0, 215, 95),\n (0, 215, 135),\n (0, 215, 175),\n (0, 215, 215),\n (0, 215, 255),\n (0, 255, 0),\n (0, 255, 95),\n (0, 255, 135),\n (0, 255, 175),\n (0, 255, 215),\n (0, 255, 255),\n (95, 0, 0),\n (95, 0, 95),\n (95, 0, 135),\n (95, 0, 175),\n (95, 0, 215),\n (95, 0, 255),\n (95, 95, 0),\n (95, 95, 95),\n (95, 95, 135),\n (95, 95, 175),\n (95, 95, 215),\n (95, 95, 255),\n (95, 135, 0),\n (95, 135, 95),\n (95, 135, 135),\n (95, 135, 175),\n (95, 135, 215),\n (95, 135, 255),\n (95, 175, 0),\n (95, 175, 95),\n (95, 175, 135),\n (95, 175, 175),\n (95, 175, 215),\n (95, 175, 255),\n (95, 215, 0),\n (95, 215, 95),\n (95, 215, 135),\n (95, 215, 175),\n (95, 215, 215),\n (95, 215, 255),\n (95, 255, 0),\n (95, 255, 95),\n (95, 255, 135),\n (95, 255, 175),\n (95, 255, 215),\n (95, 255, 255),\n (135, 0, 0),\n (135, 0, 95),\n (135, 0, 135),\n (135, 0, 175),\n (135, 0, 215),\n (135, 0, 255),\n (135, 95, 0),\n (135, 95, 95),\n (135, 95, 135),\n (135, 95, 175),\n (135, 95, 215),\n (135, 95, 255),\n (135, 135, 0),\n (135, 135, 95),\n (135, 135, 135),\n (135, 135, 175),\n (135, 135, 215),\n (135, 135, 255),\n (135, 175, 0),\n (135, 175, 95),\n (135, 175, 135),\n (135, 175, 175),\n (135, 175, 215),\n (135, 175, 255),\n (135, 215, 0),\n (135, 215, 95),\n (135, 215, 135),\n (135, 215, 175),\n (135, 215, 215),\n (135, 215, 255),\n (135, 255, 0),\n (135, 255, 95),\n (135, 255, 135),\n (135, 255, 175),\n (135, 255, 215),\n (135, 255, 255),\n (175, 0, 0),\n (175, 0, 95),\n (175, 0, 135),\n (175, 0, 175),\n (175, 0, 215),\n (175, 0, 255),\n (175, 95, 0),\n (175, 95, 95),\n (175, 95, 135),\n (175, 95, 175),\n (175, 95, 215),\n (175, 95, 255),\n (175, 135, 0),\n (175, 135, 95),\n (175, 135, 135),\n (175, 135, 175),\n (175, 135, 215),\n (175, 135, 255),\n (175, 175, 0),\n (175, 175, 95),\n (175, 175, 135),\n (175, 175, 175),\n (175, 175, 215),\n (175, 175, 255),\n (175, 215, 0),\n (175, 215, 95),\n (175, 215, 135),\n (175, 215, 175),\n (175, 215, 215),\n (175, 215, 255),\n (175, 255, 0),\n (175, 255, 95),\n (175, 255, 135),\n (175, 255, 175),\n (175, 255, 215),\n (175, 255, 255),\n (215, 0, 0),\n (215, 0, 95),\n (215, 0, 135),\n (215, 0, 175),\n (215, 0, 215),\n (215, 0, 255),\n (215, 95, 0),\n (215, 95, 95),\n (215, 95, 135),\n (215, 95, 175),\n (215, 95, 215),\n (215, 95, 255),\n (215, 135, 0),\n (215, 135, 95),\n (215, 135, 135),\n (215, 135, 175),\n (215, 135, 215),\n (215, 135, 255),\n (215, 175, 0),\n (215, 175, 95),\n (215, 175, 135),\n (215, 175, 175),\n (215, 175, 215),\n (215, 175, 255),\n (215, 215, 0),\n (215, 215, 95),\n (215, 215, 135),\n (215, 215, 175),\n (215, 215, 215),\n (215, 215, 255),\n (215, 255, 0),\n (215, 255, 95),\n (215, 255, 135),\n (215, 255, 175),\n (215, 255, 215),\n (215, 255, 255),\n (255, 0, 0),\n (255, 0, 95),\n (255, 0, 135),\n (255, 0, 175),\n (255, 0, 215),\n (255, 0, 255),\n (255, 95, 0),\n (255, 95, 95),\n (255, 95, 135),\n (255, 95, 175),\n (255, 95, 215),\n (255, 95, 255),\n (255, 135, 0),\n (255, 135, 95),\n (255, 135, 135),\n (255, 135, 175),\n (255, 135, 215),\n (255, 135, 255),\n (255, 175, 0),\n (255, 175, 95),\n (255, 175, 135),\n (255, 175, 175),\n (255, 175, 215),\n (255, 175, 255),\n (255, 215, 0),\n (255, 215, 95),\n (255, 215, 135),\n (255, 215, 175),\n (255, 215, 215),\n (255, 215, 255),\n (255, 255, 0),\n (255, 255, 95),\n (255, 255, 135),\n (255, 255, 175),\n (255, 255, 215),\n (255, 255, 255),\n (8, 8, 8),\n (18, 18, 18),\n (28, 28, 28),\n (38, 38, 38),\n (48, 48, 48),\n (58, 58, 58),\n (68, 68, 68),\n (78, 78, 78),\n (88, 88, 88),\n (98, 98, 98),\n (108, 108, 108),\n (118, 118, 118),\n (128, 128, 128),\n (138, 138, 138),\n (148, 148, 148),\n (158, 158, 158),\n (168, 168, 168),\n (178, 178, 178),\n (188, 188, 188),\n (198, 198, 198),\n (208, 208, 208),\n (218, 218, 218),\n (228, 228, 228),\n (238, 238, 238),\n ]\n)\n",[],[213,919,920,921,1016,1050,1511,2008],"0b8517a2-67fc-11f0-a99a-0224a6c84d84","_null_file.py","0b85184c-67fc-11f0-a99a-0224a6c84d84",423,["D",1753299267110],"from types import TracebackType\nfrom typing import IO, Iterable, Iterator, List, Optional, Type\n\n\nclass NullFile(IO[str]):\n def close(self) -> None:\n pass\n\n def isatty(self) -> bool:\n return False\n\n def read(self, __n: int = 1) -> str:\n return \"\"\n\n def readable(self) -> bool:\n return False\n\n def readline(self, __limit: int = 1) -> str:\n return \"\"\n\n def readlines(self, __hint: int = 1) -> List[str]:\n return []\n\n def seek(self, __offset: int, __whence: int = 1) -> int:\n return 0\n\n def seekable(self) -> bool:\n return False\n\n def tell(self) -> int:\n return 0\n\n def truncate(self, __size: Optional[int] = 1) -> int:\n return 0\n\n def writable(self) -> bool:\n return False\n\n def writelines(self, __lines: Iterable[str]) -> None:\n pass\n\n def __next__(self) -> str:\n return \"\"\n\n def __iter__(self) -> Iterator[str]:\n return iter([\"\"])\n\n def __enter__(self) -> IO[str]:\n return self\n\n def __exit__(\n self,\n __t: Optional[Type[BaseException]],\n __value: Optional[BaseException],\n __traceback: Optional[TracebackType],\n ) -> None:\n pass\n\n def write(self, text: str) -> int:\n return 0\n\n def flush(self) -> None:\n pass\n\n def fileno(self) -> int:\n return -1\n\n\nNULL_FILE = NullFile()\n",[],[213,919,920,921,1016,1050,1511,2016],"0b71df02-67fc-11f0-8d4e-0224a6c84d84","_loop.py","0b71dfb6-67fc-11f0-8d4e-0224a6c84d84",420,["D",1753299266970],"from typing import Iterable, Tuple, TypeVar\n\nT = TypeVar(\"T\")\n\n\ndef loop_first(values: Iterable[T]) -> Iterable[Tuple[bool, T]]:\n \"\"\"Iterate and generate a tuple with a flag for first value.\"\"\"\n iter_values = iter(values)\n try:\n value = next(iter_values)\n except StopIteration:\n return\n yield True, value\n for value in iter_values:\n yield False, value\n\n\ndef loop_last(values: Iterable[T]) -> Iterable[Tuple[bool, T]]:\n \"\"\"Iterate and generate a tuple with a flag for last value.\"\"\"\n iter_values = iter(values)\n try:\n previous_value = next(iter_values)\n except StopIteration:\n return\n for value in iter_values:\n yield False, previous_value\n previous_value = value\n yield True, previous_value\n\n\ndef loop_first_last(values: Iterable[T]) -> Iterable[Tuple[bool, bool, T]]:\n \"\"\"Iterate and generate a tuple with a flag for first and last value.\"\"\"\n iter_values = iter(values)\n try:\n previous_value = next(iter_values)\n except StopIteration:\n return\n first = True\n for value in iter_values:\n yield first, False, previous_value\n first = False\n previous_value = value\n yield first, True, previous_value\n",[],[213,919,920,921,1016,1050,1511,2024],"0b441ea0-67fc-11f0-8d4e-0224a6c84d84","_log_render.py","0b441f68-67fc-11f0-8d4e-0224a6c84d84",412,["D",1753299266650],"from datetime import datetime\nfrom typing import Iterable, List, Optional, TYPE_CHECKING, Union, Callable\n\n\nfrom .text import Text, TextType\n\nif TYPE_CHECKING:\n from .console import Console, ConsoleRenderable, RenderableType\n from .table import Table\n\nFormatTimeCallable = Callable[[datetime], Text]\n\n\nclass LogRender:\n def __init__(\n self,\n show_time: bool = True,\n show_level: bool = False,\n show_path: bool = True,\n time_format: Union[str, FormatTimeCallable] = \"[%x %X]\",\n omit_repeated_times: bool = True,\n level_width: Optional[int] = 8,\n ) -> None:\n self.show_time = show_time\n self.show_level = show_level\n self.show_path = show_path\n self.time_format = time_format\n self.omit_repeated_times = omit_repeated_times\n self.level_width = level_width\n self._last_time: Optional[Text] = None\n\n def __call__(\n self,\n console: \"Console\",\n renderables: Iterable[\"ConsoleRenderable\"],\n log_time: Optional[datetime] = None,\n time_format: Optional[Union[str, FormatTimeCallable]] = None,\n level: TextType = \"\",\n path: Optional[str] = None,\n line_no: Optional[int] = None,\n link_path: Optional[str] = None,\n ) -> \"Table\":\n from .containers import Renderables\n from .table import Table\n\n output = Table.grid(padding=(0, 1))\n output.expand = True\n if self.show_time:\n output.add_column(style=\"log.time\")\n if self.show_level:\n output.add_column(style=\"log.level\", width=self.level_width)\n output.add_column(ratio=1, style=\"log.message\", overflow=\"fold\")\n if self.show_path and path:\n output.add_column(style=\"log.path\")\n row: List[\"RenderableType\"] = []\n if self.show_time:\n log_time = log_time or console.get_datetime()\n time_format = time_format or self.time_format\n if callable(time_format):\n log_time_display = time_format(log_time)\n else:\n log_time_display = Text(log_time.strftime(time_format))\n if log_time_display == self._last_time and self.omit_repeated_times:\n row.append(Text(\" \" * len(log_time_display)))\n else:\n row.append(log_time_display)\n self._last_time = log_time_display\n if self.show_level:\n row.append(level)\n\n row.append(Renderables(renderables))\n if self.show_path and path:\n path_text = Text()\n path_text.append(\n path, style=f\"link file://{link_path}\" if link_path else \"\"\n )\n if line_no:\n path_text.append(\":\")\n path_text.append(\n f\"{line_no}\",\n style=f\"link file://{link_path}#{line_no}\" if link_path else \"\",\n )\n row.append(path_text)\n\n output.add_row(*row)\n return output\n\n\nif __name__ == \"__main__\": # pragma: no cover\n from pip._vendor.rich.console import Console\n\n c = Console()\n c.print(\"[on blue]Hello\", justify=\"right\")\n c.log(\"[on blue]hello\", justify=\"right\")\n",[],[213,919,920,921,1016,1050,1511,2032],"0bd4faa6-67fc-11f0-a319-0224a6c84d84","_inspect.py","0bd4fb78-67fc-11f0-a319-0224a6c84d84",437,["D",1753299267628],"import inspect\nfrom inspect import cleandoc, getdoc, getfile, isclass, ismodule, signature\nfrom typing import Any, Collection, Iterable, Optional, Tuple, Type, Union\n\nfrom .console import Group, RenderableType\nfrom .control import escape_control_codes\nfrom .highlighter import ReprHighlighter\nfrom .jupyter import JupyterMixin\nfrom .panel import Panel\nfrom .pretty import Pretty\nfrom .table import Table\nfrom .text import Text, TextType\n\n\ndef _first_paragraph(doc: str) -> str:\n \"\"\"Get the first paragraph from a docstring.\"\"\"\n paragraph, _, _ = doc.partition(\"\\n\\n\")\n return paragraph\n\n\nclass Inspect(JupyterMixin):\n \"\"\"A renderable to inspect any Python Object.\n\n Args:\n obj (Any): An object to inspect.\n title (str, optional): Title to display over inspect result, or None use type. Defaults to None.\n help (bool, optional): Show full help text rather than just first paragraph. Defaults to False.\n methods (bool, optional): Enable inspection of callables. Defaults to False.\n docs (bool, optional): Also render doc strings. Defaults to True.\n private (bool, optional): Show private attributes (beginning with underscore). Defaults to False.\n dunder (bool, optional): Show attributes starting with double underscore. Defaults to False.\n sort (bool, optional): Sort attributes alphabetically. Defaults to True.\n all (bool, optional): Show all attributes. Defaults to False.\n value (bool, optional): Pretty print value of object. Defaults to True.\n \"\"\"\n\n def __init__(\n self,\n obj: Any,\n *,\n title: Optional[TextType] = None,\n help: bool = False,\n methods: bool = False,\n docs: bool = True,\n private: bool = False,\n dunder: bool = False,\n sort: bool = True,\n all: bool = True,\n value: bool = True,\n ) -> None:\n self.highlighter = ReprHighlighter()\n self.obj = obj\n self.title = title or self._make_title(obj)\n if all:\n methods = private = dunder = True\n self.help = help\n self.methods = methods\n self.docs = docs or help\n self.private = private or dunder\n self.dunder = dunder\n self.sort = sort\n self.value = value\n\n def _make_title(self, obj: Any) -> Text:\n \"\"\"Make a default title.\"\"\"\n title_str = (\n str(obj)\n if (isclass(obj) or callable(obj) or ismodule(obj))\n else str(type(obj))\n )\n title_text = self.highlighter(title_str)\n return title_text\n\n def __rich__(self) -> Panel:\n return Panel.fit(\n Group(*self._render()),\n title=self.title,\n border_style=\"scope.border\",\n padding=(0, 1),\n )\n\n def _get_signature(self, name: str, obj: Any) -> Optional[Text]:\n \"\"\"Get a signature for a callable.\"\"\"\n try:\n _signature = str(signature(obj)) + \":\"\n except ValueError:\n _signature = \"(...)\"\n except TypeError:\n return None\n\n source_filename: Optional[str] = None\n try:\n source_filename = getfile(obj)\n except (OSError, TypeError):\n # OSError is raised if obj has no source file, e.g. when defined in REPL.\n pass\n\n callable_name = Text(name, style=\"inspect.callable\")\n if source_filename:\n callable_name.stylize(f\"link file://{source_filename}\")\n signature_text = self.highlighter(_signature)\n\n qualname = name or getattr(obj, \"__qualname__\", name)\n\n # If obj is a module, there may be classes (which are callable) to display\n if inspect.isclass(obj):\n prefix = \"class\"\n elif inspect.iscoroutinefunction(obj):\n prefix = \"async def\"\n else:\n prefix = \"def\"\n\n qual_signature = Text.assemble(\n (f\"{prefix} \", f\"inspect.{prefix.replace(' ', '_')}\"),\n (qualname, \"inspect.callable\"),\n signature_text,\n )\n\n return qual_signature\n\n def _render(self) -> Iterable[RenderableType]:\n \"\"\"Render object.\"\"\"\n\n def sort_items(item: Tuple[str, Any]) -> Tuple[bool, str]:\n key, (_error, value) = item\n return (callable(value), key.strip(\"_\").lower())\n\n def safe_getattr(attr_name: str) -> Tuple[Any, Any]:\n \"\"\"Get attribute or any exception.\"\"\"\n try:\n return (None, getattr(obj, attr_name))\n except Exception as error:\n return (error, None)\n\n obj = self.obj\n keys = dir(obj)\n total_items = len(keys)\n if not self.dunder:\n keys = [key for key in keys if not key.startswith(\"__\")]\n if not self.private:\n keys = [key for key in keys if not key.startswith(\"_\")]\n not_shown_count = total_items - len(keys)\n items = [(key, safe_getattr(key)) for key in keys]\n if self.sort:\n items.sort(key=sort_items)\n\n items_table = Table.grid(padding=(0, 1), expand=False)\n items_table.add_column(justify=\"right\")\n add_row = items_table.add_row\n highlighter = self.highlighter\n\n if callable(obj):\n signature = self._get_signature(\"\", obj)\n if signature is not None:\n yield signature\n yield \"\"\n\n if self.docs:\n _doc = self._get_formatted_doc(obj)\n if _doc is not None:\n doc_text = Text(_doc, style=\"inspect.help\")\n doc_text = highlighter(doc_text)\n yield doc_text\n yield \"\"\n\n if self.value and not (isclass(obj) or callable(obj) or ismodule(obj)):\n yield Panel(\n Pretty(obj, indent_guides=True, max_length=10, max_string=60),\n border_style=\"inspect.value.border\",\n )\n yield \"\"\n\n for key, (error, value) in items:\n key_text = Text.assemble(\n (\n key,\n \"inspect.attr.dunder\" if key.startswith(\"__\") else \"inspect.attr\",\n ),\n (\" =\", \"inspect.equals\"),\n )\n if error is not None:\n warning = key_text.copy()\n warning.stylize(\"inspect.error\")\n add_row(warning, highlighter(repr(error)))\n continue\n\n if callable(value):\n if not self.methods:\n continue\n\n _signature_text = self._get_signature(key, value)\n if _signature_text is None:\n add_row(key_text, Pretty(value, highlighter=highlighter))\n else:\n if self.docs:\n docs = self._get_formatted_doc(value)\n if docs is not None:\n _signature_text.append(\"\\n\" if \"\\n\" in docs else \" \")\n doc = highlighter(docs)\n doc.stylize(\"inspect.doc\")\n _signature_text.append(doc)\n\n add_row(key_text, _signature_text)\n else:\n add_row(key_text, Pretty(value, highlighter=highlighter))\n if items_table.row_count:\n yield items_table\n elif not_shown_count:\n yield Text.from_markup(\n f\"[b cyan]{not_shown_count}[/][i] attribute(s) not shown.[/i] \"\n f\"Run [b][magenta]inspect[/]([not b]inspect[/])[/b] for options.\"\n )\n\n def _get_formatted_doc(self, object_: Any) -> Optional[str]:\n \"\"\"\n Extract the docstring of an object, process it and returns it.\n The processing consists in cleaning up the doctring's indentation,\n taking only its 1st paragraph if `self.help` is not True,\n and escape its control codes.\n\n Args:\n object_ (Any): the object to get the docstring from.\n\n Returns:\n Optional[str]: the processed docstring, or None if no docstring was found.\n \"\"\"\n docs = getdoc(object_)\n if docs is None:\n return None\n docs = cleandoc(docs).strip()\n if not self.help:\n docs = _first_paragraph(docs)\n return escape_control_codes(docs)\n\n\ndef get_object_types_mro(obj: Union[object, Type[Any]]) -> Tuple[type, ...]:\n \"\"\"Returns the MRO of an object's class, or of the object itself if it's a class.\"\"\"\n if not hasattr(obj, \"__mro__\"):\n # N.B. we cannot use `if type(obj) is type` here because it doesn't work with\n # some types of classes, such as the ones that use abc.ABCMeta.\n obj = type(obj)\n return getattr(obj, \"__mro__\", ())\n\n\ndef get_object_types_mro_as_strings(obj: object) -> Collection[str]:\n \"\"\"\n Returns the MRO of an object's class as full qualified names, or of the object itself if it's a class.\n\n Examples:\n `object_types_mro_as_strings(JSONDecoder)` will return `['json.decoder.JSONDecoder', 'builtins.object']`\n \"\"\"\n return [\n f'{getattr(type_, \"__module__\", \"\")}.{getattr(type_, \"__qualname__\", \"\")}'\n for type_ in get_object_types_mro(obj)\n ]\n\n\ndef is_object_one_of_types(\n obj: object, fully_qualified_types_names: Collection[str]\n) -> bool:\n \"\"\"\n Returns `True` if the given object's class (or the object itself, if it's a class) has one of the\n fully qualified names in its MRO.\n \"\"\"\n for type_name in get_object_types_mro_as_strings(obj):\n if type_name in fully_qualified_types_names:\n return True\n return False\n",[],[213,919,920,921,1016,1050,1511,2040],"0b393f08-67fc-11f0-a7d9-0224a6c84d84","_fileno.py","0b393fa8-67fc-11f0-a7d9-0224a6c84d84",410,["D",1753299266442],"from __future__ import annotations\n\nfrom typing import IO, Callable\n\n\ndef get_fileno(file_like: IO[str]) -> int | None:\n \"\"\"Get fileno() from a file, accounting for poorly implemented file-like objects.\n\n Args:\n file_like (IO): A file-like object.\n\n Returns:\n int | None: The result of fileno if available, or None if operation failed.\n \"\"\"\n fileno: Callable[[], int] | None = getattr(file_like, \"fileno\", None)\n if fileno is not None:\n try:\n return fileno()\n except Exception:\n # `fileno` is documented as potentially raising a OSError\n # Alas, from the issues, there are so many poorly implemented file-like objects,\n # that `fileno()` can raise just about anything.\n return None\n return None\n",[],[213,919,920,921,1016,1050,1511,2048],"0ca59148-67fc-11f0-a7d9-0224a6c84d84","_extension.py","0ca59224-67fc-11f0-a7d9-0224a6c84d84",468,["D",1753299268925],"from typing import Any\n\n\ndef load_ipython_extension(ip: Any) -> None: # pragma: no cover\n # prevent circular import\n from pip._vendor.rich.pretty import install\n from pip._vendor.rich.traceback import install as tr_install\n\n install()\n tr_install()\n",[],[213,919,920,921,1016,1050,1511,2056],"0c125e50-67fc-11f0-bcbe-0224a6c84d84","_export_format.py","0c125f04-67fc-11f0-bcbe-0224a6c84d84",446,["D",1753299268035],"CONSOLE_HTML_FORMAT = \"\"\"\\\n\n\n\n\n\n\n\n

{code}

\n\n\n\"\"\"\n\nCONSOLE_SVG_FORMAT = \"\"\"\\\n\n\"\"\"\n\n_SVG_FONT_FAMILY = \"Rich Fira Code\"\n_SVG_CLASSES_PREFIX = \"rich-svg\"\n",[],[213,919,920,921,1016,1050,1511,2064],"0b5ea87e-67fc-11f0-a7d9-0224a6c84d84","_emoji_replace.py","0b5ea978-67fc-11f0-a7d9-0224a6c84d84",416,["D",1753299266856],"from typing import Callable, Match, Optional\nimport re\n\nfrom ._emoji_codes import EMOJI\n\n\n_ReStringMatch = Match[str] # regex match object\n_ReSubCallable = Callable[[_ReStringMatch], str] # Callable invoked by re.sub\n_EmojiSubMethod = Callable[[_ReSubCallable, str], str] # Sub method of a compiled re\n\n\ndef _emoji_replace(\n text: str,\n default_variant: Optional[str] = None,\n _emoji_sub: _EmojiSubMethod = re.compile(r\"(:(\\S*?)(?:(?:\\-)(emoji|text))?:)\").sub,\n) -> str:\n \"\"\"Replace emoji code in text.\"\"\"\n get_emoji = EMOJI.__getitem__\n variants = {\"text\": \"\\uFE0E\", \"emoji\": \"\\uFE0F\"}\n get_variant = variants.get\n default_variant_code = variants.get(default_variant, \"\") if default_variant else \"\"\n\n def do_replace(match: Match[str]) -> str:\n emoji_code, emoji_name, variant = match.groups()\n try:\n return get_emoji(emoji_name.lower()) + get_variant(\n variant, default_variant_code\n )\n except KeyError:\n return emoji_code\n\n return _emoji_sub(do_replace, text)\n",[],[213,919,920,921,1016,1050,1511,2072],"0c54dcc6-67fc-11f0-95df-0224a6c84d84","_cell_widths.py","0c54dd8e-67fc-11f0-95df-0224a6c84d84",456,["D",1753299268473],"# Auto generated by make_terminal_widths.py\n\nCELL_WIDTHS = [\n (0, 0, 0),\n (1, 31, -1),\n (127, 159, -1),\n (173, 173, 0),\n (768, 879, 0),\n (1155, 1161, 0),\n (1425, 1469, 0),\n (1471, 1471, 0),\n (1473, 1474, 0),\n (1476, 1477, 0),\n (1479, 1479, 0),\n (1536, 1541, 0),\n (1552, 1562, 0),\n (1564, 1564, 0),\n (1611, 1631, 0),\n (1648, 1648, 0),\n (1750, 1757, 0),\n (1759, 1764, 0),\n (1767, 1768, 0),\n (1770, 1773, 0),\n (1807, 1807, 0),\n (1809, 1809, 0),\n (1840, 1866, 0),\n (1958, 1968, 0),\n (2027, 2035, 0),\n (2045, 2045, 0),\n (2070, 2073, 0),\n (2075, 2083, 0),\n (2085, 2087, 0),\n (2089, 2093, 0),\n (2137, 2139, 0),\n (2192, 2193, 0),\n (2200, 2207, 0),\n (2250, 2307, 0),\n (2362, 2364, 0),\n (2366, 2383, 0),\n (2385, 2391, 0),\n (2402, 2403, 0),\n (2433, 2435, 0),\n (2492, 2492, 0),\n (2494, 2500, 0),\n (2503, 2504, 0),\n (2507, 2509, 0),\n (2519, 2519, 0),\n (2530, 2531, 0),\n (2558, 2558, 0),\n (2561, 2563, 0),\n (2620, 2620, 0),\n (2622, 2626, 0),\n (2631, 2632, 0),\n (2635, 2637, 0),\n (2641, 2641, 0),\n (2672, 2673, 0),\n (2677, 2677, 0),\n (2689, 2691, 0),\n (2748, 2748, 0),\n (2750, 2757, 0),\n (2759, 2761, 0),\n (2763, 2765, 0),\n (2786, 2787, 0),\n (2810, 2815, 0),\n (2817, 2819, 0),\n (2876, 2876, 0),\n (2878, 2884, 0),\n (2887, 2888, 0),\n (2891, 2893, 0),\n (2901, 2903, 0),\n (2914, 2915, 0),\n (2946, 2946, 0),\n (3006, 3010, 0),\n (3014, 3016, 0),\n (3018, 3021, 0),\n (3031, 3031, 0),\n (3072, 3076, 0),\n (3132, 3132, 0),\n (3134, 3140, 0),\n (3142, 3144, 0),\n (3146, 3149, 0),\n (3157, 3158, 0),\n (3170, 3171, 0),\n (3201, 3203, 0),\n (3260, 3260, 0),\n (3262, 3268, 0),\n (3270, 3272, 0),\n (3274, 3277, 0),\n (3285, 3286, 0),\n (3298, 3299, 0),\n (3315, 3315, 0),\n (3328, 3331, 0),\n (3387, 3388, 0),\n (3390, 3396, 0),\n (3398, 3400, 0),\n (3402, 3405, 0),\n (3415, 3415, 0),\n (3426, 3427, 0),\n (3457, 3459, 0),\n (3530, 3530, 0),\n (3535, 3540, 0),\n (3542, 3542, 0),\n (3544, 3551, 0),\n (3570, 3571, 0),\n (3633, 3633, 0),\n (3636, 3642, 0),\n (3655, 3662, 0),\n (3761, 3761, 0),\n (3764, 3772, 0),\n (3784, 3790, 0),\n (3864, 3865, 0),\n (3893, 3893, 0),\n (3895, 3895, 0),\n (3897, 3897, 0),\n (3902, 3903, 0),\n (3953, 3972, 0),\n (3974, 3975, 0),\n (3981, 3991, 0),\n (3993, 4028, 0),\n (4038, 4038, 0),\n (4139, 4158, 0),\n (4182, 4185, 0),\n (4190, 4192, 0),\n (4194, 4196, 0),\n (4199, 4205, 0),\n (4209, 4212, 0),\n (4226, 4237, 0),\n (4239, 4239, 0),\n (4250, 4253, 0),\n (4352, 4447, 2),\n (4448, 4607, 0),\n (4957, 4959, 0),\n (5906, 5909, 0),\n (5938, 5940, 0),\n (5970, 5971, 0),\n (6002, 6003, 0),\n (6068, 6099, 0),\n (6109, 6109, 0),\n (6155, 6159, 0),\n (6277, 6278, 0),\n (6313, 6313, 0),\n (6432, 6443, 0),\n (6448, 6459, 0),\n (6679, 6683, 0),\n (6741, 6750, 0),\n (6752, 6780, 0),\n (6783, 6783, 0),\n (6832, 6862, 0),\n (6912, 6916, 0),\n (6964, 6980, 0),\n (7019, 7027, 0),\n (7040, 7042, 0),\n (7073, 7085, 0),\n (7142, 7155, 0),\n (7204, 7223, 0),\n (7376, 7378, 0),\n (7380, 7400, 0),\n (7405, 7405, 0),\n (7412, 7412, 0),\n (7415, 7417, 0),\n (7616, 7679, 0),\n (8203, 8207, 0),\n (8232, 8238, 0),\n (8288, 8292, 0),\n (8294, 8303, 0),\n (8400, 8432, 0),\n (8986, 8987, 2),\n (9001, 9002, 2),\n (9193, 9196, 2),\n (9200, 9200, 2),\n (9203, 9203, 2),\n (9725, 9726, 2),\n (9748, 9749, 2),\n (9800, 9811, 2),\n (9855, 9855, 2),\n (9875, 9875, 2),\n (9889, 9889, 2),\n (9898, 9899, 2),\n (9917, 9918, 2),\n (9924, 9925, 2),\n (9934, 9934, 2),\n (9940, 9940, 2),\n (9962, 9962, 2),\n (9970, 9971, 2),\n (9973, 9973, 2),\n (9978, 9978, 2),\n (9981, 9981, 2),\n (9989, 9989, 2),\n (9994, 9995, 2),\n (10024, 10024, 2),\n (10060, 10060, 2),\n (10062, 10062, 2),\n (10067, 10069, 2),\n (10071, 10071, 2),\n (10133, 10135, 2),\n (10160, 10160, 2),\n (10175, 10175, 2),\n (11035, 11036, 2),\n (11088, 11088, 2),\n (11093, 11093, 2),\n (11503, 11505, 0),\n (11647, 11647, 0),\n (11744, 11775, 0),\n (11904, 11929, 2),\n (11931, 12019, 2),\n (12032, 12245, 2),\n (12272, 12329, 2),\n (12330, 12335, 0),\n (12336, 12350, 2),\n (12353, 12438, 2),\n (12441, 12442, 0),\n (12443, 12543, 2),\n (12549, 12591, 2),\n (12593, 12686, 2),\n (12688, 12771, 2),\n (12783, 12830, 2),\n (12832, 12871, 2),\n (12880, 19903, 2),\n (19968, 42124, 2),\n (42128, 42182, 2),\n (42607, 42610, 0),\n (42612, 42621, 0),\n (42654, 42655, 0),\n (42736, 42737, 0),\n (43010, 43010, 0),\n (43014, 43014, 0),\n (43019, 43019, 0),\n (43043, 43047, 0),\n (43052, 43052, 0),\n (43136, 43137, 0),\n (43188, 43205, 0),\n (43232, 43249, 0),\n (43263, 43263, 0),\n (43302, 43309, 0),\n (43335, 43347, 0),\n (43360, 43388, 2),\n (43392, 43395, 0),\n (43443, 43456, 0),\n (43493, 43493, 0),\n (43561, 43574, 0),\n (43587, 43587, 0),\n (43596, 43597, 0),\n (43643, 43645, 0),\n (43696, 43696, 0),\n (43698, 43700, 0),\n (43703, 43704, 0),\n (43710, 43711, 0),\n (43713, 43713, 0),\n (43755, 43759, 0),\n (43765, 43766, 0),\n (44003, 44010, 0),\n (44012, 44013, 0),\n (44032, 55203, 2),\n (55216, 55295, 0),\n (63744, 64255, 2),\n (64286, 64286, 0),\n (65024, 65039, 0),\n (65040, 65049, 2),\n (65056, 65071, 0),\n (65072, 65106, 2),\n (65108, 65126, 2),\n (65128, 65131, 2),\n (65279, 65279, 0),\n (65281, 65376, 2),\n (65504, 65510, 2),\n (65529, 65531, 0),\n (66045, 66045, 0),\n (66272, 66272, 0),\n (66422, 66426, 0),\n (68097, 68099, 0),\n (68101, 68102, 0),\n (68108, 68111, 0),\n (68152, 68154, 0),\n (68159, 68159, 0),\n (68325, 68326, 0),\n (68900, 68903, 0),\n (69291, 69292, 0),\n (69373, 69375, 0),\n (69446, 69456, 0),\n (69506, 69509, 0),\n (69632, 69634, 0),\n (69688, 69702, 0),\n (69744, 69744, 0),\n (69747, 69748, 0),\n (69759, 69762, 0),\n (69808, 69818, 0),\n (69821, 69821, 0),\n (69826, 69826, 0),\n (69837, 69837, 0),\n (69888, 69890, 0),\n (69927, 69940, 0),\n (69957, 69958, 0),\n (70003, 70003, 0),\n (70016, 70018, 0),\n (70067, 70080, 0),\n (70089, 70092, 0),\n (70094, 70095, 0),\n (70188, 70199, 0),\n (70206, 70206, 0),\n (70209, 70209, 0),\n (70367, 70378, 0),\n (70400, 70403, 0),\n (70459, 70460, 0),\n (70462, 70468, 0),\n (70471, 70472, 0),\n (70475, 70477, 0),\n (70487, 70487, 0),\n (70498, 70499, 0),\n (70502, 70508, 0),\n (70512, 70516, 0),\n (70709, 70726, 0),\n (70750, 70750, 0),\n (70832, 70851, 0),\n (71087, 71093, 0),\n (71096, 71104, 0),\n (71132, 71133, 0),\n (71216, 71232, 0),\n (71339, 71351, 0),\n (71453, 71467, 0),\n (71724, 71738, 0),\n (71984, 71989, 0),\n (71991, 71992, 0),\n (71995, 71998, 0),\n (72000, 72000, 0),\n (72002, 72003, 0),\n (72145, 72151, 0),\n (72154, 72160, 0),\n (72164, 72164, 0),\n (72193, 72202, 0),\n (72243, 72249, 0),\n (72251, 72254, 0),\n (72263, 72263, 0),\n (72273, 72283, 0),\n (72330, 72345, 0),\n (72751, 72758, 0),\n (72760, 72767, 0),\n (72850, 72871, 0),\n (72873, 72886, 0),\n (73009, 73014, 0),\n (73018, 73018, 0),\n (73020, 73021, 0),\n (73023, 73029, 0),\n (73031, 73031, 0),\n (73098, 73102, 0),\n (73104, 73105, 0),\n (73107, 73111, 0),\n (73459, 73462, 0),\n (73472, 73473, 0),\n (73475, 73475, 0),\n (73524, 73530, 0),\n (73534, 73538, 0),\n (78896, 78912, 0),\n (78919, 78933, 0),\n (92912, 92916, 0),\n (92976, 92982, 0),\n (94031, 94031, 0),\n (94033, 94087, 0),\n (94095, 94098, 0),\n (94176, 94179, 2),\n (94180, 94180, 0),\n (94192, 94193, 0),\n (94208, 100343, 2),\n (100352, 101589, 2),\n (101632, 101640, 2),\n (110576, 110579, 2),\n (110581, 110587, 2),\n (110589, 110590, 2),\n (110592, 110882, 2),\n (110898, 110898, 2),\n (110928, 110930, 2),\n (110933, 110933, 2),\n (110948, 110951, 2),\n (110960, 111355, 2),\n (113821, 113822, 0),\n (113824, 113827, 0),\n (118528, 118573, 0),\n (118576, 118598, 0),\n (119141, 119145, 0),\n (119149, 119170, 0),\n (119173, 119179, 0),\n (119210, 119213, 0),\n (119362, 119364, 0),\n (121344, 121398, 0),\n (121403, 121452, 0),\n (121461, 121461, 0),\n (121476, 121476, 0),\n (121499, 121503, 0),\n (121505, 121519, 0),\n (122880, 122886, 0),\n (122888, 122904, 0),\n (122907, 122913, 0),\n (122915, 122916, 0),\n (122918, 122922, 0),\n (123023, 123023, 0),\n (123184, 123190, 0),\n (123566, 123566, 0),\n (123628, 123631, 0),\n (124140, 124143, 0),\n (125136, 125142, 0),\n (125252, 125258, 0),\n (126980, 126980, 2),\n (127183, 127183, 2),\n (127374, 127374, 2),\n (127377, 127386, 2),\n (127488, 127490, 2),\n (127504, 127547, 2),\n (127552, 127560, 2),\n (127568, 127569, 2),\n (127584, 127589, 2),\n (127744, 127776, 2),\n (127789, 127797, 2),\n (127799, 127868, 2),\n (127870, 127891, 2),\n (127904, 127946, 2),\n (127951, 127955, 2),\n (127968, 127984, 2),\n (127988, 127988, 2),\n (127992, 127994, 2),\n (127995, 127999, 0),\n (128000, 128062, 2),\n (128064, 128064, 2),\n (128066, 128252, 2),\n (128255, 128317, 2),\n (128331, 128334, 2),\n (128336, 128359, 2),\n (128378, 128378, 2),\n (128405, 128406, 2),\n (128420, 128420, 2),\n (128507, 128591, 2),\n (128640, 128709, 2),\n (128716, 128716, 2),\n (128720, 128722, 2),\n (128725, 128727, 2),\n (128732, 128735, 2),\n (128747, 128748, 2),\n (128756, 128764, 2),\n (128992, 129003, 2),\n (129008, 129008, 2),\n (129292, 129338, 2),\n (129340, 129349, 2),\n (129351, 129535, 2),\n (129648, 129660, 2),\n (129664, 129672, 2),\n (129680, 129725, 2),\n (129727, 129733, 2),\n (129742, 129755, 2),\n (129760, 129768, 2),\n (129776, 129784, 2),\n (131072, 196605, 2),\n (196608, 262141, 2),\n (917505, 917505, 0),\n (917536, 917631, 0),\n (917760, 917999, 0),\n]\n",[],[213,919,920,921,1016,1050,1511,2080],"0ca06db2-67fc-11f0-aedf-0224a6c84d84","0ca06ea2-67fc-11f0-aedf-0224a6c84d84",467,["D",1753299268809],"import colorsys\nimport io\nfrom time import process_time\n\nfrom pip._vendor.rich import box\nfrom pip._vendor.rich.color import Color\nfrom pip._vendor.rich.console import Console, ConsoleOptions, Group, RenderableType, RenderResult\nfrom pip._vendor.rich.markdown import Markdown\nfrom pip._vendor.rich.measure import Measurement\nfrom pip._vendor.rich.pretty import Pretty\nfrom pip._vendor.rich.segment import Segment\nfrom pip._vendor.rich.style import Style\nfrom pip._vendor.rich.syntax import Syntax\nfrom pip._vendor.rich.table import Table\nfrom pip._vendor.rich.text import Text\n\n\nclass ColorBox:\n def __rich_console__(\n self, console: Console, options: ConsoleOptions\n ) -> RenderResult:\n for y in range(0, 5):\n for x in range(options.max_width):\n h = x / options.max_width\n l = 0.1 + ((y / 5) * 0.7)\n r1, g1, b1 = colorsys.hls_to_rgb(h, l, 1.0)\n r2, g2, b2 = colorsys.hls_to_rgb(h, l + 0.7 / 10, 1.0)\n bgcolor = Color.from_rgb(r1 * 255, g1 * 255, b1 * 255)\n color = Color.from_rgb(r2 * 255, g2 * 255, b2 * 255)\n yield Segment(\"▄\", Style(color=color, bgcolor=bgcolor))\n yield Segment.line()\n\n def __rich_measure__(\n self, console: \"Console\", options: ConsoleOptions\n ) -> Measurement:\n return Measurement(1, options.max_width)\n\n\ndef make_test_card() -> Table:\n \"\"\"Get a renderable that demonstrates a number of features.\"\"\"\n table = Table.grid(padding=1, pad_edge=True)\n table.title = \"Rich features\"\n table.add_column(\"Feature\", no_wrap=True, justify=\"center\", style=\"bold red\")\n table.add_column(\"Demonstration\")\n\n color_table = Table(\n box=None,\n expand=False,\n show_header=False,\n show_edge=False,\n pad_edge=False,\n )\n color_table.add_row(\n (\n \"✓ [bold green]4-bit color[/]\\n\"\n \"✓ [bold blue]8-bit color[/]\\n\"\n \"✓ [bold magenta]Truecolor (16.7 million)[/]\\n\"\n \"✓ [bold yellow]Dumb terminals[/]\\n\"\n \"✓ [bold cyan]Automatic color conversion\"\n ),\n ColorBox(),\n )\n\n table.add_row(\"Colors\", color_table)\n\n table.add_row(\n \"Styles\",\n \"All ansi styles: [bold]bold[/], [dim]dim[/], [italic]italic[/italic], [underline]underline[/], [strike]strikethrough[/], [reverse]reverse[/], and even [blink]blink[/].\",\n )\n\n lorem = \"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Quisque in metus sed sapien ultricies pretium a at justo. Maecenas luctus velit et auctor maximus.\"\n lorem_table = Table.grid(padding=1, collapse_padding=True)\n lorem_table.pad_edge = False\n lorem_table.add_row(\n Text(lorem, justify=\"left\", style=\"green\"),\n Text(lorem, justify=\"center\", style=\"yellow\"),\n Text(lorem, justify=\"right\", style=\"blue\"),\n Text(lorem, justify=\"full\", style=\"red\"),\n )\n table.add_row(\n \"Text\",\n Group(\n Text.from_markup(\n \"\"\"Word wrap text. Justify [green]left[/], [yellow]center[/], [blue]right[/] or [red]full[/].\\n\"\"\"\n ),\n lorem_table,\n ),\n )\n\n def comparison(renderable1: RenderableType, renderable2: RenderableType) -> Table:\n table = Table(show_header=False, pad_edge=False, box=None, expand=True)\n table.add_column(\"1\", ratio=1)\n table.add_column(\"2\", ratio=1)\n table.add_row(renderable1, renderable2)\n return table\n\n table.add_row(\n \"Asian\\nlanguage\\nsupport\",\n \":flag_for_china: 该库支持中文，日文和韩文文本！\\n:flag_for_japan: ライブラリは中国語、日本語、韓国語のテキストをサポートしています\\n:flag_for_south_korea: 이 라이브러리는 중국어, 일본어 및 한국어 텍스트를 지원합니다\",\n )\n\n markup_example = (\n \"[bold magenta]Rich[/] supports a simple [i]bbcode[/i]-like [b]markup[/b] for [yellow]color[/], [underline]style[/], and emoji! \"\n \":+1: :apple: :ant: :bear: :baguette_bread: :bus: \"\n )\n table.add_row(\"Markup\", markup_example)\n\n example_table = Table(\n show_edge=False,\n show_header=True,\n expand=False,\n row_styles=[\"none\", \"dim\"],\n box=box.SIMPLE,\n )\n example_table.add_column(\"[green]Date\", style=\"green\", no_wrap=True)\n example_table.add_column(\"[blue]Title\", style=\"blue\")\n example_table.add_column(\n \"[cyan]Production Budget\",\n style=\"cyan\",\n justify=\"right\",\n no_wrap=True,\n )\n example_table.add_column(\n \"[magenta]Box Office\",\n style=\"magenta\",\n justify=\"right\",\n no_wrap=True,\n )\n example_table.add_row(\n \"Dec 20, 2019\",\n \"Star Wars: The Rise of Skywalker\",\n \"$275,000,000\",\n \"$375,126,118\",\n )\n example_table.add_row(\n \"May 25, 2018\",\n \"[b]Solo[/]: A Star Wars Story\",\n \"$275,000,000\",\n \"$393,151,347\",\n )\n example_table.add_row(\n \"Dec 15, 2017\",\n \"Star Wars Ep. VIII: The Last Jedi\",\n \"$262,000,000\",\n \"[bold]$1,332,539,889[/bold]\",\n )\n example_table.add_row(\n \"May 19, 1999\",\n \"Star Wars Ep. [b]I[/b]: [i]The phantom Menace\",\n \"$115,000,000\",\n \"$1,027,044,677\",\n )\n\n table.add_row(\"Tables\", example_table)\n\n code = '''\\\ndef iter_last(values: Iterable[T]) -> Iterable[Tuple[bool, T]]:\n \"\"\"Iterate and generate a tuple with a flag for last value.\"\"\"\n iter_values = iter(values)\n try:\n previous_value = next(iter_values)\n except StopIteration:\n return\n for value in iter_values:\n yield False, previous_value\n previous_value = value\n yield True, previous_value'''\n\n pretty_data = {\n \"foo\": [\n 3.1427,\n (\n \"Paul Atreides\",\n \"Vladimir Harkonnen\",\n \"Thufir Hawat\",\n ),\n ],\n \"atomic\": (False, True, None),\n }\n table.add_row(\n \"Syntax\\nhighlighting\\n&\\npretty\\nprinting\",\n comparison(\n Syntax(code, \"python3\", line_numbers=True, indent_guides=True),\n Pretty(pretty_data, indent_guides=True),\n ),\n )\n\n markdown_example = \"\"\"\\\n# Markdown\n\nSupports much of the *markdown* __syntax__!\n\n- Headers\n- Basic formatting: **bold**, *italic*, `code`\n- Block quotes\n- Lists, and more...\n \"\"\"\n table.add_row(\n \"Markdown\", comparison(\"[cyan]\" + markdown_example, Markdown(markdown_example))\n )\n\n table.add_row(\n \"+more!\",\n \"\"\"Progress bars, columns, styled logging handler, tracebacks, etc...\"\"\",\n )\n return table\n\n\nif __name__ == \"__main__\": # pragma: no cover\n console = Console(\n file=io.StringIO(),\n force_terminal=True,\n )\n test_card = make_test_card()\n\n # Print once to warm cache\n start = process_time()\n console.print(test_card)\n pre_cache_taken = round((process_time() - start) * 1000.0, 1)\n\n console.file = io.StringIO()\n\n start = process_time()\n console.print(test_card)\n taken = round((process_time() - start) * 1000.0, 1)\n\n c = Console(record=True)\n c.print(test_card)\n\n print(f\"rendered in {pre_cache_taken}ms (cold cache)\")\n print(f\"rendered in {taken}ms (warm cache)\")\n\n from pip._vendor.rich.panel import Panel\n\n console = Console()\n\n sponsor_message = Table.grid(padding=1)\n sponsor_message.add_column(style=\"green\", justify=\"right\")\n sponsor_message.add_column(no_wrap=True)\n\n sponsor_message.add_row(\n \"Textualize\",\n \"[u blue link=https://github.com/textualize]https://github.com/textualize\",\n )\n sponsor_message.add_row(\n \"Twitter\",\n \"[u blue link=https://twitter.com/willmcgugan]https://twitter.com/willmcgugan\",\n )\n\n intro_message = Text.from_markup(\n \"\"\"\\\nWe hope you enjoy using Rich!\n\nRich is maintained with [red]:heart:[/] by [link=https://www.textualize.io]Textualize.io[/]\n\n- Will McGugan\"\"\"\n )\n\n message = Table.grid(padding=2)\n message.add_column()\n message.add_column(no_wrap=True)\n message.add_row(intro_message, sponsor_message)\n\n console.print(\n Panel.fit(\n message,\n box=box.ROUNDED,\n padding=(1, 2),\n title=\"[b red]Thanks for trying out Rich!\",\n border_style=\"bright_blue\",\n ),\n justify=\"center\",\n )\n",[],[213,919,920,921,1016,1050,1511,1026],"0b8dd126-67fc-11f0-a516-0224a6c84d84","0b8dd248-67fc-11f0-a516-0224a6c84d84",425,["D",1753299267165],"\"\"\"Rich text and beautiful formatting in the terminal.\"\"\"\n\nimport os\nfrom typing import IO, TYPE_CHECKING, Any, Callable, Optional, Union\n\nfrom ._extension import load_ipython_extension # noqa: F401\n\n__all__ = [\"get_console\", \"reconfigure\", \"print\", \"inspect\", \"print_json\"]\n\nif TYPE_CHECKING:\n from .console import Console\n\n# Global console used by alternative print\n_console: Optional[\"Console\"] = None\n\ntry:\n _IMPORT_CWD = os.path.abspath(os.getcwd())\nexcept FileNotFoundError:\n # Can happen if the cwd has been deleted\n _IMPORT_CWD = \"\"\n\n\ndef get_console() -> \"Console\":\n \"\"\"Get a global :class:`~rich.console.Console` instance. This function is used when Rich requires a Console,\n and hasn't been explicitly given one.\n\n Returns:\n Console: A console instance.\n \"\"\"\n global _console\n if _console is None:\n from .console import Console\n\n _console = Console()\n\n return _console\n\n\ndef reconfigure(*args: Any, **kwargs: Any) -> None:\n \"\"\"Reconfigures the global console by replacing it with another.\n\n Args:\n *args (Any): Positional arguments for the replacement :class:`~rich.console.Console`.\n **kwargs (Any): Keyword arguments for the replacement :class:`~rich.console.Console`.\n \"\"\"\n from pip._vendor.rich.console import Console\n\n new_console = Console(*args, **kwargs)\n _console = get_console()\n _console.__dict__ = new_console.__dict__\n\n\ndef print(\n *objects: Any,\n sep: str = \" \",\n end: str = \"\\n\",\n file: Optional[IO[str]] = None,\n flush: bool = False,\n) -> None:\n r\"\"\"Print object(s) supplied via positional arguments.\n This function has an identical signature to the built-in print.\n For more advanced features, see the :class:`~rich.console.Console` class.\n\n Args:\n sep (str, optional): Separator between printed objects. Defaults to \" \".\n end (str, optional): Character to write at end of output. Defaults to \"\\\\n\".\n file (IO[str], optional): File to write to, or None for stdout. Defaults to None.\n flush (bool, optional): Has no effect as Rich always flushes output. Defaults to False.\n\n \"\"\"\n from .console import Console\n\n write_console = get_console() if file is None else Console(file=file)\n return write_console.print(*objects, sep=sep, end=end)\n\n\ndef print_json(\n json: Optional[str] = None,\n *,\n data: Any = None,\n indent: Union[None, int, str] = 2,\n highlight: bool = True,\n skip_keys: bool = False,\n ensure_ascii: bool = False,\n check_circular: bool = True,\n allow_nan: bool = True,\n default: Optional[Callable[[Any], Any]] = None,\n sort_keys: bool = False,\n) -> None:\n \"\"\"Pretty prints JSON. Output will be valid JSON.\n\n Args:\n json (str): A string containing JSON.\n data (Any): If json is not supplied, then encode this data.\n indent (int, optional): Number of spaces to indent. Defaults to 2.\n highlight (bool, optional): Enable highlighting of output: Defaults to True.\n skip_keys (bool, optional): Skip keys not of a basic type. Defaults to False.\n ensure_ascii (bool, optional): Escape all non-ascii characters. Defaults to False.\n check_circular (bool, optional): Check for circular references. Defaults to True.\n allow_nan (bool, optional): Allow NaN and Infinity values. Defaults to True.\n default (Callable, optional): A callable that converts values that can not be encoded\n in to something that can be JSON encoded. Defaults to None.\n sort_keys (bool, optional): Sort dictionary keys. Defaults to False.\n \"\"\"\n\n get_console().print_json(\n json,\n data=data,\n indent=indent,\n highlight=highlight,\n skip_keys=skip_keys,\n ensure_ascii=ensure_ascii,\n check_circular=check_circular,\n allow_nan=allow_nan,\n default=default,\n sort_keys=sort_keys,\n )\n\n\ndef inspect(\n obj: Any,\n *,\n console: Optional[\"Console\"] = None,\n title: Optional[str] = None,\n help: bool = False,\n methods: bool = False,\n docs: bool = True,\n private: bool = False,\n dunder: bool = False,\n sort: bool = True,\n all: bool = False,\n value: bool = True,\n) -> None:\n \"\"\"Inspect any Python object.\n\n * inspect(

Diff · v555