rust-pgn-reader-python-binding 3.0.0__tar.gz → 3.2.0__tar.gz

{rust_pgn_reader_python_binding-3.0.0 → rust_pgn_reader_python_binding-3.2.0}/Cargo.lock

@@ -341,9 +341,9 @@ dependencies = [
 
 [[package]]
 name = "btoi"
-version = "0.4.3"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9dd6407f73a9b8b6162d8a2ef999fe6afd7cc15902ebf42c5cd296addf17e0ad"
+checksum = "3b5ab9db53bcda568284df0fd39f6eac24ad6f7ba7ff1168b9e76eba6576b976"
 dependencies = [
  "num-traits",
 ]
@@ -449,12 +449,6 @@ dependencies = [
  "half",
 ]
 
-[[package]]
-name = "circular"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0fc239e0f6cb375d2402d48afb92f76f5404fd1df208a41930ec81eda078bea"
-
 [[package]]
 name = "clap"
 version = "4.5.39"
@@ -602,9 +596,9 @@ dependencies = [
 
 [[package]]
 name = "either"
-version = "1.15.0"
+version = "1.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
+checksum = "60b1af1c220855b6ceac025d3f6ecdd2b7c4894bfe9cd9bda4fbb4bc7c0d4cf0"
 
 [[package]]
 name = "equivalent"
@@ -721,9 +715,9 @@ dependencies = [
 
 [[package]]
 name = "indoc"
-version = "2.0.6"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f4c7245a08504955605670dbf141fceab975f15ca21570696aebe9d2e71576bd"
+checksum = "b248f5224d1d606005e02c97f5aa4e88eeb230488bcc03bc9ca4d7991399f2b5"
 
 [[package]]
 name = "integer-encoding"
@@ -757,11 +751,10 @@ checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
 
 [[package]]
 name = "jobserver"
-version = "0.1.33"
+version = "0.1.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38f262f097c174adebe41eb73d66ae9c06b2844fb0da69969647bbddd9b0538a"
+checksum = "48d1dbcbbeb6a7fec7e059840aa538bd62aaccf972c7346c4d9d2059312853d0"
 dependencies = [
- "getrandom 0.3.3",
  "libc",
 ]
 
@@ -847,9 +840,9 @@ dependencies = [
 
 [[package]]
 name = "libc"
-version = "0.2.172"
+version = "0.2.169"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d750af042f7ef4f724306de029d18836c26c1765a54a6a3f094cbd23a7267ffa"
+checksum = "b5aba8db14291edd000dfcc4d620c7ebfb122c613afb886ca8803fa4e128a20a"
 
 [[package]]
 name = "libm"
@@ -1048,9 +1041,9 @@ dependencies = [
 
 [[package]]
 name = "once_cell"
-version = "1.21.3"
+version = "1.20.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
+checksum = "1261fe7e33c73b354eab43b1273a57c8f967d0391e80353e51f764ac02cf6775"
 
 [[package]]
 name = "oorandom"
@@ -1117,12 +1110,11 @@ checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
 
 [[package]]
 name = "pgn-reader"
-version = "0.26.0"
+version = "0.28.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1994b0ce2a74829bff0462e229b3f0a138cfb293e22c6a65f7966ff26d304e74"
+checksum = "d0e07db84c19e093741643903738788e6f773237c7eeb60f9a40191afc2a815a"
 dependencies = [
  "btoi",
- "circular",
  "memchr",
  "shakmaty",
 ]
@@ -1201,9 +1193,9 @@ dependencies = [
 
 [[package]]
 name = "portable-atomic"
-version = "1.11.0"
+version = "1.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "350e9b48cbc6b0e028b0473b114454c6316e57336ee184ceab6e53f72c178b3e"
+checksum = "280dc24453071f1b63954171985a0b0d30058d287960968b9b2aca264c8d4ee6"
 
 [[package]]
 name = "portable-atomic-util"
@@ -1216,18 +1208,18 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.95"
+version = "1.0.92"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02b3e5e68a3a1a02aad3ec490a98007cbc13c37cbe84a3cd7b8e406d76e7f778"
+checksum = "37d3544b3f2748c54e147655edb5025752e2303145b5aefb3c3ea2c78b973bb0"
 dependencies = [
  "unicode-ident",
 ]
 
 [[package]]
 name = "pyo3"
-version = "0.25.0"
+version = "0.25.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f239d656363bcee73afef85277f1b281e8ac6212a1d42aa90e55b90ed43c47a4"
+checksum = "8970a78afe0628a3e3430376fc5fd76b6b45c4d43360ffd6cdd40bdde72b682a"
 dependencies = [
  "chrono",
  "chrono-tz",
@@ -1264,9 +1256,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.25.0"
+version = "0.25.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "755ea671a1c34044fa165247aaf6f419ca39caa6003aee791a0df2713d8f1b6d"
+checksum = "458eb0c55e7ece017adeba38f2248ff3ac615e53660d7c71a238d7d2a01c7598"
 dependencies = [
  "once_cell",
  "target-lexicon",
@@ -1274,9 +1266,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.25.0"
+version = "0.25.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc95a2e67091e44791d4ea300ff744be5293f394f1bafd9f78c080814d35956e"
+checksum = "7114fe5457c61b276ab77c5055f206295b812608083644a5c5b2640c3102565c"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -1284,9 +1276,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.25.0"
+version = "0.25.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a179641d1b93920829a62f15e87c0ed791b6c8db2271ba0fd7c2686090510214"
+checksum = "a8725c0a622b374d6cb051d11a0983786448f7785336139c3c94f5aa6bef7e50"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -1296,9 +1288,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.25.0"
+version = "0.25.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9dff85ebcaab8c441b0e3f7ae40a6963ecea8a9f5e74f647e33fcf5ec9a1e89e"
+checksum = "4109984c22491085343c05b0dbc54ddc405c3cf7b4374fc533f5c3313a572ccc"
 dependencies = [
  "heck",
  "proc-macro2",
@@ -1309,9 +1301,9 @@ dependencies = [
 
 [[package]]
 name = "quote"
-version = "1.0.40"
+version = "1.0.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1885c039570dc00dcb4ff087a89e185fd56bae234ddc7f056a945bf36467248d"
+checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
 dependencies = [
  "proc-macro2",
 ]
@@ -1394,7 +1386,7 @@ checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
 
 [[package]]
 name = "rust_pgn_reader_python_binding"
-version = "3.0.0"
+version = "3.2.0"
 dependencies = [
  "arrow",
  "arrow-array",
@@ -1491,9 +1483,9 @@ dependencies = [
 
 [[package]]
 name = "shakmaty"
-version = "0.27.3"
+version = "0.29.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f414cadc4e727893d1a3b0dca62aaef4c1c821dcbd969f0b10a92e12d684d53a"
+checksum = "334bb41280a79854707d79c117c9818ddeaead15108e951c0b082ba2acedd0d1"
 dependencies = [
  "arrayvec",
  "bitflags",
@@ -1534,9 +1526,9 @@ checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
 
 [[package]]
 name = "syn"
-version = "2.0.101"
+version = "2.0.91"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ce2b7fc941b3a24138a0a7cf8e858bfc6a992e7978a068a5c760deb0ed43caf"
+checksum = "d53cbcb5a243bd33b7858b1d7f4aca2153490815872d86d955d6ea29f743c035"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1617,15 +1609,15 @@ checksum = "e7b17f197b3050ba473acf9181f7b1d3b66d1cf7356c6cc57886662276e65908"
 
 [[package]]
 name = "unicode-ident"
-version = "1.0.18"
+version = "1.0.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512"
+checksum = "adb9e6ca4f869e1180728b7950e35922a7fc6397f7b641499e8f3ef06e50dc83"
 
 [[package]]
 name = "unindent"
-version = "0.2.4"
+version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7264e107f553ccae879d21fbea1d6724ac785e8c3bfc762137959b5802826ef3"
+checksum = "c7de7d73e1754487cb58364ee906a499937a0dfabd86bcb980fa99ec8c8fa2ce"
 
 [[package]]
 name = "version_check"
@@ -1913,18 +1905,18 @@ dependencies = [
 
 [[package]]
 name = "zstd-safe"
-version = "7.2.4"
+version = "7.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f49c4d5f0abb602a93fb8736af2a4f4dd9512e36f7f570d66e65ff867ed3b9d"
+checksum = "54a3ab4db68cea366acc5c897c7b4d4d1b8994a9cd6e6f841f8964566a419059"
 dependencies = [
  "zstd-sys",
 ]
 
 [[package]]
 name = "zstd-sys"
-version = "2.0.15+zstd.1.5.7"
+version = "2.0.13+zstd.1.5.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eb81183ddd97d0c74cedf1d50d85c8d08c1b8b68ee863bdee9e706eedba1a237"
+checksum = "38ff0f21cfee8f97d94cef41359e0c89aa6113028ab0291aa8ca0038995a95aa"
 dependencies = [
  "cc",
  "pkg-config",

{rust_pgn_reader_python_binding-3.0.0 → rust_pgn_reader_python_binding-3.2.0}/Cargo.toml

@@ -1,7 +1,8 @@
 [package]
 name = "rust_pgn_reader_python_binding"
-version = "3.0.0"
-edition = "2021"
+version = "3.2.0"
+edition = "2024"
+readme = "README.md"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 [lib]
@@ -10,9 +11,9 @@ crate-type = ["lib", "cdylib"]
 # lib is needed for the native benchmark
 
 [dependencies]
-pyo3 = "0.25.0"
-shakmaty = "0.27"
-pgn-reader = "0.26.0"
+pyo3 = "0.25.1"
+shakmaty = "0.29"
+pgn-reader = "0.28.0"
 nom = "8.0"
 rayon = "1.10"
 num_cpus = "1.17"

rust_pgn_reader_python_binding-3.2.0/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: rust_pgn_reader_python_binding
+Version: 3.2.0
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.8

{rust_pgn_reader_python_binding-3.0.0 → rust_pgn_reader_python_binding-3.2.0}/README.md

@@ -14,15 +14,21 @@ Below are some benchmarks on Lichess's 2013-07 chess games (293,459	games) on an
 | rust_pgn_reader_python_binding                                             | PGN         | 4.7s   |
 | rust_pgn_reader_python_binding, parse_game (single_threaded)               | parquet     | 3.3s   |
 | rust_pgn_reader_python_binding, parse_games (multithreaded)                | parquet     | 0.5s   |
+| rust_pgn_reader_python_binding, parse_game_moves_arrow_chunked_array (multithreaded) | parquet     | 0.35s   |
 | [chess-library](https://github.com/Disservin/chess-library)                | PGN         | 2s     |
 | [python-chess](https://github.com/niklasf/python-chess)                    | PGN         | 3+ min |
 
-The main reason for rust_pgn_reader_python_binding being slower (at least in single threaded mode) than rust-pgn-reader is because of vector / string allocations (that show up as malloc's and free's in profiling).
+To replicate, download `2013-07-train-00000-of-00001.parquet` and then run:
 
-To replicate, download `2013-07-train-00000-of-00001.parquet` and then run `python bench_parquet_parallel.py`
+`python bench_parquet.py` (single-threaded parse_game)
+
+`python bench_parquet_parallel.py` (multithreaded parse_games)
+
+`python bench_parquet_arrow.py` (multithreaded parse_game_moves_arrow_chunked_array)
 
 ## Building
 `maturin develop`
+
 `maturin develop --release`
 
 For a more thorough tutorial, follow https://lukesalamone.github.io/posts/how-to-create-rust-python-bindings/
@@ -35,4 +41,5 @@ Linux/WSL-only:
 
 ## Testing
 `cargo test`
+
 `python -m unittest src/test.py`

{rust_pgn_reader_python_binding-3.0.0 → rust_pgn_reader_python_binding-3.2.0}/benches/parquet_bench.rs

@@ -1,16 +1,9 @@
 use arrow::array::{Array, StringArray};
-
 use parquet::arrow::arrow_reader::ParquetRecordBatchReaderBuilder;
-
-// use parquet::file::reader::{FileReader, SerializedFileReader};
-// use parquet::record::RowAccessor;
-
 use std::fs::File;
 use std::path::Path;
 use std::time::Instant;
 
-// use criterion::{criterion_group, criterion_main, Criterion};
-
 use rust_pgn_reader_python_binding::parse_multiple_games_native;
 
 pub fn bench_parquet() {

rust_pgn_reader_python_binding-3.2.0/rust_pgn_reader_python_binding.pyi

@@ -0,0 +1,49 @@
+from typing import List, Optional, Tuple
+import pyarrow
+
+class PyUciMove:
+    from_square: int
+    to_square: int
+    promotion: Optional[int]
+
+    def __init__(
+        self, from_square: int, to_square: int, promotion: Optional[int]
+    ) -> None: ...
+    @property
+    def get_from_square_name(self) -> str: ...
+    @property
+    def get_to_square_name(self) -> str: ...
+    @property
+    def get_promotion_name(self) -> Optional[str]: ...
+    def __str__(self) -> str: ...
+    def __repr__(self) -> str: ...
+
+class PositionStatus:
+    is_checkmate: bool
+    is_stalemate: bool
+    legal_move_count: int
+    is_game_over: bool
+    insufficient_material: Tuple[bool, bool]
+    turn: bool
+
+class MoveExtractor:
+    moves: List[PyUciMove]
+    valid_moves: bool
+    comments: List[str]
+    evals: List[float]
+    clock_times: List[Tuple[int, int, float]]
+    outcome: Optional[str]
+    headers: List[Tuple[str, str]]
+    castling_rights: List[Tuple[bool, bool, bool, bool]]
+    position_status: Optional[PositionStatus]
+
+    def __init__(self) -> None: ...
+    def turn(self) -> bool: ...
+
+def parse_game(pgn: str) -> MoveExtractor: ...
+def parse_games(
+    pgns: List[str], num_threads: Optional[int] = None
+) -> List[MoveExtractor]: ...
+def parse_game_moves_arrow_chunked_array(
+    pgn_chunked_array: pyarrow.ChunkedArray, num_threads: Optional[int] = None
+) -> List[MoveExtractor]: ...

{rust_pgn_reader_python_binding-3.0.0 → rust_pgn_reader_python_binding-3.2.0}/src/comment_parsing.rs

@@ -1,12 +1,15 @@
 use nom::{
     branch::alt,
     bytes::complete::{is_not, tag},
-    character::complete::{char, digit1, multispace1},
+    character::complete::{char, digit1},
     combinator::{map, map_res, not, opt, peek, recognize},
     multi::{many0, many1},
     sequence::{delimited, pair, preceded},
     IResult, Parser,
 };
+use std::borrow::Cow;
+// use nom::character::complete::multispace1;
+use nom::bytes::complete::take_while1;
 
 #[derive(Debug, PartialEq)]
 pub enum ParsedTag {
@@ -20,35 +23,43 @@ pub enum ParsedTag {
 }
 
 #[derive(Debug, PartialEq)]
-pub enum CommentContent {
-    Text(String),
+pub enum CommentContent<'a> {
+    Text(Cow<'a, str>),
     Tag(ParsedTag),
 }
 
-pub fn parse_comments(input: &str) -> IResult<&str, Vec<CommentContent>> {
+fn as_str(bytes: &[u8]) -> Result<&str, std::str::Utf8Error> {
+    std::str::from_utf8(bytes)
+}
+
+fn to_cow_str(bytes: &[u8]) -> CommentContent<'_> {
+    CommentContent::Text(String::from_utf8_lossy(bytes))
+}
+
+pub fn parse_comments(input: &[u8]) -> IResult<&[u8], Vec<CommentContent<'_>>> {
     many0(alt((
         // Attempt to parse a known structured tag first
         map(parse_structured_tag, CommentContent::Tag),
         // If not a known tag, but looks like a tag (e.g. [%unknown ...]), parse as text
         map(
             recognize(delimited(tag("[%"), is_not("]"), char(']'))),
-            |s: &str| CommentContent::Text(s.to_string()),
+            to_cow_str,
         ),
         // Otherwise, parse as regular text content. This must not be empty.
         map(
             recognize(many1(alt((
-                is_not("["), // Takes any char except '['
+                is_not([b'[']), // Takes any char except '['
                 // Takes a '[' if it's NOT followed by '%' (to allow "[abc]" as text)
                 recognize(preceded(char('['), peek(not(char('%'))))),
             )))),
-            |s: &str| CommentContent::Text(s.to_string()),
+            to_cow_str,
         ),
     )))
     .parse(input)
 }
 
 /// Parser for a complete tag like [%eval ...] or [%clk ...]
-fn parse_structured_tag(input: &str) -> IResult<&str, ParsedTag> {
+fn parse_structured_tag(input: &[u8]) -> IResult<&[u8], ParsedTag> {
     delimited(
         tag("[%"),
         alt((parse_eval_content, parse_clk_content)),
@@ -58,7 +69,7 @@ fn parse_structured_tag(input: &str) -> IResult<&str, ParsedTag> {
 }
 
 /// Parses the content of an eval tag, e.g., "eval 12.3" or "eval #3"
-fn parse_eval_content(input: &str) -> IResult<&str, ParsedTag> {
+fn parse_eval_content(input: &[u8]) -> IResult<&[u8], ParsedTag> {
     preceded(
         tag("eval"),
         preceded(
@@ -73,7 +84,7 @@ fn parse_eval_content(input: &str) -> IResult<&str, ParsedTag> {
 }
 
 /// Parses the content of a clk tag, e.g., "clk 1:23:45.6"
-fn parse_clk_content(input: &str) -> IResult<&str, ParsedTag> {
+fn parse_clk_content(input: &[u8]) -> IResult<&[u8], ParsedTag> {
     preceded(
         tag("clk"),
         preceded(
@@ -89,23 +100,29 @@ fn parse_clk_content(input: &str) -> IResult<&str, ParsedTag> {
 }
 
 /// Parser for a signed floating-point number, e.g., "-123.45", "+3.0", "7"
-fn parse_signed_float(input: &str) -> IResult<&str, f64> {
+fn parse_signed_float(input: &[u8]) -> IResult<&[u8], f64> {
     map_res(
-        recognize(pair(
-            opt(alt((char('+'), char('-')))),
-            recognize(pair(digit1, opt(preceded(char('.'), digit1)))),
-        )),
+        map_res(
+            recognize(pair(
+                opt(alt((char('+'), char('-')))),
+                recognize(pair(digit1, opt(preceded(char('.'), digit1)))),
+            )),
+            as_str,
+        ),
         |s: &str| s.parse::<f64>(),
     )
     .parse(input)
 }
 
 /// Parser for a mate value, e.g., "#-3", "#5"
-fn parse_mate_value(input: &str) -> IResult<&str, i32> {
+fn parse_mate_value(input: &[u8]) -> IResult<&[u8], i32> {
     preceded(
         char('#'),
         map_res(
-            recognize(pair(opt(char('-')), digit1)), // Recognizes signed integer
+            map_res(
+                recognize(pair(opt(char('-')), digit1)), // Recognizes signed integer
+                as_str,
+            ),
             |s: &str| s.parse::<i32>(),
         ),
     )
@@ -113,12 +130,12 @@ fn parse_mate_value(input: &str) -> IResult<&str, i32> {
 }
 
 /// Parser for a time value in H:M:S format, e.g., "12:34:56" or "1:2:3.45"
-fn parse_hms_time(input: &str) -> IResult<&str, (u32, u8, f64)> {
+fn parse_hms_time(input: &[u8]) -> IResult<&[u8], (u32, u8, f64)> {
     map(
         (
-            map_res(digit1, |s: &str| s.parse::<u32>()), // Hours
+            map_res(map_res(digit1, as_str), |s: &str| s.parse::<u32>()), // Hours
             char(':'),
-            map_res(digit1, |s: &str| s.parse::<u8>()), // Minutes (0-255, typically 0-59)
+            map_res(map_res(digit1, as_str), |s: &str| s.parse::<u8>()), // Minutes
             char(':'),
             parse_seconds_with_fraction, // Seconds with optional fraction
         ),
@@ -128,17 +145,20 @@ fn parse_hms_time(input: &str) -> IResult<&str, (u32, u8, f64)> {
 }
 
 /// Parser for seconds, which can be an integer or have a fractional part
-fn parse_seconds_with_fraction(input: &str) -> IResult<&str, f64> {
+fn parse_seconds_with_fraction(input: &[u8]) -> IResult<&[u8], f64> {
     map_res(
-        recognize(pair(digit1, opt(preceded(char('.'), digit1)))),
+        map_res(
+            recognize(pair(digit1, opt(preceded(char('.'), digit1)))),
+            as_str,
+        ),
         |s: &str| s.parse::<f64>(),
     )
     .parse(input)
 }
 
 /// Parser for one or more whitespace characters (spaces, newlines, tabs, etc.)
-fn spacing(input: &str) -> IResult<&str, &str> {
-    multispace1(input)
+fn spacing(input: &[u8]) -> IResult<&[u8], &[u8]> {
+    take_while1(|c: u8| c.is_ascii_whitespace())(input)
 }
 
 #[cfg(test)]
@@ -147,7 +167,7 @@ mod tests {
 
     #[test]
     fn test_comments1() {
-        let input = "[%eval 123] some text [%clk 12:34:56]";
+        let input = b"[%eval 123] some text [%clk 12:34:56]";
         let result = parse_comments(input);
         assert!(result.is_ok());
         let (remaining, parsed) = result.unwrap();
@@ -155,7 +175,7 @@ mod tests {
             parsed,
             vec![
                 CommentContent::Tag(ParsedTag::Eval(123.0)),
-                CommentContent::Text(" some text ".to_string()),
+                CommentContent::Text(Cow::from(" some text ")),
                 CommentContent::Tag(ParsedTag::ClkTime {
                     hours: 12,
                     minutes: 34,
@@ -163,12 +183,12 @@ mod tests {
                 })
             ]
         );
-        assert_eq!(remaining, "");
+        assert_eq!(remaining, b"");
     }
 
     #[test]
     fn test_comments2() {
-        let input = "[%clk 12:34:56] some text ";
+        let input = b"[%clk 12:34:56] some text ";
         let result = parse_comments(input);
         assert!(result.is_ok());
         let (remaining, parsed) = result.unwrap();
@@ -180,15 +200,15 @@ mod tests {
                     minutes: 34,
                     seconds: 56.0
                 }),
-                CommentContent::Text(" some text ".to_string())
+                CommentContent::Text(Cow::from(" some text "))
             ]
         );
-        assert_eq!(remaining, "");
+        assert_eq!(remaining, b"");
     }
 
     #[test]
     fn test_comment_fractional_sec() {
-        let input = "[%clk 12:34:56.0123]";
+        let input = b"[%clk 12:34:56.0123]";
         let result = parse_comments(input);
         assert!(result.is_ok());
         let (remaining, parsed) = result.unwrap();
@@ -200,32 +220,32 @@ mod tests {
                 seconds: 56.0123
             })]
         );
-        assert_eq!(remaining, "");
+        assert_eq!(remaining, b"");
     }
 
     #[test]
     fn test_parse_structured_tag_eval() {
-        let input = "[%eval 123]";
+        let input = b"[%eval 123]";
         let result = parse_structured_tag(input);
         assert!(result.is_ok());
         let (remaining, parsed) = result.unwrap();
         assert_eq!(parsed, ParsedTag::Eval(123.0));
-        assert_eq!(remaining, "");
+        assert_eq!(remaining, b"");
     }
 
     #[test]
     fn test_parse_structured_tag_eval_mate() {
-        let input = "[%eval #-3]";
+        let input = b"[%eval #-3]";
         let result = parse_structured_tag(input);
         assert!(result.is_ok());
         let (remaining, parsed) = result.unwrap();
         assert_eq!(parsed, ParsedTag::Mate(-3));
-        assert_eq!(remaining, "");
+        assert_eq!(remaining, b"");
     }
 
     #[test]
     fn test_parse_structured_tag_clk() {
-        let input = "[%clk 1:2:3.45]";
+        let input = b"[%clk 1:2:3.45]";
         let result = parse_structured_tag(input);
         assert!(result.is_ok());
         let (remaining, parsed) = result.unwrap();
@@ -237,13 +257,13 @@ mod tests {
                 seconds: 3.45
             }
         );
-        assert_eq!(remaining, "");
+        assert_eq!(remaining, b"");
     }
 
     // clk expects a particular format: H:M:S - this test ensures incorrect formats fail
     #[test]
     fn test_tag_parser_incorrect_clk_value() {
-        let input = "[%clk 123]"; // Incorrect format for clk time
+        let input = b"[%clk 123]"; // Incorrect format for clk time
         let result = parse_structured_tag(input);
         assert!(
             result.is_err(),
@@ -253,7 +273,7 @@ mod tests {
 
     #[test]
     fn test_tag_parser_incorrect_eval_value() {
-        let input = "[%eval notanumber]";
+        let input = b"[%eval notanumber]";
         let result = parse_structured_tag(input);
         assert!(
             result.is_err(),
@@ -263,7 +283,7 @@ mod tests {
 
     #[test]
     fn test_parse_clk_content_correct() {
-        let input = "clk 12:34:56";
+        let input = b"clk 12:34:56";
         let result = parse_clk_content(input);
         assert!(result.is_ok());
         let (remaining, parsed) = result.unwrap();
@@ -275,134 +295,134 @@ mod tests {
                 seconds: 56.0
             }
         );
-        assert_eq!(remaining, "");
+        assert_eq!(remaining, b"");
     }
 
     #[test]
     fn test_parse_clk_content_incorrect_name() {
         // This tests if parse_clk_content correctly fails if "clk" is not the prefix
-        let input = "eval 123";
+        let input = b"eval 123";
         let result = parse_clk_content(input);
         assert!(result.is_err());
     }
 
     #[test]
     fn test_parse_eval_content_correct_float() {
-        let input = "eval -42.5";
+        let input = b"eval -42.5";
         let result = parse_eval_content(input);
         assert!(result.is_ok());
         let (remaining, parsed) = result.unwrap();
         assert_eq!(parsed, ParsedTag::Eval(-42.5));
-        assert_eq!(remaining, "");
+        assert_eq!(remaining, b"");
     }
 
     #[test]
     fn test_parse_eval_content_correct_mate() {
-        let input = "eval #5";
+        let input = b"eval #5";
         let result = parse_eval_content(input);
         assert!(result.is_ok());
         let (remaining, parsed) = result.unwrap();
         assert_eq!(parsed, ParsedTag::Mate(5));
-        assert_eq!(remaining, "");
+        assert_eq!(remaining, b"");
     }
 
     #[test]
     fn test_parse_signed_float_positive() {
-        let input = "123.45";
+        let input = b"123.45";
         let result = parse_signed_float(input);
         assert!(result.is_ok());
         let (remaining, parsed) = result.unwrap();
         assert_eq!(parsed, 123.45);
-        assert_eq!(remaining, "");
+        assert_eq!(remaining, b"");
     }
 
     #[test]
     fn test_parse_signed_float_negative() {
-        let input = "-0.5";
+        let input = b"-0.5";
         let result = parse_signed_float(input);
         assert!(result.is_ok());
         let (remaining, parsed) = result.unwrap();
         assert_eq!(parsed, -0.5);
-        assert_eq!(remaining, "");
+        assert_eq!(remaining, b"");
     }
 
     #[test]
     fn test_parse_mate_value_positive() {
-        let input = "#7";
+        let input = b"#7";
         let result = parse_mate_value(input);
         assert!(result.is_ok());
         let (remaining, parsed) = result.unwrap();
         assert_eq!(parsed, 7);
-        assert_eq!(remaining, "");
+        assert_eq!(remaining, b"");
     }
 
     #[test]
     fn test_parse_mate_value_negative() {
-        let input = "#-2";
+        let input = b"#-2";
         let result = parse_mate_value(input);
         assert!(result.is_ok());
         let (remaining, parsed) = result.unwrap();
         assert_eq!(parsed, -2);
-        assert_eq!(remaining, "");
+        assert_eq!(remaining, b"");
     }
 
     #[test]
     fn test_parse_hms_time_simple() {
-        let input = "12:34:56";
+        let input = b"12:34:56";
         let result = parse_hms_time(input);
         assert!(result.is_ok());
         let (remaining, parsed) = result.unwrap();
         assert_eq!(parsed, (12, 34, 56.0));
-        assert_eq!(remaining, "");
+        assert_eq!(remaining, b"");
     }
 
     #[test]
     fn test_parse_hms_time_fractional() {
-        let input = "01:02:03.123";
+        let input = b"01:02:03.123";
         let result = parse_hms_time(input);
         assert!(result.is_ok());
         let (remaining, parsed) = result.unwrap();
         assert_eq!(parsed, (1, 2, 3.123));
-        assert_eq!(remaining, "");
+        assert_eq!(remaining, b"");
     }
 
     #[test]
     fn test_parse_hms_time_invalid_char_in_hour() {
-        let input = "1a:00:00";
+        let input = b"1a:00:00";
         let result = parse_hms_time(input);
         assert!(result.is_err());
     }
 
     #[test]
     fn test_parse_hms_time_missing_minutes() {
-        let input = "1::00";
+        let input = b"1::00";
         let result = parse_hms_time(input); // digit1 for minutes will fail on ':'
         assert!(result.is_err());
     }
 
     #[test]
     fn test_parse_seconds_with_fraction_integer() {
-        let input = "42";
+        let input = b"42";
         let result = parse_seconds_with_fraction(input);
         assert!(result.is_ok());
         let (remaining, parsed) = result.unwrap();
         assert_eq!(parsed, 42.0);
-        assert_eq!(remaining, "");
+        assert_eq!(remaining, b"");
     }
 
     #[test]
     fn test_parse_seconds_with_fraction_decimal() {
-        let input = "3.141";
+        let input = b"3.141";
         let result = parse_seconds_with_fraction(input);
         assert!(result.is_ok());
         let (remaining, parsed) = result.unwrap();
         assert_eq!(parsed, 3.141);
-        assert_eq!(remaining, "");
+        assert_eq!(remaining, b"");
     }
 
     #[test]
     fn test_unknown_tag_is_parsed_as_text() {
-        let input = "[%timestamp 12345] some text";
+        let input = b"[%timestamp 12345] some text";
         let result = parse_comments(input);
         assert!(result.is_ok());
         let (remaining, parsed) = result.unwrap();
@@ -410,16 +430,16 @@ mod tests {
             parsed,
             vec![
                 // The whole unknown tag becomes a text element
-                CommentContent::Text("[%timestamp 12345]".to_string()),
-                CommentContent::Text(" some text".to_string()) // Note: leading space is part of the text
+                CommentContent::Text(Cow::from("[%timestamp 12345]")),
+                CommentContent::Text(Cow::from(" some text")) // Note: leading space is part of the text
             ]
         );
-        assert_eq!(remaining, "");
+        assert_eq!(remaining, b"");
     }
 
     #[test]
     fn test_clk_tag_with_newline_spacing() {
-        let input = "[%clk\n0:09:36.2]";
+        let input = b"[%clk\n0:09:36.2]";
         let result = parse_comments(input);
         assert!(result.is_ok());
         let (remaining, parsed) = result.unwrap();
@@ -431,29 +451,29 @@ mod tests {
                 seconds: 36.2
             })]
         );
-        assert_eq!(remaining, "");
+        assert_eq!(remaining, b"");
     }
 
     #[test]
     fn test_eval_tag_with_newline_spacing() {
-        let input = "[%eval\n-0.5]";
+        let input = b"[%eval\n-0.5]";
         let result = parse_comments(input);
         assert!(result.is_ok());
         let (remaining, parsed) = result.unwrap();
         assert_eq!(parsed, vec![CommentContent::Tag(ParsedTag::Eval(-0.5))]);
-        assert_eq!(remaining, "");
+        assert_eq!(remaining, b"");
     }
 
     #[test]
     fn test_text_containing_brackets_not_tag() {
-        let input = "Text with [normal brackets] and then [%clk 1:2:3]";
+        let input = b"Text with [normal brackets] and then [%clk 1:2:3]";
         let result = parse_comments(input);
         assert!(result.is_ok());
         let (remaining, parsed) = result.unwrap();
         assert_eq!(
             parsed,
             vec![
-                CommentContent::Text("Text with [normal brackets] and then ".to_string()),
+                CommentContent::Text(Cow::from("Text with [normal brackets] and then ")),
                 CommentContent::Tag(ParsedTag::ClkTime {
                     hours: 1,
                     minutes: 2,
@@ -461,6 +481,6 @@ mod tests {
                 })
             ]
         );
-        assert_eq!(remaining, "");
+        assert_eq!(remaining, b"");
     }
 }

{rust_pgn_reader_python_binding-3.0.0 → rust_pgn_reader_python_binding-3.2.0}/src/example_str.py

@@ -24,6 +24,7 @@ print(extractor.valid_moves)
 print(extractor.evals)
 print(extractor.clock_times)
 print(extractor.outcome)
+assert extractor.position_status is not None
 print(extractor.position_status.is_checkmate)
 print(extractor.position_status.is_stalemate)
 print(extractor.position_status.is_game_over)

{rust_pgn_reader_python_binding-3.0.0 → rust_pgn_reader_python_binding-3.2.0}/src/lib.rs

@@ -1,13 +1,14 @@
 use crate::comment_parsing::{parse_comments, CommentContent, ParsedTag};
 use arrow_array::{Array, LargeStringArray, StringArray};
-use pgn_reader::{BufferedReader, RawComment, RawHeader, SanPlus, Skip, Visitor};
+use pgn_reader::{KnownOutcome, Outcome, RawComment, RawTag, Reader, SanPlus, Skip, Visitor};
 use pyo3::prelude::*;
 use pyo3_arrow::PyChunkedArray;
 use rayon::prelude::*;
 use rayon::ThreadPoolBuilder;
 use shakmaty::Color;
-use shakmaty::{uci::UciMove, Chess, Outcome, Position, Square};
+use shakmaty::{uci::UciMove, Chess, Position, Role, Square};
 use std::io::Cursor;
+use std::ops::ControlFlow;
 
 mod comment_parsing;
 
@@ -17,13 +18,13 @@ mod comment_parsing;
 pub struct PyUciMove {
     pub from_square: u8,
     pub to_square: u8,
-    pub promotion: Option<char>,
+    pub promotion: Option<u8>,
 }
 
 #[pymethods]
 impl PyUciMove {
     #[new]
-    fn new(from_square: u8, to_square: u8, promotion: Option<char>) -> Self {
+    fn new(from_square: u8, to_square: u8, promotion: Option<u8>) -> Self {
         PyUciMove {
             from_square,
             to_square,
@@ -41,24 +42,42 @@ impl PyUciMove {
         Square::new(self.to_square as u32).to_string()
     }
 
+    #[getter]
+    fn get_promotion_name(&self) -> Option<String> {
+        self.promotion.and_then(|p_u8| {
+            Role::try_from(p_u8)
+                .map(|role| format!("{:?}", role)) // Get the debug representation (e.g., "Queen")
+                .ok()
+        })
+    }
+
     // __str__ method for Python representation
     fn __str__(&self) -> String {
-        let promo_char = self.promotion.map_or("".to_string(), |p| p.to_string());
+        let promo_str = self.promotion.map_or("".to_string(), |p_u8| {
+            Role::try_from(p_u8)
+                .map(|role| role.char().to_string())
+                .unwrap_or_else(|_| "".to_string()) // Handle potential error if u8 is not a valid Role
+        });
         format!(
             "{}{}{}",
             Square::new(self.from_square as u32),
             Square::new(self.to_square as u32),
-            promo_char
+            promo_str
         )
     }
 
     // __repr__ for a more developer-friendly representation
     fn __repr__(&self) -> String {
+        let promo_repr = self.promotion.map_or("None".to_string(), |p_u8| {
+            Role::try_from(p_u8)
+                .map(|role| format!("Some('{}')", role.char()))
+                .unwrap_or_else(|_| format!("Some(InvalidRole({}))", p_u8))
+        });
         format!(
-            "PyUciMove(from_square={}, to_square={}, promotion={:?})",
+            "PyUciMove(from_square={}, to_square={}, promotion={})",
             Square::new(self.from_square as u32),
             Square::new(self.to_square as u32),
-            self.promotion
+            promo_repr
         )
     }
 }
@@ -176,15 +195,29 @@ impl MoveExtractor {
 }
 
 impl Visitor for MoveExtractor {
-    type Result = bool;
+    type Tags = Vec<(String, String)>;
+    type Movetext = ();
+    type Output = bool;
 
-    fn header(&mut self, key: &[u8], value: RawHeader<'_>) {
+    fn begin_tags(&mut self) -> ControlFlow<Self::Output, Self::Tags> {
+        self.headers.clear();
+        ControlFlow::Continue(Vec::with_capacity(10))
+    }
+
+    fn tag(
+        &mut self,
+        tags: &mut Self::Tags,
+        key: &[u8],
+        value: RawTag<'_>,
+    ) -> ControlFlow<Self::Output> {
         let key_str = String::from_utf8_lossy(key).into_owned();
         let value_str = String::from_utf8_lossy(value.as_bytes()).into_owned();
-        self.headers.push((key_str, value_str));
+        tags.push((key_str, value_str));
+        ControlFlow::Continue(())
     }
 
-    fn begin_game(&mut self) {
+    fn begin_movetext(&mut self, tags: Self::Tags) -> ControlFlow<Self::Output, Self::Movetext> {
+        self.headers = tags;
         self.moves.clear();
         self.pos = Chess::default();
         self.valid_moves = true;
@@ -193,14 +226,19 @@ impl Visitor for MoveExtractor {
         self.clock_times.clear();
 
         self.push_castling_bitboards();
+        ControlFlow::Continue(())
     }
 
-    fn san(&mut self, san_plus: SanPlus) {
+    fn san(
+        &mut self,
+        _movetext: &mut Self::Movetext,
+        san_plus: SanPlus,
+    ) -> ControlFlow<Self::Output> {
         if self.valid_moves {
             match san_plus.san.to_move(&self.pos) {
                 Ok(m) => {
-                    self.pos.play_unchecked(&m);
-                    let uci_move_obj = UciMove::from_standard(&m);
+                    self.pos.play_unchecked(m);
+                    let uci_move_obj = UciMove::from_standard(m);
 
                     match uci_move_obj {
                         UciMove::Normal {
@@ -211,7 +249,7 @@ impl Visitor for MoveExtractor {
                             let py_uci_move = PyUciMove {
                                 from_square: from as u8,
                                 to_square: to as u8,
-                                promotion: promo_opt.map(|p| p.char()),
+                                promotion: promo_opt.map(|p_role| p_role as u8),
                             };
                             self.moves.push(py_uci_move);
                             self.push_castling_bitboards();
@@ -231,15 +269,19 @@ impl Visitor for MoveExtractor {
                 }
             }
         }
+        ControlFlow::Continue(())
     }
 
-    fn comment(&mut self, _comment: RawComment<'_>) {
-        let comment = String::from_utf8_lossy(_comment.as_bytes()).into_owned();
-        match parse_comments(&comment) {
+    fn comment(
+        &mut self,
+        _movetext: &mut Self::Movetext,
+        _comment: RawComment<'_>,
+    ) -> ControlFlow<Self::Output> {
+        match parse_comments(_comment.as_bytes()) {
             Ok((remaining_input, parsed_comments)) => {
                 if !remaining_input.is_empty() {
                     eprintln!("Unparsed remaining input: {:?}", remaining_input);
-                    return;
+                    return ControlFlow::Continue(());
                 }
                 let mut eval_encountered = false;
                 let mut clk_time_encountered = false;
@@ -300,28 +342,40 @@ impl Visitor for MoveExtractor {
                 eprintln!("Error parsing comment: {:?}", e);
             }
         }
+        ControlFlow::Continue(())
     }
 
-    fn begin_variation(&mut self) -> Skip {
-        Skip(true) // stay in the mainline
+    fn begin_variation(
+        &mut self,
+        _movetext: &mut Self::Movetext,
+    ) -> ControlFlow<Self::Output, Skip> {
+        ControlFlow::Continue(Skip(true)) // stay in the mainline
     }
 
-    fn outcome(&mut self, _outcome: Option<Outcome>) {
-        self.outcome = _outcome.map(|o| match o {
-            Outcome::Decisive { winner } => format!("{:?}", winner),
-            Outcome::Draw => "Draw".to_string(),
+    fn outcome(
+        &mut self,
+        _movetext: &mut Self::Movetext,
+        _outcome: Outcome,
+    ) -> ControlFlow<Self::Output> {
+        self.outcome = Some(match _outcome {
+            Outcome::Known(known) => match known {
+                KnownOutcome::Decisive { winner } => format!("{:?}", winner),
+                KnownOutcome::Draw => "Draw".to_string(),
+            },
+            Outcome::Unknown => "Unknown".to_string(),
         });
         self.update_position_status();
+        ControlFlow::Continue(())
     }
 
-    fn end_game(&mut self) -> Self::Result {
+    fn end_game(&mut self, _movetext: Self::Movetext) -> Self::Output {
         self.valid_moves
     }
 }
 
 // --- Native Rust versions (no PyResult) ---
 pub fn parse_single_game_native(pgn: &str) -> Result<MoveExtractor, String> {
-    let mut reader = BufferedReader::new(Cursor::new(pgn));
+    let mut reader = Reader::new(Cursor::new(pgn));
     let mut extractor = MoveExtractor::new();
     match reader.read_game(&mut extractor) {
         Ok(Some(_)) => Ok(extractor),
@@ -334,7 +388,7 @@ pub fn parse_multiple_games_native(
     pgns: &Vec<String>,
     num_threads: Option<usize>,
 ) -> Result<Vec<MoveExtractor>, String> {
-    let num_threads = num_threads.unwrap_or_else(|| num_cpus::get());
+    let num_threads = num_threads.unwrap_or_else(num_cpus::get);
 
     // Build a custom Rayon thread pool with the desired number of threads
     let thread_pool = ThreadPoolBuilder::new()
@@ -363,7 +417,7 @@ fn _parse_game_moves_from_arrow_chunks_native(
     pgn_chunked_array: &PyChunkedArray,
     num_threads: Option<usize>,
 ) -> Result<Vec<MoveExtractor>, String> {
-    let num_threads = num_threads.unwrap_or_else(|| num_cpus::get());
+    let num_threads = num_threads.unwrap_or_else(num_cpus::get);
     let thread_pool = ThreadPoolBuilder::new()
         .num_threads(num_threads)
         .build()
@@ -409,15 +463,14 @@ fn _parse_game_moves_from_arrow_chunks_native(
 #[pyfunction]
 /// Parses a single PGN game string.
 fn parse_game(pgn: &str) -> PyResult<MoveExtractor> {
-    parse_single_game_native(pgn).map_err(|err| pyo3::exceptions::PyValueError::new_err(err))
+    parse_single_game_native(pgn).map_err(pyo3::exceptions::PyValueError::new_err)
 }
 
 /// In parallel, parse a set of games
 #[pyfunction]
 #[pyo3(signature = (pgns, num_threads=None))]
 fn parse_games(pgns: Vec<String>, num_threads: Option<usize>) -> PyResult<Vec<MoveExtractor>> {
-    parse_multiple_games_native(&pgns, num_threads)
-        .map_err(|err| pyo3::exceptions::PyValueError::new_err(err))
+    parse_multiple_games_native(&pgns, num_threads).map_err(pyo3::exceptions::PyValueError::new_err)
 }
 
 #[pyfunction]
@@ -427,7 +480,7 @@ fn parse_game_moves_arrow_chunked_array(
     num_threads: Option<usize>,
 ) -> PyResult<Vec<MoveExtractor>> {
     _parse_game_moves_from_arrow_chunks_native(&pgn_chunked_array, num_threads)
-        .map_err(|err| pyo3::exceptions::PyValueError::new_err(err))
+        .map_err(pyo3::exceptions::PyValueError::new_err)
 }
 
 /// Parser for chess PGN notation
@@ -441,3 +494,74 @@ fn rust_pgn_reader_python_binding(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_class::<PyUciMove>()?;
     Ok(())
 }
+
+#[cfg(test)]
+mod pyucimove_tests {
+    use super::*;
+    use shakmaty::{Role, Square};
+
+    #[test]
+    fn test_py_uci_move_no_promotion() {
+        let uci_move = PyUciMove::new(Square::E2 as u8, Square::E4 as u8, None);
+        assert_eq!(uci_move.from_square, Square::E2 as u8);
+        assert_eq!(uci_move.to_square, Square::E4 as u8);
+        assert_eq!(uci_move.promotion, None);
+        assert_eq!(uci_move.get_from_square_name(), "e2");
+        assert_eq!(uci_move.get_to_square_name(), "e4");
+        assert_eq!(uci_move.get_promotion_name(), None);
+        assert_eq!(uci_move.__str__(), "e2e4");
+        assert_eq!(
+            uci_move.__repr__(),
+            "PyUciMove(from_square=e2, to_square=e4, promotion=None)"
+        );
+    }
+
+    #[test]
+    fn test_py_uci_move_with_queen_promotion() {
+        let uci_move = PyUciMove::new(Square::E7 as u8, Square::E8 as u8, Some(Role::Queen as u8));
+        assert_eq!(uci_move.from_square, Square::E7 as u8);
+        assert_eq!(uci_move.to_square, Square::E8 as u8);
+        assert_eq!(uci_move.promotion, Some(Role::Queen as u8));
+        assert_eq!(uci_move.get_from_square_name(), "e7");
+        assert_eq!(uci_move.get_to_square_name(), "e8");
+        assert_eq!(uci_move.get_promotion_name(), Some("Queen".to_string()));
+        assert_eq!(uci_move.__str__(), "e7e8q");
+        assert_eq!(
+            uci_move.__repr__(),
+            "PyUciMove(from_square=e7, to_square=e8, promotion=Some('q'))"
+        );
+    }
+
+    #[test]
+    fn test_py_uci_move_with_rook_promotion() {
+        let uci_move = PyUciMove::new(Square::A7 as u8, Square::A8 as u8, Some(Role::Rook as u8));
+        assert_eq!(uci_move.from_square, Square::A7 as u8);
+        assert_eq!(uci_move.to_square, Square::A8 as u8);
+        assert_eq!(uci_move.promotion, Some(Role::Rook as u8));
+        assert_eq!(uci_move.get_from_square_name(), "a7");
+        assert_eq!(uci_move.get_to_square_name(), "a8");
+        assert_eq!(uci_move.get_promotion_name(), Some("Rook".to_string()));
+        assert_eq!(uci_move.__str__(), "a7a8r");
+        assert_eq!(
+            uci_move.__repr__(),
+            "PyUciMove(from_square=a7, to_square=a8, promotion=Some('r'))"
+        );
+    }
+
+    #[test]
+    fn test_py_uci_move_invalid_promotion_val() {
+        // Test with a u8 value that doesn't correspond to a valid Role
+        let uci_move = PyUciMove::new(Square::B7 as u8, Square::B8 as u8, Some(99)); // 99 is not a valid Role
+        assert_eq!(uci_move.from_square, Square::B7 as u8);
+        assert_eq!(uci_move.to_square, Square::B8 as u8);
+        assert_eq!(uci_move.promotion, Some(99));
+        assert_eq!(uci_move.get_from_square_name(), "b7");
+        assert_eq!(uci_move.get_to_square_name(), "b8");
+        assert_eq!(uci_move.get_promotion_name(), None); // Should be None as 99 is invalid
+        assert_eq!(uci_move.__str__(), "b7b8"); // Should produce no promotion char
+        assert_eq!(
+            uci_move.__repr__(),
+            "PyUciMove(from_square=b7, to_square=b8, promotion=Some(InvalidRole(99)))"
+        );
+    }
+}

rust_pgn_reader_python_binding-3.0.0/PKG-INFO

@@ -1,47 +0,0 @@
-Metadata-Version: 2.4
-Name: rust_pgn_reader_python_binding
-Version: 3.0.0
-Classifier: Programming Language :: Rust
-Classifier: Programming Language :: Python :: Implementation :: CPython
-Classifier: Programming Language :: Python :: Implementation :: PyPy
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
-
-# rust_pgn_reader_python_binding
-## Fast PGN parsing bindings for Python
-This project adds Python bindings to [rust-pgn-reader](https://github.com/niklasf/rust-pgn-reader). In addition, it also parses and extracts [%clk ..] and [%eval ..] tags from comments.
-
-## Installing
-`pip install rust_pgn_reader_python_binding`
-
-## Benchmarks
-Below are some benchmarks on Lichess's 2013-07 chess games (293,459	games) on an 7800X3D.
-
-| Parser                                                                     | File format | Time   |
-|----------------------------------------------------------------------------|-------------|--------|
-| [rust-pgn-reader](https://github.com/niklasf/rust-pgn-reader/tree/master)  | PGN         | 1s     |
-| rust_pgn_reader_python_binding                                             | PGN         | 4.7s   |
-| rust_pgn_reader_python_binding, parse_game (single_threaded)               | parquet     | 3.3s   |
-| rust_pgn_reader_python_binding, parse_games (multithreaded)                | parquet     | 0.5s   |
-| [chess-library](https://github.com/Disservin/chess-library)                | PGN         | 2s     |
-| [python-chess](https://github.com/niklasf/python-chess)                    | PGN         | 3+ min |
-
-The main reason for rust_pgn_reader_python_binding being slower (at least in single threaded mode) than rust-pgn-reader is because of vector / string allocations (that show up as malloc's and free's in profiling).
-
-To replicate, download `2013-07-train-00000-of-00001.parquet` and then run `python bench_parquet_parallel.py`
-
-## Building
-`maturin develop`
-`maturin develop --release`
-
-For a more thorough tutorial, follow https://lukesalamone.github.io/posts/how-to-create-rust-python-bindings/
-
-## Profiling
-`py-spy record -s -F -f speedscope --output profile.speedscope -- python ./src/bench_parquet.py`
-
-Linux/WSL-only:
-`py-spy record -s -F -n -f speedscope --output profile.speedscope -- python ./src/bench_parquet.py`
-
-## Testing
-`cargo test`
-`python -m unittest src/test.py`