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

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

@@ -840,9 +840,9 @@ dependencies = [
 
 [[package]]
 name = "libc"
-version = "0.2.169"
+version = "0.2.174"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5aba8db14291edd000dfcc4d620c7ebfb122c613afb886ca8803fa4e128a20a"
+checksum = "1171693293099992e19cddea4e8b849964e9846f4acee11b3948bcc337be8776"
 
 [[package]]
 name = "libm"
@@ -1386,7 +1386,7 @@ checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
 
 [[package]]
 name = "rust_pgn_reader_python_binding"
-version = "3.2.0"
+version = "3.3.0"
 dependencies = [
  "arrow",
  "arrow-array",

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

@@ -1,6 +1,6 @@
 [package]
 name = "rust_pgn_reader_python_binding"
-version = "3.2.0"
+version = "3.3.0"
 edition = "2024"
 readme = "README.md"
 
@@ -29,3 +29,5 @@ arrow = "55"
 harness = false
 name = "parquet_bench"
 
+[profile.bench]
+debug = true

{rust_pgn_reader_python_binding-3.2.0 → rust_pgn_reader_python_binding-3.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rust_pgn_reader_python_binding
-Version: 3.2.0
+Version: 3.3.0
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

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

@@ -43,7 +43,7 @@ pub fn bench_parquet() {
     // Measure start time
     let start = Instant::now();
 
-    let result = parse_multiple_games_native(&movetexts, None);
+    let result = parse_multiple_games_native(&movetexts, None, false);
 
     let duration = start.elapsed();
     println!("Time taken: {:?}", duration);

{rust_pgn_reader_python_binding-3.2.0 → rust_pgn_reader_python_binding-3.3.0}/rust_pgn_reader_python_binding.pyi

@@ -29,21 +29,26 @@ class PositionStatus:
 class MoveExtractor:
     moves: List[PyUciMove]
     valid_moves: bool
-    comments: List[str]
-    evals: List[float]
-    clock_times: List[Tuple[int, int, float]]
+    comments: List[Optional[str]]
+    evals: List[Optional[float]]
+    clock_times: List[Optional[Tuple[int, int, float]]]
     outcome: Optional[str]
     headers: List[Tuple[str, str]]
-    castling_rights: List[Tuple[bool, bool, bool, bool]]
+    castling_rights: List[Optional[Tuple[bool, bool, bool, bool]]]
     position_status: Optional[PositionStatus]
 
-    def __init__(self) -> None: ...
+    def __init__(self, store_legal_moves: bool = False) -> None: ...
     def turn(self) -> bool: ...
+    def update_position_status(self) -> None: ...
+    @property
+    def legal_moves(self) -> List[List[PyUciMove]]: ...
 
-def parse_game(pgn: str) -> MoveExtractor: ...
+def parse_game(pgn: str, store_legal_moves: bool = False) -> MoveExtractor: ...
 def parse_games(
-    pgns: List[str], num_threads: Optional[int] = None
+    pgns: List[str], num_threads: Optional[int] = None, store_legal_moves: bool = False
 ) -> List[MoveExtractor]: ...
 def parse_game_moves_arrow_chunked_array(
-    pgn_chunked_array: pyarrow.ChunkedArray, num_threads: Optional[int] = None
+    pgn_chunked_array: pyarrow.ChunkedArray,
+    num_threads: Optional[int] = None,
+    store_legal_moves: bool = False,
 ) -> List[MoveExtractor]: ...

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

@@ -1,12 +1,12 @@
-use crate::comment_parsing::{parse_comments, CommentContent, ParsedTag};
+use crate::comment_parsing::{CommentContent, ParsedTag, parse_comments};
 use arrow_array::{Array, LargeStringArray, StringArray};
 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 rayon::prelude::*;
 use shakmaty::Color;
-use shakmaty::{uci::UciMove, Chess, Position, Role, Square};
+use shakmaty::{Chess, Position, Role, Square, uci::UciMove};
 use std::io::Cursor;
 use std::ops::ControlFlow;
 
@@ -111,17 +111,21 @@ pub struct MoveExtractor {
     #[pyo3(get)]
     moves: Vec<PyUciMove>,
 
+    store_legal_moves: bool,
+    flat_legal_moves: Vec<PyUciMove>,
+    legal_moves_offsets: Vec<usize>,
+
     #[pyo3(get)]
     valid_moves: bool,
 
     #[pyo3(get)]
-    comments: Vec<String>,
+    comments: Vec<Option<String>>,
 
     #[pyo3(get)]
-    evals: Vec<f64>,
+    evals: Vec<Option<f64>>,
 
     #[pyo3(get)]
-    clock_times: Vec<(u32, u8, f64)>,
+    clock_times: Vec<Option<(u32, u8, f64)>>,
 
     #[pyo3(get)]
     outcome: Option<String>,
@@ -130,7 +134,7 @@ pub struct MoveExtractor {
     headers: Vec<(String, String)>,
 
     #[pyo3(get)]
-    castling_rights: Vec<(bool, bool, bool, bool)>,
+    castling_rights: Vec<Option<(bool, bool, bool, bool)>>,
 
     #[pyo3(get)]
     position_status: Option<PositionStatus>,
@@ -141,9 +145,13 @@ pub struct MoveExtractor {
 #[pymethods]
 impl MoveExtractor {
     #[new]
-    fn new() -> MoveExtractor {
+    #[pyo3(signature = (store_legal_moves = false))]
+    fn new(store_legal_moves: bool) -> MoveExtractor {
         MoveExtractor {
             moves: Vec::with_capacity(100),
+            store_legal_moves,
+            flat_legal_moves: Vec::with_capacity(if store_legal_moves { 100 * 30 } else { 0 }), // Pre-allocate for moves
+            legal_moves_offsets: Vec::with_capacity(if store_legal_moves { 100 } else { 0 }), // Pre-allocate for offsets
             pos: Chess::default(),
             valid_moves: true,
             comments: Vec::with_capacity(100),
@@ -172,7 +180,31 @@ impl MoveExtractor {
             castling_bitboard.contains(shakmaty::Square::H8),
         );
 
-        self.castling_rights.push(castling_rights);
+        self.castling_rights.push(Some(castling_rights));
+    }
+
+    fn push_legal_moves(&mut self) {
+        // Record the starting offset for the current position's legal moves.
+        self.legal_moves_offsets.push(self.flat_legal_moves.len());
+
+        let legal_moves_for_pos = self.pos.legal_moves();
+        self.flat_legal_moves.reserve(legal_moves_for_pos.len());
+
+        for m in legal_moves_for_pos {
+            let uci_move_obj = UciMove::from_standard(m);
+            if let UciMove::Normal {
+                from,
+                to,
+                promotion: promo_opt,
+            } = uci_move_obj
+            {
+                self.flat_legal_moves.push(PyUciMove {
+                    from_square: from as u8,
+                    to_square: to as u8,
+                    promotion: promo_opt.map(|p_role| p_role as u8),
+                });
+            }
+        }
     }
 
     fn update_position_status(&mut self) {
@@ -192,6 +224,27 @@ impl MoveExtractor {
             },
         });
     }
+
+    #[getter]
+    fn legal_moves(&self) -> Vec<Vec<PyUciMove>> {
+        let mut result = Vec::with_capacity(self.legal_moves_offsets.len());
+        if self.legal_moves_offsets.is_empty() {
+            return result;
+        }
+
+        for i in 0..self.legal_moves_offsets.len() - 1 {
+            let start = self.legal_moves_offsets[i];
+            let end = self.legal_moves_offsets[i + 1];
+            result.push(self.flat_legal_moves[start..end].to_vec());
+        }
+
+        // Handle the last chunk
+        if let Some(&start) = self.legal_moves_offsets.last() {
+            result.push(self.flat_legal_moves[start..].to_vec());
+        }
+
+        result
+    }
 }
 
 impl Visitor for MoveExtractor {
@@ -219,25 +272,36 @@ impl Visitor for MoveExtractor {
     fn begin_movetext(&mut self, tags: Self::Tags) -> ControlFlow<Self::Output, Self::Movetext> {
         self.headers = tags;
         self.moves.clear();
+        self.flat_legal_moves.clear();
+        self.legal_moves_offsets.clear();
         self.pos = Chess::default();
         self.valid_moves = true;
         self.comments.clear();
         self.evals.clear();
         self.clock_times.clear();
+        self.castling_rights.clear();
 
         self.push_castling_bitboards();
+        if self.store_legal_moves {
+            self.push_legal_moves();
+        }
         ControlFlow::Continue(())
     }
 
+    // Roughly half the time during parsing is spent here in san()
     fn san(
         &mut self,
         _movetext: &mut Self::Movetext,
         san_plus: SanPlus,
     ) -> ControlFlow<Self::Output> {
         if self.valid_moves {
+            // Most of the function time is spent calculating to_move()
             match san_plus.san.to_move(&self.pos) {
                 Ok(m) => {
                     self.pos.play_unchecked(m);
+                    if self.store_legal_moves {
+                        self.push_legal_moves();
+                    }
                     let uci_move_obj = UciMove::from_standard(m);
 
                     match uci_move_obj {
@@ -253,12 +317,20 @@ impl Visitor for MoveExtractor {
                             };
                             self.moves.push(py_uci_move);
                             self.push_castling_bitboards();
+
+                            // Push placeholders to keep vectors in sync
+                            self.comments.push(None);
+                            self.evals.push(None);
+                            self.clock_times.push(None);
                         }
                         _ => {
                             // This case handles UciMove::Put and UciMove::Null,
                             // which are not expected from standard PGN moves
                             // that PyUciMove is designed to represent.
-                            eprintln!("Unexpected UCI move type from standard PGN move: {:?}. Game moves might be invalid.", uci_move_obj);
+                            eprintln!(
+                                "Unexpected UCI move type from standard PGN move: {:?}. Game moves might be invalid.",
+                                uci_move_obj
+                            );
                             self.valid_moves = false;
                         }
                     }
@@ -283,60 +355,47 @@ impl Visitor for MoveExtractor {
                     eprintln!("Unparsed remaining input: {:?}", remaining_input);
                     return ControlFlow::Continue(());
                 }
-                let mut eval_encountered = false;
-                let mut clk_time_encountered = false;
+
                 let mut move_comments = String::new();
 
                 for content in parsed_comments {
                     match content {
                         CommentContent::Text(text) => {
                             if !text.trim().is_empty() {
+                                if !move_comments.is_empty() {
+                                    move_comments.push(' ');
+                                }
                                 move_comments.push_str(&text);
                             }
                         }
                         CommentContent::Tag(tag_content) => match tag_content {
                             ParsedTag::Eval(eval_value) => {
-                                if eval_encountered {
-                                    eprintln!(
-                                        "Multiple Eval values found in comment: {:?}",
-                                        _comment
-                                    );
-                                    // Potentially skip this eval or handle as an error
-                                    continue;
+                                if let Some(last_eval) = self.evals.last_mut() {
+                                    *last_eval = Some(eval_value);
                                 }
-                                eval_encountered = true;
-                                self.evals.push(eval_value);
                             }
                             ParsedTag::Mate(mate_value) => {
-                                // For now, add mate info to the general comments string
-                                // A dedicated field could be added to MoveExtractor if needed
                                 if !move_comments.is_empty() && !move_comments.ends_with(' ') {
                                     move_comments.push(' ');
                                 }
                                 move_comments.push_str(&format!("[Mate {}]", mate_value));
-                                // If evals should also store mate, convert mate_value to f64
-                                // e.g., self.evals.push(mate_value as f64 * 1000.0); // Or some indicator
                             }
                             ParsedTag::ClkTime {
                                 hours,
                                 minutes,
                                 seconds,
                             } => {
-                                if clk_time_encountered {
-                                    eprintln!(
-                                        "Multiple ClkTime values found in comment: {:?}",
-                                        _comment
-                                    );
-                                    // Potentially skip this clk or handle as an error
-                                    continue;
+                                if let Some(last_clk) = self.clock_times.last_mut() {
+                                    *last_clk = Some((hours, minutes, seconds));
                                 }
-                                clk_time_encountered = true;
-                                self.clock_times.push((hours, minutes, seconds));
                             }
                         },
                     }
                 }
-                self.comments.push(move_comments);
+
+                if let Some(last_comment) = self.comments.last_mut() {
+                    *last_comment = Some(move_comments);
+                }
             }
             Err(e) => {
                 eprintln!("Error parsing comment: {:?}", e);
@@ -374,9 +433,12 @@ impl Visitor for MoveExtractor {
 }
 
 // --- Native Rust versions (no PyResult) ---
-pub fn parse_single_game_native(pgn: &str) -> Result<MoveExtractor, String> {
+pub fn parse_single_game_native(
+    pgn: &str,
+    store_legal_moves: bool,
+) -> Result<MoveExtractor, String> {
     let mut reader = Reader::new(Cursor::new(pgn));
-    let mut extractor = MoveExtractor::new();
+    let mut extractor = MoveExtractor::new(store_legal_moves);
     match reader.read_game(&mut extractor) {
         Ok(Some(_)) => Ok(extractor),
         Ok(None) => Err("No game found in PGN".to_string()),
@@ -387,6 +449,7 @@ pub fn parse_single_game_native(pgn: &str) -> Result<MoveExtractor, String> {
 pub fn parse_multiple_games_native(
     pgns: &Vec<String>,
     num_threads: Option<usize>,
+    store_legal_moves: bool,
 ) -> Result<Vec<MoveExtractor>, String> {
     let num_threads = num_threads.unwrap_or_else(num_cpus::get);
 
@@ -397,25 +460,16 @@ pub fn parse_multiple_games_native(
         .expect("Failed to build Rayon thread pool");
 
     thread_pool.install(|| {
-        let results: Vec<Result<MoveExtractor, String>> = pgns
-            .par_iter()
-            .map(|pgn| parse_single_game_native(pgn))
-            .collect();
-
-        let mut extractors: Vec<MoveExtractor> = Vec::with_capacity(results.len());
-        for res in results {
-            match res {
-                Ok(extractor) => extractors.push(extractor),
-                Err(e) => return Err(e),
-            }
-        }
-        Ok(extractors)
+        pgns.par_iter()
+            .map(|pgn| parse_single_game_native(pgn, store_legal_moves))
+            .collect()
     })
 }
 
 fn _parse_game_moves_from_arrow_chunks_native(
     pgn_chunked_array: &PyChunkedArray,
     num_threads: Option<usize>,
+    store_legal_moves: bool,
 ) -> Result<Vec<MoveExtractor>, String> {
     let num_threads = num_threads.unwrap_or_else(num_cpus::get);
     let thread_pool = ThreadPoolBuilder::new()
@@ -452,7 +506,7 @@ fn _parse_game_moves_from_arrow_chunks_native(
     thread_pool.install(|| {
         pgn_str_slices
             .par_iter()
-            .map(|&pgn_s| parse_single_game_native(pgn_s))
+            .map(|&pgn_s| parse_single_game_native(pgn_s, store_legal_moves))
             .collect::<Result<Vec<MoveExtractor>, String>>()
     })
 }
@@ -461,25 +515,33 @@ fn _parse_game_moves_from_arrow_chunks_native(
 // TODO check if I can call py.allow_threads and release GIL
 // see https://docs.rs/pyo3-arrow/0.10.1/pyo3_arrow/
 #[pyfunction]
+#[pyo3(signature = (pgn, store_legal_moves = false))]
 /// Parses a single PGN game string.
-fn parse_game(pgn: &str) -> PyResult<MoveExtractor> {
-    parse_single_game_native(pgn).map_err(pyo3::exceptions::PyValueError::new_err)
+fn parse_game(pgn: &str, store_legal_moves: bool) -> PyResult<MoveExtractor> {
+    parse_single_game_native(pgn, store_legal_moves)
+        .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(pyo3::exceptions::PyValueError::new_err)
+#[pyo3(signature = (pgns, num_threads=None, store_legal_moves=false))]
+fn parse_games(
+    pgns: Vec<String>,
+    num_threads: Option<usize>,
+    store_legal_moves: bool,
+) -> PyResult<Vec<MoveExtractor>> {
+    parse_multiple_games_native(&pgns, num_threads, store_legal_moves)
+        .map_err(pyo3::exceptions::PyValueError::new_err)
 }
 
 #[pyfunction]
-#[pyo3(signature = (pgn_chunked_array, num_threads=None))]
+#[pyo3(signature = (pgn_chunked_array, num_threads=None, store_legal_moves=false))]
 fn parse_game_moves_arrow_chunked_array(
     pgn_chunked_array: PyChunkedArray,
     num_threads: Option<usize>,
+    store_legal_moves: bool,
 ) -> PyResult<Vec<MoveExtractor>> {
-    _parse_game_moves_from_arrow_chunks_native(&pgn_chunked_array, num_threads)
+    _parse_game_moves_from_arrow_chunks_native(&pgn_chunked_array, num_threads, store_legal_moves)
         .map_err(pyo3::exceptions::PyValueError::new_err)
 }
 

{rust_pgn_reader_python_binding-3.2.0 → rust_pgn_reader_python_binding-3.3.0}/src/test.py

@@ -78,16 +78,28 @@ class TestPgnExtraction(unittest.TestCase):
             "f5f8",
             "h8h7",
         ]
-        comments_reference = ["asdf", "hello"]
+
+        comments_reference = [
+            "asdf",
+            None,
+            None,
+            None,
+            None,
+            None,
+            "hello",
+        ] + [None for _ in range(57)]
+
         valid_reference = True
-        evals_reference = []
-        clock_times_reference = []
+        evals_reference = [None for _ in range(len(moves_reference))]
+        clock_times_reference = [None for _ in range(len(moves_reference))]
 
         self.assertTrue([str(move) for move in extractor.moves] == moves_reference)
         self.assertTrue(extractor.comments == comments_reference)
         self.assertTrue(extractor.valid_moves == valid_reference)
         self.assertTrue(extractor.evals == evals_reference)
         self.assertTrue(extractor.clock_times == clock_times_reference)
+
+        assert extractor.position_status is not None  # appease the type checker
         self.assertFalse(extractor.position_status.is_checkmate)
         self.assertFalse(extractor.position_status.is_stalemate)
         self.assertFalse(extractor.position_status.is_game_over)
@@ -183,10 +195,10 @@ class TestPgnExtraction(unittest.TestCase):
             "a4a5",
             "b3d5",
         ]
-        comments_reference = []
+        comments_reference = [None for _ in range(len(moves_reference))]
         valid_reference = True
-        evals_reference = []
-        clock_times_reference = []
+        evals_reference = [None for _ in range(len(moves_reference))]
+        clock_times_reference = [None for _ in range(len(moves_reference))]
         headers_reference = [
             ("Event", "Rated Classical game"),
             ("Site", "https://lichess.org/lhy6ehiv"),
@@ -211,6 +223,8 @@ class TestPgnExtraction(unittest.TestCase):
         self.assertTrue(extractor.evals == evals_reference)
         self.assertTrue(extractor.clock_times == clock_times_reference)
         self.assertTrue(extractor.headers == headers_reference)
+
+        assert extractor.position_status is not None  # appease the type checker
         self.assertFalse(extractor.position_status.is_checkmate)
         self.assertFalse(extractor.position_status.is_stalemate)
         self.assertFalse(extractor.position_status.is_game_over)
@@ -326,6 +340,8 @@ class TestPgnExtraction(unittest.TestCase):
         self.assertTrue(extractor.valid_moves == valid_reference)
         self.assertTrue(extractor.evals == evals_reference)
         self.assertTrue(extractor.clock_times == clock_times_reference)
+
+        assert extractor.position_status is not None  # appease the type checker
         self.assertFalse(extractor.position_status.is_checkmate)
         self.assertFalse(extractor.position_status.is_stalemate)
         self.assertFalse(extractor.position_status.is_game_over)
@@ -337,11 +353,6 @@ class TestPgnExtraction(unittest.TestCase):
         ]
         extractor = rust_pgn_reader_python_binding.parse_games(pgns)
 
-        comments_reference = [[], ["asdf", "hello"]]
-
-        self.assertTrue(extractor[0].comments == comments_reference[0])
-        self.assertTrue(extractor[1].comments == comments_reference[1])
-
         moves_reference = [
             [
                 "g1f3",
@@ -431,12 +442,37 @@ class TestPgnExtraction(unittest.TestCase):
             ],
         ]
 
+        comments_reference = [
+            [None for _ in range(len(moves_reference[0]))],
+            [
+                "asdf",
+                None,
+                None,
+                None,
+                None,
+                None,
+                "hello",
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ],
+        ]
+
+        self.assertTrue(extractor[0].comments == comments_reference[0])
+        self.assertTrue(extractor[1].comments == comments_reference[1])
+
         self.assertTrue(
             [str(move) for move in extractor[0].moves] == moves_reference[0]
         )
         self.assertTrue(
             [str(move) for move in extractor[1].moves] == moves_reference[1]
         )
+        assert extractor[0].position_status is not None  # appease the type checker
+
         self.assertTrue(extractor[0].position_status.is_checkmate)
         self.assertFalse(extractor[0].position_status.is_stalemate)
         self.assertTrue(extractor[0].position_status.is_game_over)
@@ -446,6 +482,7 @@ class TestPgnExtraction(unittest.TestCase):
 
         self.assertTrue(extractor[1].position_status is None)
         extractor[1].update_position_status()
+        assert extractor[1].position_status is not None  # appease the type checker
         self.assertFalse(extractor[1].position_status.is_checkmate)
         self.assertFalse(extractor[1].position_status.is_stalemate)
         self.assertFalse(extractor[1].position_status.is_game_over)
@@ -496,11 +533,6 @@ class TestPgnExtraction(unittest.TestCase):
             )
         )
 
-        comments_reference = [[], ["asdf", "hello"]]
-
-        self.assertTrue(extractors[0].comments == comments_reference[0])
-        self.assertTrue(extractors[1].comments == comments_reference[1])
-
         moves_reference = [
             [
                 "g1f3",
@@ -597,7 +629,31 @@ class TestPgnExtraction(unittest.TestCase):
             [str(move) for move in extractors[1].moves] == moves_reference[1]
         )
 
+        comments_reference = [
+            [None for _ in range(len(moves_reference[0]))],
+            [
+                "asdf",
+                None,
+                None,
+                None,
+                None,
+                None,
+                "hello",
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ],
+        ]
+
+        self.assertTrue(extractors[0].comments == comments_reference[0])
+        self.assertTrue(extractors[1].comments == comments_reference[1])
+
         extractors[0].update_position_status()  # Ensure status is calculated
+        assert extractors[0].position_status is not None  # appease the type checker
         self.assertTrue(extractors[0].position_status.is_checkmate)
         self.assertFalse(extractors[0].position_status.is_stalemate)
         self.assertTrue(extractors[0].position_status.is_game_over)
@@ -613,6 +669,7 @@ class TestPgnExtraction(unittest.TestCase):
             extractors[1].position_status is None
         )  # Not set by default for parse_game_moves_arrow_chunked_array
         extractors[1].update_position_status()
+        assert extractors[1].position_status is not None  # appease the type checker
         self.assertFalse(extractors[1].position_status.is_checkmate)
         self.assertFalse(extractors[1].position_status.is_stalemate)
         self.assertFalse(extractors[1].position_status.is_game_over)