pyisyntax 0.1.4__tar.gz → 0.1.6__tar.gz

{pyisyntax-0.1.4 → pyisyntax-0.1.6}/CHANGELOG.md

@@ -7,6 +7,17 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.1.5] - 2025-04-18
+
+### Added
+
+- Properties `offset_x`and `offset_y` for the WSI image offset in relation to the macro image.
+
+### Changed
+
+- Bump the `libisyntax` submodule commit.
+- Use `uv` for development environment management (was previously `conda-lock`).
+
 ## [0.1.4] - 2024-08-31
 
 ### Added
@@ -61,7 +72,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - This is the initial release.
 
-[unreleased]: https://github.com/anibali/pyisyntax/compare/v0.1.4...HEAD
+[unreleased]: https://github.com/anibali/pyisyntax/compare/v0.1.5...HEAD
+[0.1.4]: https://github.com/anibali/pyisyntax/compare/v0.1.4...v0.1.5
 [0.1.4]: https://github.com/anibali/pyisyntax/compare/v0.1.3...v0.1.4
 [0.1.3]: https://github.com/anibali/pyisyntax/compare/v0.1.2...v0.1.3
 [0.1.2]: https://github.com/anibali/pyisyntax/compare/v0.1.1...v0.1.2

{pyisyntax-0.1.4/pyisyntax.egg-info → pyisyntax-0.1.6}/PKG-INFO

@@ -1,9 +1,9 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: pyisyntax
-Version: 0.1.4
+Version: 0.1.6
 Summary: Python bindings for libisyntax
 Author-email: Aiden Nibali <dismaldenizen@gmail.com>
-License: MIT
+License-Expression: MIT
 Project-URL: Homepage, https://github.com/anibali/pyisyntax
 Project-URL: Source, https://github.com/anibali/pyisyntax
 Project-URL: Download, https://pypi.org/project/pyisyntax/#files
@@ -14,14 +14,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: cffi>=1.12
 Requires-Dist: numpy
-Provides-Extra: dev
-Requires-Dist: conda-lock; extra == "dev"
-Requires-Dist: pytest; extra == "dev"
-Requires-Dist: pytest-mock; extra == "dev"
-Requires-Dist: ruff==0.2.1; extra == "dev"
-Requires-Dist: tox>=4.0; extra == "dev"
-Requires-Dist: twine; extra == "dev"
-Requires-Dist: typing_extensions; extra == "dev"
+Dynamic: license-file
 
 # pyisyntax
 
@@ -73,22 +66,34 @@ with ISyntax.open("my_file.isyntax") as isyntax:
 
 To set up a development environment from the lock file:
 
-1. Ensure that you have
-   [micromamba](https://mamba.readthedocs.io/en/latest/user_guide/micromamba.html)
-   installed.
-2. Create the environment:
+1. Ensure that you have [uv](https://docs.astral.sh/uv/) installed.
+2. Create the virtual environment:
    ```console
-   $ micromamba create -n pyisyntax -f conda-lock.yml --category main --category dev
+   $ uv sync --frozen
    ```
-3. Activate the environment:
+
+To modify pyisyntax project dependencies:
+
+1. Edit dependencies in `pyproject.toml`.
+2. Update the lock file using uv:
    ```console
-   $ micromamba activate pyisyntax
+   $ uv lock
    ```
 
-To modify pyisyntax project dependencies:
+### Cutting a new release
 
-1. Edit pyproject.toml.
-2. Update the lock file using conda-lock:
+1. Ensure that tests are passing and everything is ready for release.
+2. Create and push a Git tag:
    ```console
-   $ conda-lock lock -f pyproject.toml -p linux-64 --micromamba
+   $ git tag v0.1.6
+   $ git push --tags
    ```
+3. Download the artifacts from GitHub Actions, which will include the source distribution tarball and binary wheels.
+4. Create a new release on GitHub from the tagged commit and upload the packages as attachments to the release.
+5. Also upload the packages to PyPI using Twine:
+   ```console
+   $ uv run twine upload pyisyntax-*.tar.gz pyisyntax-*.whl
+   ```
+6. Bump the version number in `pyproject.toml` and create a commit, signalling the start of development on the next version.
+
+These files should also be added to a GitHub release.

{pyisyntax-0.1.4 → pyisyntax-0.1.6}/README.md

@@ -48,22 +48,34 @@ with ISyntax.open("my_file.isyntax") as isyntax:
 
 To set up a development environment from the lock file:
 
-1. Ensure that you have
-   [micromamba](https://mamba.readthedocs.io/en/latest/user_guide/micromamba.html)
-   installed.
-2. Create the environment:
+1. Ensure that you have [uv](https://docs.astral.sh/uv/) installed.
+2. Create the virtual environment:
    ```console
-   $ micromamba create -n pyisyntax -f conda-lock.yml --category main --category dev
+   $ uv sync --frozen
    ```
-3. Activate the environment:
+
+To modify pyisyntax project dependencies:
+
+1. Edit dependencies in `pyproject.toml`.
+2. Update the lock file using uv:
    ```console
-   $ micromamba activate pyisyntax
+   $ uv lock
    ```
 
-To modify pyisyntax project dependencies:
+### Cutting a new release
 
-1. Edit pyproject.toml.
-2. Update the lock file using conda-lock:
+1. Ensure that tests are passing and everything is ready for release.
+2. Create and push a Git tag:
    ```console
-   $ conda-lock lock -f pyproject.toml -p linux-64 --micromamba
+   $ git tag v0.1.6
+   $ git push --tags
    ```
+3. Download the artifacts from GitHub Actions, which will include the source distribution tarball and binary wheels.
+4. Create a new release on GitHub from the tagged commit and upload the packages as attachments to the release.
+5. Also upload the packages to PyPI using Twine:
+   ```console
+   $ uv run twine upload pyisyntax-*.tar.gz pyisyntax-*.whl
+   ```
+6. Bump the version number in `pyproject.toml` and create a commit, signalling the start of development on the next version.
+
+These files should also be added to a GitHub release.

pyisyntax-0.1.6/isyntax/_pyisyntax.pyi

@@ -0,0 +1,4 @@
+from typing import Any
+
+ffi: Any
+lib: Any

{pyisyntax-0.1.4 → pyisyntax-0.1.6}/isyntax/lowlevel/io_management.py

@@ -27,12 +27,15 @@ class ByHandleRegistry(Generic[T]):
         Handles start at 1, autoincrement, and will automatically be recycled
         once objects are removed from the registry.
         """
-        self._list = []
+        self._list: list[T | ByHandleRegistry._EmptySlot] = []
         self._n_free = 0
         self._empty_slot = self._EmptySlot()
 
     def pop(self, handle: int) -> T:
         element = self._list[handle - 1]
+        if isinstance(element, ByHandleRegistry._EmptySlot):
+            msg = "empty slot"
+            raise IndexError(msg)
         self._list[handle - 1] = self._empty_slot
         self._n_free += 1
         if len(self._list) == handle:
@@ -52,11 +55,15 @@ class ByHandleRegistry(Generic[T]):
         return index + 1
 
     def __getitem__(self, handle: int) -> T:
-        return self._list[handle - 1]
+        element = self._list[handle - 1]
+        if isinstance(element, ByHandleRegistry._EmptySlot):
+            msg = "empty slot"
+            raise IndexError(msg)
+        return element
 
     def items(self) -> Iterator[tuple[int, T]]:
         for i, element in enumerate(self._list):
-            if element is not self._empty_slot:
+            if not isinstance(element, ByHandleRegistry._EmptySlot):
                 yield i + 1, element
 
 
@@ -69,7 +76,6 @@ def init_python_io_hooks() -> None:
         _io_registry[handle].f.seek(offset)
         return True
 
-
     @ffi.def_extern()
     def python_file_read_into(handle: int, dest: VoidPtr, bytes_to_read: int) -> int:
         bytes_read = _io_registry[handle].f.readinto(ffi.buffer(dest, bytes_to_read))
@@ -77,17 +83,14 @@ def init_python_io_hooks() -> None:
             raise RuntimeError
         return max(bytes_read, 1)
 
-
     @ffi.def_extern()
     def python_file_get_size(handle: int) -> int:
         return _io_registry[handle].n_bytes
 
-
     @ffi.def_extern()
     def python_file_close(handle: int) -> None:
         _io_registry.pop(handle).f.close()
 
-
     lib.init_python_platform_utils(
         lib.python_file_set_pos,
         lib.python_file_read_into,
@@ -109,7 +112,7 @@ def register_io(f: RawIOBase | BufferedIOBase, n_bytes: int) -> int:
     Returns:
         New handle assigned to the IO object.
     """
-    if not f.readable:
+    if not f.readable():
         msg = "IO object must be readable"
         raise RuntimeError(msg)
     return _io_registry.add(SizedIO(f, n_bytes))

{pyisyntax-0.1.4 → pyisyntax-0.1.6}/isyntax/lowlevel/libisyntax.py

@@ -77,11 +77,13 @@ def open_from_registered_handle(handle: int, *, is_init_allocators: bool = False
     init()
 
     isyntax = ffi.new("isyntax_t**")
-    check_error(lib.libisyntax_open(
-        ffi.new("char[]", str(handle).encode("utf-8")),
-        is_init_allocators,
-        isyntax,
-    ))
+    check_error(
+        lib.libisyntax_open(
+            ffi.new("char[]", str(handle).encode("utf-8")),
+            is_init_allocators,
+            isyntax,
+        ),
+    )
     return isyntax[0]
 
 
@@ -131,6 +133,14 @@ def image_get_level(wsi_image: ISyntaxImagePtr, index: int) -> ISyntaxLevelPtr:
     return lib.libisyntax_image_get_level(wsi_image, index)
 
 
+def image_get_offset_x(wsi_image: ISyntaxImagePtr) -> int:
+    return lib.libisyntax_image_get_offset_x(wsi_image)
+
+
+def image_get_offset_y(wsi_image: ISyntaxImagePtr) -> int:
+    return lib.libisyntax_image_get_offset_y(wsi_image)
+
+
 def level_get_scale(level: ISyntaxLevelPtr) -> int:
     return lib.libisyntax_level_get_scale(level)
 
@@ -165,11 +175,13 @@ def cache_create(debug_name: str | None, cache_size: int) -> ISyntaxCachePtr:
         debug_name_or_null = ffi.NULL
     else:
         debug_name_or_null = ffi.new("char[]", debug_name.encode("utf-8"))
-    check_error(lib.libisyntax_cache_create(
-        debug_name_or_null,
-        cache_size,
-        isyntax_cache,
-    ))
+    check_error(
+        lib.libisyntax_cache_create(
+            debug_name_or_null,
+            cache_size,
+            isyntax_cache,
+        ),
+    )
     return isyntax_cache[0]
 
 
@@ -192,15 +204,17 @@ def tile_read(
     pixels_buffer: "Buffer | FFI.buffer",
     pixel_format: ISyntaxPixelFormat,
 ) -> None:
-    check_error(lib.libisyntax_tile_read(
-        isyntax,
-        isyntax_cache,
-        level,
-        tile_x,
-        tile_y,
-        ffi.from_buffer("uint32_t[]", pixels_buffer, require_writable=True),
-        pixel_format,
-    ))
+    check_error(
+        lib.libisyntax_tile_read(
+            isyntax,
+            isyntax_cache,
+            level,
+            tile_x,
+            tile_y,
+            ffi.from_buffer("uint32_t[]", pixels_buffer, require_writable=True),
+            pixel_format,
+        ),
+    )
 
 
 def read_region(
@@ -214,27 +228,31 @@ def read_region(
     pixels_buffer: "Buffer | FFI.buffer",
     pixel_format: ISyntaxPixelFormat,
 ) -> None:
-    check_error(lib.libisyntax_read_region(
-        isyntax,
-        isyntax_cache,
-        level,
-        x,
-        y,
-        width,
-        height,
-        ffi.from_buffer("uint32_t[]", pixels_buffer, require_writable=True),
-        pixel_format,
-    ))
+    check_error(
+        lib.libisyntax_read_region(
+            isyntax,
+            isyntax_cache,
+            level,
+            x,
+            y,
+            width,
+            height,
+            ffi.from_buffer("uint32_t[]", pixels_buffer, require_writable=True),
+            pixel_format,
+        ),
+    )
 
 
 def read_label_image_jpeg(isyntax: ISyntaxPtr) -> memoryview:
     jpeg_buffer_ptr = ffi.new("uint8_t**")
     jpeg_size_ptr = ffi.new("uint32_t*")
-    check_error(lib.libisyntax_read_label_image_jpeg(
-        isyntax,
-        jpeg_buffer_ptr,
-        jpeg_size_ptr,
-    ))
+    check_error(
+        lib.libisyntax_read_label_image_jpeg(
+            isyntax,
+            jpeg_buffer_ptr,
+            jpeg_size_ptr,
+        ),
+    )
     jpeg_buffer = ffi.gc(jpeg_buffer_ptr[0], free)
     jpeg_size = jpeg_size_ptr[0]
     return memoryview(ffi.buffer(jpeg_buffer, jpeg_size))
@@ -243,11 +261,13 @@ def read_label_image_jpeg(isyntax: ISyntaxPtr) -> memoryview:
 def read_macro_image_jpeg(isyntax: ISyntaxPtr) -> memoryview:
     jpeg_buffer_ptr = ffi.new("uint8_t**")
     jpeg_size_ptr = ffi.new("uint32_t*")
-    check_error(lib.libisyntax_read_macro_image_jpeg(
-        isyntax,
-        jpeg_buffer_ptr,
-        jpeg_size_ptr,
-    ))
+    check_error(
+        lib.libisyntax_read_macro_image_jpeg(
+            isyntax,
+            jpeg_buffer_ptr,
+            jpeg_size_ptr,
+        ),
+    )
     jpeg_buffer = ffi.gc(jpeg_buffer_ptr[0], free)
     jpeg_size = jpeg_size_ptr[0]
     return memoryview(ffi.buffer(jpeg_buffer, jpeg_size))
@@ -256,12 +276,14 @@ def read_macro_image_jpeg(isyntax: ISyntaxPtr) -> memoryview:
 def read_icc_profile(isyntax: ISyntaxPtr, image: ISyntaxImagePtr) -> memoryview:
     profile_buffer_ptr = ffi.new("uint8_t**")
     profile_size_ptr = ffi.new("uint32_t*")
-    check_error(lib.libisyntax_read_icc_profile(
-        isyntax,
-        image,
-        profile_buffer_ptr,
-        profile_size_ptr,
-    ))
+    check_error(
+        lib.libisyntax_read_icc_profile(
+            isyntax,
+            image,
+            profile_buffer_ptr,
+            profile_size_ptr,
+        ),
+    )
     profile_buffer = ffi.gc(profile_buffer_ptr[0], free)
     profile_size = profile_size_ptr[0]
     return memoryview(ffi.buffer(profile_buffer, profile_size))

{pyisyntax-0.1.4 → pyisyntax-0.1.6}/isyntax/wrapper.py

@@ -76,6 +76,16 @@ class ISyntaxImage:
         for i in range(self.level_count):
             yield self.get_level(i)
 
+    @property
+    def offset_x(self) -> int:
+        """X-offset in pixels of the WSI image origin from the macro image origin."""
+        return libisyntax.image_get_offset_x(self.ptr)
+
+    @property
+    def offset_y(self) -> int:
+        """Y-offset in pixels of the WSI image origin from the macro image origin."""
+        return libisyntax.image_get_offset_y(self.ptr)
+
 
 class ISyntax:
     def __init__(self, f: RawIOBase | BufferedIOBase, n_bytes: int, cache_size: int = 2000) -> None:
@@ -86,7 +96,7 @@ class ISyntax:
         self.ptr = libisyntax.open_from_registered_handle(self.io_handle, is_init_allocators=False)
         self.closed = False
         self._cache_size = cache_size
-        self._cache = None
+        self._cache: ISyntaxCache | None = None
 
     @classmethod
     def open(cls: type["ISyntax"], filename: str | Path, cache_size: int = 2000) -> "ISyntax":
@@ -133,8 +143,15 @@ class ISyntax:
         """
         cache = self.get_cache()
         buf = np.empty((self.tile_height, self.tile_width, 4), dtype=np.uint8)
-        libisyntax.tile_read(self.ptr, cache.ptr, level, tile_x, tile_y,
-            buf.data, libisyntax.ISyntaxPixelFormat.RGBA)
+        libisyntax.tile_read(
+            self.ptr,
+            cache.ptr,
+            level,
+            tile_x,
+            tile_y,
+            buf.data,
+            libisyntax.ISyntaxPixelFormat.RGBA,
+        )
         return buf
 
     def read_region(self, x: int, y: int, width: int, height: int, level: int = 0) -> np.ndarray:
@@ -152,8 +169,17 @@ class ISyntax:
         """
         cache = self.get_cache()
         buf = np.empty((height, width, 4), dtype=np.uint8)
-        libisyntax.read_region(self.ptr, cache.ptr, level, x, y, width, height,
-            buf.data, libisyntax.ISyntaxPixelFormat.RGBA)
+        libisyntax.read_region(
+            self.ptr,
+            cache.ptr,
+            level,
+            x,
+            y,
+            width,
+            height,
+            buf.data,
+            libisyntax.ISyntaxPixelFormat.RGBA,
+        )
         return buf
 
     def read_label_image_jpeg(self) -> memoryview | None:
@@ -224,6 +250,16 @@ class ISyntax:
         level0 = self.wsi.get_level(0)
         return level0.mpp_y
 
+    @property
+    def offset_x(self) -> int:
+        """X-offset in pixels of the WSI image origin from the macro image origin."""
+        return self.wsi.offset_x
+
+    @property
+    def offset_y(self) -> int:
+        """Y-offset in pixels of the WSI image origin from the macro image origin."""
+        return self.wsi.offset_y
+
     def __enter__(self) -> "ISyntax":
         return self
 

pyisyntax-0.1.6/isyntax_build/builder.py

@@ -0,0 +1,112 @@
+import os
+import platform
+from importlib import resources
+from pathlib import Path
+
+from cffi import FFI
+
+import isyntax_build
+
+cdef_extra = """
+extern "Python" {
+    bool python_file_set_pos(int, int64_t);
+    int64_t python_file_read_into(int, void*, size_t);
+    int64_t python_file_get_size(int);
+    void python_file_close(int);
+}
+
+void free(void *ptr);
+"""
+
+
+def paths_to_strings(*paths: Path) -> list[str]:
+    return [str(path) for path in paths]
+
+
+def create_ffibuilder() -> FFI:
+    ffibuilder = FFI()
+
+    project_dir = Path(__file__).parent.parent
+
+    vendor = project_dir / "isyntax_build" / "vendor"
+    src = project_dir / "isyntax_build" / "src"
+    libisyntax_src = vendor / "libisyntax" / "src"
+
+    if os.name == "nt":
+        platform_sources = [
+            src / "win32_utils.c",
+        ]
+        extra_compile_args = ["/std:c11"]
+        libraries = ["winmm"]
+    else:
+        platform_sources = []
+        extra_compile_args = []
+        libraries = []
+        # The vendored libisyntax guards its SIMD/atomics on x86-centric macros
+        # that GCC does not define on aarch64 Linux, so the arm build otherwise
+        # fails to compile / links x86-only intrinsics. Select the correct paths:
+        #   __ARM_NEON__ -> intrinsics.h includes <arm_neon.h> for the NEON code
+        #   __arm64      -> ltalloc spin-wait uses sched_yield, not x86 `pause`
+        #   the last two map x86-only bit intrinsics onto portable GCC builtins
+        if platform.machine() in ("aarch64", "arm64"):
+            extra_compile_args += [
+                "-D__ARM_NEON__=1",
+                "-D__arm64=1",
+                "-D_bit_scan_forward=__builtin_ctz",
+                "-D_popcnt32=__builtin_popcount",
+            ]
+
+    ffibuilder.set_source(
+        "isyntax._pyisyntax",
+        resources.read_text(isyntax_build, "pyisyntax.c"),
+        sources=paths_to_strings(
+            libisyntax_src / "libisyntax.c",
+            libisyntax_src / "isyntax" / "isyntax.c",
+            libisyntax_src / "isyntax" / "isyntax_reader.c",
+            libisyntax_src / "utils" / "timerutils.c",
+            libisyntax_src / "utils" / "block_allocator.c",
+            libisyntax_src / "utils" / "benaphore.c",
+            libisyntax_src / "platform" / "platform.c",
+            libisyntax_src / "platform" / "work_queue.c",
+            libisyntax_src / "third_party" / "yxml.c",
+            libisyntax_src / "third_party" / "ltalloc.cc",
+            src / "python_platform_utils.c",
+            *platform_sources,
+        ),
+        include_dirs=paths_to_strings(
+            libisyntax_src,
+            libisyntax_src / "isyntax",
+            libisyntax_src / "platform",
+            libisyntax_src / "third_party",
+            libisyntax_src / "utils",
+            src,
+        ),
+        extra_compile_args=extra_compile_args,
+        libraries=libraries,
+    )
+
+    header_lines = []
+    with (libisyntax_src / "libisyntax.h").open() as f:
+        for line in f:
+            if line.startswith("#"):
+                continue
+            header_lines.append(line)
+    header_lines.append("\n")
+    with (src / "python_platform_utils.h").open() as f:
+        for line in f:
+            if line.startswith("#"):
+                continue
+            header_lines.append(line)
+    header_text = "".join(header_lines)
+    header_text += "\n\n"
+    header_text += cdef_extra
+
+    ffibuilder.cdef(header_text)
+
+    return ffibuilder
+
+
+ffibuilder = create_ffibuilder()
+
+if __name__ == "__main__":
+    ffibuilder.compile(verbose=True)

pyisyntax-0.1.6/isyntax_build/vendor/libisyntax/src/examples/isyntax_dirwalk.c

@@ -0,0 +1,91 @@
+#include "libisyntax.h"
+
+#include <stdint.h>
+#include <stdio.h>
+#include <dirent.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <malloc.h>
+
+
+#define CHECK_LIBISYNTAX_OK(_libisyntax_call) do { \
+    isyntax_error_t result = _libisyntax_call;     \
+    assert(result == LIBISYNTAX_OK);               \
+} while(0)
+
+
+#define LOG_VAR(fmt, var) printf("%s: %s=" fmt "\n", __FUNCTION__, #var, var)
+
+#ifdef _WIN32
+#define PATH_SEP "\\"
+#else
+#define PATH_SEP "/";
+#endif
+
+// This program loops through all the .isyntax files in a folder (including subfolders),
+// and outputs the barcode for each file to stdout (in comma-separated format).
+// This may be useful for large collections of WSIs where you can't tell which is which from the filename.
+
+// NOTE: the barcode/label information must be preserved for this to work.
+// This information might be deleted when using the Philips IMS export function (unless that setting is changed).
+
+int read_barcode_of_isyntax_files_in_directory(const char* dir, const char* subdir_prefix) {
+    // Looping through files in a folder.
+    // Reference: https://stackoverflow.com/questions/1271064/how-do-i-loop-through-all-files-in-a-folder-using-c
+    struct dirent *dp;
+	DIR *dfd;
+	if ((dfd = opendir(dir)) == NULL) {
+		fprintf(stderr, "Can't open %s\n", dir);
+		return 0;
+	}
+
+	char filename[260] ;
+	while ((dp = readdir(dfd)) != NULL) {
+		struct stat stbuf ;
+		sprintf(filename, "%s" PATH_SEP "%s", dir, dp->d_name);
+		if(stat(filename, &stbuf) == -1) {
+			printf("Unable to stat file: %s\n" , filename);
+			continue ;
+		}
+		if ((stbuf.st_mode & S_IFMT) == S_IFDIR) {
+			if (dp->d_name[0] != '.') {
+				char* subdir_path = malloc(260);
+				snprintf(subdir_path, 260, "%s" PATH_SEP "%s", dir, dp->d_name);
+				read_barcode_of_isyntax_files_in_directory(subdir_path, dp->d_name); // recurse into subdirectories
+				free(subdir_path);
+			}
+			continue; // Skip directories
+		} else {
+			size_t filename_len = strlen(dp->d_name);
+			const char* suffix = ".isyntax";
+			size_t suffix_len = strlen(suffix);
+			if (strncmp(dp->d_name + filename_len - suffix_len, suffix, suffix_len) == 0) {
+                // Open the iSyntax file in a special mode where the header is only read partially (for speed).
+				isyntax_t* isyntax;
+                if (libisyntax_open(filename, LIBISYNTAX_OPEN_FLAG_READ_BARCODE_ONLY, &isyntax) == LIBISYNTAX_OK) {
+                    // Print out the path of the .isyntax file + the barcode in .csv format.
+                    if (subdir_prefix) {
+						printf("%s" PATH_SEP "%s,%s\n", subdir_prefix, dp->d_name, libisyntax_get_barcode(isyntax));
+					} else {
+						printf("%s,%s\n", dp->d_name, libisyntax_get_barcode(isyntax));
+					}
+					libisyntax_close(isyntax);
+				}
+			}
+		}
+	}
+    return 0;
+}
+
+int main(int argc, char** argv) {
+	if (argc <= 1) {
+		printf("Usage: %s <directory_path> - output filename and barcode (comma-separated) for each iSyntax file in the directory and its subdirectories\n",
+		       argv[0], argv[0], argv[0], argv[0]);
+		return 0;
+	}
+
+	libisyntax_init();
+
+	char* dir = argv[1];
+	return read_barcode_of_isyntax_files_in_directory(dir, NULL);
+}