native-stockfish 0.1.0__tar.gz

native_stockfish-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 [Your Name]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

native_stockfish-0.1.0/MANIFEST.in

@@ -0,0 +1,4 @@
+include README.md
+include native_stockfish.cpp
+include pyproject.toml
+include LICENSE

native_stockfish-0.1.0/PKG-INFO

@@ -0,0 +1,103 @@
+Metadata-Version: 2.4
+Name: native_stockfish
+Version: 0.1.0
+Summary: The fastest client for the Stockfish chess engine using C++ extension.
+Home-page: https://github.com/tawfiqkhalilieh/stockfish-native
+Author: Tawfiq Khalilieh
+Author-email: taw.coding@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: C++
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+Dynamic: summary
+
+# Native Stockfish Python Client
+
+Native Stockfish is a minimal-overhead Python interface to the Stockfish chess engine.
+Stockfish runs as a native process, with all UCI communication handled in C to avoid
+Python becoming a performance bottleneck.
+
+## Prerequisites
+
+- Python 3.8+
+- A compiled Stockfish binary. You can compile Stockfish from the official source or use the submodule included in this repository.
+
+### Compiling Stockfish
+
+If you have the `Stockfish` submodule checked out:
+
+```bash
+cd Stockfish/src
+make -j profile-build
+```
+
+> Or you can use use the binray from the website.
+
+
+## Installation
+
+### From Source
+
+```bash
+pip install .
+```
+
+## Usage
+
+See `examples/basic_usage.py` for a complete example.
+
+```python
+import native_stockfish
+
+# Path to your compiled Stockfish binary
+stockfish_path = "./Stockfish/src/stockfish"
+
+client = native_stockfish.StockfishClient(stockfish_path)
+client.start()
+
+# Analyze a position (FEN string)
+# top_moves(fen, depth, count)
+moves = client.top_moves("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1", 15, 3)
+print(moves)
+
+client.stop()
+```
+
+## API
+
+### `StockfishClient(path)`
+
+Initializes the client with the path to the Stockfish executable.
+
+### `client.start()`
+
+Starts the Stockfish engine process.
+
+### `client.status()`
+
+Returns the status of the engine (e.g., "running", "stopped").
+
+### `client.top_moves(fen, depth, count)`
+
+Analyzes the given FEN position.
+
+- `fen`: The FEN string of the position to analyze.
+- `depth`: The search depth.
+- `count`: The number of top moves to return.
+
+Returns a list of top moves.
+
+### `client.stop()`
+
+Stops the Stockfish engine process.

native_stockfish-0.1.0/README.md

@@ -0,0 +1,79 @@
+# Native Stockfish Python Client
+
+Native Stockfish is a minimal-overhead Python interface to the Stockfish chess engine.
+Stockfish runs as a native process, with all UCI communication handled in C to avoid
+Python becoming a performance bottleneck.
+
+## Prerequisites
+
+- Python 3.8+
+- A compiled Stockfish binary. You can compile Stockfish from the official source or use the submodule included in this repository.
+
+### Compiling Stockfish
+
+If you have the `Stockfish` submodule checked out:
+
+```bash
+cd Stockfish/src
+make -j profile-build
+```
+
+> Or you can use use the binray from the website.
+
+
+## Installation
+
+### From Source
+
+```bash
+pip install .
+```
+
+## Usage
+
+See `examples/basic_usage.py` for a complete example.
+
+```python
+import native_stockfish
+
+# Path to your compiled Stockfish binary
+stockfish_path = "./Stockfish/src/stockfish"
+
+client = native_stockfish.StockfishClient(stockfish_path)
+client.start()
+
+# Analyze a position (FEN string)
+# top_moves(fen, depth, count)
+moves = client.top_moves("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1", 15, 3)
+print(moves)
+
+client.stop()
+```
+
+## API
+
+### `StockfishClient(path)`
+
+Initializes the client with the path to the Stockfish executable.
+
+### `client.start()`
+
+Starts the Stockfish engine process.
+
+### `client.status()`
+
+Returns the status of the engine (e.g., "running", "stopped").
+
+### `client.top_moves(fen, depth, count)`
+
+Analyzes the given FEN position.
+
+- `fen`: The FEN string of the position to analyze.
+- `depth`: The search depth.
+- `count`: The number of top moves to return.
+
+Returns a list of top moves.
+
+### `client.stop()`
+
+Stops the Stockfish engine process.

native_stockfish-0.1.0/native_stockfish.cpp

@@ -0,0 +1,212 @@
+#include <Python.h>
+#include <string>
+#include <unistd.h>
+#include <vector>
+#include <signal.h>
+#include <sys/wait.h>
+
+typedef struct {
+  // might find some use for this in the future, maybe in handling exceptions
+  PyObject_HEAD int engine_running;
+  const char *stockfish_path;
+  pid_t stockfish_process;
+  int (*dprintf)(int, const char *format, ...);
+  int write_fd;
+  FILE *output;
+  int in[2];
+  int out[2];
+} StockfishClient;
+
+static PyObject *Stockfish_start(StockfishClient *self, PyObject *args) {
+  self->engine_running = 1;
+  Py_RETURN_NONE;
+}
+
+static PyObject *Stockfish_stop(StockfishClient *self, PyObject *args) {
+  self->engine_running = 0;
+  Py_RETURN_NONE;
+}
+
+static PyObject *Stockfish_status(StockfishClient *self, PyObject *args) {
+  if (self->engine_running)
+    return PyUnicode_FromString("running");
+  else
+    return PyUnicode_FromString("stopped");
+}
+
+static int Stockfish_init(StockfishClient *self, PyObject *args,
+                          PyObject *kwds) {
+
+  const char *stockfish_path_param;
+
+  if (!PyArg_ParseTuple(args, "s", &stockfish_path_param)) {
+    return 0; // Python exception is automatically set
+  }
+
+  int in[2], out[2];
+  if (pipe(in) || pipe(out)) {
+    return 0;
+  }
+
+  pid_t pid = fork();
+  if (pid == 0) {
+    // Child process
+    dup2(in[0], STDIN_FILENO);
+    dup2(out[1], STDOUT_FILENO);
+    // Close unused pipe ends
+    close(in[0]);
+    close(in[1]);
+    close(out[0]);
+    close(out[1]);
+
+    execl(stockfish_path_param, "stockfish", NULL);
+    _exit(1); // Properly exit child if exec fails
+  }
+
+  // Parent process
+  close(in[0]);  // Close read end of input pipe
+  close(out[1]); // Close write end of output pipe
+
+  self->dprintf = dprintf;
+  self->write_fd = in[1];
+  self->output = fdopen(out[0], "r");
+  self->stockfish_process = pid;
+  self->engine_running = 0;
+  self->stockfish_path = stockfish_path_param;
+  self->in[0] = in[0];
+  self->in[1] = in[1];
+  self->out[0] = out[0];
+  self->out[1] = out[1];
+  return 0;
+}
+
+static void Stockfish_dealloc(StockfishClient *self) {
+  if (self->output) {
+    fclose(self->output);
+    self->output = NULL;
+  }
+  if (self->write_fd > 0) {
+    close(self->write_fd);
+    self->write_fd = -1;
+  }
+  
+  if (self->stockfish_process > 0) {
+      kill(self->stockfish_process, SIGTERM);
+      waitpid(self->stockfish_process, NULL, 0);
+      self->stockfish_process = 0;
+  }
+
+  Py_TYPE(self)->tp_free((PyObject *)self);
+}
+
+static PyObject *top_moves(StockfishClient *self, PyObject *args) {
+  const char *fen;
+  int depth;
+  int multiv;
+
+  if (!PyArg_ParseTuple(args, "sii", &fen, &depth, &multiv)) {
+    return NULL; // Python exception is automatically set
+  }
+
+  std::string cmd = "uci\nisready\nsetoption name MultiPV value " +
+                    std::to_string(multiv) + "\n";
+
+  dprintf(self->in[1], "%s", cmd.c_str());
+
+  char buf[2048];
+  while (fgets(buf, sizeof(buf), self->output)) {
+    std::string line(buf);
+    if (line.find("readyok") != std::string::npos)
+      break;
+  }
+
+  char cmd2[200];
+  snprintf(cmd2, sizeof(cmd2), "position fen %s\ngo depth %d\n", fen, depth);
+
+  dprintf(self->in[1], "%s", cmd2);
+
+  std::vector<std::string> found_moves(multiv, "");
+
+  while (fgets(buf, sizeof(buf), self->output)) {
+    std::string line(buf);
+    std::string search_str = "info depth " + std::to_string(depth);
+    if (line.find(search_str) != std::string::npos) {
+      int pv_index = 1;
+      size_t multipv_pos = line.find(" multipv ");
+      if (multipv_pos != std::string::npos) {
+        try {
+          pv_index = std::stoi(line.substr(multipv_pos + 9));
+        } catch (...) {
+          pv_index = 1;
+        }
+      }
+
+      if (pv_index >= 1 && pv_index <= multiv) {
+        size_t pv_pos = line.find(" pv ");
+        if (pv_pos != std::string::npos) {
+          size_t move_start = pv_pos + 4; // Length of " pv " is 4
+          size_t move_end = line.find(" ", move_start);
+          std::string move_str;
+          if (move_end != std::string::npos) {
+            move_str = line.substr(move_start, move_end - move_start);
+          } else {
+            move_str = line.substr(move_start);
+            if (!move_str.empty() && move_str.back() == '\n') {
+              move_str.pop_back();
+            }
+          }
+          found_moves[pv_index - 1] = move_str;
+        }
+      }
+    }
+
+    if (line.find("bestmove") != std::string::npos)
+      break;
+  }
+
+  PyObject *result_tuple = PyTuple_New(multiv);
+  for (int i = 0; i < multiv; ++i) {
+    PyObject *str_obj = PyUnicode_FromString(found_moves[i].c_str());
+    PyTuple_SetItem(result_tuple, i, str_obj);
+  }
+
+  return result_tuple;
+}
+
+static PyMethodDef Stockfish_methods[] = {
+    {"start", (PyCFunction)Stockfish_start, METH_NOARGS, "Start engine"},
+    {"stop", (PyCFunction)Stockfish_stop, METH_NOARGS, "Stop engine"},
+    {"status", (PyCFunction)Stockfish_status, METH_NOARGS, "Get status"},
+    {"top_moves", (PyCFunction)top_moves, METH_VARARGS, "Get top moves"},
+    {NULL}};
+
+static PyTypeObject StockfishType = {PyVarObject_HEAD_INIT(NULL, 0)};
+
+static int init_stockfish_type() {
+  StockfishType.tp_name = "native_stockfish.StockfishClient";
+  StockfishType.tp_basicsize = sizeof(StockfishClient);
+  StockfishType.tp_flags = Py_TPFLAGS_DEFAULT;
+  StockfishType.tp_new = PyType_GenericNew;
+  StockfishType.tp_init = (initproc)Stockfish_init;
+  StockfishType.tp_dealloc = (destructor)Stockfish_dealloc;
+  StockfishType.tp_methods = Stockfish_methods;
+
+  return PyType_Ready(&StockfishType);
+}
+
+static PyModuleDef moduledef = {PyModuleDef_HEAD_INIT, "native_stockfish",
+                                "Stockfish C++ client", -1, NULL};
+
+PyMODINIT_FUNC PyInit_native_stockfish(void) {
+  if (init_stockfish_type() < 0)
+    return NULL;
+
+  PyObject *m = PyModule_Create(&moduledef);
+  if (!m)
+    return NULL;
+
+  Py_INCREF(&StockfishType);
+  PyModule_AddObject(m, "StockfishClient", (PyObject *)&StockfishType);
+
+  return m;
+}

native_stockfish-0.1.0/native_stockfish.egg-info/PKG-INFO

@@ -0,0 +1,103 @@
+Metadata-Version: 2.4
+Name: native_stockfish
+Version: 0.1.0
+Summary: The fastest client for the Stockfish chess engine using C++ extension.
+Home-page: https://github.com/tawfiqkhalilieh/stockfish-native
+Author: Tawfiq Khalilieh
+Author-email: taw.coding@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: C++
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+Dynamic: summary
+
+# Native Stockfish Python Client
+
+Native Stockfish is a minimal-overhead Python interface to the Stockfish chess engine.
+Stockfish runs as a native process, with all UCI communication handled in C to avoid
+Python becoming a performance bottleneck.
+
+## Prerequisites
+
+- Python 3.8+
+- A compiled Stockfish binary. You can compile Stockfish from the official source or use the submodule included in this repository.
+
+### Compiling Stockfish
+
+If you have the `Stockfish` submodule checked out:
+
+```bash
+cd Stockfish/src
+make -j profile-build
+```
+
+> Or you can use use the binray from the website.
+
+
+## Installation
+
+### From Source
+
+```bash
+pip install .
+```
+
+## Usage
+
+See `examples/basic_usage.py` for a complete example.
+
+```python
+import native_stockfish
+
+# Path to your compiled Stockfish binary
+stockfish_path = "./Stockfish/src/stockfish"
+
+client = native_stockfish.StockfishClient(stockfish_path)
+client.start()
+
+# Analyze a position (FEN string)
+# top_moves(fen, depth, count)
+moves = client.top_moves("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1", 15, 3)
+print(moves)
+
+client.stop()
+```
+
+## API
+
+### `StockfishClient(path)`
+
+Initializes the client with the path to the Stockfish executable.
+
+### `client.start()`
+
+Starts the Stockfish engine process.
+
+### `client.status()`
+
+Returns the status of the engine (e.g., "running", "stopped").
+
+### `client.top_moves(fen, depth, count)`
+
+Analyzes the given FEN position.
+
+- `fen`: The FEN string of the position to analyze.
+- `depth`: The search depth.
+- `count`: The number of top moves to return.
+
+Returns a list of top moves.
+
+### `client.stop()`
+
+Stops the Stockfish engine process.

native_stockfish-0.1.0/native_stockfish.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+LICENSE
+MANIFEST.in
+README.md
+native_stockfish.cpp
+pyproject.toml
+setup.py
+native_stockfish.egg-info/PKG-INFO
+native_stockfish.egg-info/SOURCES.txt
+native_stockfish.egg-info/dependency_links.txt
+native_stockfish.egg-info/top_level.txt

native_stockfish-0.1.0/native_stockfish.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

native_stockfish-0.1.0/native_stockfish.egg-info/top_level.txt

@@ -0,0 +1 @@
+native_stockfish

native_stockfish-0.1.0/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"

native_stockfish-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

native_stockfish-0.1.0/setup.py

@@ -0,0 +1,31 @@
+from setuptools import setup, Extension
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+module = Extension(
+    "native_stockfish",
+    sources=["native_stockfish.cpp"],
+    language="c++",
+    extra_compile_args=["-std=c++17"], 
+)
+
+setup(
+    name="native_stockfish",
+    version="0.1.0",
+    author="Tawfiq Khalilieh",
+    author_email="taw.coding@gmail.com",
+    description="The fastest client for the Stockfish chess engine using C++ extension.",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/tawfiqkhalilieh/stockfish-native",
+    ext_modules=[module],
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "Programming Language :: C++",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: POSIX :: Linux",
+    ],
+    python_requires=">=3.8",
+)
+