Datasets:

CodeLogic-Team
/

CodeLens

@@ -1,60 +1 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.avro filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.lz4 filter=lfs diff=lfs merge=lfs -text
-*.mds filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
 *.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
-# Audio files - uncompressed
-*.pcm filter=lfs diff=lfs merge=lfs -text
-*.sam filter=lfs diff=lfs merge=lfs -text
-*.raw filter=lfs diff=lfs merge=lfs -text
-# Audio files - compressed
-*.aac filter=lfs diff=lfs merge=lfs -text
-*.flac filter=lfs diff=lfs merge=lfs -text
-*.mp3 filter=lfs diff=lfs merge=lfs -text
-*.ogg filter=lfs diff=lfs merge=lfs -text
-*.wav filter=lfs diff=lfs merge=lfs -text
-# Image files - uncompressed
-*.bmp filter=lfs diff=lfs merge=lfs -text
-*.gif filter=lfs diff=lfs merge=lfs -text
-*.png filter=lfs diff=lfs merge=lfs -text
-*.tiff filter=lfs diff=lfs merge=lfs -text
-# Image files - compressed
-*.jpg filter=lfs diff=lfs merge=lfs -text
-*.jpeg filter=lfs diff=lfs merge=lfs -text
-*.webp filter=lfs diff=lfs merge=lfs -text
-# Video files - compressed
-*.mp4 filter=lfs diff=lfs merge=lfs -text
-*.webm filter=lfs diff=lfs merge=lfs -text






















1	*.parquet filter=lfs diff=lfs merge=lfs -text

.gitignore ADDED Viewed

	@@ -0,0 +1,4 @@

+__pycache__/
+*.py[cod]
+.venv/
+.cache/

CHANGELOG.md ADDED Viewed

	@@ -0,0 +1,7 @@

+# Changes
+## 1.0.0 — 2026-09-07
+- Four Parquet configurations with train and validation splits.
+- Added a fixed 100-problem TACO SFT holdout; preserved historical memberships.
+- Included taxonomies, source/file manifests, reward code, and validation scripts.

LICENSE ADDED Viewed

	@@ -0,0 +1,22 @@

+SOURCE-SPECIFIC DATA LICENSES
+This dataset combines separately licensed sources. No single permissive license
+replaces the terms of the underlying records.
+KodCode-derived data (data/kodcode/): Creative Commons Attribution-
+NonCommercial 4.0 International (CC BY-NC 4.0).
+https://creativecommons.org/licenses/by-nc/4.0/legalcode
+TACO-derived data (TACO records in data/taco_leetcode/): the upstream release
+states Apache License 2.0, with additional source-specific MIT / CC BY 4.0
+material and source-rights qualifications. Those upstream terms remain.
+https://huggingface.co/datasets/BAAI/TACO#license
+https://www.apache.org/licenses/LICENSE-2.0
+LeetCodeDataset-derived data (leetcode2k records in data/taco_leetcode/):
+the upstream release declares Apache License 2.0; preserve source attribution.
+https://huggingface.co/datasets/newfacade/LeetCodeDataset
+Source attribution and references are in NOTICE.md. Packaging and metadata do
+not remove upstream conditions. No separate code license is asserted here.
+Copies of the Apache 2.0, CC BY-NC 4.0 and CC BY 4.0 texts are in LICENSES/.

LICENSES/Apache-2.0.txt ADDED Viewed

	@@ -0,0 +1,202 @@

+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+   1. Definitions.
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+   END OF TERMS AND CONDITIONS
+   APPENDIX: How to apply the Apache License to your work.
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+   Copyright [yyyy] [name of copyright owner]
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+       http://www.apache.org/licenses/LICENSE-2.0
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

LICENSES/CC-BY-4.0.txt ADDED Viewed

	@@ -0,0 +1,396 @@

+Attribution 4.0 International
+=======================================================================
+Creative Commons Corporation ("Creative Commons") is not a law firm and
+does not provide legal services or legal advice. Distribution of
+Creative Commons public licenses does not create a lawyer-client or
+other relationship. Creative Commons makes its licenses and related
+information available on an "as-is" basis. Creative Commons gives no
+warranties regarding its licenses, any material licensed under their
+terms and conditions, or any related information. Creative Commons
+disclaims all liability for damages resulting from their use to the
+fullest extent possible.
+Using Creative Commons Public Licenses
+Creative Commons public licenses provide a standard set of terms and
+conditions that creators and other rights holders may use to share
+original works of authorship and other material subject to copyright
+and certain other rights specified in the public license below. The
+following considerations are for informational purposes only, are not
+exhaustive, and do not form part of our licenses.
+     Considerations for licensors: Our public licenses are
+     intended for use by those authorized to give the public
+     permission to use material in ways otherwise restricted by
+     copyright and certain other rights. Our licenses are
+     irrevocable. Licensors should read and understand the terms
+     and conditions of the license they choose before applying it.
+     Licensors should also secure all rights necessary before
+     applying our licenses so that the public can reuse the
+     material as expected. Licensors should clearly mark any
+     material not subject to the license. This includes other CC-
+     licensed material, or material used under an exception or
+     limitation to copyright. More considerations for licensors:
+    wiki.creativecommons.org/Considerations_for_licensors
+     Considerations for the public: By using one of our public
+     licenses, a licensor grants the public permission to use the
+     licensed material under specified terms and conditions. If
+     the licensor's permission is not necessary for any reason--for
+     example, because of any applicable exception or limitation to
+     copyright--then that use is not regulated by the license. Our
+     licenses grant only permissions under copyright and certain
+     other rights that a licensor has authority to grant. Use of
+     the licensed material may still be restricted for other
+     reasons, including because others have copyright or other
+     rights in the material. A licensor may make special requests,
+     such as asking that all changes be marked or described.
+     Although not required by our licenses, you are encouraged to
+     respect those requests where reasonable. More considerations
+     for the public:
+    wiki.creativecommons.org/Considerations_for_licensees
+=======================================================================
+Creative Commons Attribution 4.0 International Public License
+By exercising the Licensed Rights (defined below), You accept and agree
+to be bound by the terms and conditions of this Creative Commons
+Attribution 4.0 International Public License ("Public License"). To the
+extent this Public License may be interpreted as a contract, You are
+granted the Licensed Rights in consideration of Your acceptance of
+these terms and conditions, and the Licensor grants You such rights in
+consideration of benefits the Licensor receives from making the
+Licensed Material available under these terms and conditions.
+Section 1 -- Definitions.
+  a. Adapted Material means material subject to Copyright and Similar
+     Rights that is derived from or based upon the Licensed Material
+     and in which the Licensed Material is translated, altered,
+     arranged, transformed, or otherwise modified in a manner requiring
+     permission under the Copyright and Similar Rights held by the
+     Licensor. For purposes of this Public License, where the Licensed
+     Material is a musical work, performance, or sound recording,
+     Adapted Material is always produced where the Licensed Material is
+     synched in timed relation with a moving image.
+  b. Adapter's License means the license You apply to Your Copyright
+     and Similar Rights in Your contributions to Adapted Material in
+     accordance with the terms and conditions of this Public License.
+  c. Copyright and Similar Rights means copyright and/or similar rights
+     closely related to copyright including, without limitation,
+     performance, broadcast, sound recording, and Sui Generis Database
+     Rights, without regard to how the rights are labeled or
+     categorized. For purposes of this Public License, the rights
+     specified in Section 2(b)(1)-(2) are not Copyright and Similar
+     Rights.
+  d. Effective Technological Measures means those measures that, in the
+     absence of proper authority, may not be circumvented under laws
+     fulfilling obligations under Article 11 of the WIPO Copyright
+     Treaty adopted on December 20, 1996, and/or similar international
+     agreements.
+  e. Exceptions and Limitations means fair use, fair dealing, and/or
+     any other exception or limitation to Copyright and Similar Rights
+     that applies to Your use of the Licensed Material.
+  f. Licensed Material means the artistic or literary work, database,
+     or other material to which the Licensor applied this Public
+     License.
+  g. Licensed Rights means the rights granted to You subject to the
+     terms and conditions of this Public License, which are limited to
+     all Copyright and Similar Rights that apply to Your use of the
+     Licensed Material and that the Licensor has authority to license.
+  h. Licensor means the individual(s) or entity(ies) granting rights
+     under this Public License.
+  i. Share means to provide material to the public by any means or
+     process that requires permission under the Licensed Rights, such
+     as reproduction, public display, public performance, distribution,
+     dissemination, communication, or importation, and to make material
+     available to the public including in ways that members of the
+     public may access the material from a place and at a time
+     individually chosen by them.
+  j. Sui Generis Database Rights means rights other than copyright
+     resulting from Directive 96/9/EC of the European Parliament and of
+     the Council of 11 March 1996 on the legal protection of databases,
+     as amended and/or succeeded, as well as other essentially
+     equivalent rights anywhere in the world.
+  k. You means the individual or entity exercising the Licensed Rights
+     under this Public License. Your has a corresponding meaning.
+Section 2 -- Scope.
+  a. License grant.
+       1. Subject to the terms and conditions of this Public License,
+          the Licensor hereby grants You a worldwide, royalty-free,
+          non-sublicensable, non-exclusive, irrevocable license to
+          exercise the Licensed Rights in the Licensed Material to:
+            a. reproduce and Share the Licensed Material, in whole or
+               in part; and
+            b. produce, reproduce, and Share Adapted Material.
+       2. Exceptions and Limitations. For the avoidance of doubt, where
+          Exceptions and Limitations apply to Your use, this Public
+          License does not apply, and You do not need to comply with
+          its terms and conditions.
+       3. Term. The term of this Public License is specified in Section
+          6(a).
+       4. Media and formats; technical modifications allowed. The
+          Licensor authorizes You to exercise the Licensed Rights in
+          all media and formats whether now known or hereafter created,
+          and to make technical modifications necessary to do so. The
+          Licensor waives and/or agrees not to assert any right or
+          authority to forbid You from making technical modifications
+          necessary to exercise the Licensed Rights, including
+          technical modifications necessary to circumvent Effective
+          Technological Measures. For purposes of this Public License,
+          simply making modifications authorized by this Section 2(a)
+          (4) never produces Adapted Material.
+       5. Downstream recipients.
+            a. Offer from the Licensor -- Licensed Material. Every
+               recipient of the Licensed Material automatically
+               receives an offer from the Licensor to exercise the
+               Licensed Rights under the terms and conditions of this
+               Public License.
+            b. No downstream restrictions. You may not offer or impose
+               any additional or different terms or conditions on, or
+               apply any Effective Technological Measures to, the
+               Licensed Material if doing so restricts exercise of the
+               Licensed Rights by any recipient of the Licensed
+               Material.
+       6. No endorsement. Nothing in this Public License constitutes or
+          may be construed as permission to assert or imply that You
+          are, or that Your use of the Licensed Material is, connected
+          with, or sponsored, endorsed, or granted official status by,
+          the Licensor or others designated to receive attribution as
+          provided in Section 3(a)(1)(A)(i).
+  b. Other rights.
+       1. Moral rights, such as the right of integrity, are not
+          licensed under this Public License, nor are publicity,
+          privacy, and/or other similar personality rights; however, to
+          the extent possible, the Licensor waives and/or agrees not to
+          assert any such rights held by the Licensor to the limited
+          extent necessary to allow You to exercise the Licensed
+          Rights, but not otherwise.
+       2. Patent and trademark rights are not licensed under this
+          Public License.
+       3. To the extent possible, the Licensor waives any right to
+          collect royalties from You for the exercise of the Licensed
+          Rights, whether directly or through a collecting society
+          under any voluntary or waivable statutory or compulsory
+          licensing scheme. In all other cases the Licensor expressly
+          reserves any right to collect such royalties.
+Section 3 -- License Conditions.
+Your exercise of the Licensed Rights is expressly made subject to the
+following conditions.
+  a. Attribution.
+       1. If You Share the Licensed Material (including in modified
+          form), You must:
+            a. retain the following if it is supplied by the Licensor
+               with the Licensed Material:
+                 i. identification of the creator(s) of the Licensed
+                    Material and any others designated to receive
+                    attribution, in any reasonable manner requested by
+                    the Licensor (including by pseudonym if
+                    designated);
+                ii. a copyright notice;
+               iii. a notice that refers to this Public License;
+                iv. a notice that refers to the disclaimer of
+                    warranties;
+                 v. a URI or hyperlink to the Licensed Material to the
+                    extent reasonably practicable;
+            b. indicate if You modified the Licensed Material and
+               retain an indication of any previous modifications; and
+            c. indicate the Licensed Material is licensed under this
+               Public License, and include the text of, or the URI or
+               hyperlink to, this Public License.
+       2. You may satisfy the conditions in Section 3(a)(1) in any
+          reasonable manner based on the medium, means, and context in
+          which You Share the Licensed Material. For example, it may be
+          reasonable to satisfy the conditions by providing a URI or
+          hyperlink to a resource that includes the required
+          information.
+       3. If requested by the Licensor, You must remove any of the
+          information required by Section 3(a)(1)(A) to the extent
+          reasonably practicable.
+       4. If You Share Adapted Material You produce, the Adapter's
+          License You apply must not prevent recipients of the Adapted
+          Material from complying with this Public License.
+Section 4 -- Sui Generis Database Rights.
+Where the Licensed Rights include Sui Generis Database Rights that
+apply to Your use of the Licensed Material:
+  a. for the avoidance of doubt, Section 2(a)(1) grants You the right
+     to extract, reuse, reproduce, and Share all or a substantial
+     portion of the contents of the database;
+  b. if You include all or a substantial portion of the database
+     contents in a database in which You have Sui Generis Database
+     Rights, then the database in which You have Sui Generis Database
+     Rights (but not its individual contents) is Adapted Material; and
+  c. You must comply with the conditions in Section 3(a) if You Share
+     all or a substantial portion of the contents of the database.
+For the avoidance of doubt, this Section 4 supplements and does not
+replace Your obligations under this Public License where the Licensed
+Rights include other Copyright and Similar Rights.
+Section 5 -- Disclaimer of Warranties and Limitation of Liability.
+  a. UNLESS OTHERWISE SEPARATELY UNDERTAKEN BY THE LICENSOR, TO THE
+     EXTENT POSSIBLE, THE LICENSOR OFFERS THE LICENSED MATERIAL AS-IS
+     AND AS-AVAILABLE, AND MAKES NO REPRESENTATIONS OR WARRANTIES OF
+     ANY KIND CONCERNING THE LICENSED MATERIAL, WHETHER EXPRESS,
+     IMPLIED, STATUTORY, OR OTHER. THIS INCLUDES, WITHOUT LIMITATION,
+     WARRANTIES OF TITLE, MERCHANTABILITY, FITNESS FOR A PARTICULAR
+     PURPOSE, NON-INFRINGEMENT, ABSENCE OF LATENT OR OTHER DEFECTS,
+     ACCURACY, OR THE PRESENCE OR ABSENCE OF ERRORS, WHETHER OR NOT
+     KNOWN OR DISCOVERABLE. WHERE DISCLAIMERS OF WARRANTIES ARE NOT
+     ALLOWED IN FULL OR IN PART, THIS DISCLAIMER MAY NOT APPLY TO YOU.
+  b. TO THE EXTENT POSSIBLE, IN NO EVENT WILL THE LICENSOR BE LIABLE
+     TO YOU ON ANY LEGAL THEORY (INCLUDING, WITHOUT LIMITATION,
+     NEGLIGENCE) OR OTHERWISE FOR ANY DIRECT, SPECIAL, INDIRECT,
+     INCIDENTAL, CONSEQUENTIAL, PUNITIVE, EXEMPLARY, OR OTHER LOSSES,
+     COSTS, EXPENSES, OR DAMAGES ARISING OUT OF THIS PUBLIC LICENSE OR
+     USE OF THE LICENSED MATERIAL, EVEN IF THE LICENSOR HAS BEEN
+     ADVISED OF THE POSSIBILITY OF SUCH LOSSES, COSTS, EXPENSES, OR
+     DAMAGES. WHERE A LIMITATION OF LIABILITY IS NOT ALLOWED IN FULL OR
+     IN PART, THIS LIMITATION MAY NOT APPLY TO YOU.
+  c. The disclaimer of warranties and limitation of liability provided
+     above shall be interpreted in a manner that, to the extent
+     possible, most closely approximates an absolute disclaimer and
+     waiver of all liability.
+Section 6 -- Term and Termination.
+  a. This Public License applies for the term of the Copyright and
+     Similar Rights licensed here. However, if You fail to comply with
+     this Public License, then Your rights under this Public License
+     terminate automatically.
+  b. Where Your right to use the Licensed Material has terminated under
+     Section 6(a), it reinstates:
+       1. automatically as of the date the violation is cured, provided
+          it is cured within 30 days of Your discovery of the
+          violation; or
+       2. upon express reinstatement by the Licensor.
+     For the avoidance of doubt, this Section 6(b) does not affect any
+     right the Licensor may have to seek remedies for Your violations
+     of this Public License.
+  c. For the avoidance of doubt, the Licensor may also offer the
+     Licensed Material under separate terms or conditions or stop
+     distributing the Licensed Material at any time; however, doing so
+     will not terminate this Public License.
+  d. Sections 1, 5, 6, 7, and 8 survive termination of this Public
+     License.
+Section 7 -- Other Terms and Conditions.
+  a. The Licensor shall not be bound by any additional or different
+     terms or conditions communicated by You unless expressly agreed.
+  b. Any arrangements, understandings, or agreements regarding the
+     Licensed Material not stated herein are separate from and
+     independent of the terms and conditions of this Public License.
+Section 8 -- Interpretation.
+  a. For the avoidance of doubt, this Public License does not, and
+     shall not be interpreted to, reduce, limit, restrict, or impose
+     conditions on any use of the Licensed Material that could lawfully
+     be made without permission under this Public License.
+  b. To the extent possible, if any provision of this Public License is
+     deemed unenforceable, it shall be automatically reformed to the
+     minimum extent necessary to make it enforceable. If the provision
+     cannot be reformed, it shall be severed from this Public License
+     without affecting the enforceability of the remaining terms and
+     conditions.
+  c. No term or condition of this Public License will be waived and no
+     failure to comply consented to unless expressly agreed to by the
+     Licensor.
+  d. Nothing in this Public License constitutes or may be interpreted
+     as a limitation upon, or waiver of, any privileges and immunities
+     that apply to the Licensor or You, including from the legal
+     processes of any jurisdiction or authority.
+=======================================================================
+Creative Commons is not a party to its public
+licenses. Notwithstanding, Creative Commons may elect to apply one of
+its public licenses to material it publishes and in those instances
+will be considered the “Licensor.” The text of the Creative Commons
+public licenses is dedicated to the public domain under the CC0 Public
+Domain Dedication. Except for the limited purpose of indicating that
+material is shared under a Creative Commons public license or as
+otherwise permitted by the Creative Commons policies published at
+creativecommons.org/policies, Creative Commons does not authorize the
+use of the trademark "Creative Commons" or any other trademark or logo
+of Creative Commons without its prior written consent including,
+without limitation, in connection with any unauthorized modifications
+to any of its public licenses or any other arrangements,
+understandings, or agreements concerning use of licensed material. For
+the avoidance of doubt, this paragraph does not form part of the
+public licenses.
+Creative Commons may be contacted at creativecommons.org.

LICENSES/CC-BY-NC-4.0.txt ADDED Viewed

	@@ -0,0 +1,408 @@

+Attribution-NonCommercial 4.0 International
+=======================================================================
+Creative Commons Corporation ("Creative Commons") is not a law firm and
+does not provide legal services or legal advice. Distribution of
+Creative Commons public licenses does not create a lawyer-client or
+other relationship. Creative Commons makes its licenses and related
+information available on an "as-is" basis. Creative Commons gives no
+warranties regarding its licenses, any material licensed under their
+terms and conditions, or any related information. Creative Commons
+disclaims all liability for damages resulting from their use to the
+fullest extent possible.
+Using Creative Commons Public Licenses
+Creative Commons public licenses provide a standard set of terms and
+conditions that creators and other rights holders may use to share
+original works of authorship and other material subject to copyright
+and certain other rights specified in the public license below. The
+following considerations are for informational purposes only, are not
+exhaustive, and do not form part of our licenses.
+     Considerations for licensors: Our public licenses are
+     intended for use by those authorized to give the public
+     permission to use material in ways otherwise restricted by
+     copyright and certain other rights. Our licenses are
+     irrevocable. Licensors should read and understand the terms
+     and conditions of the license they choose before applying it.
+     Licensors should also secure all rights necessary before
+     applying our licenses so that the public can reuse the
+     material as expected. Licensors should clearly mark any
+     material not subject to the license. This includes other CC-
+     licensed material, or material used under an exception or
+     limitation to copyright. More considerations for licensors:
+    wiki.creativecommons.org/Considerations_for_licensors
+     Considerations for the public: By using one of our public
+     licenses, a licensor grants the public permission to use the
+     licensed material under specified terms and conditions. If
+     the licensor's permission is not necessary for any reason--for
+     example, because of any applicable exception or limitation to
+     copyright--then that use is not regulated by the license. Our
+     licenses grant only permissions under copyright and certain
+     other rights that a licensor has authority to grant. Use of
+     the licensed material may still be restricted for other
+     reasons, including because others have copyright or other
+     rights in the material. A licensor may make special requests,
+     such as asking that all changes be marked or described.
+     Although not required by our licenses, you are encouraged to
+     respect those requests where reasonable. More considerations
+     for the public:
+    wiki.creativecommons.org/Considerations_for_licensees
+=======================================================================
+Creative Commons Attribution-NonCommercial 4.0 International Public
+License
+By exercising the Licensed Rights (defined below), You accept and agree
+to be bound by the terms and conditions of this Creative Commons
+Attribution-NonCommercial 4.0 International Public License ("Public
+License"). To the extent this Public License may be interpreted as a
+contract, You are granted the Licensed Rights in consideration of Your
+acceptance of these terms and conditions, and the Licensor grants You
+such rights in consideration of benefits the Licensor receives from
+making the Licensed Material available under these terms and
+conditions.
+Section 1 -- Definitions.
+  a. Adapted Material means material subject to Copyright and Similar
+     Rights that is derived from or based upon the Licensed Material
+     and in which the Licensed Material is translated, altered,
+     arranged, transformed, or otherwise modified in a manner requiring
+     permission under the Copyright and Similar Rights held by the
+     Licensor. For purposes of this Public License, where the Licensed
+     Material is a musical work, performance, or sound recording,
+     Adapted Material is always produced where the Licensed Material is
+     synched in timed relation with a moving image.
+  b. Adapter's License means the license You apply to Your Copyright
+     and Similar Rights in Your contributions to Adapted Material in
+     accordance with the terms and conditions of this Public License.
+  c. Copyright and Similar Rights means copyright and/or similar rights
+     closely related to copyright including, without limitation,
+     performance, broadcast, sound recording, and Sui Generis Database
+     Rights, without regard to how the rights are labeled or
+     categorized. For purposes of this Public License, the rights
+     specified in Section 2(b)(1)-(2) are not Copyright and Similar
+     Rights.
+  d. Effective Technological Measures means those measures that, in the
+     absence of proper authority, may not be circumvented under laws
+     fulfilling obligations under Article 11 of the WIPO Copyright
+     Treaty adopted on December 20, 1996, and/or similar international
+     agreements.
+  e. Exceptions and Limitations means fair use, fair dealing, and/or
+     any other exception or limitation to Copyright and Similar Rights
+     that applies to Your use of the Licensed Material.
+  f. Licensed Material means the artistic or literary work, database,
+     or other material to which the Licensor applied this Public
+     License.
+  g. Licensed Rights means the rights granted to You subject to the
+     terms and conditions of this Public License, which are limited to
+     all Copyright and Similar Rights that apply to Your use of the
+     Licensed Material and that the Licensor has authority to license.
+  h. Licensor means the individual(s) or entity(ies) granting rights
+     under this Public License.
+  i. NonCommercial means not primarily intended for or directed towards
+     commercial advantage or monetary compensation. For purposes of
+     this Public License, the exchange of the Licensed Material for
+     other material subject to Copyright and Similar Rights by digital
+     file-sharing or similar means is NonCommercial provided there is
+     no payment of monetary compensation in connection with the
+     exchange.
+  j. Share means to provide material to the public by any means or
+     process that requires permission under the Licensed Rights, such
+     as reproduction, public display, public performance, distribution,
+     dissemination, communication, or importation, and to make material
+     available to the public including in ways that members of the
+     public may access the material from a place and at a time
+     individually chosen by them.
+  k. Sui Generis Database Rights means rights other than copyright
+     resulting from Directive 96/9/EC of the European Parliament and of
+     the Council of 11 March 1996 on the legal protection of databases,
+     as amended and/or succeeded, as well as other essentially
+     equivalent rights anywhere in the world.
+  l. You means the individual or entity exercising the Licensed Rights
+     under this Public License. Your has a corresponding meaning.
+Section 2 -- Scope.
+  a. License grant.
+       1. Subject to the terms and conditions of this Public License,
+          the Licensor hereby grants You a worldwide, royalty-free,
+          non-sublicensable, non-exclusive, irrevocable license to
+          exercise the Licensed Rights in the Licensed Material to:
+            a. reproduce and Share the Licensed Material, in whole or
+               in part, for NonCommercial purposes only; and
+            b. produce, reproduce, and Share Adapted Material for
+               NonCommercial purposes only.
+       2. Exceptions and Limitations. For the avoidance of doubt, where
+          Exceptions and Limitations apply to Your use, this Public
+          License does not apply, and You do not need to comply with
+          its terms and conditions.
+       3. Term. The term of this Public License is specified in Section
+          6(a).
+       4. Media and formats; technical modifications allowed. The
+          Licensor authorizes You to exercise the Licensed Rights in
+          all media and formats whether now known or hereafter created,
+          and to make technical modifications necessary to do so. The
+          Licensor waives and/or agrees not to assert any right or
+          authority to forbid You from making technical modifications
+          necessary to exercise the Licensed Rights, including
+          technical modifications necessary to circumvent Effective
+          Technological Measures. For purposes of this Public License,
+          simply making modifications authorized by this Section 2(a)
+          (4) never produces Adapted Material.
+       5. Downstream recipients.
+            a. Offer from the Licensor -- Licensed Material. Every
+               recipient of the Licensed Material automatically
+               receives an offer from the Licensor to exercise the
+               Licensed Rights under the terms and conditions of this
+               Public License.
+            b. No downstream restrictions. You may not offer or impose
+               any additional or different terms or conditions on, or
+               apply any Effective Technological Measures to, the
+               Licensed Material if doing so restricts exercise of the
+               Licensed Rights by any recipient of the Licensed
+               Material.
+       6. No endorsement. Nothing in this Public License constitutes or
+          may be construed as permission to assert or imply that You
+          are, or that Your use of the Licensed Material is, connected
+          with, or sponsored, endorsed, or granted official status by,
+          the Licensor or others designated to receive attribution as
+          provided in Section 3(a)(1)(A)(i).
+  b. Other rights.
+       1. Moral rights, such as the right of integrity, are not
+          licensed under this Public License, nor are publicity,
+          privacy, and/or other similar personality rights; however, to
+          the extent possible, the Licensor waives and/or agrees not to
+          assert any such rights held by the Licensor to the limited
+          extent necessary to allow You to exercise the Licensed
+          Rights, but not otherwise.
+       2. Patent and trademark rights are not licensed under this
+          Public License.
+       3. To the extent possible, the Licensor waives any right to
+          collect royalties from You for the exercise of the Licensed
+          Rights, whether directly or through a collecting society
+          under any voluntary or waivable statutory or compulsory
+          licensing scheme. In all other cases the Licensor expressly
+          reserves any right to collect such royalties, including when
+          the Licensed Material is used other than for NonCommercial
+          purposes.
+Section 3 -- License Conditions.
+Your exercise of the Licensed Rights is expressly made subject to the
+following conditions.
+  a. Attribution.
+       1. If You Share the Licensed Material (including in modified
+          form), You must:
+            a. retain the following if it is supplied by the Licensor
+               with the Licensed Material:
+                 i. identification of the creator(s) of the Licensed
+                    Material and any others designated to receive
+                    attribution, in any reasonable manner requested by
+                    the Licensor (including by pseudonym if
+                    designated);
+                ii. a copyright notice;
+               iii. a notice that refers to this Public License;
+                iv. a notice that refers to the disclaimer of
+                    warranties;
+                 v. a URI or hyperlink to the Licensed Material to the
+                    extent reasonably practicable;
+            b. indicate if You modified the Licensed Material and
+               retain an indication of any previous modifications; and
+            c. indicate the Licensed Material is licensed under this
+               Public License, and include the text of, or the URI or
+               hyperlink to, this Public License.
+       2. You may satisfy the conditions in Section 3(a)(1) in any
+          reasonable manner based on the medium, means, and context in
+          which You Share the Licensed Material. For example, it may be
+          reasonable to satisfy the conditions by providing a URI or
+          hyperlink to a resource that includes the required
+          information.
+       3. If requested by the Licensor, You must remove any of the
+          information required by Section 3(a)(1)(A) to the extent
+          reasonably practicable.
+       4. If You Share Adapted Material You produce, the Adapter's
+          License You apply must not prevent recipients of the Adapted
+          Material from complying with this Public License.
+Section 4 -- Sui Generis Database Rights.
+Where the Licensed Rights include Sui Generis Database Rights that
+apply to Your use of the Licensed Material:
+  a. for the avoidance of doubt, Section 2(a)(1) grants You the right
+     to extract, reuse, reproduce, and Share all or a substantial
+     portion of the contents of the database for NonCommercial purposes
+     only;
+  b. if You include all or a substantial portion of the database
+     contents in a database in which You have Sui Generis Database
+     Rights, then the database in which You have Sui Generis Database
+     Rights (but not its individual contents) is Adapted Material; and
+  c. You must comply with the conditions in Section 3(a) if You Share
+     all or a substantial portion of the contents of the database.
+For the avoidance of doubt, this Section 4 supplements and does not
+replace Your obligations under this Public License where the Licensed
+Rights include other Copyright and Similar Rights.
+Section 5 -- Disclaimer of Warranties and Limitation of Liability.
+  a. UNLESS OTHERWISE SEPARATELY UNDERTAKEN BY THE LICENSOR, TO THE
+     EXTENT POSSIBLE, THE LICENSOR OFFERS THE LICENSED MATERIAL AS-IS
+     AND AS-AVAILABLE, AND MAKES NO REPRESENTATIONS OR WARRANTIES OF
+     ANY KIND CONCERNING THE LICENSED MATERIAL, WHETHER EXPRESS,
+     IMPLIED, STATUTORY, OR OTHER. THIS INCLUDES, WITHOUT LIMITATION,
+     WARRANTIES OF TITLE, MERCHANTABILITY, FITNESS FOR A PARTICULAR
+     PURPOSE, NON-INFRINGEMENT, ABSENCE OF LATENT OR OTHER DEFECTS,
+     ACCURACY, OR THE PRESENCE OR ABSENCE OF ERRORS, WHETHER OR NOT
+     KNOWN OR DISCOVERABLE. WHERE DISCLAIMERS OF WARRANTIES ARE NOT
+     ALLOWED IN FULL OR IN PART, THIS DISCLAIMER MAY NOT APPLY TO YOU.
+  b. TO THE EXTENT POSSIBLE, IN NO EVENT WILL THE LICENSOR BE LIABLE
+     TO YOU ON ANY LEGAL THEORY (INCLUDING, WITHOUT LIMITATION,
+     NEGLIGENCE) OR OTHERWISE FOR ANY DIRECT, SPECIAL, INDIRECT,
+     INCIDENTAL, CONSEQUENTIAL, PUNITIVE, EXEMPLARY, OR OTHER LOSSES,
+     COSTS, EXPENSES, OR DAMAGES ARISING OUT OF THIS PUBLIC LICENSE OR
+     USE OF THE LICENSED MATERIAL, EVEN IF THE LICENSOR HAS BEEN
+     ADVISED OF THE POSSIBILITY OF SUCH LOSSES, COSTS, EXPENSES, OR
+     DAMAGES. WHERE A LIMITATION OF LIABILITY IS NOT ALLOWED IN FULL OR
+     IN PART, THIS LIMITATION MAY NOT APPLY TO YOU.
+  c. The disclaimer of warranties and limitation of liability provided
+     above shall be interpreted in a manner that, to the extent
+     possible, most closely approximates an absolute disclaimer and
+     waiver of all liability.
+Section 6 -- Term and Termination.
+  a. This Public License applies for the term of the Copyright and
+     Similar Rights licensed here. However, if You fail to comply with
+     this Public License, then Your rights under this Public License
+     terminate automatically.
+  b. Where Your right to use the Licensed Material has terminated under
+     Section 6(a), it reinstates:
+       1. automatically as of the date the violation is cured, provided
+          it is cured within 30 days of Your discovery of the
+          violation; or
+       2. upon express reinstatement by the Licensor.
+     For the avoidance of doubt, this Section 6(b) does not affect any
+     right the Licensor may have to seek remedies for Your violations
+     of this Public License.
+  c. For the avoidance of doubt, the Licensor may also offer the
+     Licensed Material under separate terms or conditions or stop
+     distributing the Licensed Material at any time; however, doing so
+     will not terminate this Public License.
+  d. Sections 1, 5, 6, 7, and 8 survive termination of this Public
+     License.
+Section 7 -- Other Terms and Conditions.
+  a. The Licensor shall not be bound by any additional or different
+     terms or conditions communicated by You unless expressly agreed.
+  b. Any arrangements, understandings, or agreements regarding the
+     Licensed Material not stated herein are separate from and
+     independent of the terms and conditions of this Public License.
+Section 8 -- Interpretation.
+  a. For the avoidance of doubt, this Public License does not, and
+     shall not be interpreted to, reduce, limit, restrict, or impose
+     conditions on any use of the Licensed Material that could lawfully
+     be made without permission under this Public License.
+  b. To the extent possible, if any provision of this Public License is
+     deemed unenforceable, it shall be automatically reformed to the
+     minimum extent necessary to make it enforceable. If the provision
+     cannot be reformed, it shall be severed from this Public License
+     without affecting the enforceability of the remaining terms and
+     conditions.
+  c. No term or condition of this Public License will be waived and no
+     failure to comply consented to unless expressly agreed to by the
+     Licensor.
+  d. Nothing in this Public License constitutes or may be interpreted
+     as a limitation upon, or waiver of, any privileges and immunities
+     that apply to the Licensor or You, including from the legal
+     processes of any jurisdiction or authority.
+=======================================================================
+Creative Commons is not a party to its public
+licenses. Notwithstanding, Creative Commons may elect to apply one of
+its public licenses to material it publishes and in those instances
+will be considered the “Licensor.” The text of the Creative Commons
+public licenses is dedicated to the public domain under the CC0 Public
+Domain Dedication. Except for the limited purpose of indicating that
+material is shared under a Creative Commons public license or as
+otherwise permitted by the Creative Commons policies published at
+creativecommons.org/policies, Creative Commons does not authorize the
+use of the trademark "Creative Commons" or any other trademark or logo
+of Creative Commons without its prior written consent including,
+without limitation, in connection with any unauthorized modifications
+to any of its public licenses or any other arrangements,
+understandings, or agreements concerning use of licensed material. For
+the avoidance of doubt, this paragraph does not form part of the
+public licenses.
+Creative Commons may be contacted at creativecommons.org.

NOTICE.md ADDED Viewed

	@@ -0,0 +1,14 @@

+# Sources
+- [KodCode](https://arxiv.org/abs/2503.02951), Xu et al., 2025.
+  Sources: [V1-SFT-4o](https://huggingface.co/datasets/KodCode/KodCode-V1-SFT-4o)
+  and [Light-RL-10K](https://huggingface.co/datasets/KodCode/KodCode-Light-RL-10K).
+- [TACO](https://arxiv.org/abs/2312.14852), Li et al., 2023.
+  Source: [BAAI/TACO](https://huggingface.co/datasets/BAAI/TACO).
+- [LeetCodeDataset](https://arxiv.org/abs/2504.14655), 2025.
+  Source: [newfacade/LeetCodeDataset](https://huggingface.co/datasets/newfacade/LeetCodeDataset).
+This release packages filtered project snapshots, preserves reference answers
+and RL tests, carries category labels, and adds a TACO SFT holdout.
+Upstream authors retain attribution. Exact revisions and file identities are
+recorded under metadata/. TACO's own source acknowledgments also apply.

README.md CHANGED Viewed

@@ -1,3 +1,80 @@
 ---
-license: unknown
 ---

 ---
+pretty_name: Code Reasoning Data
+language:
+- en
+task_categories:
+- text-generation
+tags:
+- code
+- sft
+- reinforcement-learning
+license: other
+license_name: source-specific-licenses
+license_link: LICENSE
+size_categories:
+- 10K<n<100K
+configs:
+- config_name: kodcode_sft
+  default: true
+  data_files:
+  - split: train
+    path: data/kodcode/sft/train.parquet
+  - split: validation
+    path: data/kodcode/sft/validation.parquet
+- config_name: kodcode_rl
+  data_files:
+  - split: train
+    path: data/kodcode/rl/train.parquet
+  - split: validation
+    path: data/kodcode/rl/validation.parquet
+- config_name: taco_leetcode_sft
+  data_files:
+  - split: train
+    path: data/taco_leetcode/sft/train.parquet
+  - split: validation
+    path: data/taco_leetcode/sft/validation.parquet
+- config_name: taco_leetcode_rl
+  data_files:
+  - split: train
+    path: data/taco_leetcode/rl/train.parquet
+  - split: validation
+    path: data/taco_leetcode/rl/validation.parquet
 ---
+# Code Reasoning Data
+Code-training data with SFT answers, executable RL tests, and category labels.
+| Configuration | Train | Validation |
+|---|---:|---:|
+| `kodcode_sft` | 35,974 | 100 |
+| `kodcode_rl` | 35,974 | 100 |
+| `taco_leetcode_sft` | 21,779 | 100 |
+| `taco_leetcode_rl` | 17,249 | 100 |
+```python
+from datasets import load_dataset
+ds = load_dataset("./dataset", "kodcode_sft")
+# After upload, replace ./dataset with your Hugging Face dataset repository ID.
+```
+SFT: use `messages` or `prompt` / `response`. RL: use `prompt` and
+`reward_model.ground_truth`. Apply the target model's template at training time.
+Use only the documented input/target fields; labels and tests are metadata.
+KodCode uses ten primary categories; TACO/LeetCode uses seven category-removal
+groups. Their taxonomies and historical ablation memberships are separate.
+The TACO SFT validation split is new in this release. Other splits are historical.
+These configurations are separate experiments, not a joint SFT-to-RL split.
+Historical TACO RL validation overlaps the original SFT pool on 71 problems.
+See [TACO/LeetCode notes](docs/taco_leetcode.md) for historical export.
+```bash
+pip install -r requirements.txt
+python scripts/validate_release.py --hf
+```
+Source-specific licenses apply; see [LICENSE](LICENSE) and [NOTICE](NOTICE.md).
+Reward scripts require Linux; usage and limits are in [verification notes](docs/rl_verification.md).

data/kodcode/rl/train.parquet ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:a23ea34d57279ae59d7068c4bbd55df08df49b3d4ca42853a49302365d54f224
+size 31938297

data/kodcode/rl/validation.parquet ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:380992eb51a792f641d31306704e5eb58f26ef53e4d81ee4757c5552cf046ece
+size 127880

data/kodcode/sft/train.parquet ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:f28beea278bfc762fad78a3cb11041380e765cbb0c328104b34a0023e202001c
+size 45871516

data/kodcode/sft/validation.parquet ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:12b191279320d21ef8ca008e9ca75fa39cc41d061880f62ac0a142a139bcc232
+size 160105

data/taco_leetcode/rl/train.parquet ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:9cda87499760450fa89755a8b61c821b6f58a7421b15e8a8f1ca636705130b3f
+size 458373045

data/taco_leetcode/rl/validation.parquet ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:d049040b92177b9f5651a1db465545bfd0ff44cc6075e0726c19b4e6ceea3441
+size 1224277

data/taco_leetcode/sft/train.parquet ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:0de1e7a0341bc9e735427d35761b53d6918f66b9cb750f4f8cbe26e5965403ef
+size 38500020

data/taco_leetcode/sft/validation.parquet ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:3f637a2b0f6e466335dddd08834fa56d1eaabf7b1792bf9cbbda21c95501e362
+size 195929

docs/kodcode.md ADDED Viewed

	@@ -0,0 +1,18 @@

+# KodCode
+The released pool contains 36,074 distinct problems: 35,974 train and 100 fixed
+validation, shared by SFT and RL. It follows the project's deduplication,
+interface repair, execution checks, and reviewed category mapping.
+The earlier 37,881-answer diagnostic pool is not included as another configuration.
+`primary_category` is the ten-category v2 label. `v1_*` fields preserve the
+older reviewed labels; `v1_alternative_category` belongs to that older taxonomy.
+`techniques` retains auxiliary text tags, not extra v2 primary labels.
+Historical main ablations remove the primary category only.
+```bash
+python scripts/build_kodcode.py --arm no_dynamic_programming --output arm.parquet
+```
+Frozen labeled source exports can be repackaged with `--source DIR`.
+File and membership hashes are in metadata/kodcode/.

docs/rl_verification.md ADDED Viewed

	@@ -0,0 +1,24 @@

+# RL verification
+Call the appropriate module's `compute_score(data_source, solution_str,
+ground_truth)`, passing `reward_model.ground_truth` from an RL row.
+| Family | Tests | Reward |
+|---|---|---|
+| KodCode | Python test module and named test functions | 1 only if every test passes; otherwise 0 |
+| TACO/LeetCode | Standard-input or function-call cases | 1 for full pass; otherwise 0.8 × pass fraction |
+The bundled code preserves the historical scorer. KodCode defaults to 1 second
+per test and 180 seconds per completion; TACO defaults to 2 and 6 seconds.
+Both default to 2 GiB memory and 16 MiB file-output limits. Training runs may
+override these arguments; record any changes when comparing results.
+Execution requires Linux. Install `verification/requirements.txt` for the
+third-party modules recorded by the KodCode tests; solutions may need other imports.
+Process resource limits are not a security isolation boundary; run untrusted
+generated code in an isolated container without credentials or network access.
+Dataset loading and structural validation do not execute problem code.
+```bash
+python verification/smoke_test.py
+```

docs/taco_leetcode.md ADDED Viewed

	@@ -0,0 +1,26 @@

+# TACO + LeetCode
+The historical SFT pool has 21,879 rows (19,493 TACO; 2,386 LeetCodeDataset).
+This release holds out 100 unique-prompt problems using seed 20260907 and
+source/category stratification, leaving 21,779 training rows.
+The original order and all original SFT fields remain recoverable.
+RL retains the original 17,249 train / 100 validation split and all reward tests.
+Its training metadata marks 11,587 reference-execution-verified rows and 5,662
+structural-only rows; validation has 71 and 29 respectively.
+The two task configurations were not built as a shared SFT-to-RL partition.
+Seven removal categories use `overlap_categories`; `no_tags` marks unlabeled
+rows. Original detailed SFT labels remain in `raw_*` columns. Recorded historical SFT
+arms have 14,043 rows and RL arms have 12,168. Release SFT arm exports exclude
+the new holdout and therefore need not remain equal-size.
+```bash
+# Original 21,879-row SFT pool, in original order:
+python scripts/build_taco_leetcode.py --arm full_sft --historical --output original.parquet
+# Historical RL arm:
+python scripts/build_taco_leetcode.py --kind rl --arm no_graph --output arm.parquet
+```
+The build script also accepts a frozen source export through `--source DIR`.
+Source records, IDs, and split hashes are documented in metadata/taco_leetcode/.

metadata/content_preservation.json ADDED Viewed

	@@ -0,0 +1,29 @@

+{
+  "status": "PASS",
+  "source_transfer": {
+    "files": 15,
+    "sha256_matches": 15
+  },
+  "historical_sft_original_fields_and_order_restored": true,
+  "taco_rl_prompts_and_all_reward_payloads_unchanged": {
+    "train": true,
+    "validation": true
+  },
+  "sft_holdout_recomputed_identically": true,
+  "reward_smoke_linux": {
+    "status": "PASS",
+    "synthetic_only": true,
+    "kodcode_full_and_half": [
+      1.0,
+      0.0
+    ],
+    "taco_full_and_half": [
+      1.0,
+      0.4
+    ]
+  },
+  "runtime": {
+    "python": "3.12.10",
+    "pyarrow": "23.0.1"
+  }
+}

metadata/kodcode/ablation_membership.json ADDED Viewed

The diff for this file is too large to render. See raw diff

metadata/kodcode/dataset_manifest.json ADDED Viewed

	@@ -0,0 +1,156 @@

+{
+  "version": "1.0.0",
+  "family": "kodcode",
+  "split_policy": {
+    "train": "historical",
+    "validation": "historical fixed 100; shared SFT/RL"
+  },
+  "files": {
+    "sft/train": {
+      "path": "data/kodcode/sft/train.parquet",
+      "rows": 35974,
+      "bytes": 45871516,
+      "sha256": "f28beea278bfc762fad78a3cb11041380e765cbb0c328104b34a0023e202001c",
+      "problem_id_set_sha256": "8f99c9121ffedf641bd6176e23ab29b973c06bcbc22433f159d4507887d133e7",
+      "columns": [
+        "problem_id",
+        "original_question_id",
+        "source_dataset",
+        "subset",
+        "style",
+        "difficulty",
+        "entry_point",
+        "test_count_used",
+        "test_code_repaired",
+        "reference_full_execution_verified",
+        "messages",
+        "prompt",
+        "response",
+        "response_source",
+        "quality_status",
+        "v1_primary_category",
+        "v1_subcategory",
+        "v1_confidence",
+        "v1_alternative_category",
+        "techniques",
+        "rationale",
+        "classifier_model",
+        "classification_stage",
+        "v1_taxonomy_version",
+        "was_reviewed",
+        "v1_first_pass_category",
+        "review_changed",
+        "primary_category",
+        "subcategory",
+        "confidence",
+        "taxonomy_version",
+        "mapping_method"
+      ]
+    },
+    "sft/validation": {
+      "path": "data/kodcode/sft/validation.parquet",
+      "rows": 100,
+      "bytes": 160105,
+      "sha256": "12b191279320d21ef8ca008e9ca75fa39cc41d061880f62ac0a142a139bcc232",
+      "problem_id_set_sha256": "f755bf33f003a79bc14d90fdd573ba39234afc2e2e750d6e99788c1de6c91401",
+      "columns": [
+        "problem_id",
+        "original_question_id",
+        "source_dataset",
+        "subset",
+        "style",
+        "difficulty",
+        "entry_point",
+        "test_count_used",
+        "test_code_repaired",
+        "reference_full_execution_verified",
+        "messages",
+        "prompt",
+        "response",
+        "response_source",
+        "quality_status",
+        "v1_primary_category",
+        "v1_subcategory",
+        "v1_confidence",
+        "v1_alternative_category",
+        "techniques",
+        "rationale",
+        "classifier_model",
+        "classification_stage",
+        "v1_taxonomy_version",
+        "was_reviewed",
+        "v1_first_pass_category",
+        "review_changed",
+        "primary_category",
+        "subcategory",
+        "confidence",
+        "taxonomy_version",
+        "mapping_method"
+      ]
+    },
+    "rl/train": {
+      "path": "data/kodcode/rl/train.parquet",
+      "rows": 35974,
+      "bytes": 31938297,
+      "sha256": "a23ea34d57279ae59d7068c4bbd55df08df49b3d4ca42853a49302365d54f224",
+      "problem_id_set_sha256": "8f99c9121ffedf641bd6176e23ab29b973c06bcbc22433f159d4507887d133e7",
+      "columns": [
+        "prompt",
+        "data_source",
+        "ability",
+        "reward_model",
+        "extra_info",
+        "problem_id",
+        "v1_primary_category",
+        "v1_subcategory",
+        "v1_confidence",
+        "v1_alternative_category",
+        "techniques",
+        "rationale",
+        "classifier_model",
+        "classification_stage",
+        "v1_taxonomy_version",
+        "was_reviewed",
+        "v1_first_pass_category",
+        "review_changed",
+        "primary_category",
+        "subcategory",
+        "confidence",
+        "taxonomy_version",
+        "mapping_method"
+      ]
+    },
+    "rl/validation": {
+      "path": "data/kodcode/rl/validation.parquet",
+      "rows": 100,
+      "bytes": 127880,
+      "sha256": "380992eb51a792f641d31306704e5eb58f26ef53e4d81ee4757c5552cf046ece",
+      "problem_id_set_sha256": "f755bf33f003a79bc14d90fdd573ba39234afc2e2e750d6e99788c1de6c91401",
+      "columns": [
+        "prompt",
+        "data_source",
+        "ability",
+        "reward_model",
+        "extra_info",
+        "problem_id",
+        "v1_primary_category",
+        "v1_subcategory",
+        "v1_confidence",
+        "v1_alternative_category",
+        "techniques",
+        "rationale",
+        "classifier_model",
+        "classification_stage",
+        "v1_taxonomy_version",
+        "was_reviewed",
+        "v1_first_pass_category",
+        "review_changed",
+        "primary_category",
+        "subcategory",
+        "confidence",
+        "taxonomy_version",
+        "mapping_method"
+      ]
+    }
+  }
+}

metadata/kodcode/source_manifest.json ADDED Viewed

	@@ -0,0 +1,63 @@

+{
+  "version": "1.0.0",
+  "snapshot": "kodcode_clean_36074_v2",
+  "upstream": [
+    {
+      "repo_id": "KodCode/KodCode-V1-SFT-4o",
+      "revision": "14f8782fb7787c7e31dd4a1372518bc10fedb66e",
+      "license": "cc-by-nc-4.0"
+    },
+    {
+      "repo_id": "KodCode/KodCode-Light-RL-10K",
+      "revision": "dcf78a8bbba9a613b596ce993c4921a38687dfcc",
+      "license": "cc-by-nc-4.0"
+    }
+  ],
+  "processing": [
+    "37,881 source answer rows / 36,446 original questions",
+    "original-question deduplication and fixed validation exclusion",
+    "interface repair, static checks and exact-reward reference verification",
+    "36,074 accepted problems; 35,974 train / 100 validation",
+    "reviewed v1 labels mapped deterministically to v2 ten-category taxonomy"
+  ],
+  "source_files": {
+    "memberships.json": {
+      "bytes": 8027652,
+      "sha256": "b436b9bcdc3e03d540d52b6be06eb153ca0a3e9e53c151e7dc1126d089ed8790"
+    },
+    "original_arm_manifest.json": {
+      "bytes": 14333,
+      "sha256": "e675e9af6c96d1f9936ba5ee7ea2754a087675a238628f21572781694ce080f2"
+    },
+    "rl_train.parquet": {
+      "bytes": 31938297,
+      "sha256": "a23ea34d57279ae59d7068c4bbd55df08df49b3d4ca42853a49302365d54f224"
+    },
+    "rl_validation.parquet": {
+      "bytes": 127880,
+      "sha256": "380992eb51a792f641d31306704e5eb58f26ef53e4d81ee4757c5552cf046ece"
+    },
+    "sft_train.parquet": {
+      "bytes": 45871516,
+      "sha256": "f28beea278bfc762fad78a3cb11041380e765cbb0c328104b34a0023e202001c"
+    },
+    "sft_validation.parquet": {
+      "bytes": 160105,
+      "sha256": "12b191279320d21ef8ca008e9ca75fa39cc41d061880f62ac0a142a139bcc232"
+    },
+    "taxonomy.json": {
+      "bytes": 4000,
+      "sha256": "905e6c82e9acbe795234f33f1b14c3a0a414c5f4c995fc269fc97b37ad77cce2"
+    }
+  },
+  "release_data_transform": "The four labeled Parquet payloads are byte-identical to the frozen source.",
+  "build_source_layout": [
+    "sft_train.parquet",
+    "sft_validation.parquet",
+    "rl_train.parquet",
+    "rl_validation.parquet",
+    "taxonomy.json",
+    "memberships.json",
+    "original_arm_manifest.json"
+  ]
+}

metadata/kodcode/taxonomy.json ADDED Viewed

	@@ -0,0 +1,84 @@

+{
+  "name": "kodcode_capability_taxonomy_balanced",
+  "version": "2.0.0",
+  "derivation": "Deterministic mapping from reviewed taxonomy v1.1.0; no API calls.",
+  "primary_label_policy": "Use exactly one v2 category derived from the reviewed v1 primary category and subcategory.",
+  "categories": [
+    {
+      "id": "hashing_counting_and_sets",
+      "definition": "Hash maps, hash sets, membership, frequency counting, deduplication, and collection counting.",
+      "v1_sources": ["array_hashing_and_sorting/hashing_counting"]
+    },
+    {
+      "id": "sequence_transformations",
+      "definition": "Direct transformations, scans, filtering, rearrangement, and construction of sequences.",
+      "v1_sources": ["array_hashing_and_sorting/sequence_transformation"]
+    },
+    {
+      "id": "sorting_and_ordered_processing",
+      "definition": "Sorting and order-dependent collection processing without an essential greedy proof.",
+      "v1_sources": ["array_hashing_and_sorting/sorting"]
+    },
+    {
+      "id": "range_window_and_matrix_processing",
+      "definition": "Sliding windows, two pointers, prefix computations, matrix operations, and local range processing.",
+      "v1_sources": [
+        "array_hashing_and_sorting/sliding_window",
+        "array_hashing_and_sorting/two_pointers",
+        "array_hashing_and_sorting/prefix_sum",
+        "array_hashing_and_sorting/matrix"
+      ]
+    },
+    {
+      "id": "string_and_parsing",
+      "definition": "Textual structure, parsing, matching, tokenization, encoding, and string transformation.",
+      "v1_sources": ["string_and_parsing/*"]
+    },
+    {
+      "id": "dynamic_programming",
+      "definition": "State transitions, memoization, overlapping subproblems, and optimal substructure.",
+      "v1_sources": ["dynamic_programming/*"]
+    },
+    {
+      "id": "graph_structures_and_stateful_systems",
+      "definition": "Graphs, trees, explicit data structures, repeated queries, and evolving stateful systems.",
+      "v1_sources": [
+        "graph_and_tree_algorithms/*",
+        "data_structures_and_queries/*",
+        "simulation_and_stateful_logic/*"
+      ]
+    },
+    {
+      "id": "greedy_search_and_optimization",
+      "definition": "Greedy decisions, monotone or combinatorial search, backtracking, scheduling, and optimization.",
+      "v1_sources": ["greedy_search_and_optimization/*"]
+    },
+    {
+      "id": "math_and_number_theory",
+      "definition": "Arithmetic, algebra, number theory, combinatorics, geometry, probability, and numerical reasoning.",
+      "v1_sources": ["math_and_number_theory/*"]
+    },
+    {
+      "id": "direct_implementation_and_utilities",
+      "definition": "Direct implementation, aggregation, validation, conversion, formatting, library, file, and date utilities.",
+      "v1_sources": ["direct_implementation_and_utilities/*"]
+    }
+  ],
+  "mapping": {
+    "array_hashing_and_sorting/hashing_counting": "hashing_counting_and_sets",
+    "array_hashing_and_sorting/sequence_transformation": "sequence_transformations",
+    "array_hashing_and_sorting/sorting": "sorting_and_ordered_processing",
+    "array_hashing_and_sorting/sliding_window": "range_window_and_matrix_processing",
+    "array_hashing_and_sorting/two_pointers": "range_window_and_matrix_processing",
+    "array_hashing_and_sorting/prefix_sum": "range_window_and_matrix_processing",
+    "array_hashing_and_sorting/matrix": "range_window_and_matrix_processing",
+    "string_and_parsing/*": "string_and_parsing",
+    "dynamic_programming/*": "dynamic_programming",
+    "graph_and_tree_algorithms/*": "graph_structures_and_stateful_systems",
+    "data_structures_and_queries/*": "graph_structures_and_stateful_systems",
+    "simulation_and_stateful_logic/*": "graph_structures_and_stateful_systems",
+    "greedy_search_and_optimization/*": "greedy_search_and_optimization",
+    "math_and_number_theory/*": "math_and_number_theory",
+    "direct_implementation_and_utilities/*": "direct_implementation_and_utilities"
+  }
+}

metadata/release_files.json ADDED Viewed

	@@ -0,0 +1,165 @@

+{
+  "version": "1.0.0",
+  "files": {
+    ".gitattributes": {
+      "bytes": 46,
+      "sha256": "30129f61f2a1b984b358279fb24769ff73836dc7f839a765b67775ae2af04a13"
+    },
+    ".gitignore": {
+      "bytes": 38,
+      "sha256": "6c1257632e97376c4342ba9ce2d0a6a1c84d7c2519a0711a29969970c6e3cd6c"
+    },
+    "CHANGELOG.md": {
+      "bytes": 263,
+      "sha256": "145e44726deacf49a583b76c618c287a5659464702929b4bc562dc559669dcf6"
+    },
+    "data/kodcode/rl/train.parquet": {
+      "bytes": 31938297,
+      "sha256": "a23ea34d57279ae59d7068c4bbd55df08df49b3d4ca42853a49302365d54f224"
+    },
+    "data/kodcode/rl/validation.parquet": {
+      "bytes": 127880,
+      "sha256": "380992eb51a792f641d31306704e5eb58f26ef53e4d81ee4757c5552cf046ece"
+    },
+    "data/kodcode/sft/train.parquet": {
+      "bytes": 45871516,
+      "sha256": "f28beea278bfc762fad78a3cb11041380e765cbb0c328104b34a0023e202001c"
+    },
+    "data/kodcode/sft/validation.parquet": {
+      "bytes": 160105,
+      "sha256": "12b191279320d21ef8ca008e9ca75fa39cc41d061880f62ac0a142a139bcc232"
+    },
+    "data/taco_leetcode/rl/train.parquet": {
+      "bytes": 458373045,
+      "sha256": "9cda87499760450fa89755a8b61c821b6f58a7421b15e8a8f1ca636705130b3f"
+    },
+    "data/taco_leetcode/rl/validation.parquet": {
+      "bytes": 1224277,
+      "sha256": "d049040b92177b9f5651a1db465545bfd0ff44cc6075e0726c19b4e6ceea3441"
+    },
+    "data/taco_leetcode/sft/train.parquet": {
+      "bytes": 38500020,
+      "sha256": "0de1e7a0341bc9e735427d35761b53d6918f66b9cb750f4f8cbe26e5965403ef"
+    },
+    "data/taco_leetcode/sft/validation.parquet": {
+      "bytes": 195929,
+      "sha256": "3f637a2b0f6e466335dddd08834fa56d1eaabf7b1792bf9cbbda21c95501e362"
+    },
+    "docs/kodcode.md": {
+      "bytes": 823,
+      "sha256": "f3f28f4e7e6d0d1f0ad3bd435725b893efbc18cf92e27a3554c7ebec5ce7d170"
+    },
+    "docs/rl_verification.md": {
+      "bytes": 1147,
+      "sha256": "958f38e86ff1429bc7063e58d359a39aa2358f1a3c3d2444d42ae7d9539b89c1"
+    },
+    "docs/taco_leetcode.md": {
+      "bytes": 1320,
+      "sha256": "d090f3850464245cc2c2d407c23886cba8c9d38573df4c6de85b0c1318dfb3bf"
+    },
+    "LICENSE": {
+      "bytes": 1094,
+      "sha256": "b7b3bf61277c2f6891b3a714ddd0f8dbde92a343f50ac3718afe88c0de2fef18"
+    },
+    "LICENSES/Apache-2.0.txt": {
+      "bytes": 11358,
+      "sha256": "cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30"
+    },
+    "LICENSES/CC-BY-4.0.txt": {
+      "bytes": 18657,
+      "sha256": "9ba9550ad48438d0836ddab3da480b3b69ffa0aac7b7878b5a0039e7ab429411"
+    },
+    "LICENSES/CC-BY-NC-4.0.txt": {
+      "bytes": 19347,
+      "sha256": "41003d4a74749c0220e33dd415042164b5a1093ed401f36277234f772d22d3d0"
+    },
+    "metadata/content_preservation.json": {
+      "bytes": 597,
+      "sha256": "0006c07f61d6d0e34d3c94ae324500175e00a4f437e0238ec2456c21d91e9b39"
+    },
+    "metadata/kodcode/ablation_membership.json": {
+      "bytes": 8030134,
+      "sha256": "f38870deb54eabfa13d68f5afb9f7177c26eb4b81b50fc632fe45899fdc6e593"
+    },
+    "metadata/kodcode/dataset_manifest.json": {
+      "bytes": 4503,
+      "sha256": "419528e755bfabe417c2db63d494ec13d026ba23e47bd30f191745eebf5696dd"
+    },
+    "metadata/kodcode/source_manifest.json": {
+      "bytes": 2173,
+      "sha256": "70f39a27ef00fdccfc5f769ed6818e092c93d4eaa4f8d34c8db31a11e878587e"
+    },
+    "metadata/kodcode/taxonomy.json": {
+      "bytes": 4000,
+      "sha256": "905e6c82e9acbe795234f33f1b14c3a0a414c5f4c995fc269fc97b37ad77cce2"
+    },
+    "metadata/taco_leetcode/ablation_membership.json": {
+      "bytes": 7429861,
+      "sha256": "cc60808c1344a6d3095f57f3c653b68027a7ef2bec3495c45dc6b6fb8f024ea9"
+    },
+    "metadata/taco_leetcode/dataset_manifest.json": {
+      "bytes": 3880,
+      "sha256": "762f94c43f5f3acd7e2ebd6d1c8b4ba2c029e0071daaf547ace8f15e98bacd9f"
+    },
+    "metadata/taco_leetcode/source_manifest.json": {
+      "bytes": 3337,
+      "sha256": "e1f1aba4bb4149303694a8e99a177a0eca8e71ad0e8bd27dc2290f388a005aa8"
+    },
+    "metadata/taco_leetcode/taxonomy.json": {
+      "bytes": 991,
+      "sha256": "e28786f2f9d89723d0fe2ef33ae3f2df95a1b09f10f9d784d3b9b6bf155124dd"
+    },
+    "metadata/validation_report.json": {
+      "bytes": 1802,
+      "sha256": "e1aff965903d91f5f489463c4acac910e30be9f5ffc90104e7d3f788f99b5bfd"
+    },
+    "NOTICE.md": {
+      "bytes": 823,
+      "sha256": "6480096e84a44838ce4e5d6aaf7dee78be3037bd93a625c032c39cc2fedf4d88"
+    },
+    "README.md": {
+      "bytes": 2397,
+      "sha256": "6ce733786d33625e55f3f4e1c546db0d23f41a3369199c7f52e9445509cabc3d"
+    },
+    "requirements.txt": {
+      "bytes": 46,
+      "sha256": "f099c62b8f276a0de63c9b76c820e07b76fa3bb6b4c24c2e1760af1a5e9f4a49"
+    },
+    "scripts/build_kodcode.py": {
+      "bytes": 3176,
+      "sha256": "2383109536a512555a7d57af608cadf06c4c4d179c411e977b7d7d40ddfaed4b"
+    },
+    "scripts/build_taco_leetcode.py": {
+      "bytes": 8344,
+      "sha256": "e9a14358a2d83fd6e966b9b3cba6f02da2b5de8d9df34c5504894384b8e8b010"
+    },
+    "scripts/release_utils.py": {
+      "bytes": 2995,
+      "sha256": "9d8d4ef4c509818376987acb2969efe9437732a26e7713c5942f51bb7fe83bcf"
+    },
+    "scripts/validate_release.py": {
+      "bytes": 9964,
+      "sha256": "6eb536a434802a79f582aec1912a641cc88785e201c07dc9abc52aa5c0d01f8d"
+    },
+    "verification/kodcode_reward.py": {
+      "bytes": 8324,
+      "sha256": "236efba226c40e2b3678ddf54f03d43fd9d968b6a56bf375bb7a07d9066a860c"
+    },
+    "verification/requirements.txt": {
+      "bytes": 210,
+      "sha256": "e22fa8f19e502cd2244a89c5c7856621562f207a4fed88ef68bedbf2a8f98127"
+    },
+    "verification/smoke_test.py": {
+      "bytes": 1125,
+      "sha256": "3fc784f834a9ec8d004c524071c69cfdcc0d7779e5abffe776d4be0897f29a82"
+    },
+    "verification/stage3_reward_base.py": {
+      "bytes": 17604,
+      "sha256": "36e1ec828d7532c6a0a99e978470e2ef135bc8beabdfdcec8672fc006ea69b02"
+    },
+    "verification/taco_leetcode_reward.py": {
+      "bytes": 17700,
+      "sha256": "eec5f4e9c426edb48486e1e0e9179856157a3ccb769dd54a2ff4d55e0577c033"
+    }
+  }
+}

metadata/taco_leetcode/ablation_membership.json ADDED Viewed

The diff for this file is too large to render. See raw diff

metadata/taco_leetcode/dataset_manifest.json ADDED Viewed

	@@ -0,0 +1,129 @@

+{
+  "version": "1.0.0",
+  "family": "taco_leetcode",
+  "split_policy": {
+    "sft": {
+      "seed": 20260907,
+      "rows": 100,
+      "method": "source/category largest remainder; SHA256(seed:id) rank; unique prompts only",
+      "strata": {
+        "leetcode2k::data_structure": 6,
+        "leetcode2k::dynamic_programming": 2,
+        "leetcode2k::graph": 2,
+        "leetcode2k::greedy_search": 0,
+        "leetcode2k::math_number_theory": 1,
+        "leetcode2k::other_algorithm": 0,
+        "taco::data_structure": 15,
+        "taco::dynamic_programming": 8,
+        "taco::graph": 5,
+        "taco::greedy_search": 9,
+        "taco::implementation_simulation": 8,
+        "taco::math_number_theory": 17,
+        "taco::no_tags": 21,
+        "taco::other_algorithm": 6
+      },
+      "origin": "Added for this release; not the historical experiment validation set.",
+      "historical_sft_rows": 21879,
+      "historical_rl_validation_overlap_with_original_sft_train": 71
+    },
+    "rl": "Original 17,249 train + 100 validation"
+  },
+  "files": {
+    "sft/train": {
+      "path": "data/taco_leetcode/sft/train.parquet",
+      "rows": 21779,
+      "bytes": 38500020,
+      "sha256": "0de1e7a0341bc9e735427d35761b53d6918f66b9cb750f4f8cbe26e5965403ef",
+      "problem_id_set_sha256": "a86bdadb6164700a5c3f130d6f7fae13cdbaaa1b5060eddcf9e2319c233df553",
+      "columns": [
+        "id",
+        "dataset",
+        "arm",
+        "source_bucket",
+        "removed_category",
+        "primary_category",
+        "overlap_categories",
+        "source",
+        "difficulty",
+        "name",
+        "task_id",
+        "tags",
+        "raw_tags",
+        "skill_types",
+        "prompt",
+        "answer",
+        "messages",
+        "raw_primary_category",
+        "raw_overlap_categories",
+        "problem_id",
+        "response",
+        "source_row_index"
+      ]
+    },
+    "sft/validation": {
+      "path": "data/taco_leetcode/sft/validation.parquet",
+      "rows": 100,
+      "bytes": 195929,
+      "sha256": "3f637a2b0f6e466335dddd08834fa56d1eaabf7b1792bf9cbbda21c95501e362",
+      "problem_id_set_sha256": "faaadbec2f35ac2cae8ea3557c3e16c9836ee21d66855810c571fd762be1aac1",
+      "columns": [
+        "id",
+        "dataset",
+        "arm",
+        "source_bucket",
+        "removed_category",
+        "primary_category",
+        "overlap_categories",
+        "source",
+        "difficulty",
+        "name",
+        "task_id",
+        "tags",
+        "raw_tags",
+        "skill_types",
+        "prompt",
+        "answer",
+        "messages",
+        "raw_primary_category",
+        "raw_overlap_categories",
+        "problem_id",
+        "response",
+        "source_row_index"
+      ]
+    },
+    "rl/train": {
+      "path": "data/taco_leetcode/rl/train.parquet",
+      "rows": 17249,
+      "bytes": 458373045,
+      "sha256": "9cda87499760450fa89755a8b61c821b6f58a7421b15e8a8f1ca636705130b3f",
+      "problem_id_set_sha256": "e6c155b05f012fefb7ad768459e629e89d90dc22566fb2570b43685f7b7509eb",
+      "columns": [
+        "prompt",
+        "data_source",
+        "ability",
+        "reward_model",
+        "extra_info",
+        "problem_id",
+        "primary_category",
+        "overlap_categories"
+      ]
+    },
+    "rl/validation": {
+      "path": "data/taco_leetcode/rl/validation.parquet",
+      "rows": 100,
+      "bytes": 1224277,
+      "sha256": "d049040b92177b9f5651a1db465545bfd0ff44cc6075e0726c19b4e6ceea3441",
+      "problem_id_set_sha256": "546e314b99d913a2c6b658114ef67512805ddff33274152b6e8419e9059ff087",
+      "columns": [
+        "prompt",
+        "data_source",
+        "ability",
+        "reward_model",
+        "extra_info",
+        "problem_id",
+        "primary_category",
+        "overlap_categories"
+      ]
+    }
+  }
+}

metadata/taco_leetcode/source_manifest.json ADDED Viewed

	@@ -0,0 +1,98 @@

+{
+  "version": "1.0.0",
+  "snapshot": "legacy_full_archive_20260729",
+  "upstream": [
+    {
+      "repo_id": "BAAI/TACO",
+      "split": "train",
+      "revision": null,
+      "revision_note": "Exact upstream revision unrecovered; frozen archive identity retained.",
+      "license": "apache-2.0 and upstream source-specific terms"
+    },
+    {
+      "repo_id": "newfacade/LeetCodeDataset",
+      "split": "train",
+      "revision_prefix": "34803eb64eab",
+      "revision_note": "Prefix preserved in the historical source path.",
+      "license": "apache-2.0"
+    }
+  ],
+  "archive_part_sha256_recorded": {
+    "sft/component_03644": "8856b89b5f01a948f959418e41af6ad5afb28b0bff6f1aa88195090684d41c88",
+    "rl/component_03651": "9f8d120bf38eff7e894d15f45aa56ef590f57eaa800d4845786dd018e8e66d43",
+    "rl_membership/component_03649": "c1aaa251e432b8b309668f6b01e92e4f844953b8ec2a9b11b821600fa2b4eed7",
+    "category_index/component_03642": "7d4637071c2b8d92a2dd424f9b9d8740aff4124bf05267da2a6da5c6c34bef55"
+  },
+  "source_files": {
+    "category_index.json": {
+      "bytes": 3485312,
+      "sha256": "d459c28e2858bda78e1fadba67cdb58616f819be4a3d98d7df81b9077704f101"
+    },
+    "memberships.json": {
+      "bytes": 4495036,
+      "sha256": "082b38d7497da162c5d39706ae011b3723b55a02f5a9ab4321ab0be14be12a25"
+    },
+    "rl_original_manifest.json": {
+      "bytes": 7316,
+      "sha256": "86147098122a2b2169867fca28f5285b552b9edc9fe67f555642e1e7bba13c96"
+    },
+    "rl_train.parquet": {
+      "bytes": 458101723,
+      "sha256": "1855443b5d49036778acf363790a10245d11956f43950dfdd6ef4d47094563e9"
+    },
+    "rl_validation.parquet": {
+      "bytes": 1222408,
+      "sha256": "92ef07f0114717d9724119c8dba29243b3406586bd6ee187e4fe606bbe3ae023"
+    },
+    "sft_original.parquet": {
+      "bytes": 33896246,
+      "sha256": "e97678b23a4c696820c1b021edbe8cafa42438fe6f4b2026eebbb33f25582e98"
+    },
+    "sft_original_identity.json": {
+      "bytes": 39,
+      "sha256": "c1fbe205bb747152f72189f81272af3c913df913adebe77dcc5f6b4862ead0e7"
+    },
+    "sft_original_manifest.json": {
+      "bytes": 3835894,
+      "sha256": "a9b0e9dd3d1fb1447badc2f9044aedaefbbd3b578c2a874c6bcb1eb75acb3309"
+    }
+  },
+  "sft": {
+    "historical_rows": 21879,
+    "taco": 19493,
+    "leetcode": 2386,
+    "data_seed": 20260603,
+    "release_rows": {
+      "train": 21779,
+      "validation": 100
+    },
+    "release_split_seed": 20260907,
+    "release_changes": [
+      "new fixed holdout",
+      "formal category aliases; original labels in raw_*",
+      "problem_id/response aliases and original row order index"
+    ]
+  },
+  "rl": {
+    "train": 17249,
+    "validation": 100,
+    "split_seed": 20260609,
+    "matched_arm_seed": 20260610,
+    "reference_verified_train": 11587,
+    "structural_only_train": 5662,
+    "reference_verified_validation": 71,
+    "structural_only_validation": 29,
+    "release_changes": [
+      "add ID and formal category columns",
+      "replace model directory keys with model names"
+    ],
+    "reward": "1 if all pass; otherwise 0.8 * passed_tests / total_tests"
+  },
+  "build_source_layout": [
+    "sft_original.parquet",
+    "rl_train.parquet",
+    "rl_validation.parquet",
+    "category_index.json",
+    "memberships.json"
+  ]
+}

metadata/taco_leetcode/taxonomy.json ADDED Viewed

	@@ -0,0 +1,31 @@

+{
+  "name": "taco_leetcode_legacy_7",
+  "version": "1.0.0",
+  "categories": [
+    "math_number_theory",
+    "data_structure",
+    "dynamic_programming",
+    "greedy_search",
+    "implementation_simulation",
+    "graph",
+    "other_algorithm"
+  ],
+  "unlabeled_value": "no_tags",
+  "raw_to_formal": {
+    "math_number_theory": "math_number_theory",
+    "data_structure": "data_structure",
+    "dynamic_programming": "dynamic_programming",
+    "greedy_search": "greedy_search",
+    "implementation_simulation": "implementation_simulation",
+    "graph": "graph",
+    "other_algorithm": "other_algorithm",
+    "no_tags": "no_tags",
+    "sorting": "other_algorithm",
+    "string": "other_algorithm",
+    "bit_manipulation": "other_algorithm",
+    "recursion_backtracking": "other_algorithm",
+    "geometry": "other_algorithm",
+    "other_tagged": "other_algorithm"
+  },
+  "ablation_rule": "Remove any row whose overlap_categories contains the selected category."
+}

metadata/validation_report.json ADDED Viewed

	@@ -0,0 +1,69 @@

+{
+  "status": "PASS",
+  "configs": {
+    "kodcode_sft": {
+      "train_rows": 35974,
+      "validation_rows": 100,
+      "train_validation_id_overlap": 0,
+      "train_validation_prompt_overlap": 0,
+      "huggingface_load": "PASS"
+    },
+    "kodcode_rl": {
+      "train_rows": 35974,
+      "validation_rows": 100,
+      "train_validation_id_overlap": 0,
+      "train_validation_prompt_overlap": 0,
+      "test_cases": {
+        "train": 210741,
+        "validation": 572
+      },
+      "verification": {
+        "train": {},
+        "validation": {}
+      },
+      "huggingface_load": "PASS"
+    },
+    "taco_leetcode_sft": {
+      "train_rows": 21779,
+      "validation_rows": 100,
+      "train_validation_id_overlap": 0,
+      "train_validation_prompt_overlap": 0,
+      "huggingface_load": "PASS"
+    },
+    "taco_leetcode_rl": {
+      "train_rows": 17249,
+      "validation_rows": 100,
+      "train_validation_id_overlap": 0,
+      "train_validation_prompt_overlap": 0,
+      "test_cases": {
+        "train": 993732,
+        "validation": 5433
+      },
+      "verification": {
+        "train": {
+          "reference_execution": 11587,
+          "structural_only": 5662
+        },
+        "validation": {
+          "structural_only": 29,
+          "reference_execution": 71
+        }
+      },
+      "huggingface_load": "PASS"
+    }
+  },
+  "checks": [
+    "hashes",
+    "every-row schema",
+    "split IDs",
+    "split prompts",
+    "original question IDs",
+    "reward test structure",
+    "all ablation memberships"
+  ],
+  "cross_config_id_overlap": {
+    "taco_sft_train_vs_rl_validation": 71,
+    "taco_sft_validation_vs_rl_train": 48,
+    "note": "Independent historical experiments; not a joint multi-stage holdout."
+  }
+}

requirements.txt ADDED Viewed

	@@ -0,0 +1,3 @@

+datasets==4.8.5
+pyarrow==23.0.1
+PyYAML==6.0.2

scripts/build_kodcode.py ADDED Viewed

	@@ -0,0 +1,70 @@

+"""Build from the frozen labeled snapshot, or export a recorded ablation arm."""
+from __future__ import annotations
+import argparse
+import shutil
+from pathlib import Path
+import pyarrow.parquet as pq
+from release_utils import ROOT, export_rows, load_json, make_manifest, member_record, sha256, write_json
+EXPECTED = {
+    'sft_train': 'f28beea278bfc762fad78a3cb11041380e765cbb0c328104b34a0023e202001c',
+    'rl_train': 'a23ea34d57279ae59d7068c4bbd55df08df49b3d4ca42853a49302365d54f224',
+    'sft_validation': '12b191279320d21ef8ca008e9ca75fa39cc41d061880f62ac0a142a139bcc232',
+    'rl_validation': '380992eb51a792f641d31306704e5eb58f26ef53e4d81ee4757c5552cf046ece',
+}
+def build(source, root):
+    for name, expected in EXPECTED.items():
+        kind, split = name.split('_')
+        path = source / (name + '.parquet')
+        if sha256(path) != expected:
+            raise ValueError(f'Frozen source identity mismatch: {name}')
+        dest = root / 'data/kodcode' / kind / (split + '.parquet')
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copyfile(path, dest)
+    metadata = root / 'metadata/kodcode'
+    metadata.mkdir(parents=True, exist_ok=True)
+    shutil.copyfile(source / 'taxonomy.json', metadata / 'taxonomy.json')
+    recorded = load_json(source / 'original_arm_manifest.json')
+    ids = load_json(source / 'memberships.json')
+    arms = {}
+    for item in recorded['arms']:
+        arm = member_record(ids[item['name']], item['removed_category'])
+        if arm['rows'] != item['rows'] or arm['problem_id_set_sha256'] != item['problem_id_set_sha256']:
+            raise ValueError('Historical arm identity mismatch: ' + item['name'])
+        arm['sampling_seed'] = item.get('sampling_seed')
+        arms[item['name']] = arm
+    write_json(metadata / 'ablation_membership.json', {
+        'version': '1.0.0', 'data_seed': recorded['data_seed'],
+        'rule': 'Remove the primary category only, then use the frozen equal-size sample.',
+        'applies_to': ['kodcode_sft/train', 'kodcode_rl/train'], 'arms': arms,
+    }, compact=True)
+    make_manifest(root, 'kodcode', {'train': 'historical', 'validation': 'historical fixed 100; shared SFT/RL'})
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--source', type=Path, help='Frozen source export with sft_train.parquet, etc.')
+    parser.add_argument('--root', type=Path, default=ROOT)
+    parser.add_argument('--arm')
+    parser.add_argument('--kind', choices=['sft', 'rl'], default='sft')
+    parser.add_argument('--output', type=Path)
+    args = parser.parse_args()
+    if args.arm:
+        if args.output is None:
+            parser.error('--output is required with --arm')
+        membership = load_json(args.root / 'metadata/kodcode/ablation_membership.json')['arms'][args.arm]
+        table = pq.read_table(args.root / 'data/kodcode' / args.kind / 'train.parquet')
+        export_rows(table, membership['problem_ids'], args.output)
+    elif args.source:
+        build(args.source, args.root)
+    else:
+        parser.error('Use --source to build or --arm NAME --output FILE to export.')
+if __name__ == '__main__':
+    main()

scripts/build_taco_leetcode.py ADDED Viewed

	@@ -0,0 +1,141 @@

+"""Build the legacy family, add a fixed SFT holdout, or export historical arms."""
+from __future__ import annotations
+import argparse
+import hashlib
+from collections import Counter, defaultdict
+from pathlib import Path
+import pyarrow as pa
+import pyarrow.parquet as pq
+from release_utils import (ROOT, export_rows, load_json, make_manifest, member_record,
+                           normalized_prompt, write_json, write_parquet)
+SPLIT_SEED = 20260907
+CATEGORIES = ['math_number_theory', 'data_structure', 'dynamic_programming', 'greedy_search',
+              'implementation_simulation', 'graph', 'other_algorithm']
+RAW_TO_FORMAL = {x: x for x in CATEGORIES + ['no_tags']}
+RAW_TO_FORMAL.update({x: 'other_algorithm' for x in
+                      ['sorting', 'string', 'bit_manipulation', 'recursion_backtracking', 'geometry', 'other_tagged']})
+def formal(value):
+    return RAW_TO_FORMAL.get(value, 'other_algorithm') if value else 'no_tags'
+def choose_validation(rows, count=100):
+    """Largest-remainder source/category allocation, hash-ranked unique prompts."""
+    multiplicity = Counter(normalized_prompt(r['prompt']) for r in rows)
+    strata = defaultdict(list)
+    full_counts = Counter((r['dataset'], r['primary_category']) for r in rows)
+    for row in rows:
+        if multiplicity[normalized_prompt(row['prompt'])] == 1:
+            strata[row['dataset'], row['primary_category']].append(row)
+    quotas = {key: count * n // len(rows) for key, n in full_counts.items()}
+    remaining = count - sum(quotas.values())
+    order = sorted(full_counts, key=lambda key: (-(count * full_counts[key] % len(rows)), key))
+    for key in order[:remaining]:
+        quotas[key] += 1
+    selected = []
+    for key in sorted(quotas):
+        if len(strata[key]) < quotas[key]:
+            raise ValueError(f'Insufficient unique prompts for stratum {key}')
+        ranked = sorted(strata[key], key=lambda r: hashlib.sha256(f'{SPLIT_SEED}:{r["id"]}'.encode()).hexdigest())
+        selected.extend(r['id'] for r in ranked[:quotas[key]])
+    assert len(selected) == count
+    return set(selected), {'seed': SPLIT_SEED, 'rows': count,
+                          'method': 'source/category largest remainder; SHA256(seed:id) rank; unique prompts only',
+                          'strata': {'::'.join(k): v for k, v in sorted(quotas.items())}}
+def build(source, root):
+    rows = pq.read_table(source / 'sft_original.parquet').to_pylist()
+    if len(rows) != 21879 or len({r['id'] for r in rows}) != 21879:
+        raise ValueError('Expected the original 21,879 distinct SFT rows')
+    for row in rows:
+        row['raw_primary_category'] = row['primary_category']
+        row['raw_overlap_categories'] = row['overlap_categories']
+        row['primary_category'] = formal(row['primary_category'])
+        row['overlap_categories'] = sorted({formal(x) for x in
+            (row['raw_overlap_categories'] or [row['raw_primary_category']])})
+    selected, policy = choose_validation(rows)
+    full_table = pa.Table.from_pylist(rows)
+    full_table = full_table.append_column('problem_id', full_table['id'])
+    full_table = full_table.append_column('response', full_table['answer'])
+    full_table = full_table.append_column('source_row_index', pa.array(range(len(rows)), type=pa.int32()))
+    for split in ['train', 'validation']:
+        indices = [i for i, r in enumerate(rows) if (r['id'] in selected) == (split == 'validation')]
+        write_parquet(root / 'data/taco_leetcode/sft' / (split + '.parquet'), full_table.take(pa.array(indices)))
+    categories = load_json(source / 'category_index.json')
+    rl_ids = {}
+    for split in ['train', 'validation']:
+        table = pq.read_table(source / ('rl_' + split + '.parquet'))
+        infos = table['extra_info'].to_pylist()
+        ids = [info['problem_id'] for info in infos]
+        rl_ids[split] = ids
+        if not set(ids) <= categories.keys():
+            raise ValueError('Missing original RL category index')
+        # Retain model names and counts, without machine-specific filesystem paths.
+        for info in infos:
+            token_counts = info.get('prompt_tokens_by_model')
+            if token_counts:
+                info['prompt_tokens_by_model'] = {Path(k).name: v for k, v in token_counts.items()}
+        table = table.set_column(table.schema.get_field_index('extra_info'), 'extra_info', pa.array(infos))
+        table = table.append_column('problem_id', pa.array(ids))
+        table = table.append_column('primary_category', pa.array([formal(categories[x]['primary_category']) for x in ids]))
+        table = table.append_column('overlap_categories', pa.array([
+            sorted({formal(v) for v in (categories[x]['overlap_categories'] or [categories[x]['primary_category']])})
+            for x in ids], type=pa.list_(pa.string())))
+        write_parquet(root / 'data/taco_leetcode/rl' / (split + '.parquet'), table)
+    recorded = load_json(source / 'memberships.json')
+    membership = {'version': '1.0.0', 'sft_historical': {}, 'sft_release': {}, 'rl_historical': {},
+                  'sft_rule': 'Frozen original arms, followed by removal of the new SFT holdout for release arms.',
+                  'rl_rule': 'Remove every intersecting overlap category; frozen seed-20260610 12,168-row samples.',
+                  'split_seed': SPLIT_SEED, 'validation_ids': sorted(selected)}
+    for arm, ids in recorded['sft'].items():
+        removed = arm[3:] if arm.startswith('no_') else None
+        membership['sft_historical'][arm] = member_record(ids, removed)
+        membership['sft_release'][arm] = member_record([x for x in ids if x not in selected], removed)
+    membership['rl_historical']['full_dapo'] = member_record(rl_ids['train'])
+    for arm, ids in recorded['rl'].items():
+        membership['rl_historical'][arm] = member_record(ids, arm[3:] if arm.startswith('no_') else None)
+    metadata = root / 'metadata/taco_leetcode'
+    write_json(metadata / 'ablation_membership.json', membership, compact=True)
+    write_json(metadata / 'taxonomy.json', {'name': 'taco_leetcode_legacy_7', 'version': '1.0.0',
+               'categories': CATEGORIES, 'unlabeled_value': 'no_tags', 'raw_to_formal': RAW_TO_FORMAL,
+               'ablation_rule': 'Remove any row whose overlap_categories contains the selected category.'})
+    policy['origin'] = 'Added for this release; not the historical experiment validation set.'
+    policy['historical_sft_rows'] = 21879
+    policy['historical_rl_validation_overlap_with_original_sft_train'] = len(set(rl_ids['validation']) & {r['id'] for r in rows})
+    make_manifest(root, 'taco_leetcode', {'sft': policy, 'rl': 'Original 17,249 train + 100 validation'})
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--source', type=Path, help='Frozen source export directory')
+    parser.add_argument('--root', type=Path, default=ROOT)
+    parser.add_argument('--arm')
+    parser.add_argument('--kind', choices=['sft', 'rl'], default='sft')
+    parser.add_argument('--historical', action='store_true', help='Restore original SFT membership including the new holdout')
+    parser.add_argument('--output', type=Path)
+    args = parser.parse_args()
+    if args.arm:
+        if args.output is None:
+            parser.error('--output is required with --arm')
+        members = load_json(args.root / 'metadata/taco_leetcode/ablation_membership.json')
+        kind = 'rl_historical' if args.kind == 'rl' else 'sft_historical' if args.historical else 'sft_release'
+        table = pq.read_table(args.root / 'data/taco_leetcode' / args.kind / 'train.parquet')
+        if args.kind == 'sft' and args.historical:
+            table = pa.concat_tables([table, pq.read_table(args.root / 'data/taco_leetcode/sft/validation.parquet')])
+            table = table.set_column(table.schema.get_field_index('primary_category'), 'primary_category', table['raw_primary_category'])
+            table = table.set_column(table.schema.get_field_index('overlap_categories'), 'overlap_categories', table['raw_overlap_categories'])
+        export_rows(table, members[kind][args.arm]['problem_ids'], args.output)
+    elif args.source:
+        build(args.source, args.root)
+    else:
+        parser.error('Use --source to build or --arm NAME --output FILE to export.')
+if __name__ == '__main__':
+    main()

scripts/release_utils.py ADDED Viewed

	@@ -0,0 +1,87 @@

+"""Small, deterministic helpers for the four dataset configurations."""
+from __future__ import annotations
+import hashlib
+import json
+from pathlib import Path
+import pyarrow as pa
+import pyarrow.parquet as pq
+ROOT = Path(__file__).resolve().parents[1]
+def load_json(path):
+    return json.loads(Path(path).read_text(encoding='utf-8'))
+def write_json(path, value, *, compact=False):
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(value, ensure_ascii=False, indent=None if compact else 2,
+                               separators=(',', ':') if compact else None) + '\n', encoding='utf-8')
+def sha256(path):
+    result = hashlib.sha256()
+    with Path(path).open('rb') as handle:
+        for block in iter(lambda: handle.read(4194304), b''):
+            result.update(block)
+    return result.hexdigest()
+def id_hash(ids):
+    return hashlib.sha256(('\n'.join(sorted(ids)) + '\n').encode()).hexdigest()
+def normalized_prompt(text):
+    return ' '.join(text.split())
+def ids_from_table(table):
+    if 'problem_id' in table.column_names:
+        return table['problem_id'].to_pylist()
+    return [row['problem_id'] for row in table['extra_info'].to_pylist()]
+def write_parquet(path, table):
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    pq.write_table(table, path, compression='zstd', row_group_size=1024)
+def describe_file(path, root):
+    path = Path(path)
+    parquet = pq.ParquetFile(path)
+    columns = ['problem_id'] if 'problem_id' in parquet.schema_arrow.names else ['extra_info']
+    ids = ids_from_table(parquet.read(columns=columns))
+    return {'path': path.relative_to(root).as_posix(), 'rows': parquet.metadata.num_rows,
+            'bytes': path.stat().st_size, 'sha256': sha256(path),
+            'problem_id_set_sha256': id_hash(ids), 'columns': parquet.schema_arrow.names}
+def make_manifest(root, family, split_policy):
+    files = {}
+    for kind in ['sft', 'rl']:
+        for split in ['train', 'validation']:
+            path = root / 'data' / family / kind / (split + '.parquet')
+            files[f'{kind}/{split}'] = describe_file(path, root)
+    result = {'version': '1.0.0', 'family': family, 'split_policy': split_policy, 'files': files}
+    write_json(root / 'metadata' / family / 'dataset_manifest.json', result)
+    return result
+def member_record(ids, removed_category=None):
+    return {'rows': len(ids), 'problem_ids': ids, 'problem_id_set_sha256': id_hash(ids),
+            'removed_category': removed_category}
+def export_rows(table, ids, destination):
+    all_ids = ids_from_table(table)
+    lookup = {v: i for i, v in enumerate(all_ids)}
+    if len(lookup) != len(all_ids):
+        raise ValueError('Duplicate source IDs')
+    missing = set(ids) - lookup.keys()
+    if missing:
+        raise ValueError(f'{len(missing)} arm IDs absent from this split')
+    write_parquet(destination, table.take(pa.array([lookup[v] for v in ids], type=pa.int64())))

scripts/validate_release.py ADDED Viewed

	@@ -0,0 +1,174 @@

+"""Validate every row and recorded identity; optionally load all HF configs."""
+from __future__ import annotations
+import argparse
+import json
+import sys
+from collections import Counter
+from pathlib import Path
+import pyarrow.parquet as pq
+import yaml
+from release_utils import ROOT, id_hash, load_json, normalized_prompt, sha256, write_json
+EXPECTED = {'kodcode_sft': (35974, 100), 'kodcode_rl': (35974, 100),
+            'taco_leetcode_sft': (21779, 100), 'taco_leetcode_rl': (17249, 100)}
+def check_file(path, family, kind, allowed):
+    parquet = pq.ParquetFile(path)
+    cols = ['problem_id', 'primary_category', 'prompt']
+    cols += ['response', 'messages'] if kind == 'sft' else ['reward_model', 'extra_info']
+    if family == 'kodcode' and kind == 'sft':
+        cols += ['original_question_id']
+    if family == 'taco_leetcode':
+        cols += ['overlap_categories']
+    ids, prompts, originals, categories, overlaps = [], {}, set(), {}, {}
+    verification = Counter()
+    tests_total = 0
+    for batch in parquet.iter_batches(batch_size=64, columns=cols):
+        for row in batch.to_pylist():
+            problem_id = row['problem_id']
+            assert isinstance(problem_id, str) and problem_id
+            assert row['primary_category'] in allowed, (problem_id, row['primary_category'])
+            ids.append(problem_id)
+            categories[problem_id] = row['primary_category']
+            if family == 'taco_leetcode':
+                assert row['overlap_categories'] and set(row['overlap_categories']) <= allowed
+                overlaps[problem_id] = row['overlap_categories']
+            if kind == 'sft':
+                assert isinstance(row['prompt'], str) and row['prompt'].strip()
+                assert isinstance(row['response'], str) and row['response'].strip()
+                messages = row['messages']
+                assert messages and messages[-1]['role'] == 'assistant'
+                assert messages[-1]['content'] == row['response']
+                users = [m['content'] for m in messages if m['role'] == 'user']
+                assert users and users[-1] == row['prompt']
+                text = row['prompt']
+                if family == 'kodcode':
+                    originals.add(row['original_question_id'])
+            else:
+                messages = row['prompt']
+                assert messages and all(m['role'] in ('user', 'system') for m in messages)
+                assert any(m['role'] == 'user' and m['content'].strip() for m in messages)
+                info = row['extra_info']
+                assert info['problem_id'] == problem_id
+                ground = row['reward_model']['ground_truth']
+                ground = json.loads(ground) if isinstance(ground, str) else ground
+                assert ground['problem_id'] == problem_id
+                if family == 'kodcode':
+                    assert ground['test_code'].strip() and ground['test_functions']
+                    n = len(ground['test_functions'])
+                    assert info['source_full_execution_verified'] is True
+                    originals.add(info['original_question_id'])
+                else:
+                    assert ground['tests']
+                    assert ground['mode'] in ('stdin', 'function'), ground['mode']
+                    n = len(ground['tests'])
+                    verification['reference_execution' if info['canonical_verified'] else 'structural_only'] += 1
+                assert n == info['test_count_used'], (problem_id, n, info['test_count_used'])
+                tests_total += n
+                text = '\n'.join(m['content'] for m in messages if m['role'] == 'user')
+            prompts[problem_id] = normalized_prompt(text)
+    assert len(set(ids)) == len(ids), f'Duplicate IDs in {path}'
+    return {'ids': ids, 'prompts': prompts, 'originals': originals, 'categories': categories,
+            'overlaps': overlaps, 'verification': dict(verification), 'tests': tests_total}
+def check_members(members, pool, *, overlap_removal=False):
+    for name, item in members.items():
+        ids = item['problem_ids']
+        assert len(ids) == item['rows'] == len(set(ids))
+        assert id_hash(ids) == item['problem_id_set_sha256']
+        assert set(ids) <= pool['categories'].keys(), name
+        removed = item['removed_category']
+        if removed:
+            for pid in ids:
+                labels = pool['overlaps'][pid] if overlap_removal else [pool['categories'][pid]]
+                assert removed not in labels, (name, pid)
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--root', type=Path, default=ROOT)
+    parser.add_argument('--hf', action='store_true', help='Load all four configurations using datasets')
+    parser.add_argument('--cache-dir', type=Path, help='HF cache outside the release directory')
+    parser.add_argument('--report', type=Path)
+    args = parser.parse_args()
+    root = args.root.resolve()
+    file_index = root / 'metadata/release_files.json'
+    if file_index.exists():
+        for relpath, identity in load_json(file_index)['files'].items():
+            path = root / relpath
+            assert path.is_file() and path.stat().st_size == identity['bytes'], relpath
+            assert sha256(path) == identity['sha256'], relpath
+        print('RELEASE_FILE_INDEX_PASS', flush=True)
+    header = root.joinpath('README.md').read_text(encoding='utf-8').split('---', 2)[1]
+    configs = yaml.safe_load(header)['configs']
+    assert {x['config_name'] for x in configs} == set(EXPECTED)
+    report = {'status': 'PASS', 'configs': {}, 'checks': ['hashes', 'every-row schema', 'split IDs',
+              'split prompts', 'original question IDs', 'reward test structure', 'all ablation memberships']}
+    checked = {}
+    for family in ['kodcode', 'taco_leetcode']:
+        manifest = load_json(root / 'metadata' / family / 'dataset_manifest.json')
+        taxonomy = load_json(root / 'metadata' / family / 'taxonomy.json')
+        allowed = {x['id'] for x in taxonomy['categories']} if family == 'kodcode' else set(taxonomy['categories']) | {'no_tags'}
+        for kind in ['sft', 'rl']:
+            name = family + '_' + kind
+            results = {}
+            for split, expected_rows in zip(['train', 'validation'], EXPECTED[name]):
+                item = manifest['files'][kind + '/' + split]
+                path = root / item['path']
+                assert path.stat().st_size == item['bytes']
+                assert sha256(path) == item['sha256'], path
+                result = check_file(path, family, kind, allowed)
+                assert len(result['ids']) == expected_rows == item['rows']
+                assert id_hash(result['ids']) == item['problem_id_set_sha256']
+                results[split] = result
+                checked[name, split] = result
+            assert not set(results['train']['ids']) & set(results['validation']['ids'])
+            assert not results['train']['originals'] & results['validation']['originals']
+            shared_prompts = set(results['train']['prompts'].values()) & set(results['validation']['prompts'].values())
+            assert not shared_prompts, (name, 'duplicate prompts across splits', len(shared_prompts))
+            report['configs'][name] = {'train_rows': len(results['train']['ids']),
+                                      'validation_rows': len(results['validation']['ids']),
+                                      'train_validation_id_overlap': 0, 'train_validation_prompt_overlap': 0}
+            if kind == 'rl':
+                report['configs'][name]['test_cases'] = {s: r['tests'] for s, r in results.items()}
+                report['configs'][name]['verification'] = {s: r['verification'] for s, r in results.items()}
+            print(name, 'PASS', flush=True)
+    for split in ['train', 'validation']:
+        assert set(checked['kodcode_sft', split]['ids']) == set(checked['kodcode_rl', split]['ids'])
+    kod_members = load_json(root / 'metadata/kodcode/ablation_membership.json')['arms']
+    check_members(kod_members, checked['kodcode_sft', 'train'])
+    legacy = load_json(root / 'metadata/taco_leetcode/ablation_membership.json')
+    original_sft = {key: {**checked['taco_leetcode_sft', 'train'][key], **checked['taco_leetcode_sft', 'validation'][key]}
+                    for key in ['categories', 'overlaps']}
+    check_members(legacy['sft_historical'], original_sft, overlap_removal=True)
+    check_members(legacy['sft_release'], checked['taco_leetcode_sft', 'train'], overlap_removal=True)
+    check_members(legacy['rl_historical'], checked['taco_leetcode_rl', 'train'], overlap_removal=True)
+    report['cross_config_id_overlap'] = {
+        'taco_sft_train_vs_rl_validation': len(set(checked['taco_leetcode_sft', 'train']['ids']) & set(checked['taco_leetcode_rl', 'validation']['ids'])),
+        'taco_sft_validation_vs_rl_train': len(set(checked['taco_leetcode_sft', 'validation']['ids']) & set(checked['taco_leetcode_rl', 'train']['ids'])),
+        'note': 'Independent historical experiments; not a joint multi-stage holdout.',
+    }
+    if args.hf:
+        from datasets import get_dataset_config_names, load_dataset
+        cache = str(args.cache_dir.resolve()) if args.cache_dir else None
+        assert set(get_dataset_config_names(str(root), cache_dir=cache)) == set(EXPECTED)
+        for name, sizes in EXPECTED.items():
+            ds = load_dataset(str(root), name, cache_dir=cache)
+            assert set(ds) == {'train', 'validation'}
+            for split, expected in zip(['train', 'validation'], sizes):
+                assert len(ds[split]) == expected
+                assert ds[split][0]['problem_id']
+            report['configs'][name]['huggingface_load'] = 'PASS'
+            print(name, 'HF_LOAD_PASS', flush=True)
+    if args.report:
+        write_json(args.report, report)
+    print(json.dumps({'status': report['status'], 'configs': len(report['configs'])}))
+if __name__ == '__main__':
+    main()

verification/kodcode_reward.py ADDED Viewed

	@@ -0,0 +1,254 @@

+#!/usr/bin/env python3
+"""Sandboxed strict all-tests-pass reward for the verified KodCode RL-10K subset."""
+from __future__ import annotations
+import json
+import importlib.util
+import os
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+from typing import Any
+_BASE_PATH = Path(__file__).with_name("stage3_reward_base.py")
+_BASE_SPEC = importlib.util.spec_from_file_location("diagnose_dapo_stage3_reward_base", _BASE_PATH)
+if _BASE_SPEC is None or _BASE_SPEC.loader is None:
+    raise ImportError(f"cannot load reward base: {_BASE_PATH}")
+_BASE = importlib.util.module_from_spec(_BASE_SPEC)
+_BASE_SPEC.loader.exec_module(_BASE)
+_kill_process_group = _BASE._kill_process_group
+_set_eval_limits = _BASE._set_eval_limits
+extract_code = _BASE.extract_code
+STATUS = {
+    "passed": 0,
+    "wrong_answer": 1,
+    "syntax_error": 2,
+    "runtime_error": 3,
+    "timeout": 4,
+    "sandbox_error": 5,
+}
+SANDBOX = r'''
+import contextlib
+import io
+import json
+import signal
+import sys
+import types
+payload = json.loads(sys.stdin.read())
+code = payload["code"]
+test_code = payload["test_code"]
+test_names = payload["test_functions"]
+per_test_timeout = float(payload["per_test_timeout"])
+def emit(status, passed_tests, total_tests, **extra):
+    result = {
+        "status": status,
+        "passed_tests": passed_tests,
+        "total_tests": total_tests,
+        **extra,
+    }
+    sys.__stdout__.write(json.dumps(result, ensure_ascii=False) + "\n")
+    sys.__stdout__.flush()
+def on_timeout(signum, frame):
+    raise TimeoutError("per-test timeout")
+total = len(test_names)
+try:
+    module = types.ModuleType("solution")
+    module.__dict__["__name__"] = "solution"
+    captured_out, captured_err = io.StringIO(), io.StringIO()
+    with contextlib.redirect_stdout(captured_out), contextlib.redirect_stderr(captured_err):
+        exec(compile(code, "<generated_solution>", "exec"), module.__dict__)
+    sys.modules["solution"] = module
+    test_ns = dict(module.__dict__)
+    test_ns["__name__"] = "kodcode_hidden_tests"
+    with contextlib.redirect_stdout(captured_out), contextlib.redirect_stderr(captured_err):
+        exec(compile(test_code, "<hidden_tests>", "exec"), test_ns)
+except SyntaxError as exc:
+    emit("syntax_error", 0, total, error=str(exc)[:500])
+    raise SystemExit
+except BaseException as exc:
+    emit("runtime_error", 0, total, error=f"{type(exc).__name__}: {exc}"[:500])
+    raise SystemExit
+signal.signal(signal.SIGALRM, on_timeout)
+passed = 0
+wrong = 0
+runtime = 0
+timeouts = 0
+errors = []
+for index, name in enumerate(test_names):
+    function = test_ns.get(name)
+    if not callable(function):
+        runtime += 1
+        errors.append({"test": name, "error": "missing test function"})
+        continue
+    try:
+        signal.setitimer(signal.ITIMER_REAL, per_test_timeout)
+        with contextlib.redirect_stdout(captured_out), contextlib.redirect_stderr(captured_err):
+            function()
+        passed += 1
+    except (AssertionError,) as exc:
+        wrong += 1
+        errors.append({"test": name, "error": f"AssertionError: {exc}"[:300]})
+    except TimeoutError as exc:
+        timeouts += 1
+        errors.append({"test": name, "error": str(exc)})
+    except BaseException as exc:
+        runtime += 1
+        errors.append({"test": name, "error": f"{type(exc).__name__}: {exc}"[:300]})
+    finally:
+        signal.setitimer(signal.ITIMER_REAL, 0)
+    if timeouts >= 3:
+        remaining = total - (index + 1)
+        timeouts += remaining
+        break
+status = "passed" if passed == total else "timeout" if timeouts else "runtime_error" if runtime else "wrong_answer"
+emit(
+    status,
+    passed,
+    total,
+    wrong_answers=wrong,
+    runtime_errors=runtime,
+    timeouts=timeouts,
+    errors=errors[:5],
+)
+'''
+def _ground_truth(value: Any) -> dict[str, Any]:
+    if isinstance(value, str):
+        return json.loads(value)
+    if isinstance(value, dict):
+        return value
+    raise TypeError(f"unsupported ground truth type: {type(value).__name__}")
+def _run(
+    code: str,
+    ground_truth: dict[str, Any],
+    exec_timeout: float,
+    per_test_timeout: float,
+    memory_limit_gib: float,
+    output_limit_mib: float,
+) -> dict[str, Any]:
+    payload = {
+        "code": code,
+        "test_code": ground_truth["test_code"],
+        "test_functions": ground_truth["test_functions"],
+        "per_test_timeout": per_test_timeout,
+    }
+    with tempfile.TemporaryDirectory(prefix="kodcode_reward_") as temp_dir:
+        proc = subprocess.Popen(
+            [sys.executable, "-I", "-c", SANDBOX],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            cwd=temp_dir,
+            start_new_session=True,
+            preexec_fn=lambda: _set_eval_limits(
+                memory_limit_gib, exec_timeout, output_limit_mib
+            ),
+        )
+        try:
+            stdout, stderr = proc.communicate(
+                input=json.dumps(payload, ensure_ascii=False),
+                timeout=exec_timeout,
+            )
+        except subprocess.TimeoutExpired:
+            _kill_process_group(proc)
+            stdout, stderr = proc.communicate()
+            return {
+                "status": "timeout",
+                "passed_tests": 0,
+                "total_tests": len(ground_truth["test_functions"]),
+                "error": "completion hard timeout",
+            }
+        finally:
+            if proc.poll() is None:
+                _kill_process_group(proc)
+        lines = [line for line in stdout.splitlines() if line.strip()]
+        if not lines:
+            return {
+                "status": "sandbox_error",
+                "passed_tests": 0,
+                "total_tests": len(ground_truth["test_functions"]),
+                "error": stderr[-500:],
+            }
+        try:
+            return json.loads(lines[-1])
+        except json.JSONDecodeError:
+            return {
+                "status": "sandbox_error",
+                "passed_tests": 0,
+                "total_tests": len(ground_truth["test_functions"]),
+                "error": (stdout + "\n" + stderr)[-500:],
+            }
+def compute_score(
+    data_source: str,
+    solution_str: str,
+    ground_truth: Any,
+    exec_timeout: float = 180.0,
+    per_test_timeout: float = 1.0,
+    memory_limit_gib: float = 2.0,
+    output_limit_mib: float = 16.0,
+    **_: Any,
+) -> dict[str, float]:
+    del data_source
+    truth = _ground_truth(ground_truth)
+    starter = ""
+    code = extract_code(solution_str, starter)
+    result = _run(
+        code,
+        truth,
+        float(exec_timeout),
+        float(per_test_timeout),
+        float(memory_limit_gib),
+        float(output_limit_mib),
+    )
+    passed_tests = int(result.get("passed_tests") or 0)
+    total_tests = int(result.get("total_tests") or len(truth["test_functions"]))
+    pass_frac = passed_tests / max(total_tests, 1)
+    passed = total_tests > 0 and passed_tests == total_tests
+    # Training reward is deliberately binary. pass_frac remains diagnostic only.
+    score = 1.0 if passed else 0.0
+    status = str(result.get("status") or "sandbox_error")
+    return {
+        "score": float(score),
+        "passed": float(passed),
+        "pass_frac": float(pass_frac),
+        "status_code": float(STATUS.get(status, STATUS["sandbox_error"])),
+        "passed_tests": float(passed_tests),
+        "total_tests": float(total_tests),
+        "wrong_answers": float(result.get("wrong_answers") or 0),
+        "runtime_errors": float(result.get("runtime_errors") or 0),
+        "timeouts": float(result.get("timeouts") or 0),
+    }
+if __name__ == "__main__":
+    truth = {
+        "test_code": (
+            "from solution import add\n"
+            "def test_one():\n    assert add(1, 2) == 3\n"
+            "def test_two():\n    assert add(-1, 1) == 0\n"
+        ),
+        "test_functions": ["test_one", "test_two"],
+    }
+    good = compute_score("selftest", "def add(a, b):\n    return a + b\n", truth)
+    bad = compute_score("selftest", "def add(a, b):\n    return 0\n", truth)
+    assert good["score"] == 1.0 and good["passed"] == 1.0, good
+    assert bad["score"] == 0.0 and bad["passed"] == 0.0, bad
+    assert bad["pass_frac"] == 0.5, bad
+    print(json.dumps({"good": good, "bad": bad}, indent=2))

verification/requirements.txt ADDED Viewed

	@@ -0,0 +1,9 @@

+# Reward modules use the Python standard library on Linux.
+# Some dataset tests additionally import these common packages.
+numpy>=1.26
+pandas>=2.2
+pytest>=8
+scipy>=1.11
+scikit-learn>=1.3
+sympy>=1.12
+Pillow>=10

verification/smoke_test.py ADDED Viewed

	@@ -0,0 +1,20 @@

+"""Check both reward formulas using tiny, self-contained synthetic tasks."""
+import json
+import kodcode_reward
+import taco_leetcode_reward
+truth = {'test_code': 'from solution import add\ndef test_one():\n    assert add(1,2)==3\ndef test_two():\n    assert add(-1,1)==0\n',
+         'test_functions': ['test_one', 'test_two']}
+good = 'def add(a,b):\n    return a+b\n'
+bad = 'def add(a,b):\n    return 0\n'
+k_good = kodcode_reward.compute_score('smoke', good, truth)
+k_bad = kodcode_reward.compute_score('smoke', bad, truth)
+assert k_good['score'] == 1 and k_bad['score'] == 0 and k_bad['pass_frac'] == 0.5
+truth = {'mode': 'function', 'entry_point': 'add', 'tests': [
+    {'args': [1, 2], 'output': 3}, {'args': [-1, 1], 'output': 0}]}
+t_good = taco_leetcode_reward.compute_score('smoke', good, truth)
+t_bad = taco_leetcode_reward.compute_score('smoke', bad, truth)
+assert t_good['score'] == 1 and t_bad['score'] == 0.4, (t_good, t_bad)
+print(json.dumps({'kodcode': {'full': k_good['score'], 'half': k_bad['score']},
+                  'taco_leetcode': {'full': t_good['score'], 'half': t_bad['score']}, 'status': 'PASS'}))

verification/stage3_reward_base.py ADDED Viewed

	@@ -0,0 +1,540 @@

+#!/usr/bin/env python3
+"""Rule-based code reward for Stage 3 verl/DAPO smoke tests."""
+from __future__ import annotations
+import ast
+import json
+import os
+import re
+import resource
+import signal
+import subprocess
+import sys
+import tempfile
+from typing import Any
+FENCE_RE = re.compile(r"```(?:python|py)?\s*(.*?)```", re.DOTALL | re.IGNORECASE)
+MAX_PARSE_CODE_CHARS = 65_536
+MAX_PARSE_TRIM_ATTEMPTS = 64
+STATUS_CODE = {
+    "passed": 0,
+    "syntax_error": 1,
+    "missing_entry_point": 2,
+    "entry_point_not_callable": 3,
+    "wrong_answer": 4,
+    "runtime_error": 5,
+    "timeout": 6,
+    "harness_error": 7,
+    "no_tests": 8,
+    "eval_error": 9,
+}
+EVAL_HARNESS = r'''
+import ast
+import io
+import json
+import math
+import signal
+import sys
+import traceback
+from bisect import *
+from collections import *
+from functools import *
+from heapq import *
+from itertools import *
+from math import *
+from operator import *
+from string import *
+from typing import *
+payload = json.loads(sys.stdin.read())
+code = payload["code"]
+mode = payload["mode"]
+entry_point = payload.get("entry_point")
+tests = payload.get("tests") or []
+per_test_timeout = float(payload.get("per_test_timeout", 2.0))
+class FakeStdin:
+    def __init__(self, text):
+        self._text = io.StringIO(str(text))
+        self.buffer = io.BytesIO(str(text).encode())
+    def read(self, *args):
+        return self._text.read(*args)
+    def readline(self, *args):
+        return self._text.readline(*args)
+    def readlines(self, *args):
+        return self._text.readlines(*args)
+    def __iter__(self):
+        return iter(self._text)
+def norm_text(value):
+    text = "" if value is None else str(value)
+    return "\n".join(line.rstrip() for line in text.strip().splitlines()).strip()
+def stdout_equal(got, expected):
+    a, b = norm_text(got), norm_text(expected)
+    return a == b or a.split() == b.split()
+def value_equal(a, b):
+    if isinstance(a, bool) or isinstance(b, bool):
+        return a == b
+    if isinstance(a, (int, float)) and isinstance(b, (int, float)):
+        return math.isclose(float(a), float(b), rel_tol=1e-6, abs_tol=1e-6)
+    if isinstance(a, (list, tuple)) and isinstance(b, (list, tuple)):
+        return len(a) == len(b) and all(value_equal(x, y) for x, y in zip(a, b))
+    if isinstance(a, dict) and isinstance(b, dict):
+        return set(a.keys()) == set(b.keys()) and all(value_equal(a[k], b[k]) for k in a)
+    return str(a) == str(b)
+def result(**kwargs):
+    print(json.dumps(kwargs, ensure_ascii=False))
+def timeout_handler(signum, frame):
+    raise TimeoutError("per-test timeout")
+try:
+    ast.parse(code)
+except (SyntaxError, ValueError, MemoryError, RecursionError) as exc:
+    result(
+        passed=False,
+        status="syntax_error",
+        interface_ok=False,
+        passed_tests=0,
+        total_tests=len(tests),
+        wrong_answers=0,
+        runtime_errors=0,
+        timeouts=0,
+        error=str(exc)[:300],
+    )
+    raise SystemExit
+try:
+    if not tests:
+        result(
+            passed=False,
+            status="no_tests",
+            interface_ok=False,
+            passed_tests=0,
+            total_tests=0,
+            wrong_answers=0,
+            runtime_errors=0,
+            timeouts=0,
+        )
+        raise SystemExit
+    if mode == "function":
+        ns = {"__name__": "__main__"}
+        signal.signal(signal.SIGALRM, timeout_handler)
+        try:
+            signal.setitimer(signal.ITIMER_REAL, per_test_timeout)
+            exec(compile(code, "<solution>", "exec"), ns)
+        except TimeoutError as exc:
+            result(
+                passed=False,
+                status="timeout",
+                interface_ok=False,
+                passed_tests=0,
+                total_tests=len(tests),
+                wrong_answers=0,
+                runtime_errors=0,
+                timeouts=len(tests),
+                error=str(exc)[:300],
+            )
+            raise SystemExit
+        finally:
+            signal.setitimer(signal.ITIMER_REAL, 0)
+        try:
+            candidate = eval(entry_point, ns)
+        except Exception as exc:
+            result(
+                passed=False,
+                status="missing_entry_point",
+                interface_ok=False,
+                passed_tests=0,
+                total_tests=len(tests),
+                wrong_answers=0,
+                runtime_errors=0,
+                timeouts=0,
+                error=str(exc)[:300],
+            )
+            raise SystemExit
+        if not callable(candidate):
+            result(
+                passed=False,
+                status="entry_point_not_callable",
+                interface_ok=False,
+                passed_tests=0,
+                total_tests=len(tests),
+                wrong_answers=0,
+                runtime_errors=0,
+                timeouts=0,
+            )
+            raise SystemExit
+        passed_tests = 0
+        wrong_answers = 0
+        runtime_errors = 0
+        timeouts = 0
+        for idx, test in enumerate(tests):
+            args = test.get("args") or []
+            kwargs = test.get("kwargs") or {}
+            expected = test.get("output")
+            try:
+                signal.setitimer(signal.ITIMER_REAL, per_test_timeout)
+                got = candidate(*args, **kwargs)
+                if value_equal(got, expected):
+                    passed_tests += 1
+                else:
+                    wrong_answers += 1
+            except TimeoutError:
+                timeouts += 1
+            except Exception:
+                runtime_errors += 1
+            finally:
+                signal.setitimer(signal.ITIMER_REAL, 0)
+            if timeouts >= 3:
+                break
+        skipped_after_timeout = len(tests) - (passed_tests + wrong_answers + runtime_errors + timeouts)
+        timeouts += max(skipped_after_timeout, 0)
+        passed = passed_tests == len(tests)
+        status = "passed" if passed else "timeout" if timeouts else "runtime_error" if runtime_errors else "wrong_answer"
+        result(
+            passed=passed,
+            status=status,
+            interface_ok=True,
+            passed_tests=passed_tests,
+            total_tests=len(tests),
+            wrong_answers=wrong_answers,
+            runtime_errors=runtime_errors,
+            timeouts=timeouts,
+        )
+    else:
+        signal.signal(signal.SIGALRM, timeout_handler)
+        passed_tests = 0
+        wrong_answers = 0
+        runtime_errors = 0
+        timeouts = 0
+        for idx, test in enumerate(tests):
+            old_stdin, old_stdout = sys.stdin, sys.stdout
+            fake_out = io.StringIO()
+            ns = {"__name__": "__main__"}
+            case_failed = False
+            try:
+                sys.stdin = FakeStdin(test.get("input", ""))
+                sys.stdout = fake_out
+                try:
+                    signal.setitimer(signal.ITIMER_REAL, per_test_timeout)
+                    exec(compile(code, "<solution>", "exec"), ns)
+                except SystemExit:
+                    pass
+                except TimeoutError:
+                    timeouts += 1
+                    case_failed = True
+                except Exception:
+                    runtime_errors += 1
+                    case_failed = True
+                finally:
+                    signal.setitimer(signal.ITIMER_REAL, 0)
+            finally:
+                sys.stdin, sys.stdout = old_stdin, old_stdout
+            if not case_failed:
+                got = fake_out.getvalue()
+                expected = test.get("output", "")
+                if stdout_equal(got, expected):
+                    passed_tests += 1
+                else:
+                    wrong_answers += 1
+            if timeouts >= 3:
+                break
+        skipped_after_timeout = len(tests) - (passed_tests + wrong_answers + runtime_errors + timeouts)
+        timeouts += max(skipped_after_timeout, 0)
+        passed = passed_tests == len(tests)
+        status = "passed" if passed else "timeout" if timeouts else "runtime_error" if runtime_errors else "wrong_answer"
+        result(
+            passed=passed,
+            status=status,
+            interface_ok=True,
+            passed_tests=passed_tests,
+            total_tests=len(tests),
+            wrong_answers=wrong_answers,
+            runtime_errors=runtime_errors,
+            timeouts=timeouts,
+        )
+except TimeoutError as exc:
+    result(
+        passed=False,
+        status="timeout",
+        interface_ok=True,
+        passed_tests=0,
+        total_tests=len(tests),
+        wrong_answers=0,
+        runtime_errors=0,
+        timeouts=len(tests),
+        error=str(exc)[:300],
+    )
+except Exception as exc:
+    result(
+        passed=False,
+        status="runtime_error",
+        interface_ok=True,
+        passed_tests=0,
+        total_tests=len(tests),
+        wrong_answers=0,
+        runtime_errors=len(tests),
+        timeouts=0,
+        error=str(exc)[:300],
+        traceback=traceback.format_exc()[-500:],
+    )
+'''
+def _json_loads_maybe(value: Any) -> Any:
+    if isinstance(value, str):
+        try:
+            return json.loads(value)
+        except Exception:
+            return {}
+    return value if isinstance(value, dict) else {}
+def _trim_parseable_code(code: str) -> str:
+    # Generated text can contain NUL bytes, which make ast.parse raise
+    # ValueError instead of SyntaxError. They are never valid Python source.
+    text = code.replace("\x00", "").strip()[:MAX_PARSE_CODE_CHARS]
+    if not text:
+        return text
+    lines = text.splitlines()
+    first_end = max(1, len(lines) - MAX_PARSE_TRIM_ATTEMPTS + 1)
+    for end in range(len(lines), first_end - 1, -1):
+        candidate = "\n".join(lines[:end]).strip()
+        if not candidate:
+            continue
+        try:
+            ast.parse(candidate)
+            return candidate
+        except (SyntaxError, ValueError, MemoryError, RecursionError):
+            continue
+    return text
+def extract_code(text: str, starter_code: str = "") -> str:
+    text = text or ""
+    fenced = FENCE_RE.findall(text)
+    if fenced:
+        code = fenced[0].strip()
+    else:
+        lines = text.splitlines()
+        start = None
+        for idx, line in enumerate(lines):
+            stripped = line.strip()
+            if re.match(r"(from\s+\S+\s+import\s+|import\s+\S+|class\s+\w+|def\s+\w+|if\s+__name__)", stripped):
+                start = idx
+                break
+        code = "\n".join(lines[start:]).strip() if start is not None else text.strip()
+    starter = (starter_code or "").strip()
+    if starter and "class Solution" in code and starter not in code:
+        code = starter.rstrip() + "\n\n" + code
+    return _trim_parseable_code(code)
+def _format_ok(solution_str: str) -> bool:
+    text = (solution_str or "").strip()
+    if not text:
+        return False
+    if "```" in text:
+        return False
+    prose_markers = ["Here is", "Explanation", "```python", "The solution"]
+    return not any(marker.lower() in text[:160].lower() for marker in prose_markers)
+def _set_eval_limits(memory_limit_gib: float, exec_timeout: float, output_limit_mib: float) -> None:
+    memory_bytes = max(1, int(memory_limit_gib * 1024**3))
+    output_bytes = max(1, int(output_limit_mib * 1024**2))
+    cpu_seconds = max(1, int(exec_timeout) + 1)
+    resource.setrlimit(resource.RLIMIT_AS, (memory_bytes, memory_bytes))
+    resource.setrlimit(resource.RLIMIT_CPU, (cpu_seconds, cpu_seconds))
+    resource.setrlimit(resource.RLIMIT_FSIZE, (output_bytes, output_bytes))
+    resource.setrlimit(resource.RLIMIT_NOFILE, (128, 128))
+    resource.setrlimit(resource.RLIMIT_NPROC, (256, 256))
+def _kill_process_group(proc: subprocess.Popen[str]) -> None:
+    try:
+        os.killpg(proc.pid, signal.SIGKILL)
+    except ProcessLookupError:
+        pass
+def _run_eval(
+    code: str,
+    meta: dict[str, Any],
+    exec_timeout: float,
+    per_test_timeout: float,
+    memory_limit_gib: float,
+    output_limit_mib: float,
+) -> dict[str, Any]:
+    payload = {
+        "code": code,
+        "mode": meta.get("mode"),
+        "entry_point": meta.get("entry_point"),
+        "tests": meta.get("tests") or [],
+        "per_test_timeout": per_test_timeout,
+    }
+    proc = None
+    try:
+        with (
+            tempfile.TemporaryFile(mode="w+t", encoding="utf-8") as stdout_file,
+            tempfile.TemporaryFile(mode="w+t", encoding="utf-8") as stderr_file,
+        ):
+            proc = subprocess.Popen(
+                [sys.executable, "-c", EVAL_HARNESS],
+                stdin=subprocess.PIPE,
+                stdout=stdout_file,
+                stderr=stderr_file,
+                text=True,
+                start_new_session=True,
+                preexec_fn=lambda: _set_eval_limits(memory_limit_gib, exec_timeout, output_limit_mib),
+            )
+            try:
+                proc.communicate(input=json.dumps(payload, ensure_ascii=False), timeout=exec_timeout)
+            except subprocess.TimeoutExpired:
+                _kill_process_group(proc)
+                proc.communicate()
+                raise
+            _kill_process_group(proc)
+            stdout_file.seek(0)
+            stdout = stdout_file.read()
+        parsed = None
+        for line in reversed(stdout.strip().splitlines()):
+            candidate = _json_loads_maybe(line)
+            if isinstance(candidate, dict) and "passed" in candidate and "total_tests" in candidate:
+                parsed = candidate
+                break
+        if parsed is None:
+            return {
+                "passed": False,
+                "status": "harness_error",
+                "interface_ok": False,
+                "passed_tests": 0,
+                "total_tests": len(payload["tests"]),
+                "wrong_answers": 0,
+                "runtime_errors": len(payload["tests"]),
+                "timeouts": 0,
+            }
+        return parsed
+    except subprocess.TimeoutExpired:
+        return {
+            "passed": False,
+            "status": "timeout",
+            "interface_ok": True,
+            "passed_tests": 0,
+            "total_tests": len(payload["tests"]),
+            "wrong_answers": 0,
+            "runtime_errors": 0,
+            "timeouts": len(payload["tests"]),
+        }
+    except Exception:
+        return {
+            "passed": False,
+            "status": "eval_error",
+            "interface_ok": False,
+            "passed_tests": 0,
+            "total_tests": len(payload["tests"]),
+            "wrong_answers": 0,
+            "runtime_errors": len(payload["tests"]),
+            "timeouts": 0,
+        }
+def compute_score(
+    data_source: str,
+    solution_str: str,
+    ground_truth: Any,
+    extra_info: dict[str, Any] | None = None,
+    exec_timeout: float = 6.0,
+    per_test_timeout: float = 2.0,
+    memory_limit_gib: float = 2.0,
+    output_limit_mib: float = 16.0,
+) -> dict[str, float]:
+    """Return a strict binary all-tests-pass execution reward."""
+    del data_source
+    meta = _json_loads_maybe(ground_truth)
+    if not meta and extra_info:
+        meta = _json_loads_maybe(extra_info)
+    tests = meta.get("tests") or []
+    format_ok = _format_ok(solution_str)
+    try:
+        code = extract_code(solution_str, meta.get("starter_code") or "")
+        ast.parse(code)
+        parse_ok = True
+    except (SyntaxError, ValueError, MemoryError, RecursionError):
+        code = ""
+        parse_ok = False
+    if not tests:
+        eval_result = {
+            "passed": False,
+            "status": "no_tests",
+            "interface_ok": False,
+            "passed_tests": 0,
+            "total_tests": 0,
+        }
+    elif not parse_ok:
+        eval_result = {
+            "passed": False,
+            "status": "syntax_error",
+            "interface_ok": False,
+            "passed_tests": 0,
+            "total_tests": len(tests),
+        }
+    else:
+        try:
+            eval_result = _run_eval(
+                code,
+                meta,
+                exec_timeout=exec_timeout,
+                per_test_timeout=per_test_timeout,
+                memory_limit_gib=memory_limit_gib,
+                output_limit_mib=output_limit_mib,
+            )
+        except (Exception, MemoryError) as exc:
+            eval_result = {
+                "passed": False,
+                "status": "eval_error",
+                "interface_ok": False,
+                "passed_tests": 0,
+                "total_tests": len(tests),
+                "error": str(exc)[:300],
+            }
+    total_tests = int(eval_result.get("total_tests") or len(tests) or 0)
+    passed_tests = int(eval_result.get("passed_tests") or 0)
+    pass_frac = passed_tests / max(total_tests, 1)
+    interface_ok = bool(eval_result.get("interface_ok"))
+    passed = bool(eval_result.get("passed"))
+    status = str(eval_result.get("status") or "eval_error")
+    # pass_frac is retained for diagnostics only and never shapes the reward.
+    score = 1.0 if total_tests > 0 and passed else 0.0
+    return {
+        "score": score,
+        "acc": 1.0 if passed else 0.0,
+        "format_ok": float(format_ok),
+        "parse_ok": float(parse_ok),
+        "interface_ok": float(interface_ok),
+        "pass_frac": float(pass_frac),
+        "passed": 1.0 if passed else 0.0,
+        "passed_tests": float(passed_tests),
+        "total_tests": float(total_tests),
+        "wrong_answers": float(eval_result.get("wrong_answers") or 0),
+        "runtime_errors": float(eval_result.get("runtime_errors") or 0),
+        "timeouts": float(eval_result.get("timeouts") or 0),
+        "status_code": float(STATUS_CODE.get(status, STATUS_CODE["eval_error"])),
+    }

verification/taco_leetcode_reward.py ADDED Viewed

	@@ -0,0 +1,541 @@

+#!/usr/bin/env python3
+"""Rule-based code reward for Stage 3 verl/DAPO smoke tests."""
+from __future__ import annotations
+import ast
+import json
+import os
+import re
+import resource
+import signal
+import subprocess
+import sys
+import tempfile
+from typing import Any
+FENCE_RE = re.compile(r"```(?:python|py)?\s*(.*?)```", re.DOTALL | re.IGNORECASE)
+MAX_PARSE_CODE_CHARS = 65_536
+MAX_PARSE_TRIM_ATTEMPTS = 64
+STATUS_CODE = {
+    "passed": 0,
+    "syntax_error": 1,
+    "missing_entry_point": 2,
+    "entry_point_not_callable": 3,
+    "wrong_answer": 4,
+    "runtime_error": 5,
+    "timeout": 6,
+    "harness_error": 7,
+    "no_tests": 8,
+    "eval_error": 9,
+}
+EVAL_HARNESS = r'''
+import ast
+import io
+import json
+import math
+import signal
+import sys
+import traceback
+from bisect import *
+from collections import *
+from functools import *
+from heapq import *
+from itertools import *
+from math import *
+from operator import *
+from string import *
+from typing import *
+payload = json.loads(sys.stdin.read())
+code = payload["code"]
+mode = payload["mode"]
+entry_point = payload.get("entry_point")
+tests = payload.get("tests") or []
+per_test_timeout = float(payload.get("per_test_timeout", 2.0))
+class FakeStdin:
+    def __init__(self, text):
+        self._text = io.StringIO(str(text))
+        self.buffer = io.BytesIO(str(text).encode())
+    def read(self, *args):
+        return self._text.read(*args)
+    def readline(self, *args):
+        return self._text.readline(*args)
+    def readlines(self, *args):
+        return self._text.readlines(*args)
+    def __iter__(self):
+        return iter(self._text)
+def norm_text(value):
+    text = "" if value is None else str(value)
+    return "\n".join(line.rstrip() for line in text.strip().splitlines()).strip()
+def stdout_equal(got, expected):
+    a, b = norm_text(got), norm_text(expected)
+    return a == b or a.split() == b.split()
+def value_equal(a, b):
+    if isinstance(a, bool) or isinstance(b, bool):
+        return a == b
+    if isinstance(a, (int, float)) and isinstance(b, (int, float)):
+        return math.isclose(float(a), float(b), rel_tol=1e-6, abs_tol=1e-6)
+    if isinstance(a, (list, tuple)) and isinstance(b, (list, tuple)):
+        return len(a) == len(b) and all(value_equal(x, y) for x, y in zip(a, b))
+    if isinstance(a, dict) and isinstance(b, dict):
+        return set(a.keys()) == set(b.keys()) and all(value_equal(a[k], b[k]) for k in a)
+    return str(a) == str(b)
+def result(**kwargs):
+    print(json.dumps(kwargs, ensure_ascii=False))
+def timeout_handler(signum, frame):
+    raise TimeoutError("per-test timeout")
+try:
+    ast.parse(code)
+except (SyntaxError, ValueError, MemoryError, RecursionError) as exc:
+    result(
+        passed=False,
+        status="syntax_error",
+        interface_ok=False,
+        passed_tests=0,
+        total_tests=len(tests),
+        wrong_answers=0,
+        runtime_errors=0,
+        timeouts=0,
+        error=str(exc)[:300],
+    )
+    raise SystemExit
+try:
+    if not tests:
+        result(
+            passed=False,
+            status="no_tests",
+            interface_ok=False,
+            passed_tests=0,
+            total_tests=0,
+            wrong_answers=0,
+            runtime_errors=0,
+            timeouts=0,
+        )
+        raise SystemExit
+    if mode == "function":
+        ns = {"__name__": "__main__"}
+        signal.signal(signal.SIGALRM, timeout_handler)
+        try:
+            signal.setitimer(signal.ITIMER_REAL, per_test_timeout)
+            exec(compile(code, "<solution>", "exec"), ns)
+        except TimeoutError as exc:
+            result(
+                passed=False,
+                status="timeout",
+                interface_ok=False,
+                passed_tests=0,
+                total_tests=len(tests),
+                wrong_answers=0,
+                runtime_errors=0,
+                timeouts=len(tests),
+                error=str(exc)[:300],
+            )
+            raise SystemExit
+        finally:
+            signal.setitimer(signal.ITIMER_REAL, 0)
+        try:
+            candidate = eval(entry_point, ns)
+        except Exception as exc:
+            result(
+                passed=False,
+                status="missing_entry_point",
+                interface_ok=False,
+                passed_tests=0,
+                total_tests=len(tests),
+                wrong_answers=0,
+                runtime_errors=0,
+                timeouts=0,
+                error=str(exc)[:300],
+            )
+            raise SystemExit
+        if not callable(candidate):
+            result(
+                passed=False,
+                status="entry_point_not_callable",
+                interface_ok=False,
+                passed_tests=0,
+                total_tests=len(tests),
+                wrong_answers=0,
+                runtime_errors=0,
+                timeouts=0,
+            )
+            raise SystemExit
+        passed_tests = 0
+        wrong_answers = 0
+        runtime_errors = 0
+        timeouts = 0
+        for idx, test in enumerate(tests):
+            args = test.get("args") or []
+            kwargs = test.get("kwargs") or {}
+            expected = test.get("output")
+            try:
+                signal.setitimer(signal.ITIMER_REAL, per_test_timeout)
+                got = candidate(*args, **kwargs)
+                if value_equal(got, expected):
+                    passed_tests += 1
+                else:
+                    wrong_answers += 1
+            except TimeoutError:
+                timeouts += 1
+            except Exception:
+                runtime_errors += 1
+            finally:
+                signal.setitimer(signal.ITIMER_REAL, 0)
+            if timeouts >= 3:
+                break
+        skipped_after_timeout = len(tests) - (passed_tests + wrong_answers + runtime_errors + timeouts)
+        timeouts += max(skipped_after_timeout, 0)
+        passed = passed_tests == len(tests)
+        status = "passed" if passed else "timeout" if timeouts else "runtime_error" if runtime_errors else "wrong_answer"
+        result(
+            passed=passed,
+            status=status,
+            interface_ok=True,
+            passed_tests=passed_tests,
+            total_tests=len(tests),
+            wrong_answers=wrong_answers,
+            runtime_errors=runtime_errors,
+            timeouts=timeouts,
+        )
+    else:
+        signal.signal(signal.SIGALRM, timeout_handler)
+        passed_tests = 0
+        wrong_answers = 0
+        runtime_errors = 0
+        timeouts = 0
+        for idx, test in enumerate(tests):
+            old_stdin, old_stdout = sys.stdin, sys.stdout
+            fake_out = io.StringIO()
+            ns = {"__name__": "__main__"}
+            case_failed = False
+            try:
+                sys.stdin = FakeStdin(test.get("input", ""))
+                sys.stdout = fake_out
+                try:
+                    signal.setitimer(signal.ITIMER_REAL, per_test_timeout)
+                    exec(compile(code, "<solution>", "exec"), ns)
+                except SystemExit:
+                    pass
+                except TimeoutError:
+                    timeouts += 1
+                    case_failed = True
+                except Exception:
+                    runtime_errors += 1
+                    case_failed = True
+                finally:
+                    signal.setitimer(signal.ITIMER_REAL, 0)
+            finally:
+                sys.stdin, sys.stdout = old_stdin, old_stdout
+            if not case_failed:
+                got = fake_out.getvalue()
+                expected = test.get("output", "")
+                if stdout_equal(got, expected):
+                    passed_tests += 1
+                else:
+                    wrong_answers += 1
+            if timeouts >= 3:
+                break
+        skipped_after_timeout = len(tests) - (passed_tests + wrong_answers + runtime_errors + timeouts)
+        timeouts += max(skipped_after_timeout, 0)
+        passed = passed_tests == len(tests)
+        status = "passed" if passed else "timeout" if timeouts else "runtime_error" if runtime_errors else "wrong_answer"
+        result(
+            passed=passed,
+            status=status,
+            interface_ok=True,
+            passed_tests=passed_tests,
+            total_tests=len(tests),
+            wrong_answers=wrong_answers,
+            runtime_errors=runtime_errors,
+            timeouts=timeouts,
+        )
+except TimeoutError as exc:
+    result(
+        passed=False,
+        status="timeout",
+        interface_ok=True,
+        passed_tests=0,
+        total_tests=len(tests),
+        wrong_answers=0,
+        runtime_errors=0,
+        timeouts=len(tests),
+        error=str(exc)[:300],
+    )
+except Exception as exc:
+    result(
+        passed=False,
+        status="runtime_error",
+        interface_ok=True,
+        passed_tests=0,
+        total_tests=len(tests),
+        wrong_answers=0,
+        runtime_errors=len(tests),
+        timeouts=0,
+        error=str(exc)[:300],
+        traceback=traceback.format_exc()[-500:],
+    )
+'''
+def _json_loads_maybe(value: Any) -> Any:
+    if isinstance(value, str):
+        try:
+            return json.loads(value)
+        except Exception:
+            return {}
+    return value if isinstance(value, dict) else {}
+def _trim_parseable_code(code: str) -> str:
+    # Generated text can contain NUL bytes, which make ast.parse raise
+    # ValueError instead of SyntaxError. They are never valid Python source.
+    text = code.replace("\x00", "").strip()[:MAX_PARSE_CODE_CHARS]
+    if not text:
+        return text
+    lines = text.splitlines()
+    first_end = max(1, len(lines) - MAX_PARSE_TRIM_ATTEMPTS + 1)
+    for end in range(len(lines), first_end - 1, -1):
+        candidate = "\n".join(lines[:end]).strip()
+        if not candidate:
+            continue
+        try:
+            ast.parse(candidate)
+            return candidate
+        except (SyntaxError, ValueError, MemoryError, RecursionError):
+            continue
+    return text
+def extract_code(text: str, starter_code: str = "") -> str:
+    text = text or ""
+    fenced = FENCE_RE.findall(text)
+    if fenced:
+        code = fenced[0].strip()
+    else:
+        lines = text.splitlines()
+        start = None
+        for idx, line in enumerate(lines):
+            stripped = line.strip()
+            if re.match(r"(from\s+\S+\s+import\s+|import\s+\S+|class\s+\w+|def\s+\w+|if\s+__name__)", stripped):
+                start = idx
+                break
+        code = "\n".join(lines[start:]).strip() if start is not None else text.strip()
+    starter = (starter_code or "").strip()
+    if starter and "class Solution" in code and starter not in code:
+        code = starter.rstrip() + "\n\n" + code
+    return _trim_parseable_code(code)
+def _format_ok(solution_str: str) -> bool:
+    text = (solution_str or "").strip()
+    if not text:
+        return False
+    if "```" in text:
+        return False
+    prose_markers = ["Here is", "Explanation", "```python", "The solution"]
+    return not any(marker.lower() in text[:160].lower() for marker in prose_markers)
+def _set_eval_limits(memory_limit_gib: float, exec_timeout: float, output_limit_mib: float) -> None:
+    memory_bytes = max(1, int(memory_limit_gib * 1024**3))
+    output_bytes = max(1, int(output_limit_mib * 1024**2))
+    cpu_seconds = max(1, int(exec_timeout) + 1)
+    resource.setrlimit(resource.RLIMIT_AS, (memory_bytes, memory_bytes))
+    resource.setrlimit(resource.RLIMIT_CPU, (cpu_seconds, cpu_seconds))
+    resource.setrlimit(resource.RLIMIT_FSIZE, (output_bytes, output_bytes))
+    resource.setrlimit(resource.RLIMIT_NOFILE, (128, 128))
+    resource.setrlimit(resource.RLIMIT_NPROC, (256, 256))
+def _kill_process_group(proc: subprocess.Popen[str]) -> None:
+    try:
+        os.killpg(proc.pid, signal.SIGKILL)
+    except ProcessLookupError:
+        pass
+def _run_eval(
+    code: str,
+    meta: dict[str, Any],
+    exec_timeout: float,
+    per_test_timeout: float,
+    memory_limit_gib: float,
+    output_limit_mib: float,
+) -> dict[str, Any]:
+    payload = {
+        "code": code,
+        "mode": meta.get("mode"),
+        "entry_point": meta.get("entry_point"),
+        "tests": meta.get("tests") or [],
+        "per_test_timeout": per_test_timeout,
+    }
+    proc = None
+    try:
+        with (
+            tempfile.TemporaryFile(mode="w+t", encoding="utf-8") as stdout_file,
+            tempfile.TemporaryFile(mode="w+t", encoding="utf-8") as stderr_file,
+        ):
+            proc = subprocess.Popen(
+                [sys.executable, "-c", EVAL_HARNESS],
+                stdin=subprocess.PIPE,
+                stdout=stdout_file,
+                stderr=stderr_file,
+                text=True,
+                start_new_session=True,
+                preexec_fn=lambda: _set_eval_limits(memory_limit_gib, exec_timeout, output_limit_mib),
+            )
+            try:
+                proc.communicate(input=json.dumps(payload, ensure_ascii=False), timeout=exec_timeout)
+            except subprocess.TimeoutExpired:
+                _kill_process_group(proc)
+                proc.communicate()
+                raise
+            _kill_process_group(proc)
+            stdout_file.seek(0)
+            stdout = stdout_file.read()
+        parsed = None
+        for line in reversed(stdout.strip().splitlines()):
+            candidate = _json_loads_maybe(line)
+            if isinstance(candidate, dict) and "passed" in candidate and "total_tests" in candidate:
+                parsed = candidate
+                break
+        if parsed is None:
+            return {
+                "passed": False,
+                "status": "harness_error",
+                "interface_ok": False,
+                "passed_tests": 0,
+                "total_tests": len(payload["tests"]),
+                "wrong_answers": 0,
+                "runtime_errors": len(payload["tests"]),
+                "timeouts": 0,
+            }
+        return parsed
+    except subprocess.TimeoutExpired:
+        return {
+            "passed": False,
+            "status": "timeout",
+            "interface_ok": True,
+            "passed_tests": 0,
+            "total_tests": len(payload["tests"]),
+            "wrong_answers": 0,
+            "runtime_errors": 0,
+            "timeouts": len(payload["tests"]),
+        }
+    except Exception:
+        return {
+            "passed": False,
+            "status": "eval_error",
+            "interface_ok": False,
+            "passed_tests": 0,
+            "total_tests": len(payload["tests"]),
+            "wrong_answers": 0,
+            "runtime_errors": len(payload["tests"]),
+            "timeouts": 0,
+        }
+def compute_score(
+    data_source: str,
+    solution_str: str,
+    ground_truth: Any,
+    extra_info: dict[str, Any] | None = None,
+    exec_timeout: float = 6.0,
+    per_test_timeout: float = 2.0,
+    memory_limit_gib: float = 2.0,
+    output_limit_mib: float = 16.0,
+) -> dict[str, float]:
+    """Return full-pass bonus or capped partial-credit execution reward."""
+    del data_source
+    meta = _json_loads_maybe(ground_truth)
+    if not meta and extra_info:
+        meta = _json_loads_maybe(extra_info)
+    tests = meta.get("tests") or []
+    format_ok = _format_ok(solution_str)
+    try:
+        code = extract_code(solution_str, meta.get("starter_code") or "")
+        ast.parse(code)
+        parse_ok = True
+    except (SyntaxError, ValueError, MemoryError, RecursionError):
+        code = ""
+        parse_ok = False
+    if not tests:
+        eval_result = {
+            "passed": False,
+            "status": "no_tests",
+            "interface_ok": False,
+            "passed_tests": 0,
+            "total_tests": 0,
+        }
+    elif not parse_ok:
+        eval_result = {
+            "passed": False,
+            "status": "syntax_error",
+            "interface_ok": False,
+            "passed_tests": 0,
+            "total_tests": len(tests),
+        }
+    else:
+        try:
+            eval_result = _run_eval(
+                code,
+                meta,
+                exec_timeout=exec_timeout,
+                per_test_timeout=per_test_timeout,
+                memory_limit_gib=memory_limit_gib,
+                output_limit_mib=output_limit_mib,
+            )
+        except (Exception, MemoryError) as exc:
+            eval_result = {
+                "passed": False,
+                "status": "eval_error",
+                "interface_ok": False,
+                "passed_tests": 0,
+                "total_tests": len(tests),
+                "error": str(exc)[:300],
+            }
+    total_tests = int(eval_result.get("total_tests") or len(tests) or 0)
+    passed_tests = int(eval_result.get("passed_tests") or 0)
+    pass_frac = passed_tests / max(total_tests, 1)
+    interface_ok = bool(eval_result.get("interface_ok"))
+    passed = bool(eval_result.get("passed"))
+    status = str(eval_result.get("status") or "eval_error")
+    # A fully correct solution gets 1.0. Any imperfect solution is capped at
+    # 0.8 and scaled by its test pass fraction. For example, 70/80 -> 0.7.
+    score = 1.0 if total_tests > 0 and passed else 0.8 * pass_frac
+    return {
+        "score": score,
+        "acc": 1.0 if passed else 0.0,
+        "format_ok": float(format_ok),
+        "parse_ok": float(parse_ok),
+        "interface_ok": float(interface_ok),
+        "pass_frac": float(pass_frac),
+        "passed": 1.0 if passed else 0.0,
+        "passed_tests": float(passed_tests),
+        "total_tests": float(total_tests),
+        "wrong_answers": float(eval_result.get("wrong_answers") or 0),
+        "runtime_errors": float(eval_result.get("runtime_errors") or 0),
+        "timeouts": float(eval_result.get("timeouts") or 0),
+        "status_code": float(STATUS_CODE.get(status, STATUS_CODE["eval_error"])),
+    }