[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6,"_7":8},"actionData","errors","root",{"_1675":1676,"_1677":70,"_1678":18,"_1679":18,"_1680":18,"_1681":70,"_1682":18,"_1683":18,"_1684":18,"_1685":18,"_1686":-5,"_1687":1688},"routes/s.$postId",{"_9":10,"_11":12,"_13":-7,"_14":-7,"_15":16,"_17":18,"_19":18,"_20":-5,"_21":22,"_23":24},"kind","post_with_profile","postWithProfile",{"_31":32,"_33":34},"messagingRoomId","referrer","imagegenOgImagePolicy","current_wide","preferIntrinsicAspectRatioForOgImage",false,"enforceRenderedOgImg","ogImageVariantOverride","defaultOgDescription","ChatGPT helps you get answers, find inspiration, and be more productive.","shareReceivePerformance",{"_25":26,"_27":28,"_29":30},"loaderDurationMs",711.347279000096,"apiStartMs",23.579216999933124,"apiDurationMs",687.6946510002017,"post",{"_53":54,"_55":56,"_57":-5,"_58":-5,"_59":-5,"_60":-5,"_61":62,"_63":64,"_46":65,"_66":67,"_68":18},"profile",{"_35":36,"_37":36,"_38":39,"_40":-5,"_41":-5,"_42":43,"_44":18,"_45":-5,"_46":-5,"_47":-5,"_48":18,"_49":-5,"_50":-5,"_51":-5,"_52":18},"user_id","anonymous","username","profile_picture_url","https://cdn.openai.com/sora/images/profile_placeholder_v4.png","profile_picture_id","is_default_profile_picture","follower_count",0,"is_following","display_name","permalink","can_cameo","verified","character_count","owner_profile","social_context","follows_you","id","cd_68fff489c7808191b3d33b35f04a7e80","posted_at",1761604745.779525,"text","og_title","og_description","og_image_variant","attachments",[76],"preview_image_url","https://ogimg.chatgpt.com/?postId=cd_68fff489c7808191b3d33b35f04a7e80","https://chatgpt.com/s/cd_68fff489c7808191b3d33b35f04a7e80","permissions",{"_69":70,"_71":18,"_72":18,"_73":70,"_74":75},"use_experimental_unfurl","can_read",true,"can_write","can_delete","can_remix","share_setting","public",{"_53":77,"_78":79,"_9":80,"_81":82,"_83":84,"_85":86,"_87":88,"_89":90,"_91":-5},"cd_68fff489c7808191b3d33b35f04a7e80-attachment-0","tags",[],"codex","task",{"_53":1634,"_130":1635,"_272":1636,"_1637":70,"_94":95,"_1638":18,"_1639":1640,"_234":70,"_1641":1642,"_1643":-5,"_1644":1645},"current_user_turn",{"_104":285,"_53":96,"_108":285,"_1481":1628,"_1483":1629,"_1485":1486,"_143":-5,"_130":1487},"current_assistant_turn",{"_104":105,"_53":95,"_106":-5,"_107":-5,"_108":105,"_109":1571,"_111":1572,"_113":114,"_115":-5,"_116":-5,"_117":1573,"_119":1574,"_121":1575,"_123":124,"_125":-5,"_126":127,"_128":1576,"_130":131,"_132":-5,"_133":134,"_135":1577,"_137":138,"_139":140,"_141":-5,"_142":-5,"_143":96,"_144":1578,"_146":-5,"_147":-5,"_148":18,"_149":-5,"_150":-5},"current_diff_task_turn",{"_104":105,"_53":95,"_106":-5,"_107":-5,"_108":105,"_109":1514,"_111":1515,"_113":114,"_115":-5,"_116":-5,"_117":1516,"_119":1517,"_121":1518,"_123":124,"_125":-5,"_126":127,"_128":1519,"_130":131,"_132":-5,"_133":134,"_135":1520,"_137":138,"_139":140,"_141":-5,"_142":-5,"_143":96,"_144":1521,"_146":-5,"_147":-5,"_148":18,"_149":-5,"_150":-5},"turns",{"_92":93,"_94":95},"example_task_info","turn_mapping",{"_96":97,"_95":98},"current_turn_id","task_e_68fff486a1488331b22bbee5a1f5faa5~assttrn_e_68fff4892680833199b4205249bf3c36","task_e_68fff486a1488331b22bbee5a1f5faa5~usertrn_e_68fff4892628833193e9ca1bc712d99b",{"_53":96,"_99":1479,"_101":1480,"_103":-5},{"_53":95,"_99":100,"_101":102,"_103":96},"turn",{"_104":105,"_53":95,"_106":-5,"_107":-5,"_108":105,"_109":110,"_111":112,"_113":114,"_115":-5,"_116":-5,"_117":118,"_119":120,"_121":122,"_123":124,"_125":-5,"_126":127,"_128":129,"_130":131,"_132":-5,"_133":134,"_135":136,"_137":138,"_139":140,"_141":-5,"_142":-5,"_143":96,"_144":145,"_146":-5,"_147":-5,"_148":18,"_149":-5,"_150":-5},"children",[],"parent","type","assistant","sibling_turn_ids","attempt_placement","role","output_items",[301,302,303],"child_turns",[],"conversation_id","None","error","latest_event","worklog",{"_299":300},"app_server_events",{"_296":298},"thread_events",{"_296":297},"turn_status","completed","cancellation_requested_at","pull_request_status","externally_created","pull_request_data",{"_264":265,"_255":266,"_267":268,"_269":18,"_270":70,"_271":18,"_272":273,"_274":275,"_276":138,"_277":138,"_278":-5,"_279":-5,"_280":-5,"_281":-5,"_282":-5,"_283":-5,"_284":-5,"_285":286,"_287":288,"_289":-5,"_290":-5,"_291":-5},"created_at",1761604745.150474,"internal_only_rollouts","environment_id","68ff9059f2b481918c501dc522f82cbb","environment",{"_53":134,"_171":-5,"_172":173,"_174":175,"_176":18,"_177":178,"_179":180,"_181":182,"_183":-5,"_184":-5,"_185":18,"_186":187,"_188":178,"_189":178,"_190":191,"_192":193,"_194":195,"_196":-5,"_197":198,"_199":200,"_201":202,"_203":204,"_66":-5,"_130":205,"_206":207,"_208":209,"_210":211,"_212":18,"_213":18},"branch","main","base_commit_sha","6f3d45e454f8dc21fdf98e9862ada6b980a6ef1f","branch_name","direct_push_pushed_commit_sha","previous_turn_id","logs",{"_144":151},"proxy_events","debug_metadata","discarded","model_version","languages",[152,153,154],{"_155":167,"_157":168},{"_155":163,"_157":164},{"_155":156,"_157":158},"key",{"_159":160,"_104":161,"_130":162},"value","file_000000009f1c61f78702954f18f5ad7c","name","warm_up_git_repo_1761604748","UserSetupScript","2025-10-27T22:39:08.038542",{"_159":165,"_104":161,"_130":166},"file_00000000767061f792844e8a6df5d945","auto_setup","2025-10-27T20:43:20.170770",{"_159":169,"_104":161,"_130":170},"file_00000000171061f7ae63467aa11fb707","setup_autodetect","2025-10-27T20:43:15.959024","devcontainer","machine_id","wham-public/wham-universal","label","PythonCall.jl","is_pinned","description","","workspace_dir","/workspace","agent_network_access",{"_257":258,"_259":-5,"_260":-5,"_261":-5,"_262":-5,"_263":-5},"codex_github_direct","github_connector_id","enable_gitlab_webhooks","repos",[217],"setup","maintenance_setup","repo_map",{"_217":218},"env_vars",{},"secrets",{},"secrets_with_domains","task_count",7,"creator_id","user-ysreFvBHE9ow5F95WM9cGrbl","share_settings","workspace","share_targets",[],1761579097.948829,"auto_setup_settings",{"_216":70},"cache_settings",{"_214":70,"_215":178},"etag","\"02025f0c-0000-0200-0000-68fff0dd0000\"","enable_authtranslator","enable_docker_in_docker","post_setup_cache_enabled","cache_invalidation_key","use_auto_setup","github-309740192",{"_53":219,"_159":175,"_220":221,"_222":223,"_224":225,"_226":138,"_227":228,"_229":230,"_231":232,"_233":75,"_234":-5,"_235":18,"_236":70,"_237":70,"_238":70,"_239":18,"_240":-5,"_241":242,"_243":-5,"_66":244},"309740192","owner",{"_249":250,"_53":251,"_104":252,"_253":254,"_255":256},"repository_full_name","JuliaPy/PythonCall.jl","clone_url","https://github.com/JuliaPy/PythonCall.jl.git","default_branch","git_commits_url","https://api.github.com/repos/JuliaPy/PythonCall.jl/git/commits{/sha}","git_refs_url","https://api.github.com/repos/JuliaPy/PythonCall.jl/git/refs{/sha}","git_url","git://github.com/JuliaPy/PythonCall.jl.git","visibility","archived","allow_auto_merge","allow_merge_commit","allow_rebase_merge","allow_squash_merge","allow_update_branch","language","size",5105,"master_branch",{"_245":70,"_246":18,"_247":70,"_248":70},"admin","maintain","push","pull","login","JuliaPy",22030672,"Organization","avatar_url","https://avatars.githubusercontent.com/u/22030672?v=4","url","https://api.github.com/users/JuliaPy","mode","off","preset_allowlist","allowlist_domains","allowlist_rules","denylist_domains","safe_methods_only","number",703,"https://github.com/JuliaPy/PythonCall.jl/issues/703","state","open","merged","mergeable","draft","title","Remove methods like ==(::Py, ::Number) and +(::Number, ::Py)","body","These are handy but they break the general model that a Python `int` is not a Julia `Integer` etc.\n\nFor example we currently have `Py(3) == 3` but `hash(Py(3)) != hash(3)`, which breaks a Julia invariant.\n\nI suspect it might lead to method invalidations too but I don't know.","base","head","base_sha","head_sha","head_repo_id","head_repo_full_name","merge_commit_sha","comments","diff","user",{"_249":292,"_159":292,"_293":-5,"_253":294,"_53":295},"commits",1,"changed_files","additions","deletions","cjdoris","email","https://avatars.githubusercontent.com/u/1844215?v=4",1844215,"events",[],[],"messages",[],{"_104":1453,"_1454":1455,"_1456":1457,"_1458":1459,"_1460":-5},{"_104":1427,"_108":105,"_320":1428},{"_104":304,"_305":306},"partial_repo_snapshot","files",[307,308,309],{"_310":1119,"_312":-5,"_313":1120,"_315":-5},{"_310":919,"_312":-5,"_313":920,"_315":-5},{"_310":311,"_312":-5,"_313":314,"_315":-5},"path","test/Core.jl","contents","line_range_contents",[316],"missing_reason",{"_317":288,"_318":319,"_320":321,"_322":70},"line_range_start","line_range_end",861,"content",[323,324,325,326,327,328,329,330,331,332,333,334,335,336,332,337,338,339,340,332,341,342,343,332,344,345,346,347,348,349,350,351,352,353,350,332,354,355,356,357,358,332,359,355,360,357,361,362,360,363,364,332,365,366,367,368,369,370,371,372,373,374,375,332,376,377,378,379,380,381,382,383,384,385,386,387,332,388,389,390,391,332,392,393,394,395,396,397,398,399,397,332,400,401,402,395,403,397,398,404,397,332,405,398,406,407,397,408,409,332,410,411,412,413,414,415,416,417,418,419,420,332,421,422,423,424,425,426,427,332,428,422,424,429,430,431,332,432,433,434,435,436,437,438,332,439,440,441,442,443,444,445,446,332,447,448,449,450,451,332,452,453,454,455,456,332,457,458,459,460,461,462,397,332,463,458,459,464,465,462,397,332,466,458,459,467,468,462,397,332,469,458,459,470,471,462,397,332,472,411,473,474,475,476,477,478,332,479,411,480,481,482,483,484,485,332,486,487,488,489,490,332,491,178,492,493,494,495,496,497,498,499,497,498,500,497,501,502,496,503,499,503,500,504,491,178,505,506,395,507,397,332,508,395,509,397,332,510,395,511,397,332,512,395,513,397,332,514,395,515,397,332,516,517,518,519,462,397,332,520,517,518,521,462,397,332,522,517,518,523,462,397,332,524,525,526,527,528,529,530,531,532,517,518,533,534,535,536,537,462,397,332,538,517,518,533,539,535,540,537,462,397,332,541,517,518,533,542,535,543,537,462,397,332,544,517,518,533,545,535,546,537,462,397,332,547,398,548,397,332,549,398,550,397,332,551,552,553,554,462,397,332,555,552,553,556,462,397,332,557,552,553,558,462,397,332,559,491,178,560,561,562,563,564,565,566,332,567,568,569,397,332,570,568,571,397,332,572,573,574,575,576,577,332,578,579,580,581,332,491,178,582,583,584,585,586,587,588,589,590,591,592,593,594,595,596,597,598,491,178,599,600,601,491,178,602,603,604,605,606,607,608,609,491,178,610,611,612,613,614,615,616,617,618,619,620,621,622,491,178,623,624,625,626,627,628,629,630,631,632,633,634,635,636,491,178,637,638,639,626,640,641,629,630,631,632,642,643,644,645,646,647,648,649,491,178,650,651,652,626,653,654,655,656,657,658,659,660,661,662,663,491,178,664,665,666,667,668,669,670,671,672,491,178,673,674,675,676,677,678,679,680,677,678,679,681,677,678,679,682,677,678,679,683,684,491,178,685,686,687,688,676,689,687,690,691,689,687,692,693,689,687,694,695,696,491,178,697,698,699,688,700,701,699,702,703,704,699,705,706,707,701,699,708,709,710,711,491,178,712,713,714,715,716,717,718,719,720,721,722,715,723,724,725,726,727,717,728,729,730,731,732,719,491,178,733,734,735,736,737,738,739,735,740,741,738,742,735,740,741,743,491,178,744,745,746,747,748,749,750,746,740,748,749,751,746,740,748,752,491,178,753,524,491,178,754,755,756,757,758,756,759,760,756,761,762,763,491,178,764,524,491,178,765,524,491,178,766,767,768,769,770,771,772,773,774,775,776,777,778,779,780,781,782,783,784,785,786,787,788,789,491,178,790,791,792,793,794,795,796,797,798,799,800,801,802,803,804,805,806,807,808,809,810,811,812,813,814,815,816,817,817,818,819,820,821,822,823,824,825,826,827,828,829,830,831,832,829,833,834,835,836,823,837,838,839,840,841,842,843,844,845,846,847,848,849,850,851,852,853,854,491,178,855,856,857,858,858,859,860,861,862,491,178,863,864,865,866,867,868,869,870,871,872,873,332,874,875,876,877,878,879,880,332,881,882,883,884,885,886,332,887,888,889,884,890,891,892,893,894,332,491,178,895,896,897,898,899,900,901,397,902,332,903,897,898,899,904,902,332,491,178,905,906,907,908,909,910,911,491,178,912,913,914,915,916,917,918,397,332,491],"contains_end_of_file","@testitem \"object\" begin"," import Markdown"," @testset \"pyis\" begin"," x = pylist()"," y = PythonCall.pynew(x)"," z = pylist()"," @test pyis(x, x)"," @test pyis(x, y)"," @test !pyis(x, z)"," end"," @testset \"pyrepr\" begin"," @test pyrepr(String, pybuiltins.None) == \"None\""," @test pyrepr(String, pyint(123)) == \"123\""," @test pyrepr(String, \"hello\") == \"'hello'\""," @testset \"pyascii\" begin"," @test pyascii(String, pybuiltins.None) == \"None\""," @test pyascii(String, pyint(234)) == \"234\""," @test pyascii(String, \"hello\") == \"'hello'\""," @testset \"pyhasattr\" begin"," @test pyhasattr(pybuiltins.None, \"__class__\")"," @test !pyhasattr(pybuiltins.None, \"not_an_attr\")"," @testset \"pygetattr\" begin"," @test pyisinstance(pygetattr(pybuiltins.None, \"__class__\"), pybuiltins.type)"," @test_throws PyException pygetattr(pybuiltins.None, \"not_an_attr\")"," @test pyisinstance("," pygetattr(pybuiltins.None, \"__class__\", pybuiltins.None),"," pybuiltins.type,"," )"," @test pyis("," pygetattr(pybuiltins.None, \"not_an_attr\", pybuiltins.None),"," pybuiltins.None,"," @testset \"pysetattr\" begin"," x = pytype(\"Foo\", (), ())()"," @test_throws PyException pysetattr(pybuiltins.None, \"not_an_attr\", 123)"," pysetattr(x, \"foo\", 123)"," @test pyeq(Bool, pygetattr(x, \"foo\"), 123)"," @testset \"pydelattr\" begin"," @test !pyhasattr(x, \"foo\")"," @test pyhasattr(x, \"foo\")"," pydelattr(x, \"foo\")"," @test_throws PyException pydelattr(pybuiltins.None, \"__class__\")"," @test_throws PyException pydelattr(pybuiltins.None, \"not_an_attr\")"," @testset \"pyissubclass\" begin"," @test pyissubclass(pybuiltins.object, pybuiltins.object)"," @test pyissubclass(pybuiltins.int, pybuiltins.object)"," @test pyissubclass(pybuiltins.bool, pybuiltins.object)"," @test pyissubclass(pybuiltins.bool, pybuiltins.int)"," @test !pyissubclass(pybuiltins.int, pybuiltins.bool)"," @test !pyissubclass(pybuiltins.object, pybuiltins.int)"," @test !pyissubclass(pybuiltins.object, pybuiltins.bool)"," @test_throws PyException pyissubclass(pybuiltins.None, pybuiltins.None)"," @test_throws PyException pyissubclass(pybuiltins.object, pybuiltins.None)"," @test_throws PyException pyissubclass(pybuiltins.None, pybuiltins.object)"," @testset \"pyisinstance\" begin"," o = pybuiltins.object()"," i = pybuiltins.int()"," b = pybuiltins.bool()"," @test pyisinstance(o, pybuiltins.object)"," @test pyisinstance(i, pybuiltins.object)"," @test pyisinstance(b, pybuiltins.object)"," @test pyisinstance(b, pybuiltins.int)"," @test !pyisinstance(i, pybuiltins.bool)"," @test !pyisinstance(o, pybuiltins.int)"," @test !pyisinstance(o, pybuiltins.bool)"," @test_throws PyException pyisinstance(o, pybuiltins.None)"," @testset \"pyhash\" begin"," @test pyhash(pybuiltins.None) isa Integer"," @test pyhash(pybuiltins.None) == pyhash(pybuiltins.None)"," @test pyhash(pytuple((1, 2, 3))) == pyhash(pytuple((1, 2, 3)))"," @testset \"pytruth\" begin"," @test !pytruth(pybuiltins.None)"," @test pytruth(pybuiltins.object)"," for n = -2:2"," @test pytruth(pyint(n)) == (n != 0)"," end"," for n = 0:3"," @test pytruth(pylist(zeros(n))) == (n != 0)"," @testset \"pynot\" begin"," @test pynot(pybuiltins.None)"," @test !pynot(pybuiltins.int)"," @test pynot(pyfloat(n)) == (n == 0)"," @test pynot(pylist(zeros(n))) == (n == 0)"," @testset \"pylen\" begin"," @test pylen(pytuple(zeros(n))) == n"," @test pylen(pylist(zeros(n))) == n"," @test_throws PyException pylen(pybuiltins.None)"," @test_throws PyException pylen(pyint(0))"," @testset \"pygetitem\" begin"," x = pyrange(3)"," @test_throws PyException pygetitem(x, pybuiltins.None)"," @test_throws PyException pygetitem(x, 3)"," @test_throws PyException pygetitem(x, -4)"," @test pyeq(Bool, pygetitem(x, 0), 0)"," @test pyeq(Bool, pygetitem(x, 1), 1)"," @test pyeq(Bool, pygetitem(x, 2), 2)"," @test pyeq(Bool, pygetitem(x, -1), 2)"," @test pyeq(Bool, pygetitem(x, -2), 1)"," @test pyeq(Bool, pygetitem(x, -3), 0)"," @testset \"pysetitem\" begin"," x = pydict()"," @test_throws PyException pygetitem(x, \"foo\")"," pysetitem(x, \"foo\", 123)"," @test pyeq(Bool, pygetitem(x, \"foo\"), 123)"," pysetitem(x, \"foo\", 0)"," @test pyeq(Bool, pygetitem(x, \"foo\"), 0)"," @testset \"pydelitem\" begin"," @test pylen(x) == 1"," pydelitem(x, \"foo\")"," @test pylen(x) == 0"," @testset \"pydir\" begin"," x = pytype(\"Foo\", (), [\"foo\" => 1, \"bar\" => 2])()"," d = pydir(x)"," @test pycontains(d, \"__class__\")"," @test pycontains(d, \"foo\")"," @test pycontains(d, \"bar\")"," @test !pycontains(d, \"baz\")"," @testset \"pycall\" begin"," @test pyeq(Bool, pycall(pybuiltins.int), 0)"," @test_throws PyException pycall(pybuiltins.None)"," @test pyeq(Bool, pycall(pybuiltins.int, \"10\"), 10)"," @test_throws PyException pycall(pybuiltins.int, \"10\", \"20\")"," @test pyeq(Bool, pycall(pybuiltins.int, \"10\", base = 16), 16)"," @test_throws PyException pycall(pybuiltins.int, \"10\", base = \"16\")"," @test_throws PyException pycall(pybuiltins.int, \"10\", bad_argument = 0)"," @testset \"pyeq\" begin"," @test pyis(pyeq(pybuiltins.None, pybuiltins.None), pybuiltins.True)"," @test pyeq(Bool, pybuiltins.None, pybuiltins.None)"," @test pyis(pyeq(pybuiltins.None, pybuiltins.int), pybuiltins.False)"," @test !pyeq(Bool, pybuiltins.None, pybuiltins.int)"," @testset \"pyne\" begin"," @test pyis(pyne(pybuiltins.None, pybuiltins.None), pybuiltins.False)"," @test !pyne(Bool, pybuiltins.None, pybuiltins.None)"," @test pyis(pyne(pybuiltins.None, pybuiltins.int), pybuiltins.True)"," @test pyne(Bool, pybuiltins.None, pybuiltins.int)"," @testset \"pylt\" begin"," for a = -1:1"," for b = -1:1"," @test pyis(pylt(pyint(a), pyint(b)), pybool(a < b))"," @test pylt(Bool, pyint(a), pyint(b)) == (a < b)"," end"," @testset \"pyle\" begin"," @test pyis(pyle(pyint(a), pyint(b)), pybool(a ≤ b))"," @test pyle(Bool, pyint(a), pyint(b)) == (a ≤ b)"," @testset \"pygt\" begin"," @test pyis(pygt(pyint(a), pyint(b)), pybool(a > b))"," @test pygt(Bool, pyint(a), pyint(b)) == (a > b)"," @testset \"pyge\" begin"," @test pyis(pyge(pyint(a), pyint(b)), pybool(a ≥ b))"," @test pyge(Bool, pyint(a), pyint(b)) == (a ≥ b)"," @testset \"pycontains\" begin"," @test pycontains(x, 0)"," @test pycontains(x, 1)"," @test pycontains(x, 2)"," @test !pycontains(x, 3)"," @test !pycontains(x, -1)"," @test !pycontains(x, pybuiltins.None)"," @testset \"pyin\" begin"," @test pyin(0, x)"," @test pyin(1, x)"," @test pyin(2, x)"," @test !pyin(3, x)"," @test !pyin(-1, x)"," @test !pyin(pybuiltins.None, x)"," @testset \"getdoc\" begin"," @test Base.Docs.getdoc(Py(nothing)) isa Markdown.MD"," @test Base.Docs.getdoc(Py(12)) isa Markdown.MD"," @test Base.Docs.getdoc(pybuiltins.int) isa Markdown.MD"," @test Base.Docs.getdoc(PythonCall.PyNULL) === nothing","end","@testitem \"iter\" begin"," @test_throws PyException pyiter(pybuiltins.None)"," @test_throws PyException pyiter(pybuiltins.True)"," # unsafe_pynext"," it = pyiter(pyrange(2))"," x = PythonCall.unsafe_pynext(it)"," @test !PythonCall.pyisnull(x)"," @test pyeq(Bool, x, 0)"," @test pyeq(Bool, x, 1)"," @test PythonCall.pyisnull(x)"," # pynext"," x = pynext(it)"," @test_throws PyException pynext(it)","@testitem \"number\" begin"," @testset \"pyneg\" begin"," @test pyeq(Bool, pyneg(pyint(n)), pyint(-n))"," @testset \"pypos\" begin"," @test pyeq(Bool, pypos(pyint(n)), pyint(n))"," @testset \"pyabs\" begin"," @test pyeq(Bool, pyabs(pyint(n)), pyint(abs(n)))"," @testset \"pyinv\" begin"," @test pyeq(Bool, pyinv(pyint(n)), pyint(-n - 1))"," @testset \"pyindex\" begin"," @test pyeq(Bool, pyindex(pyint(n)), pyint(n))"," @testset \"pyadd\" begin"," for x = -2:2"," for y = -2:2"," @test pyeq(Bool, pyadd(pyint(x), pyint(y)), pyint(x + y))"," @testset \"pysub\" begin"," @test pyeq(Bool, pysub(pyint(x), pyint(y)), pyint(x - y))"," @testset \"pymul\" begin"," @test pyeq(Bool, pymul(pyint(x), pyint(y)), pyint(x * y))"," # TODO"," # @testset \"pymatmul\" begin"," # for x in -2:2"," # for y in -2:2"," # @test pyeq(Bool, pymul(pyint(x), pyint(y)), pyint(x*y))"," # end"," # end"," # end"," @testset \"pytruediv\" begin"," if y == 0"," @test_throws PyException pytruediv(pyint(x), pyint(y))"," else"," @test pyeq(Bool, pytruediv(pyint(x), pyint(y)), pyfloat(x / y))"," end"," @testset \"pyfloordiv\" begin"," @test_throws PyException pyfloordiv(pyint(x), pyint(y))"," @test pyeq(Bool, pyfloordiv(pyint(x), pyint(y)), pyfloat(fld(x, y)))"," @testset \"pymod\" begin"," @test_throws PyException pymod(pyint(x), pyint(y))"," @test pyeq(Bool, pymod(pyint(x), pyint(y)), pyint(mod(x, y)))"," @testset \"pydivmod\" begin"," @test_throws PyException pydivmod(pyint(x), pyint(y))"," @test pyeq(Bool, pydivmod(pyint(x), pyint(y)), pytuple(fldmod(x, y)))"," @testset \"pylshift\" begin"," @test pyeq(Bool, pylshift(pyint(123), pyint(n)), pyint(123 << n))"," @testset \"pyrshift\" begin"," @test pyeq(Bool, pyrshift(pyint(123), pyint(n)), pyint(123 >> n))"," @testset \"pyand\" begin"," for x = 0:3"," for y = 0:3"," @test pyeq(Bool, pyand(pyint(x), pyint(y)), pyint(x & y))"," @testset \"pyxor\" begin"," @test pyeq(Bool, pyxor(pyint(x), pyint(y)), pyint(x ⊻ y))"," @testset \"pyor\" begin"," @test pyeq(Bool, pyor(pyint(x), pyint(y)), pyint(x | y))"," # TODO: in-place operators","@testitem \"builtins\" begin"," @testset \"pyprint\" begin"," buf = pyimport(\"io\").StringIO()"," ans = pyprint(\"hello\", 12, file = buf)"," @test ans === nothing"," buf.seek(0)"," @test pyeq(Bool, buf.read().strip(), \"hello 12\")"," @testset \"pyall\" begin"," for val in [[true, true], [true, false], [false, false]]"," @test pyall(pylist(val)) === all(val)"," @testset \"pyany\" begin"," @test pyany(pylist(val)) === any(val)"," @testset \"pycallable\" begin"," @test pycallable(pybuiltins.str) === true"," @test pycallable(pybuiltins.any) === true"," @test pycallable(pybuiltins.None) === false"," @test pycallable(pybuiltins.True) === false"," @test pycallable(pybuiltins.object) === true"," @testset \"pycompile\" begin"," ans = pycompile(\"3+4\", \"foo.py\", \"eval\")"," @test pyeq(Bool, ans.co_filename, \"foo.py\")"," @test pyeq(Bool, pybuiltins.eval(ans, pydict()), 7)","@testitem \"import\" begin"," sys = pyimport(\"sys\")"," os = pyimport(\"os\")"," @test pyeq(Bool, sys.__name__, \"sys\")"," @test pyeq(Bool, os.__name__, \"os\")"," sysos = pyimport(\"sys\", \"os\")"," @test sysos isa Tuple{Py,Py}"," @test pyis(sysos[1], sys)"," @test pyis(sysos[2], os)"," ver = pyimport(\"sys\" => \"version\")"," @test pyis(ver, sys.version)"," path = pyimport(\"sys\" => \"path\")"," @test pyis(path, sys.path)"," verpath = pyimport(\"sys\" => (\"version\", \"path\"))"," @test verpath isa Tuple{Py,Py}"," @test pyis(verpath[1], ver)"," @test pyis(verpath[2], path)","@testitem \"consts\" begin"," @test pybuiltins.None isa Py"," @test pystr(String, pybuiltins.None) == \"None\"","@testitem \"str\" begin"," @test pyisinstance(pystr(\"foo\"), pybuiltins.str)"," @test pyeq(Bool, pystr(pystr(\"foo\")), pystr(\"foo\"))"," @test pyeq(Bool, pystr(SubString(\"foobarbaz\", 4:6)), pystr(\"bar\"))"," @test pyeq(Bool, pystr('x'), pystr(\"x\"))"," @test pystr(String, pybuiltins.None) === \"None\""," @test pystr(String, pyint(123)) === \"123\""," @test pystr(String, pystr(\"foo\")) === \"foo\"","@testitem \"bytes\" begin"," @test pyisinstance(pybytes(UInt8[1, 2, 3]), pybuiltins.bytes)"," @test pyeq(Bool, pybytes(pylist([1, 2, 3])), pybytes(UInt8[1, 2, 3]))"," @test pyeq(Bool, pybytes(b\"foo\"), pystr(\"foo\").encode(\"ascii\"))"," @test pyeq("," Bool,"," pybytes(codeunits(SubString(\"foobarbaz\", 4:6))),"," pystr(\"bar\").encode(\"ascii\"),"," )"," @test pybytes(Vector, pylist([1, 2, 3])) == UInt8[1, 2, 3]"," @test pybytes(Vector{UInt8}, pylist([1, 2, 3])) == UInt8[1, 2, 3]"," @test pybytes(Base.CodeUnits, pystr(\"foo\").encode(\"ascii\")) == b\"foo\""," @test pybytes(Base.CodeUnits{UInt8,String}, pystr(\"bar\").encode(\"ascii\")) == b\"bar\"","@testitem \"tuple\" begin"," z = pytuple()"," @test pyisinstance(z, pybuiltins.tuple)"," @test pylen(z) == 0"," x = pytuple((1, 2, 3))"," @test pyisinstance(x, pybuiltins.tuple)"," @test pylen(x) == 3"," @test pyeq(Bool, pygetitem(x, 0), 1)"," @test pyeq(Bool, pygetitem(x, 1), 2)"," @test pyeq(Bool, pygetitem(x, 2), 3)"," @test pyeq(Bool, pytuple([1, 2, 3]), x)"," @test pyeq(Bool, pytuple(i + 1 for i = 0:10 if i < 3), x)"," @test pyeq(Bool, pytuple(pytuple((1, 2, 3))), x)"," @test pyeq(Bool, pytuple(pylist([1, 2, 3])), x)","@testitem \"list\" begin"," z = pylist()"," @test pyisinstance(z, pybuiltins.list)"," x = pylist((1, 2, 3))"," @test pyisinstance(x, pybuiltins.list)"," @test pyeq(Bool, pylist([1, 2, 3]), x)"," @test pyeq(Bool, pylist(i + 1 for i = 0:10 if i < 3), x)"," @test pyeq(Bool, pylist(pylist((1, 2, 3))), x)"," @test pyeq(Bool, pylist(pytuple([1, 2, 3])), x)"," @test pyeq(Bool, pycollist([1, 2, 3]), pylist([1, 2, 3]))"," @test pyeq(Bool, pycollist([1 2; 3 4]), pylist((pylist([1, 3]), pylist([2, 4]))))"," @test pyeq(Bool, pyrowlist([1, 2, 3]), pylist([1, 2, 3]))"," @test pyeq(Bool, pyrowlist([1 2; 3 4]), pylist((pylist([1, 2]), pylist([3, 4]))))","@testitem \"dict\" begin"," z = pydict()"," @test pyisinstance(z, pybuiltins.dict)"," x = pydict(foo = 1, bar = 2)"," @test pyisinstance(x, pybuiltins.dict)"," @test pylen(x) == 2"," @test pyeq(Bool, pygetitem(x, \"foo\"), 1)"," @test pyeq(Bool, pygetitem(x, \"bar\"), 2)"," @test pyeq(Bool, pydict([\"foo\" => 1, \"bar\" => 2]), x)"," @test pyeq(Bool, pydict([(\"foo\" => 1), (\"bar\" => 2)]), x)"," @test pyeq(Bool, pydict(Dict(\"foo\" => 1, \"bar\" => 2)), x)"," @test pyeq(Bool, pydict((foo = 1, bar = 2)), x)"," @test pyeq(Bool, pydict(x), x)"," @test pyeq(Bool, pydict(\"foo\" => 1, \"bar\" => 2), x)","@testitem \"bool\" begin"," @test pyis(pybool(), pybuiltins.False)"," @test pyis(pybool(false), pybuiltins.False)"," @test pyis(pybool(true), pybuiltins.True)"," @test pyis(pybool(0.0), pybuiltins.False)"," @test pyis(pybool(-1.2), pybuiltins.True)"," @test pyis(pybool(pybuiltins.None), pybuiltins.False)"," @test pyis(pybool(pylist()), pybuiltins.False)"," @test pyis(pybool(pylist([1, 2, 3])), pybuiltins.True)","@testitem \"int\" begin"," @test pyisinstance(pyint(), pybuiltins.int)"," @test pystr(String, pyint()) == \"0\""," x = 123"," y = pyint(x)"," @test pyisinstance(y, pybuiltins.int)"," @test pystr(String, y) == string(x)"," x = BigInt(123) << 200"," x = UInt(123)"," x = UInt128(123) << 100"," @test pyeq(Bool, pyint(pyint(123)), pyint(123))"," @test pyeq(Bool, pyint(pyfloat(12.3)), pyint(12))","@testitem \"float\" begin"," y = pyfloat()"," @test pyisinstance(y, pybuiltins.float)"," @test pyeq(Bool, y, pyint(0))"," y = pyfloat(x)"," @test pyeq(Bool, y, pyint(x))"," x = 0.25"," @test pyeq(Bool, y, pytruediv(1, 4))"," x = 1 // 4"," @test pyeq(Bool, y, pyfloat(float(x)))"," @test pyeq(Bool, pyfloat(pyfloat(12.3)), pyfloat(12.3))"," @test pyeq(Bool, pyfloat(pyint(123)), pyfloat(123))","@testitem \"complex\" begin"," y = pycomplex()"," @test pyisinstance(y, pybuiltins.complex)"," x = 12.3"," y = pycomplex(x)"," @test pyeq(Bool, y, pyfloat(x))"," xr, xi = 12, 34"," y = pycomplex(xr, xi)"," @test pyeq(Bool, y.real, pyfloat(xr))"," @test pyeq(Bool, y.imag, pyfloat(xi))"," x = Complex(12, 34)"," @test pyeq(Bool, y.real, pyfloat(real(x)))"," @test pyeq(Bool, y.imag, pyfloat(imag(x)))"," @test pyeq(Bool, pycomplex(y), y)"," @test pyeq(Bool, pycomplex(pyint(12), pyint(34)), y)","@testitem \"set\" begin"," y = pyset()"," yf = pyfrozenset()"," @test pyisinstance(y, pybuiltins.set)"," @test pylen(y) == 0"," @test pyisinstance(yf, pybuiltins.frozenset)"," @test pylen(yf) == 0"," @test pyeq(Bool, y, yf)"," x = [1, 2, 3, 2, 1]"," y = pyset(x)"," yf = pyfrozenset(x)"," @test pylen(y) == 3"," @test pycontains(y, 1)"," @test pycontains(y, 2)"," @test pycontains(y, 3)"," @test pyeq(Bool, pyset(y), y)"," @test pylen(yf) == 3"," @test pycontains(yf, 1)"," @test pycontains(yf, 2)"," @test pycontains(yf, 3)"," @test pyeq(Bool, pyfrozenset(y), y)","@testitem \"slice\" begin"," x = pyslice(12)"," @test pyisinstance(x, pybuiltins.slice)"," @test pyeq(Bool, x.start, pybuiltins.None)"," @test pyeq(Bool, x.stop, 12)"," @test pyeq(Bool, x.step, pybuiltins.None)"," x = pyslice(12, 34)"," @test pyeq(Bool, x.start, 12)"," @test pyeq(Bool, x.stop, 34)"," x = pyslice(12, 34, 56)"," @test pyeq(Bool, x.step, 56)","@testitem \"range\" begin"," x = pyrange(123)"," @test pyisinstance(x, pybuiltins.range)"," @test pyeq(Bool, x.start, 0)"," @test pyeq(Bool, x.stop, 123)"," @test pyeq(Bool, x.step, 1)"," x = pyrange(12, 123)"," x = pyrange(12, 123, 3)"," @test pyeq(Bool, x.step, 3)","@testitem \"none\" begin","@testitem \"type\" begin"," x = pytype(pyint())"," @test pyisinstance(x, pybuiltins.type)"," @test pyis(x, pybuiltins.int)"," x = pytype(pybuiltins.type)"," @test pyis(x, pybuiltins.type)"," x = pytype(\"Foo\", (), [\"foo\" => 1, \"bar\" => 2])"," @test pyeq(Bool, x.__name__, \"Foo\")"," @test pyeq(Bool, x.foo, 1)"," @test pyeq(Bool, x.bar, 2)","@testitem \"fraction\" begin","@testitem \"method\" begin","@testitem \"datetime\" begin"," using Dates"," dt = pyimport(\"datetime\")"," x1 = pydate(2001, 2, 3)"," @test pyisinstance(x1, dt.date)"," @test pyeq(Bool, x1, dt.date(2001, 2, 3))"," x2 = pydate(Date(2002, 3, 4))"," @test pyisinstance(x2, dt.date)"," @test pyeq(Bool, x2, dt.date(2002, 3, 4))"," x3 = pytime(12, 3, 4, 5)"," @test pyisinstance(x3, dt.time)"," @test pyeq(Bool, x3, dt.time(12, 3, 4, 5))"," x4 = pytime(Time(23, 4, 5, 0, 6))"," @test pyisinstance(x4, dt.time)"," @test pyeq(Bool, x4, dt.time(23, 4, 5, 6))"," x5 = pydatetime(2001, 2, 3, 4, 5, 6, 7)"," @test pyisinstance(x5, dt.datetime)"," @test pyeq(Bool, x5, dt.datetime(2001, 2, 3, 4, 5, 6, 7))"," x6 = pydatetime(Date(2007, 8, 9))"," @test pyisinstance(x6, dt.datetime)"," @test pyeq(Bool, x6, dt.datetime(2007, 8, 9))"," x7 = pydatetime(DateTime(2001, 2, 3, 4, 5, 6, 7))"," @test pyisinstance(x7, dt.datetime)"," @test pyeq(Bool, x7, dt.datetime(2001, 2, 3, 4, 5, 6, 7000))","@testitem \"code\" begin"," # check for ArgumentError when inputs are mixed up"," @test_throws ArgumentError pyeval(Main, \"1+1\")"," @test_throws ArgumentError pyeval(Main, Main)"," @test_throws ArgumentError pyeval(\"1+1\", \"1+1\")"," @test_throws ArgumentError pyexec(Main, \"1+1\")"," @test_throws ArgumentError pyexec(Main, Main)"," @test_throws ArgumentError pyexec(\"1+1\", \"1+1\")"," # basic code execution"," m = Module(:test)"," g = pydict()"," @test pyeq(Bool, pyeval(\"1+1\", m), 2)"," @test pyeq(Bool, pyeval(\"1+1\", g), 2)"," @test pyeq(Bool, pyeval(pystr(\"1+1\"), g), 2)"," @test pyexec(\"1+1\", m) === nothing"," @test pyexec(\"1+1\", g) === nothing"," @test pyexec(pystr(\"1+1\"), g) === nothing"," # check the globals are what we think they are"," @test pyis(pyeval(\"globals()\", g), g)"," mg = pyeval(\"globals()\", m)"," @test pyisinstance(mg, pybuiltins.dict)"," # these automatically gain 1 item, __builtins__"," @test length(g) == 1"," @test length(mg) == 1"," @test pycontains(g, \"__builtins__\")"," @test pycontains(mg, \"__builtins__\")"," # code should fail when x does not exist"," @test_throws PyException pyeval(\"x+1\", g)"," # now set x and try again"," g[\"x\"] = 1"," @test pyeq(Bool, pyeval(\"x+1\", g), 2)"," # set x using pyexec this time"," pyexec(\"x=2\", g)"," @test pyeq(Bool, g[\"x\"], 2)"," @test pyeq(Bool, pyeval(\"x+1\", g), 3)"," # now use locals"," # check empty locals have no effect"," l = pydict()"," @test pyeq(Bool, pyeval(\"x+1\", g, l), 3)"," @test pyeq(Bool, pyeval(\"x+1\", g, Dict()), 3)"," # now set x locally"," l[\"x\"] = 3"," @test pyeq(Bool, pyeval(\"x+1\", g, l), 4)"," @test pyeq(Bool, pyeval(\"x+1\", g, Dict(\"x\" => 0)), 1)"," @test pyeq(Bool, pyeval(\"x+1\", g, (x = 1,)), 2)"," # check pyexec runs in local scope"," pyexec(\"x=4\", g, l)"," @test pyeq(Bool, l[\"x\"], 4)"," # check global code runs in global scope"," pyexec(\"global y; y=x+1\", g, l)"," @test pyeq(Bool, g[\"y\"], 5)"," @test !pycontains(l, \"y\")"," # check pyeval converts types correctly"," @test pyeval(Int, \"1+1\", g) === 2"," @test pyeval(Nothing, \"None\", g) === nothing"," # @pyexec"," @test_throws PyException @pyexec(`raise ValueError`)"," @test @pyexec(`1 + 2`) === nothing"," @test @pyexec(`ans = 1 + 2` => (ans::Int,)) === (ans = 3,)"," @test @pyexec((x = 1, y = 2) => `ans = x + y` => (ans::Int,)) === (ans = 3,)"," # @pyeval"," @test_throws PyException @pyeval(`import sys`) # not an expression"," @test_throws PyException @pyeval(`None + None`)"," @test @pyeval(`1 + 2` => Int) === 3"," @test @pyeval((x = 1, y = 2) => `x + y` => Int) === 3","@testitem \"@pyconst\" begin"," f() = @pyconst \"hello\""," g() = @pyconst \"hello\""," @test f() === f()"," @test g() === g()"," @test g() !== f()"," @test f() isa Py"," @test pyeq(Bool, f(), \"hello\")","@testitem \"Base.jl\" begin"," @testset \"broadcast\" begin"," # Py always broadcasts as a scalar when combined with other Py values"," x = Py.([1 2; 3 4]) .+ Py(1)"," @test isequal(x, Py.([2 3; 4 5]))"," x = Py(\"foo\") .* Py.([1 2; 3 4])"," @test isequal(x, Py.([\"foo\" \"foofoo\"; \"foofoofoo\" \"foofoofoofoo\"]))"," @test_throws MethodError [1 2; 3 4] .+ Py(1)"," # this previously treated the list as a shape (2,) object"," # but now tries to do `1 + [1, 2]` which properly fails"," @test_throws PyException [1 2; 3 4] .+ pylist([1, 2])"," @testset \"Julia numbers\" begin"," @test Py(3) != 3"," @test 3 != Py(3)"," @test_throws MethodError Py(1) + 1"," @test_throws MethodError 1 + Py(1)"," @test_throws MethodError Py(1) < 2"," @test_throws MethodError 2 < Py(1)"," @testset \"showable\" begin"," @test showable(MIME(\"text/plain\"), Py(nothing))"," @test showable(MIME(\"text/plain\"), Py(12))"," # https://github.com/JuliaPy/PythonCall.jl/issues/522"," @test showable(MIME(\"text/plain\"), PythonCall.pynew())"," @test !showable(MIME(\"text/html\"), PythonCall.pynew())"," @testset \"show\" begin"," @test sprint(show, MIME(\"text/plain\"), Py(nothing)) == \"Python: None\""," @test sprint(show, MIME(\"text/plain\"), Py(12)) == \"Python: 12\""," @test sprint(show, MIME(\"text/plain\"), PythonCall.pynew()) == \"Python: NULL\""," # test compact printing"," @test sprint(show, MIME(\"text/plain\"), Py(String('A':'Z')), context=(:compact=>true, :displaysize=>(50, 20))) == \"Py: 'ABCDE ... WXYZ'\""," @test sprint(show, MIME(\"text/plain\"), Py(String('A':'Z')), context=(:compact=>true, :limit=>false, :displaysize=>(50, 20))) == \"Py: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'\""," @test_throws MethodError sprint(show, MIME(\"text/html\"), PythonCall.pynew())","@testitem \"pywith\" begin"," @testset \"no error\" begin"," tdir = pyimport(\"tempfile\").TemporaryDirectory()"," tname = pyconvert(String, tdir.name)"," @test isdir(tname)"," pywith(tdir) do name"," @test pyconvert(String, name) == tname"," @test !isdir(tname)"," @testset \"error\" begin"," @test_throws PyException pywith(name -> name.invalid_attr, tdir)","@testitem \"propertynames\" begin"," x = pyint(7)"," task = Threads.@spawn propertynames(x)"," properties = propertynames(x)"," @test :__init__ in properties"," prop_task = fetch(task)"," @test properties == prop_task","@testitem \"on_main_thread\" begin"," refid = PythonCall.C.on_main_thread() do; Threads.threadid(); end"," tasks = [Threads.@spawn(PythonCall.C.on_main_thread() do; Threads.threadid(); end) for _ in 1:20]"," @test all(t -> fetch(t) == refid, tasks)"," @test_throws DivideError redirect_stderr(devnull) do"," PythonCall.C.on_main_thread() do"," throw(DivideError())","docs/src/pythoncall-reference.md",[921],{"_317":288,"_318":922,"_320":923,"_322":70},274,[924,178,925,178,926,927,928,929,178,930,178,931,178,926,932,933,934,935,936,937,938,939,940,941,942,943,944,945,946,929,178,947,178,948,178,926,949,950,951,952,953,954,955,956,957,958,959,960,961,962,963,964,965,966,967,968,969,970,971,972,973,974,975,976,977,978,979,980,981,982,929,178,983,178,984,178,926,985,986,929,178,987,178,988,178,989,990,178,926,991,992,993,994,995,996,929,178,997,178,998,178,999,1000,1001,1002,178,926,1003,1004,1005,1006,1007,1008,1009,1010,1011,1012,1013,1014,1015,1016,1017,1018,1019,1020,1021,1022,1023,1024,1025,1026,1027,1028,1029,1030,1031,1032,1033,1034,929,178,1035,178,1036,178,999,1037,1038,1002,178,1039,1040,178,926,1041,1042,1043,1044,1045,1046,1047,1048,929,178,1049,178,1050,1051,178,926,1052,1053,1054,1055,1056,929,178,1057,178,1058,178,1059,178,926,1060,1061,1062,1063,1064,1065,1066,1067,1068,1069,929,178,1070,178,1071,1072,1073,178,1074,1075,1076,1077,491,178,1078,1079,178,1080,1081,929,178,1082,178,926,1083,1084,929,178,1085,178,1086,1087,178,926,1088,1089,1090,1091,1092,929,178,1093,178,1094,1095,926,1096,1097,1098,1099,929,178,1100,178,1101,1102,178,926,1103,1104,1105,1106,1107,1108,929,178,1109,178,1110,178,926,1111,1112,1113,1114,1115,1116,1117,1118,929],"# [PythonCall API Reference](@id py-reference)","## `Py` objects","```@docs","Py","pybuiltins","```","## Constructors","These functions construct Python objects of builtin types from Julia values.","pybool","pycollist","pybytes","pycomplex","pydict","pyfloat","pyfrozenset","pyint","pylist","pyrange","pyrowlist","pyset","pyslice","pystr","pytuple","## Builtins","These functions mimic the Python builtin functions or keywords of the same name.","pyall","pyany","pyascii","pycall","pycallable","pycompile","pycontains","pydelattr","pydelitem","pydir","pyeval","@pyeval","pyexec","@pyexec","pygetattr","pygetitem","pyhasattr","pyhasitem","pyhash","pyhelp","pyimport","pyin","pyis","pyisinstance","pyissubclass","pyiter","pylen","pynext","pyprint","pyrepr","pysetattr","pysetitem","pytype(::Any)","pywith","## Conversion to Julia","These functions convert Python values to Julia values, using the rules documented [here](@ref jl2py).","pyconvert","@pyconvert","## Wrap Julia values","These functions explicitly wrap Julia values into Python objects, documented [here](@ref julia-wrappers).","As documented [here](@ref py2jl), Julia values are wrapped like this automatically on","conversion to Python, unless the value is immutable and has a corresponding Python type.","pyjl","pyjlraw","pyisjl","pyjlvalue","pybinaryio","pytextio","## Arithmetic","These functions are equivalent to the corresponding Python arithmetic operators.","Note that the equivalent Julia operators are overloaded to call these when all arguments","are `Py`. Hence the following are equivalent: `Py(1) + Py(2)`, `pyadd(1, 2)`,","`pyadd(Py(1), Py(2))`, etc. When mixing Julia and Python values explicitly call the","`py*` helper.","pyneg","pypos","pyabs","pyinv","pyindex","pyadd","pysub","pymul","pymatmul","pypow","pyfloordiv","pytruediv","pymod","pydivmod","pylshift","pyrshift","pyand","pyxor","pyor","pyiadd","pyisub","pyimul","pyimatmul","pyipow","pyifloordiv","pyitruediv","pyimod","pyilshift","pyirshift","pyiand","pyixor","pyior","## Logic","These functions are equivalent to the corresponding Python logical operators.","are `Py`. Hence the following are equivalent: `Py(1) < Py(2)`, `pylt(1, 2)`,","`pylt(Py(1), Py(2))`, etc. When mixing Julia and Python values explicitly call the","Note that the binary operators by default return `Py` (not `Bool`) since comparisons in","Python do not necessarily return `bool`.","pytruth","pynot","pyeq","pyne","pyle","pylt","pyge","pygt","## Create classes","These functions can be used to create new Python classes where the functions are implemented","in Julia. You can instead use [`@pyeval`](@ref) etc. to create pure-Python classes.","pytype(::Any, ::Any, ::Any)","pyfunc","pyclassmethod","pystaticmethod","pyproperty","## [Wrapper types](@id python-wrappers)","The following types wrap a Python object, giving it the semantics of a Julia object. For example `PyList(x)` interprets the Python sequence `x` as a Julia abstract vector.","Apart from a few fundamental immutable types, conversion from Python to Julia `Any` will return a wrapper type such as one of these, or simply `Py` if no wrapper type is suitable.","PyList","PySet","PyDict","PyIterable","PyArray","PyIO","PyTable","PyPandasDataFrame","PyObjectArray","PyException","### [Custom wrappers](@id python-wrappers-custom)","Here is a minimal example of defining a wrapper type. You may add methods, fields and a","supertype to the type to specialise its behaviour. See any of the above wrapper types for","examples.","```julia","# The new type with a field for the Python object being wrapped.","struct MyType"," py::Py","# Says that the object is a wrapper.","ispy(x::MyType) = true","# Says how to access the underlying Python object.","Py(x::MyType) = x.py","## `@py` and `@pyconst`","@py","@pyconst","## Multi-threading","These functions are not exported. They support multi-threading of Python and/or Julia.","See also [`juliacall.AnyValue._jl_call_nogil`](@ref julia-wrappers).","PythonCall.GIL.lock","PythonCall.GIL.@lock","PythonCall.GIL.unlock","PythonCall.GIL.@unlock","PythonCall.GC.gc","## The Python interpreter","These functions are not exported. They give information about which Python interpreter is","being used.","PythonCall.python_version","PythonCall.python_executable_path","PythonCall.python_library_path","PythonCall.python_library_handle","## Low-level API","The functions here are not exported. They are mostly unsafe in the sense that you can","crash Julia by using them incorrectly.","PythonCall.pynew","PythonCall.pyisnull","PythonCall.pycopy!","PythonCall.getptr","PythonCall.pydel!","PythonCall.unsafe_pynext","## NumpyDates","The submodule `PythonCall.NumpyDates` provides types corresponding to Numpy's `datetime64` and `timedelta64` types. Enables conversion of these Numpy types (either as scalars or in arrays) to native Julia types.","PythonCall.NumpyDates","PythonCall.NumpyDates.AbstractDateTime64","PythonCall.NumpyDates.InlineDateTime64","PythonCall.NumpyDates.DateTime64","PythonCall.NumpyDates.AbstractTimeDelta64","PythonCall.NumpyDates.InlineTimeDelta64","PythonCall.NumpyDates.TimeDelta64","PythonCall.NumpyDates.Unit","src/Core/Py.jl",[1121],{"_317":288,"_318":1122,"_320":1123,"_322":70},439,[1124,1125,178,1126,1127,178,1128,178,1129,1126,1130,178,1126,1131,178,1132,1126,1133,178,1126,1134,178,1135,1126,1136,178,1137,178,1138,1139,1140,178,1141,178,1142,1143,178,1144,178,1145,178,1126,1146,178,1147,178,1148,1149,178,1150,1151,1126,1152,1153,1154,1155,1156,332,178,1157,178,1158,178,1159,178,1126,1160,178,1161,178,1162,1163,1164,1165,178,1166,1126,1167,178,1126,1168,178,1169,178,1170,1171,1172,178,1173,1174,178,1175,1176,1177,1178,1126,1179,1180,1181,1182,1183,332,1184,1185,491,178,1186,1187,1188,1189,1190,1191,1192,1193,1194,1195,1196,1197,1198,491,178,1199,1200,1201,1202,1203,1204,1205,1206,1207,1208,1209,1210,1211,1212,1213,1214,178,1215,1216,178,1217,1218,1219,1220,1221,1222,397,1155,1219,1223,1221,1224,1225,1226,1227,1228,462,397,332,491,178,1229,1230,1231,1155,1232,332,1233,1234,1235,1236,1237,1238,1239,332,1240,1241,1242,1243,1244,1245,1246,1247,1248,1249,1250,1251,1252,1253,1254,1255,1256,1257,1258,1259,1260,1261,1257,537,462,1262,1263,1227,1264,1265,1266,1267,1268,1269,1270,1271,1272,1273,1260,1274,1257,537,1275,1276,1277,1278,1279,1280,1279,1281,462,1282,1283,1284,1285,1286,1287,1227,1288,1289,1290,1291,1292,1293,1294,1295,462,1221,1296,1297,1298,1286,1287,1227,1264,1299,1265,1300,1301,1302,1303,1304,1305,1306,1307,1308,1279,1295,462,397,1155,1309,332,491,178,178,1310,178,1311,1312,178,1313,1314,178,1315,1316,178,1317,1318,1319,1320,1321,1322,1323,1324,537,462,1325,397,178,1326,1327,1328,1329,1330,397,1331,1332,178,1333,1334,491,178,1335,178,1336,178,1337,1338,178,1339,1340,178,1341,178,1342,178,1343,178,1344,1345,1346,491,178,1347,1348,1349,1350,332,178,1351,1348,1352,1350,332,178,1353,178,1354,178,1355,1356,1357,1358,1359,1155,1360,332,491,178,1361,178,1362,178,1363,178,1364,178,1365,1366,1367,1368,1369,1370,1371,1372,1373,178,1374,1375,178,1376,1377,1378,1379,1380,178,1381,1382,1383,1384,1385,1386,1387,1388,1389,1390,1391,1392,1393,1394,1395,178,1396,178,1397,1398,1399,1400,1401,1402,1403,1404,1405,1406,1407,1408,1409,1410,1408,1411,1412,1405,1413,1414,1405,1415,1416,1405,1155,1417,1418,332,1419,1420,1421,1422,1423,332,1424,491,1425,1426],"incref(x::C.PyPtr) = (C.Py_IncRef(x); x)","decref(x::C.PyPtr) = (C.Py_DecRef(x); x)","\"\"\""," ispy(x)","True if `x` is a Python object.","This includes `Py` and Python wrapper types such as `PyList`.","ispy(x) = false"," pyisnull(x)","True if the Python object `x` is NULL.","pyisnull(x) = getptr(x) == C.PyNULL"," getptr(x)","Get the underlying pointer from the Python object `x`.","getptr(x) = ispy(x) ? getptr(Py(x)::Py) : throw(MethodError(getptr, (x,)))","py_finalizer(x::Py) = GC.enqueue(getptr(x))","ispy(::Py) = true","getptr(x::Py) = C.PyPtr(getfield(x, :ptr))","pyconvert(::Type{Py}, x::Py) = x","setptr!(x::Py, ptr::C.PyPtr) = (setfield!(x, :ptr, Ptr{Cvoid}(ptr)); x)","incref(x::Py) = Base.GC.@preserve x (incref(getptr(x)); x)","decref(x::Py) = Base.GC.@preserve x (decref(getptr(x)); x)","Base.unsafe_convert(::Type{C.PyPtr}, x::Py) = getptr(x)","const PYNULL_CACHE = Py[]"," pynew([ptr])","A new `Py` representing the Python object at `ptr` (NULL by default).","If `ptr` is given and non-NULL, this function steals a reference to the Python object it","points at, i.e. the new `Py` object owns a reference.","Note that NULL Python objects are not safe in the sense that most API functions will probably","crash your Julia session if you pass a NULL argument.","pynew() ="," if isempty(PYNULL_CACHE)"," Py(Val(:new), C.PyNULL)"," else"," pop!(PYNULL_CACHE)","const PyNULL = pynew()","pynew(ptr::C.PyPtr) = setptr!(pynew(), ptr)","pynew(x::Py) = Base.GC.@preserve x pynew(incref(getptr(x)))"," pycopy!(dst::Py, src)","Copy the Python object `src` into `dst`, so that they both represent the same object.","This function exists to support module-level constant Python objects. It is illegal to call","most PythonCall API functions at the top level of a module (i.e. before `__init__()` has run)","so you cannot do `const x = pything()` at the top level. Instead do `const x = pynew()` at","the top level then `pycopy!(x, pything())` inside `__init__()`.","Assumes `dst` is NULL, otherwise a memory leak will occur.","pycopy!(dst::Py, src) = Base.GC.@preserve src setptr!(dst, incref(getptr(src)))"," pydel!(x::Py)","Delete the Python object `x`.","DANGER! Use this function ONLY IF the Julia object `x` could have been garbage-collected","anyway, i.e. was about to become unreachable. This means you MUST KNOW that no other part of","the program has the Julia object `x`.","This decrements the reference count, sets the pointer to NULL and appends `x` to a cache","of unused objects (`PYNULL_CACHE`).","This is an optimization to avoid excessive allocation and deallocation in Julia, which can","be a significant source of slow-down in code which uses a lot of Python objects. It allows","`pynew()` to pop an item from `PYNULL_CACHE` instead of allocating one, and avoids calling","the relatively slow finalizer on `x`.","function pydel!(x::Py)"," ptr = getptr(x)"," if ptr != C.PyNULL"," C.Py_DecRef(ptr)"," setptr!(x, C.PyNULL)"," push!(PYNULL_CACHE, x)"," return","macro autopy(args...)"," vs = args[1:end-1]"," ts = [Symbol(v, \"_\") for v in vs]"," body = args[end]"," # ans = gensym(\"ans\")"," esc(quote"," # $([:($t = $ispy($v) ? $v : $Py($v)) for (t, v) in zip(ts, vs)]...)"," # $ans = $body"," # $([:($ispy($v) || $pydel!($t)) for (t, v) in zip(ts, vs)]...)"," # $ans"," $([:($t = $Py($v)) for (t, v) in zip(ts, vs)]...)"," $body"," end)","Py(x::Py) = x","Py(x::Nothing) = pybuiltins.None","Py(x::Bool) = x ? pybuiltins.True : pybuiltins.False","Py(x::Union{AbstractString,AbstractChar}) = pystr(x)","Py(x::Base.CodeUnits{UInt8,String}) = pybytes(x)","Py(x::Base.CodeUnits{UInt8,SubString{String}}) = pybytes(x)","Py(x::Tuple) = pytuple_fromiter(x)","Py(x::Pair) = pytuple_fromiter(x)","Py(x::Integer) = pyint(x)","Py(x::Rational{<:Integer}) = pyfraction(x)","Py(x::Union{Float16,Float32,Float64}) = pyfloat(x)","Py(x::Union{Complex{Float16},Complex{Float32},Complex{Float64}}) = pycomplex(x)","Py(x::AbstractRange{<:Integer}) = pyrange_fromrange(x)","Py(x::Date) = pydate(x)","Py(x::Time) = pytime(x)","Py(x::DateTime) = pydatetime(x)","Base.string(x::Py) = pyisnull(x) ? \"\" : pystr(String, x)","Base.print(io::IO, x::Py) = print(io, string(x))","function Base.show(io::IO, x::Py)"," if get(io, :typeinfo, Any) == Py"," if pyisnull(x)"," print(io, \"NULL\")"," else"," print(io, pyrepr(String, x))"," print(io, \"\")"," s = pyrepr(String, x)"," if startswith(s, \"<\") && endswith(s, \">\")"," print(io, \"\")","function Base.show(io::IO, ::MIME\"text/plain\", o::Py)"," if pyisnull(o)"," str = \"NULL\""," str = pyrepr(String, o)"," hasprefix = (get(io, :typeinfo, Any) != Py)::Bool"," compact = get(io, :compact, false)::Bool"," limit = get(io, :limit, true)::Bool"," if compact"," # compact should output a single line, which we force by replacing newline"," # characters with spaces"," str = replace(str, \"\\n\" => \" \")"," multiline = '\\n' in str"," prefix = !hasprefix ? \"\" : compact ? \"Py: \" : multiline ? \"Python:\\n\" : \"Python: \""," print(io, prefix)"," h, w = displaysize(io)"," if limit"," # limit: fit the printed text into the display size"," h, w = displaysize(io)"," h = max(h - 3, 5) # use 3 fewer lines to allow for the prompt, but always allow at least 5 lines"," if multiline"," # multiline: we truncate each line to the width of the screen, and skip"," # middle lines if there are too many for the height"," h -= 1 # for the prefix"," lines = split(str, '\\n')"," function printlines(io, lines, w)"," for (i, line) in enumerate(lines)"," if i > 1"," println(io)"," end"," if length(line) > w"," print(io, line[1:nextind(line, 0, w - 1)], '…')"," else"," print(io, line)"," if length(lines) ≤ h"," printlines(io, lines, w)"," h0 = cld(h - 1, 2)"," h1 = h - 1 - h0"," i0 = h0"," i1 = length(lines) - h1 + 1"," # this indent computation tries to center the \"more lines\" message near the"," # middle of the span of non-whitespace in lines"," indent = 0"," for (c0, c1) in zip(lines[i0], lines[i1])"," if c0 == c1 && isspace(c0)"," indent += 1"," break"," maxlen = min(w, max(length(lines[i0]), length(lines[i1])))"," msg = \"... $(length(lines)-h0-h1) more lines ...\""," indent = max(0, fld(maxlen + indent - length(msg), 2))"," printlines(io, lines[1:h0], w)"," println(io)"," printstyled(io, \" \"^indent, msg, color = :light_black)"," printlines(io, lines[end-h1+1:end], w)"," elseif compact"," # compact: we print up to one screen width, skipping characters in the"," # middle if the string is too long for the width"," maxlen = w - length(prefix)"," if length(str) ≤ maxlen"," print(io, str)"," gap = \" ... \""," gaplen = length(gap)"," w0 = cld(maxlen - gaplen, 2)"," i0 = nextind(str, 1, w0 - 1)"," i1 = prevind(str, ncodeunits(str), maxlen - gaplen - w0 - 1)"," print(io, str[begin:i0])"," printstyled(io, gap, color = :light_black)"," print(io, str[i1:end])"," # single-line: we print up to one screenfull, skipping characters in the"," # middle if the string is too long. We skip a whole line of characters."," maxlen = h * w - length(prefix)"," i0 = nextind(str, 0, h0 * w - length(prefix))"," i1 = prevind(str, ncodeunits(str) + 1, h1 * w)"," println(io, str[1:i0])"," msg = \"... $(length(str[nextind(str,i0):prevind(str,i1)])) more chars ...\""," printstyled("," io,"," \" \"^max(0, fld(w - length(msg), 2)),"," msg,"," color = :light_black,"," )"," print(io, str)","Base.showable(::MIME\"text/plain\", ::Py) = true","Base.getproperty(x::Py, k::Symbol) = pygetattr(x, string(k))","Base.getproperty(x::Py, k::String) = pygetattr(x, k)","Base.hasproperty(x::Py, k::Symbol) = pyhasattr(x, string(k))","Base.hasproperty(x::Py, k::String) = pyhasattr(x, k)","Base.setproperty!(x::Py, k::Symbol, v) = pysetattr(x, string(k), v)","Base.setproperty!(x::Py, k::String, v) = pysetattr(x, k, v)","function Base.propertynames(x::Py, private::Bool = false)"," properties = C.on_main_thread() do"," # this follows the logic of rlcompleter.py"," function classmembers(c)"," r = pydir(c)"," if pyhasattr(c, \"__bases__\")"," for b in c.__bases__"," r = pyiadd(r, classmembers(b))"," return r"," words = pyset(pydir(x::Py))"," words.discard(\"__builtins__\")"," if pyhasattr(x, \"__class__\")"," words.add(\"__class__\")"," words.update(classmembers(x.__class__))"," map(pystr_asstring, words)"," end::Vector{String} # explicit type since on_main_thread() is type-unstable"," # private || filter!(w->!startswith(w, \"_\"), words)"," map(Symbol, properties)","Base.Bool(x::Py) = pytruth(x)","Base.length(x::Py) = pylen(x)","Base.getindex(x::Py, i) = pygetitem(x, i)","Base.getindex(x::Py, i...) = pygetitem(x, i)","Base.setindex!(x::Py, v, i) = (pysetitem(x, i, v); x)","Base.setindex!(x::Py, v, i...) = (pysetitem(x, i, v); x)","Base.delete!(x::Py, i) = (pydelitem(x, i); x)","Base.haskey(x::Py, i) = pyhasitem(x, i)","Base.get(x::Py, i, d) = pygetitem(x, i, d)","function Base.get(f::Base.Callable, x::Py, i)"," v = pygetitem(x, i, nothing)"," v === nothing ? f() : v","Base.get!(x::Py, i, d) ="," get(x, i) do"," pysetitem(x, i, d)"," pygetitem(x, i)","Base.get!(f::Base.Callable, x::Py, i) ="," pysetitem(x, i, f())","Base.eltype(::Type{Py}) = Py","Base.IteratorSize(::Type{Py}) = Base.SizeUnknown()","function Base.iterate(x::Py, it::Py = pyiter(x))"," v = unsafe_pynext(it)"," if pyisnull(v)"," pydel!(it)"," nothing"," (v, it)","Base.in(v, x::Py) = pycontains(x, v)","Base.hash(x::Py, h::UInt) = reinterpret(UInt, Int(pyhash(x))) - 3h","Base.broadcastable(x::Py) = Ref(x)","(f::Py)(args...; kwargs...) = pycall(f, args...; kwargs...)","# comparisons","Base.:(==)(x::Py, y::Py) = pyeq(x, y)","Base.:(!=)(x::Py, y::Py) = pyne(x, y)","Base.:(<=)(x::Py, y::Py) = pyle(x, y)","Base.:(<)(x::Py, y::Py) = pylt(x, y)","Base.:(>=)(x::Py, y::Py) = pyge(x, y)","Base.:(>)(x::Py, y::Py) = pygt(x, y)","Base.isless(x::Py, y::Py) = pylt(Bool, x, y)","Base.isequal(x::Py, y::Py) = pyeq(Bool, x, y)","Base.zero(::Type{Py}) = pyint(0)","Base.one(::Type{Py}) = pyint(1)","# unary arithmetic","Base.:(+)(x::Py) = pypos(x)","Base.:(-)(x::Py) = pyneg(x)","Base.abs(x::Py) = pyabs(x)","Base.:(~)(x::Py) = pyinv(x)","# binary arithmetic","Base.:(+)(x::Py, y::Py) = pyadd(x, y)","Base.:(-)(x::Py, y::Py) = pysub(x, y)","Base.:(*)(x::Py, y::Py) = pymul(x, y)","# Base.:(+)(x::Py, y::Py) = pymatmul(x, y)","Base.div(x::Py, y::Py) = pyfloordiv(x, y)","Base.:(/)(x::Py, y::Py) = pytruediv(x, y)","Base.rem(x::Py, y::Py) = pymod(x, y)","# Base.:(+)(x::Py, y::Py) = pydivmod(x, y)","Base.:(<<)(x::Py, y::Py) = pylshift(x, y)","Base.:(>>)(x::Py, y::Py) = pyrshift(x, y)","Base.:(&)(x::Py, y::Py) = pyand(x, y)","Base.xor(x::Py, y::Py) = pyxor(x, y)","Base.:(|)(x::Py, y::Py) = pyor(x, y)","Base.:(^)(x::Py, y::Py) = pypow(x, y)","Base.powermod(x::Py, y::Py, z::Py) = pypow(x, y, z)","# documentation","function Base.Docs.getdoc(x::Py, @nospecialize(sig) = Union{})"," pyisnull(x) && return nothing"," parts = []"," inspect = pyimport(\"inspect\")"," # head line"," if pytruth(inspect.ismodule(x))"," desc = pyhasattr(x, \"__path__\") ? \"package\" : \"module\""," name = \"$(x.__name__)\""," elseif pytruth(inspect.isgetsetdescriptor(x))"," desc = \"getset descriptor\""," name = \"$(x.__objclass__.__name__).$(x.__name__)\""," elseif pytruth(inspect.ismemberdescriptor(x))"," desc = \"member descriptor\""," elseif pytruth(inspect.isclass(x))"," desc = \"class\""," elseif pytruth(inspect.isfunction(x)) || pytruth(inspect.isbuiltin(x))"," desc = \"function\""," elseif pytruth(inspect.ismethod(x))"," desc = \"method\""," desc = \"object of type\""," name = \"$(pytype(x).__name__)\""," push!(parts, Markdown.Paragraph([\"Python $desc \", Markdown.Code(name), \".\"]))"," # docstring"," doc = pyimport(\"inspect\").getdoc(x)"," if !pyisnone(doc)"," push!(parts, Markdown.Code(\"text\", pystr_asstring(doc)))"," return Markdown.MD(parts)","Base.Docs.doc(x::Py, sig::Type = Union{}) = Base.Docs.getdoc(x, sig)","Base.Docs.Binding(x::Py, k::Symbol) = getproperty(x, k)","message",[1429,1430,1431,1432,1433,1434,1435,1436],{"_1437":57,"_57":1452},{"_1437":1443,"_310":1119,"_317":1450,"_318":1451},{"_1437":57,"_57":1449},{"_1437":1443,"_310":919,"_317":1447,"_318":1448},{"_1437":57,"_57":1446},{"_1437":1443,"_310":311,"_317":1444,"_318":1445},{"_1437":57,"_57":1442},{"_1437":1438,"_1439":1440,"_317":288,"_318":1441},"content_type","terminal_chunk_citation","terminal_chunk_id","44f68f",2,"\n\n**Testing**\n* ⚠️ `julia --project -e 'using Pkg; Pkg.test()'` (fails because `julia` executable is unavailable in the environment)","repo_file_citation",786,803,"\n* Revised broadcast tests to operate purely on Python objects and added assertions that Julia number interop now raises `MethodError`, ensuring the new behaviour is covered.",102,149,"\n* Updated the arithmetic and logic documentation to clarify that Julia operators delegate to Python only when all operands are `Py` values and to recommend using the explicit `py*` helpers for mixed inputs.",365,400,"**Summary**\n* Restricted comparison and arithmetic overloads to `Py` arguments so that mixed `Py`/`Number` operator methods are no longer provided by default.","pr","pr_title","Remove Py/Number operator overloads","pr_message","## Summary\n- remove comparison and arithmetic overloads that mix `Py` and Julia `Number`\n- document that Julia operators only dispatch to Python when given `Py` arguments\n- adjust tests to operate on Python objects and assert Julia number interop is rejected\n\n## Testing\n- not run (Julia executable not available in environment)\n","output_diff",{"_104":1458,"_1461":1462,"_139":140,"_1463":-5,"_284":1464,"_1465":1466,"_1467":1468,"_1469":1470,"_1471":1472,"_1473":1474,"_1475":-5},"pre_apply_patch","repo_id","/workspace/PythonCall.jl","preapply_patch_base_commit_sha","diff --git a/docs/src/pythoncall-reference.md b/docs/src/pythoncall-reference.md\nindex f09d5f12050c3383ea2f51a92e323d9fe60af92f..40af2a69c2bfeea7ef733dec25c44c14a00a07af 100644\n--- a/docs/src/pythoncall-reference.md\n+++ b/docs/src/pythoncall-reference.md\n@@ -78,95 +78,97 @@ These functions convert Python values to Julia values, using the rules documente\n pyconvert\n @pyconvert\n ```\n \n ## Wrap Julia values\n \n These functions explicitly wrap Julia values into Python objects, documented [here](@ref julia-wrappers).\n \n As documented [here](@ref py2jl), Julia values are wrapped like this automatically on\n conversion to Python, unless the value is immutable and has a corresponding Python type.\n \n ```@docs\n pyjl\n pyjlraw\n pyisjl\n pyjlvalue\n pybinaryio\n pytextio\n ```\n \n ## Arithmetic\n \n These functions are equivalent to the corresponding Python arithmetic operators.\n \n Note that the equivalent Julia operators are overloaded to call these when all arguments\n-are `Py` (or `Number`). Hence the following are equivalent: `Py(1)+Py(2)`, `Py(1)+2`,\n-`pyadd(1, 2)`, `pyadd(Py(1), Py(2))`, etc.\n+are `Py`. Hence the following are equivalent: `Py(1) + Py(2)`, `pyadd(1, 2)`,\n+`pyadd(Py(1), Py(2))`, etc. When mixing Julia and Python values explicitly call the\n+`py*` helper.\n \n ```@docs\n pyneg\n pypos\n pyabs\n pyinv\n pyindex\n pyadd\n pysub\n pymul\n pymatmul\n pypow\n pyfloordiv\n pytruediv\n pymod\n pydivmod\n pylshift\n pyrshift\n pyand\n pyxor\n pyor\n pyiadd\n pyisub\n pyimul\n pyimatmul\n pyipow\n pyifloordiv\n pyitruediv\n pyimod\n pyilshift\n pyirshift\n pyiand\n pyixor\n pyior\n ```\n \n ## Logic\n \n These functions are equivalent to the corresponding Python logical operators.\n \n Note that the equivalent Julia operators are overloaded to call these when all arguments\n-are `Py` (or `Number`). Hence the following are equivalent: `Py(1) < Py(2)`, `Py(1) < 2`,\n-`pylt(1, 2)`, `pylt(Py(1), Py(2))`, etc.\n+are `Py`. Hence the following are equivalent: `Py(1) < Py(2)`, `pylt(1, 2)`,\n+`pylt(Py(1), Py(2))`, etc. When mixing Julia and Python values explicitly call the\n+`py*` helper.\n \n Note that the binary operators by default return `Py` (not `Bool`) since comparisons in\n Python do not necessarily return `bool`.\n \n ```@docs\n pytruth\n pynot\n pyeq\n pyne\n pyle\n pylt\n pyge\n pygt\n ```\n \n ## Create classes\n \n These functions can be used to create new Python classes where the functions are implemented\n in Julia. You can instead use [`@pyeval`](@ref) etc. to create pure-Python classes.\n \n ```@docs\n pytype(::Any, ::Any, ::Any)\n pyfunc\n pyclassmethod\n pystaticmethod\ndiff --git a/src/Core/Py.jl b/src/Core/Py.jl\nindex 8b26f036add89c1c4ba86c32107cc89bb713fb65..a481aa4daba86be5571c50a35d55414015e4a585 100644\n--- a/src/Core/Py.jl\n+++ b/src/Core/Py.jl\n@@ -350,132 +350,76 @@ function Base.iterate(x::Py, it::Py = pyiter(x))\n pydel!(it)\n nothing\n else\n (v, it)\n end\n end\n \n Base.in(v, x::Py) = pycontains(x, v)\n \n Base.hash(x::Py, h::UInt) = reinterpret(UInt, Int(pyhash(x))) - 3h\n \n Base.broadcastable(x::Py) = Ref(x)\n \n (f::Py)(args...; kwargs...) = pycall(f, args...; kwargs...)\n \n # comparisons\n Base.:(==)(x::Py, y::Py) = pyeq(x, y)\n Base.:(!=)(x::Py, y::Py) = pyne(x, y)\n Base.:(<=)(x::Py, y::Py) = pyle(x, y)\n Base.:(<)(x::Py, y::Py) = pylt(x, y)\n Base.:(>=)(x::Py, y::Py) = pyge(x, y)\n Base.:(>)(x::Py, y::Py) = pygt(x, y)\n Base.isless(x::Py, y::Py) = pylt(Bool, x, y)\n Base.isequal(x::Py, y::Py) = pyeq(Bool, x, y)\n \n-# we also allow comparison with numbers\n-Base.:(==)(x::Py, y::Number) = pyeq(x, y)\n-Base.:(!=)(x::Py, y::Number) = pyne(x, y)\n-Base.:(<=)(x::Py, y::Number) = pyle(x, y)\n-Base.:(<)(x::Py, y::Number) = pylt(x, y)\n-Base.:(>=)(x::Py, y::Number) = pyge(x, y)\n-Base.:(>)(x::Py, y::Number) = pygt(x, y)\n-Base.isless(x::Py, y::Number) = pylt(Bool, x, y)\n-Base.isequal(x::Py, y::Number) = pyeq(Bool, x, y)\n-\n-Base.:(==)(x::Number, y::Py) = pyeq(x, y)\n-Base.:(!=)(x::Number, y::Py) = pyne(x, y)\n-Base.:(<=)(x::Number, y::Py) = pyle(x, y)\n-Base.:(<)(x::Number, y::Py) = pylt(x, y)\n-Base.:(>=)(x::Number, y::Py) = pyge(x, y)\n-Base.:(>)(x::Number, y::Py) = pygt(x, y)\n-Base.isless(x::Number, y::Py) = pylt(Bool, x, y)\n-Base.isequal(x::Number, y::Py) = pyeq(Bool, x, y)\n-\n Base.zero(::Type{Py}) = pyint(0)\n Base.one(::Type{Py}) = pyint(1)\n \n # unary arithmetic\n Base.:(+)(x::Py) = pypos(x)\n Base.:(-)(x::Py) = pyneg(x)\n Base.abs(x::Py) = pyabs(x)\n Base.:(~)(x::Py) = pyinv(x)\n \n # binary arithmetic\n Base.:(+)(x::Py, y::Py) = pyadd(x, y)\n Base.:(-)(x::Py, y::Py) = pysub(x, y)\n Base.:(*)(x::Py, y::Py) = pymul(x, y)\n # Base.:(+)(x::Py, y::Py) = pymatmul(x, y)\n Base.div(x::Py, y::Py) = pyfloordiv(x, y)\n Base.:(/)(x::Py, y::Py) = pytruediv(x, y)\n Base.rem(x::Py, y::Py) = pymod(x, y)\n # Base.:(+)(x::Py, y::Py) = pydivmod(x, y)\n Base.:(<<)(x::Py, y::Py) = pylshift(x, y)\n Base.:(>>)(x::Py, y::Py) = pyrshift(x, y)\n Base.:(&)(x::Py, y::Py) = pyand(x, y)\n Base.xor(x::Py, y::Py) = pyxor(x, y)\n Base.:(|)(x::Py, y::Py) = pyor(x, y)\n Base.:(^)(x::Py, y::Py) = pypow(x, y)\n \n-# also allow binary arithmetic with numbers\n-Base.:(+)(x::Number, y::Py) = pyadd(x, y)\n-Base.:(-)(x::Number, y::Py) = pysub(x, y)\n-Base.:(*)(x::Number, y::Py) = pymul(x, y)\n-# Base.:(+)(x::Number, y::Py) = pymatmul(x, y)\n-Base.div(x::Number, y::Py) = pyfloordiv(x, y)\n-Base.:(/)(x::Number, y::Py) = pytruediv(x, y)\n-Base.rem(x::Number, y::Py) = pymod(x, y)\n-# Base.:(+)(x::Number, y::Py) = pydivmod(x, y)\n-Base.:(<<)(x::Number, y::Py) = pylshift(x, y)\n-Base.:(>>)(x::Number, y::Py) = pyrshift(x, y)\n-Base.:(&)(x::Number, y::Py) = pyand(x, y)\n-Base.xor(x::Number, y::Py) = pyxor(x, y)\n-Base.:(|)(x::Number, y::Py) = pyor(x, y)\n-Base.:(^)(x::Number, y::Py) = pypow(x, y)\n-\n-Base.:(+)(x::Py, y::Number) = pyadd(x, y)\n-Base.:(-)(x::Py, y::Number) = pysub(x, y)\n-Base.:(*)(x::Py, y::Number) = pymul(x, y)\n-# Base.:(+)(x::Py, y::Number) = pymatmul(x, y)\n-Base.div(x::Py, y::Number) = pyfloordiv(x, y)\n-Base.:(/)(x::Py, y::Number) = pytruediv(x, y)\n-Base.rem(x::Py, y::Number) = pymod(x, y)\n-# Base.:(+)(x::Py, y::Number) = pydivmod(x, y)\n-Base.:(<<)(x::Py, y::Number) = pylshift(x, y)\n-Base.:(>>)(x::Py, y::Number) = pyrshift(x, y)\n-Base.:(&)(x::Py, y::Number) = pyand(x, y)\n-Base.xor(x::Py, y::Number) = pyxor(x, y)\n-Base.:(|)(x::Py, y::Number) = pyor(x, y)\n-Base.:(^)(x::Py, y::Number) = pypow(x, y)\n-\n Base.powermod(x::Py, y::Py, z::Py) = pypow(x, y, z)\n-Base.powermod(x::Number, y::Py, z::Py) = pypow(x, y, z)\n-Base.powermod(x::Py, y::Number, z::Py) = pypow(x, y, z)\n-Base.powermod(x::Py, y::Py, z::Number) = pypow(x, y, z)\n-Base.powermod(x::Number, y::Number, z::Py) = pypow(x, y, z)\n-Base.powermod(x::Number, y::Py, z::Number) = pypow(x, y, z)\n-Base.powermod(x::Py, y::Number, z::Number) = pypow(x, y, z)\n \n # documentation\n function Base.Docs.getdoc(x::Py, @nospecialize(sig) = Union{})\n pyisnull(x) && return nothing\n parts = []\n inspect = pyimport(\"inspect\")\n # head line\n if pytruth(inspect.ismodule(x))\n desc = pyhasattr(x, \"__path__\") ? \"package\" : \"module\"\n name = \"$(x.__name__)\"\n elseif pytruth(inspect.isgetsetdescriptor(x))\n desc = \"getset descriptor\"\n name = \"$(x.__objclass__.__name__).$(x.__name__)\"\n elseif pytruth(inspect.ismemberdescriptor(x))\n desc = \"member descriptor\"\n name = \"$(x.__objclass__.__name__).$(x.__name__)\"\n elseif pytruth(inspect.isclass(x))\n desc = \"class\"\n name = \"$(x.__name__)\"\n elseif pytruth(inspect.isfunction(x)) || pytruth(inspect.isbuiltin(x))\n desc = \"function\"\n name = \"$(x.__name__)\"\n elseif pytruth(inspect.ismethod(x))\n desc = \"method\"\n name = \"$(x.__name__)\"\ndiff --git a/test/Core.jl b/test/Core.jl\nindex 8f2e428a41ea8eaea253c60e7c312c35e292e4d5..e6254811781ba42fdab441867117234548d9473a 100644\n--- a/test/Core.jl\n+++ b/test/Core.jl\n@@ -762,59 +762,68 @@ end\n # @pyexec\n @test_throws PyException @pyexec(`raise ValueError`)\n @test @pyexec(`1 + 2`) === nothing\n @test @pyexec(`ans = 1 + 2` => (ans::Int,)) === (ans = 3,)\n @test @pyexec((x = 1, y = 2) => `ans = x + y` => (ans::Int,)) === (ans = 3,)\n # @pyeval\n @test_throws PyException @pyeval(`import sys`) # not an expression\n @test_throws PyException @pyeval(`None + None`)\n @test @pyeval(`1 + 2` => Int) === 3\n @test @pyeval((x = 1, y = 2) => `x + y` => Int) === 3\n end\n \n @testitem \"@pyconst\" begin\n f() = @pyconst \"hello\"\n g() = @pyconst \"hello\"\n @test f() === f()\n @test f() === f()\n @test g() === g()\n @test g() !== f()\n @test f() isa Py\n @test pyeq(Bool, f(), \"hello\")\n end\n \n @testitem \"Base.jl\" begin\n @testset \"broadcast\" begin\n- # Py always broadcasts as a scalar\n- x = [1 2; 3 4] .+ Py(1)\n- @test isequal(x, [Py(2) Py(3); Py(4) Py(5)])\n- x = Py(\"foo\") .* [1 2; 3 4]\n- @test isequal(x, [Py(\"foo\") Py(\"foofoo\"); Py(\"foofoofoo\") Py(\"foofoofoofoo\")])\n+ # Py always broadcasts as a scalar when combined with other Py values\n+ x = Py.([1 2; 3 4]) .+ Py(1)\n+ @test isequal(x, Py.([2 3; 4 5]))\n+ x = Py(\"foo\") .* Py.([1 2; 3 4])\n+ @test isequal(x, Py.([\"foo\" \"foofoo\"; \"foofoofoo\" \"foofoofoofoo\"]))\n+ @test_throws MethodError [1 2; 3 4] .+ Py(1)\n # this previously treated the list as a shape (2,) object\n # but now tries to do `1 + [1, 2]` which properly fails\n @test_throws PyException [1 2; 3 4] .+ pylist([1, 2])\n end\n+ @testset \"Julia numbers\" begin\n+ @test Py(3) != 3\n+ @test 3 != Py(3)\n+ @test_throws MethodError Py(1) + 1\n+ @test_throws MethodError 1 + Py(1)\n+ @test_throws MethodError Py(1) < 2\n+ @test_throws MethodError 2 < Py(1)\n+ end\n @testset \"showable\" begin\n @test showable(MIME(\"text/plain\"), Py(nothing))\n @test showable(MIME(\"text/plain\"), Py(12))\n # https://github.com/JuliaPy/PythonCall.jl/issues/522\n @test showable(MIME(\"text/plain\"), PythonCall.pynew())\n @test !showable(MIME(\"text/html\"), PythonCall.pynew())\n end\n @testset \"show\" begin\n @test sprint(show, MIME(\"text/plain\"), Py(nothing)) == \"Python: None\"\n @test sprint(show, MIME(\"text/plain\"), Py(12)) == \"Python: 12\"\n # https://github.com/JuliaPy/PythonCall.jl/issues/522\n @test sprint(show, MIME(\"text/plain\"), PythonCall.pynew()) == \"Python: NULL\"\n # test compact printing\n @test sprint(show, MIME(\"text/plain\"), Py(String('A':'Z')), context=(:compact=>true, :displaysize=>(50, 20))) == \"Py: 'ABCDE ... WXYZ'\"\n @test sprint(show, MIME(\"text/plain\"), Py(String('A':'Z')), context=(:compact=>true, :limit=>false, :displaysize=>(50, 20))) == \"Py: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'\"\n @test_throws MethodError sprint(show, MIME(\"text/html\"), PythonCall.pynew())\n end\n end\n \n @testitem \"pywith\" begin\n @testset \"no error\" begin\n tdir = pyimport(\"tempfile\").TemporaryDirectory()\n tname = pyconvert(String, tdir.name)\n @test isdir(tname)\n pywith(tdir) do name\n","external_storage_diff",{"_1476":1477,"_1478":-5},"files_modified",3,"lines_added",20,"lines_removed",65,"commit_message","Remove Number interop operator overloads","additional_parent_commit_shas","file_id","file_00000000473461f78ffbfdd23edfc546","ttl",{"_104":285,"_53":96,"_108":285,"_1481":1482,"_1483":1484,"_1485":1486,"_143":-5,"_130":1487},[95],"input_items",[1506,1507],"external_post_config",{"_1488":1489,"_222":223,"_1490":265,"_233":-5,"_1461":217,"_1491":18,"_1492":-5,"_1493":-5,"_1494":-5,"_1495":1496,"_1497":-5,"_1498":-5,"_1499":1500,"_1501":18,"_1502":70,"_1503":65,"_1504":18,"_1505":-5},"user_model_slug","slug",1761604745.149147,"installation_id",91838277,"pr_number","enable_internal_github_app_routing","gitlab_service_account_project_id","review_trigger","comment_id","comment_type","issue","pr_write_guard_token","pending_pr_reaction_id","pending_comment_reaction_id",310999550,"comment_if_no_findings","comment_on_error","share_url","is_parallel_review","review_summary_id",{"_104":1427,"_108":285,"_320":1511},{"_272":273,"_274":275,"_1508":-5,"_1509":178,"_282":-5,"_104":1510},"base_ref","head_ref","pull_request_info",[1512],{"_1437":57,"_57":1513},"@codex can you make a pr to implement this",[1544,1545,1546],[],{"_299":1543},{"_296":1542},{"_296":1541},{"_264":265,"_255":266,"_267":268,"_269":18,"_270":70,"_271":18,"_272":273,"_274":275,"_276":138,"_277":138,"_278":-5,"_279":-5,"_280":-5,"_281":-5,"_282":-5,"_283":-5,"_284":-5,"_285":1540,"_287":288,"_289":-5,"_290":-5,"_291":-5},{"_53":134,"_171":-5,"_172":173,"_174":175,"_176":18,"_177":178,"_179":180,"_181":1529,"_183":-5,"_184":-5,"_185":18,"_186":1530,"_188":178,"_189":178,"_190":1531,"_192":1532,"_194":1533,"_196":-5,"_197":198,"_199":200,"_201":202,"_203":1534,"_66":-5,"_130":205,"_206":1535,"_208":1536,"_210":211,"_212":18,"_213":18},{"_144":1522},[1523,1524,1525],{"_155":1528,"_157":168},{"_155":1527,"_157":164},{"_155":1526,"_157":158},{"_159":160,"_104":161,"_130":162},{"_159":165,"_104":161,"_130":166},{"_159":169,"_104":161,"_130":170},{"_257":258,"_259":-5,"_260":-5,"_261":-5,"_262":-5,"_263":-5},[217],{"_217":1537},{},{},[],{"_216":70},{"_214":70,"_215":178},{"_53":219,"_159":175,"_220":1538,"_222":223,"_224":225,"_226":138,"_227":228,"_229":230,"_231":232,"_233":75,"_234":-5,"_235":18,"_236":70,"_237":70,"_238":70,"_239":18,"_240":-5,"_241":242,"_243":-5,"_66":1539},{"_249":250,"_53":251,"_104":252,"_253":254,"_255":256},{"_245":70,"_246":18,"_247":70,"_248":70},{"_249":292,"_159":292,"_293":-5,"_253":294,"_53":295},[],[],[],{"_104":1453,"_1454":1455,"_1456":1457,"_1458":1569,"_1460":-5},{"_104":1427,"_108":105,"_320":1560},{"_104":304,"_305":1547},[1548,1549,1550],{"_310":1119,"_312":-5,"_313":1557,"_315":-5},{"_310":919,"_312":-5,"_313":1554,"_315":-5},{"_310":311,"_312":-5,"_313":1551,"_315":-5},[1552],{"_317":288,"_318":319,"_320":1553,"_322":70},[323,324,325,326,327,328,329,330,331,332,333,334,335,336,332,337,338,339,340,332,341,342,343,332,344,345,346,347,348,349,350,351,352,353,350,332,354,355,356,357,358,332,359,355,360,357,361,362,360,363,364,332,365,366,367,368,369,370,371,372,373,374,375,332,376,377,378,379,380,381,382,383,384,385,386,387,332,388,389,390,391,332,392,393,394,395,396,397,398,399,397,332,400,401,402,395,403,397,398,404,397,332,405,398,406,407,397,408,409,332,410,411,412,413,414,415,416,417,418,419,420,332,421,422,423,424,425,426,427,332,428,422,424,429,430,431,332,432,433,434,435,436,437,438,332,439,440,441,442,443,444,445,446,332,447,448,449,450,451,332,452,453,454,455,456,332,457,458,459,460,461,462,397,332,463,458,459,464,465,462,397,332,466,458,459,467,468,462,397,332,469,458,459,470,471,462,397,332,472,411,473,474,475,476,477,478,332,479,411,480,481,482,483,484,485,332,486,487,488,489,490,332,491,178,492,493,494,495,496,497,498,499,497,498,500,497,501,502,496,503,499,503,500,504,491,178,505,506,395,507,397,332,508,395,509,397,332,510,395,511,397,332,512,395,513,397,332,514,395,515,397,332,516,517,518,519,462,397,332,520,517,518,521,462,397,332,522,517,518,523,462,397,332,524,525,526,527,528,529,530,531,532,517,518,533,534,535,536,537,462,397,332,538,517,518,533,539,535,540,537,462,397,332,541,517,518,533,542,535,543,537,462,397,332,544,517,518,533,545,535,546,537,462,397,332,547,398,548,397,332,549,398,550,397,332,551,552,553,554,462,397,332,555,552,553,556,462,397,332,557,552,553,558,462,397,332,559,491,178,560,561,562,563,564,565,566,332,567,568,569,397,332,570,568,571,397,332,572,573,574,575,576,577,332,578,579,580,581,332,491,178,582,583,584,585,586,587,588,589,590,591,592,593,594,595,596,597,598,491,178,599,600,601,491,178,602,603,604,605,606,607,608,609,491,178,610,611,612,613,614,615,616,617,618,619,620,621,622,491,178,623,624,625,626,627,628,629,630,631,632,633,634,635,636,491,178,637,638,639,626,640,641,629,630,631,632,642,643,644,645,646,647,648,649,491,178,650,651,652,626,653,654,655,656,657,658,659,660,661,662,663,491,178,664,665,666,667,668,669,670,671,672,491,178,673,674,675,676,677,678,679,680,677,678,679,681,677,678,679,682,677,678,679,683,684,491,178,685,686,687,688,676,689,687,690,691,689,687,692,693,689,687,694,695,696,491,178,697,698,699,688,700,701,699,702,703,704,699,705,706,707,701,699,708,709,710,711,491,178,712,713,714,715,716,717,718,719,720,721,722,715,723,724,725,726,727,717,728,729,730,731,732,719,491,178,733,734,735,736,737,738,739,735,740,741,738,742,735,740,741,743,491,178,744,745,746,747,748,749,750,746,740,748,749,751,746,740,748,752,491,178,753,524,491,178,754,755,756,757,758,756,759,760,756,761,762,763,491,178,764,524,491,178,765,524,491,178,766,767,768,769,770,771,772,773,774,775,776,777,778,779,780,781,782,783,784,785,786,787,788,789,491,178,790,791,792,793,794,795,796,797,798,799,800,801,802,803,804,805,806,807,808,809,810,811,812,813,814,815,816,817,817,818,819,820,821,822,823,824,825,826,827,828,829,830,831,832,829,833,834,835,836,823,837,838,839,840,841,842,843,844,845,846,847,848,849,850,851,852,853,854,491,178,855,856,857,858,858,859,860,861,862,491,178,863,864,865,866,867,868,869,870,871,872,873,332,874,875,876,877,878,879,880,332,881,882,883,884,885,886,332,887,888,889,884,890,891,892,893,894,332,491,178,895,896,897,898,899,900,901,397,902,332,903,897,898,899,904,902,332,491,178,905,906,907,908,909,910,911,491,178,912,913,914,915,916,917,918,397,332,491],[1555],{"_317":288,"_318":922,"_320":1556,"_322":70},[924,178,925,178,926,927,928,929,178,930,178,931,178,926,932,933,934,935,936,937,938,939,940,941,942,943,944,945,946,929,178,947,178,948,178,926,949,950,951,952,953,954,955,956,957,958,959,960,961,962,963,964,965,966,967,968,969,970,971,972,973,974,975,976,977,978,979,980,981,982,929,178,983,178,984,178,926,985,986,929,178,987,178,988,178,989,990,178,926,991,992,993,994,995,996,929,178,997,178,998,178,999,1000,1001,1002,178,926,1003,1004,1005,1006,1007,1008,1009,1010,1011,1012,1013,1014,1015,1016,1017,1018,1019,1020,1021,1022,1023,1024,1025,1026,1027,1028,1029,1030,1031,1032,1033,1034,929,178,1035,178,1036,178,999,1037,1038,1002,178,1039,1040,178,926,1041,1042,1043,1044,1045,1046,1047,1048,929,178,1049,178,1050,1051,178,926,1052,1053,1054,1055,1056,929,178,1057,178,1058,178,1059,178,926,1060,1061,1062,1063,1064,1065,1066,1067,1068,1069,929,178,1070,178,1071,1072,1073,178,1074,1075,1076,1077,491,178,1078,1079,178,1080,1081,929,178,1082,178,926,1083,1084,929,178,1085,178,1086,1087,178,926,1088,1089,1090,1091,1092,929,178,1093,178,1094,1095,926,1096,1097,1098,1099,929,178,1100,178,1101,1102,178,926,1103,1104,1105,1106,1107,1108,929,178,1109,178,1110,178,926,1111,1112,1113,1114,1115,1116,1117,1118,929],[1558],{"_317":288,"_318":1122,"_320":1559,"_322":70},[1124,1125,178,1126,1127,178,1128,178,1129,1126,1130,178,1126,1131,178,1132,1126,1133,178,1126,1134,178,1135,1126,1136,178,1137,178,1138,1139,1140,178,1141,178,1142,1143,178,1144,178,1145,178,1126,1146,178,1147,178,1148,1149,178,1150,1151,1126,1152,1153,1154,1155,1156,332,178,1157,178,1158,178,1159,178,1126,1160,178,1161,178,1162,1163,1164,1165,178,1166,1126,1167,178,1126,1168,178,1169,178,1170,1171,1172,178,1173,1174,178,1175,1176,1177,1178,1126,1179,1180,1181,1182,1183,332,1184,1185,491,178,1186,1187,1188,1189,1190,1191,1192,1193,1194,1195,1196,1197,1198,491,178,1199,1200,1201,1202,1203,1204,1205,1206,1207,1208,1209,1210,1211,1212,1213,1214,178,1215,1216,178,1217,1218,1219,1220,1221,1222,397,1155,1219,1223,1221,1224,1225,1226,1227,1228,462,397,332,491,178,1229,1230,1231,1155,1232,332,1233,1234,1235,1236,1237,1238,1239,332,1240,1241,1242,1243,1244,1245,1246,1247,1248,1249,1250,1251,1252,1253,1254,1255,1256,1257,1258,1259,1260,1261,1257,537,462,1262,1263,1227,1264,1265,1266,1267,1268,1269,1270,1271,1272,1273,1260,1274,1257,537,1275,1276,1277,1278,1279,1280,1279,1281,462,1282,1283,1284,1285,1286,1287,1227,1288,1289,1290,1291,1292,1293,1294,1295,462,1221,1296,1297,1298,1286,1287,1227,1264,1299,1265,1300,1301,1302,1303,1304,1305,1306,1307,1308,1279,1295,462,397,1155,1309,332,491,178,178,1310,178,1311,1312,178,1313,1314,178,1315,1316,178,1317,1318,1319,1320,1321,1322,1323,1324,537,462,1325,397,178,1326,1327,1328,1329,1330,397,1331,1332,178,1333,1334,491,178,1335,178,1336,178,1337,1338,178,1339,1340,178,1341,178,1342,178,1343,178,1344,1345,1346,491,178,1347,1348,1349,1350,332,178,1351,1348,1352,1350,332,178,1353,178,1354,178,1355,1356,1357,1358,1359,1155,1360,332,491,178,1361,178,1362,178,1363,178,1364,178,1365,1366,1367,1368,1369,1370,1371,1372,1373,178,1374,1375,178,1376,1377,1378,1379,1380,178,1381,1382,1383,1384,1385,1386,1387,1388,1389,1390,1391,1392,1393,1394,1395,178,1396,178,1397,1398,1399,1400,1401,1402,1403,1404,1405,1406,1407,1408,1409,1410,1408,1411,1412,1405,1413,1414,1405,1415,1416,1405,1155,1417,1418,332,1419,1420,1421,1422,1423,332,1424,491,1425,1426],[1561,1562,1563,1564,1565,1566,1567,1568],{"_1437":57,"_57":1452},{"_1437":1443,"_310":1119,"_317":1450,"_318":1451},{"_1437":57,"_57":1449},{"_1437":1443,"_310":919,"_317":1447,"_318":1448},{"_1437":57,"_57":1446},{"_1437":1443,"_310":311,"_317":1444,"_318":1445},{"_1437":57,"_57":1442},{"_1437":1438,"_1439":1440,"_317":288,"_318":1441},{"_104":1458,"_1461":1462,"_139":140,"_1463":-5,"_284":1464,"_1465":1570,"_1467":1468,"_1469":1470,"_1471":1472,"_1473":1474,"_1475":-5},{"_1476":1477,"_1478":-5},[1601,1602,1603],[],{"_299":1600},{"_296":1599},{"_296":1598},{"_264":265,"_255":266,"_267":268,"_269":18,"_270":70,"_271":18,"_272":273,"_274":275,"_276":138,"_277":138,"_278":-5,"_279":-5,"_280":-5,"_281":-5,"_282":-5,"_283":-5,"_284":-5,"_285":1597,"_287":288,"_289":-5,"_290":-5,"_291":-5},{"_53":134,"_171":-5,"_172":173,"_174":175,"_176":18,"_177":178,"_179":180,"_181":1586,"_183":-5,"_184":-5,"_185":18,"_186":1587,"_188":178,"_189":178,"_190":1588,"_192":1589,"_194":1590,"_196":-5,"_197":198,"_199":200,"_201":202,"_203":1591,"_66":-5,"_130":205,"_206":1592,"_208":1593,"_210":211,"_212":18,"_213":18},{"_144":1579},[1580,1581,1582],{"_155":1585,"_157":168},{"_155":1584,"_157":164},{"_155":1583,"_157":158},{"_159":160,"_104":161,"_130":162},{"_159":165,"_104":161,"_130":166},{"_159":169,"_104":161,"_130":170},{"_257":258,"_259":-5,"_260":-5,"_261":-5,"_262":-5,"_263":-5},[217],{"_217":1594},{},{},[],{"_216":70},{"_214":70,"_215":178},{"_53":219,"_159":175,"_220":1595,"_222":223,"_224":225,"_226":138,"_227":228,"_229":230,"_231":232,"_233":75,"_234":-5,"_235":18,"_236":70,"_237":70,"_238":70,"_239":18,"_240":-5,"_241":242,"_243":-5,"_66":1596},{"_249":250,"_53":251,"_104":252,"_253":254,"_255":256},{"_245":70,"_246":18,"_247":70,"_248":70},{"_249":292,"_159":292,"_293":-5,"_253":294,"_53":295},[],[],[],{"_104":1453,"_1454":1455,"_1456":1457,"_1458":1626,"_1460":-5},{"_104":1427,"_108":105,"_320":1617},{"_104":304,"_305":1604},[1605,1606,1607],{"_310":1119,"_312":-5,"_313":1614,"_315":-5},{"_310":919,"_312":-5,"_313":1611,"_315":-5},{"_310":311,"_312":-5,"_313":1608,"_315":-5},[1609],{"_317":288,"_318":319,"_320":1610,"_322":70},[323,324,325,326,327,328,329,330,331,332,333,334,335,336,332,337,338,339,340,332,341,342,343,332,344,345,346,347,348,349,350,351,352,353,350,332,354,355,356,357,358,332,359,355,360,357,361,362,360,363,364,332,365,366,367,368,369,370,371,372,373,374,375,332,376,377,378,379,380,381,382,383,384,385,386,387,332,388,389,390,391,332,392,393,394,395,396,397,398,399,397,332,400,401,402,395,403,397,398,404,397,332,405,398,406,407,397,408,409,332,410,411,412,413,414,415,416,417,418,419,420,332,421,422,423,424,425,426,427,332,428,422,424,429,430,431,332,432,433,434,435,436,437,438,332,439,440,441,442,443,444,445,446,332,447,448,449,450,451,332,452,453,454,455,456,332,457,458,459,460,461,462,397,332,463,458,459,464,465,462,397,332,466,458,459,467,468,462,397,332,469,458,459,470,471,462,397,332,472,411,473,474,475,476,477,478,332,479,411,480,481,482,483,484,485,332,486,487,488,489,490,332,491,178,492,493,494,495,496,497,498,499,497,498,500,497,501,502,496,503,499,503,500,504,491,178,505,506,395,507,397,332,508,395,509,397,332,510,395,511,397,332,512,395,513,397,332,514,395,515,397,332,516,517,518,519,462,397,332,520,517,518,521,462,397,332,522,517,518,523,462,397,332,524,525,526,527,528,529,530,531,532,517,518,533,534,535,536,537,462,397,332,538,517,518,533,539,535,540,537,462,397,332,541,517,518,533,542,535,543,537,462,397,332,544,517,518,533,545,535,546,537,462,397,332,547,398,548,397,332,549,398,550,397,332,551,552,553,554,462,397,332,555,552,553,556,462,397,332,557,552,553,558,462,397,332,559,491,178,560,561,562,563,564,565,566,332,567,568,569,397,332,570,568,571,397,332,572,573,574,575,576,577,332,578,579,580,581,332,491,178,582,583,584,585,586,587,588,589,590,591,592,593,594,595,596,597,598,491,178,599,600,601,491,178,602,603,604,605,606,607,608,609,491,178,610,611,612,613,614,615,616,617,618,619,620,621,622,491,178,623,624,625,626,627,628,629,630,631,632,633,634,635,636,491,178,637,638,639,626,640,641,629,630,631,632,642,643,644,645,646,647,648,649,491,178,650,651,652,626,653,654,655,656,657,658,659,660,661,662,663,491,178,664,665,666,667,668,669,670,671,672,491,178,673,674,675,676,677,678,679,680,677,678,679,681,677,678,679,682,677,678,679,683,684,491,178,685,686,687,688,676,689,687,690,691,689,687,692,693,689,687,694,695,696,491,178,697,698,699,688,700,701,699,702,703,704,699,705,706,707,701,699,708,709,710,711,491,178,712,713,714,715,716,717,718,719,720,721,722,715,723,724,725,726,727,717,728,729,730,731,732,719,491,178,733,734,735,736,737,738,739,735,740,741,738,742,735,740,741,743,491,178,744,745,746,747,748,749,750,746,740,748,749,751,746,740,748,752,491,178,753,524,491,178,754,755,756,757,758,756,759,760,756,761,762,763,491,178,764,524,491,178,765,524,491,178,766,767,768,769,770,771,772,773,774,775,776,777,778,779,780,781,782,783,784,785,786,787,788,789,491,178,790,791,792,793,794,795,796,797,798,799,800,801,802,803,804,805,806,807,808,809,810,811,812,813,814,815,816,817,817,818,819,820,821,822,823,824,825,826,827,828,829,830,831,832,829,833,834,835,836,823,837,838,839,840,841,842,843,844,845,846,847,848,849,850,851,852,853,854,491,178,855,856,857,858,858,859,860,861,862,491,178,863,864,865,866,867,868,869,870,871,872,873,332,874,875,876,877,878,879,880,332,881,882,883,884,885,886,332,887,888,889,884,890,891,892,893,894,332,491,178,895,896,897,898,899,900,901,397,902,332,903,897,898,899,904,902,332,491,178,905,906,907,908,909,910,911,491,178,912,913,914,915,916,917,918,397,332,491],[1612],{"_317":288,"_318":922,"_320":1613,"_322":70},[924,178,925,178,926,927,928,929,178,930,178,931,178,926,932,933,934,935,936,937,938,939,940,941,942,943,944,945,946,929,178,947,178,948,178,926,949,950,951,952,953,954,955,956,957,958,959,960,961,962,963,964,965,966,967,968,969,970,971,972,973,974,975,976,977,978,979,980,981,982,929,178,983,178,984,178,926,985,986,929,178,987,178,988,178,989,990,178,926,991,992,993,994,995,996,929,178,997,178,998,178,999,1000,1001,1002,178,926,1003,1004,1005,1006,1007,1008,1009,1010,1011,1012,1013,1014,1015,1016,1017,1018,1019,1020,1021,1022,1023,1024,1025,1026,1027,1028,1029,1030,1031,1032,1033,1034,929,178,1035,178,1036,178,999,1037,1038,1002,178,1039,1040,178,926,1041,1042,1043,1044,1045,1046,1047,1048,929,178,1049,178,1050,1051,178,926,1052,1053,1054,1055,1056,929,178,1057,178,1058,178,1059,178,926,1060,1061,1062,1063,1064,1065,1066,1067,1068,1069,929,178,1070,178,1071,1072,1073,178,1074,1075,1076,1077,491,178,1078,1079,178,1080,1081,929,178,1082,178,926,1083,1084,929,178,1085,178,1086,1087,178,926,1088,1089,1090,1091,1092,929,178,1093,178,1094,1095,926,1096,1097,1098,1099,929,178,1100,178,1101,1102,178,926,1103,1104,1105,1106,1107,1108,929,178,1109,178,1110,178,926,1111,1112,1113,1114,1115,1116,1117,1118,929],[1615],{"_317":288,"_318":1122,"_320":1616,"_322":70},[1124,1125,178,1126,1127,178,1128,178,1129,1126,1130,178,1126,1131,178,1132,1126,1133,178,1126,1134,178,1135,1126,1136,178,1137,178,1138,1139,1140,178,1141,178,1142,1143,178,1144,178,1145,178,1126,1146,178,1147,178,1148,1149,178,1150,1151,1126,1152,1153,1154,1155,1156,332,178,1157,178,1158,178,1159,178,1126,1160,178,1161,178,1162,1163,1164,1165,178,1166,1126,1167,178,1126,1168,178,1169,178,1170,1171,1172,178,1173,1174,178,1175,1176,1177,1178,1126,1179,1180,1181,1182,1183,332,1184,1185,491,178,1186,1187,1188,1189,1190,1191,1192,1193,1194,1195,1196,1197,1198,491,178,1199,1200,1201,1202,1203,1204,1205,1206,1207,1208,1209,1210,1211,1212,1213,1214,178,1215,1216,178,1217,1218,1219,1220,1221,1222,397,1155,1219,1223,1221,1224,1225,1226,1227,1228,462,397,332,491,178,1229,1230,1231,1155,1232,332,1233,1234,1235,1236,1237,1238,1239,332,1240,1241,1242,1243,1244,1245,1246,1247,1248,1249,1250,1251,1252,1253,1254,1255,1256,1257,1258,1259,1260,1261,1257,537,462,1262,1263,1227,1264,1265,1266,1267,1268,1269,1270,1271,1272,1273,1260,1274,1257,537,1275,1276,1277,1278,1279,1280,1279,1281,462,1282,1283,1284,1285,1286,1287,1227,1288,1289,1290,1291,1292,1293,1294,1295,462,1221,1296,1297,1298,1286,1287,1227,1264,1299,1265,1300,1301,1302,1303,1304,1305,1306,1307,1308,1279,1295,462,397,1155,1309,332,491,178,178,1310,178,1311,1312,178,1313,1314,178,1315,1316,178,1317,1318,1319,1320,1321,1322,1323,1324,537,462,1325,397,178,1326,1327,1328,1329,1330,397,1331,1332,178,1333,1334,491,178,1335,178,1336,178,1337,1338,178,1339,1340,178,1341,178,1342,178,1343,178,1344,1345,1346,491,178,1347,1348,1349,1350,332,178,1351,1348,1352,1350,332,178,1353,178,1354,178,1355,1356,1357,1358,1359,1155,1360,332,491,178,1361,178,1362,178,1363,178,1364,178,1365,1366,1367,1368,1369,1370,1371,1372,1373,178,1374,1375,178,1376,1377,1378,1379,1380,178,1381,1382,1383,1384,1385,1386,1387,1388,1389,1390,1391,1392,1393,1394,1395,178,1396,178,1397,1398,1399,1400,1401,1402,1403,1404,1405,1406,1407,1408,1409,1410,1408,1411,1412,1405,1413,1414,1405,1415,1416,1405,1155,1417,1418,332,1419,1420,1421,1422,1423,332,1424,491,1425,1426],[1618,1619,1620,1621,1622,1623,1624,1625],{"_1437":57,"_57":1452},{"_1437":1443,"_310":1119,"_317":1450,"_318":1451},{"_1437":57,"_57":1449},{"_1437":1443,"_310":919,"_317":1447,"_318":1448},{"_1437":57,"_57":1446},{"_1437":1443,"_310":311,"_317":1444,"_318":1445},{"_1437":57,"_57":1442},{"_1437":1438,"_1439":1440,"_317":288,"_318":1441},{"_104":1458,"_1461":1462,"_139":140,"_1463":-5,"_284":1464,"_1465":1627,"_1467":1468,"_1469":1470,"_1471":1472,"_1473":1474,"_1475":-5},{"_1476":1477,"_1478":-5},[1630,1631],{"_1488":1489,"_222":223,"_1490":265,"_233":-5,"_1461":217,"_1491":18,"_1492":-5,"_1493":-5,"_1494":-5,"_1495":1496,"_1497":-5,"_1498":-5,"_1499":1500,"_1501":18,"_1502":70,"_1503":65,"_1504":18,"_1505":-5},{"_104":1427,"_108":285,"_320":1632},{"_272":273,"_274":275,"_1508":-5,"_1509":178,"_282":-5,"_104":1510},[1633],{"_1437":57,"_57":1513},"task_e_68fff486a1488331b22bbee5a1f5faa5",1761604742.630143,"Github Mention: Remove methods like ==(::Py, ::Number) and +(::Number, ::Py)","has_generated_title","has_unread_turn","denormalized_metadata",{"_1665":43,"_1666":1667,"_1668":-5,"_1669":-5,"_1659":1670,"_1671":-5,"_1672":-5,"_1673":-5,"_1674":-5},"task_status_display",{"_1653":1654,"_1655":175,"_141":138,"_1656":-5,"_1657":1453},"creator_workspace","external_pull_requests",[1646],{"_53":1647,"_1648":95,"_1649":1650,"_1651":178},"github-309740192-703","assistant_turn_id","pull_request",{"_264":265,"_255":266,"_267":268,"_269":18,"_270":70,"_271":18,"_272":273,"_274":275,"_276":138,"_277":138,"_278":-5,"_279":-5,"_280":-5,"_281":-5,"_282":-5,"_283":-5,"_284":-5,"_285":1652,"_287":288,"_289":-5,"_290":-5,"_291":-5},"codex_updated_sha",{"_249":292,"_159":292,"_293":-5,"_253":294,"_53":295},"latest_turn_status_display",{"_1658":95,"_123":124,"_1659":1660,"_106":1661,"_1662":-5,"_1663":-5,"_1664":1453,"_125":-5},"environment_label","fix_task_id","initial_intent","turn_id","diff_stats",{"_1467":1468,"_1469":1470,"_1471":1472},[],"image_asset_pointer_citations","issue_counts","intent","num_follow_ups","repo_name_map",{},"last_user_turn_created_at","last_turn_status",{"_1467":-5,"_1469":-5,"_1471":-5},"last_pushed_turn_id","start_branch_name","pushed_branch_name","cached_pull_request_data","dd",{"_1689":1690,"_1691":1692},"disablePrefetch","shouldPrefetchAccount","shouldPrefetchUser","shouldPrefetchSystemHints","manageRootRouteStylesheet","mobileWebHandoffEnabled","promoteCss","disableSSR","stripModulepreloadImports","paidCampaignAppRedirect","statsigGateEvaluationsPromise",["P",1688],"traceId","2800733803396159090","traceTime",1791606634267]