[jnifti] jnifti reading nii.gz and writign nii.gz for nifti-1/2, add compression apis

Author: fangq

.github/check-pypi-upload.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+PYPKG_BUILD_VERSION=$(awk -F"-" '{ print $2 }' <<< $(ls dist/ | head -1))
+PYPKG_VERSIONS_STRING=$(pip index versions jdata | grep versions:)
+PYPKG_VERSIONS_STRING=${PYPKG_VERSIONS_STRING#*:}
+UPLOAD_TO_PYPI=1
+while IFS=', ' read -ra PYPKG_VERSIONS_ARRAY; do
+  for VERSION in "${PYPKG_VERSIONS_ARRAY[@]}"; do
+    if [ "$PYPKG_BUILD_VERSION" = "$VERSION" ]; then
+      UPLOAD_TO_PYPI=0
+    fi
+  done;
+done <<< "$PYPKG_VERSIONS_STRING"
+if [ "$UPLOAD_TO_PYPI" = 1 ]; then
+  echo "Wheel version wasn't found on PyPi.";
+else
+  echo "Wheel was found on PyPi.";
+fi
+echo "perform_pypi_upload=$UPLOAD_TO_PYPI" >> $GITHUB_OUTPUT

.github/workflows/run_test.yml

@@ -3,7 +3,7 @@ name: Test JData
 on: [push]
 
 jobs:
-  build:
+  test:
     runs-on: ubuntu-22.04
     strategy:
       matrix:
@@ -35,3 +35,30 @@ jobs:
           pip install bjdata lz4 blosc2
           cp -a test/benchcodecs.py .
           python -m benchcodecs
+
+  deploy:
+    runs-on: ubuntu-22.04
+    needs: test
+    steps:
+      - name: Checkout repo
+        uses: actions/checkout@v3
+        with:
+          submodules: 'recursive'
+      - name: Install build
+        run: python3 -m pip install --upgrade build
+      - name: Build wheel
+        run: |
+          python3 -m build
+      - name: Check If the Build Version Exists on PyPI
+        id: perform_pypi_upload_check
+        shell: bash
+        run: |
+          $GITHUB_WORKSPACE/.github/check-pypi-upload.sh
+      - name: Upload packages to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        if: ${{ github.actor == 'fangq' && steps.perform_pypi_upload_check.outputs.perform_pypi_upload == 1  && github.event_name != 'pull_request'}}
+        with:
+          password: ${{ secrets.PYPI_API_TOKEN }}
+          verify_metadata: false
+          verbose: true
+          skip_existing: true

Makefile

@@ -11,11 +11,6 @@ test:
 build:
 	$(PY) -m build
 
-report:
-	@echo '====== all imported functions ======'
-	@grep '^\s*[a-z]*,' jdata/__init__.py | sed -e 's/^\s*//g' -e 's/,//g' | sort | uniq -c
-	@echo '====== all tested functions ======'
-	@grep 'def\s*test' test/run_test.py | sed -e 's/\s*def test_//g' -e 's/(self)://g' -e 's/_.*//g' | sort | uniq -c
 
 .DEFAULT_GOAL=all
-.PHONY: all pretty test report
+.PHONY: all pretty test

README.md

@@ -2,7 +2,7 @@
 
 # JData for Python - lightweight and serializable data annotations for Python
 
-- Copyright: (C) Qianqian Fang (2019-2024) <q.fang at neu.edu>
+- Copyright: (C) Qianqian Fang (2019-2025) <q.fang at neu.edu>
 - License: Apache License, Version 2.0
 - Version: 0.6.0
 - URL: https://github.com/NeuroJSON/pyjdata
@@ -65,23 +65,23 @@ are no longer supported.
 One can also install this module from the source code. To do this, you first
 check out a copy of the latest code from Github by
 ```
-    git clone https://github.com/NeuroJSON/pyjdata.git
-    cd pyjdata
+git clone https://github.com/NeuroJSON/pyjdata.git
+cd pyjdata
 ```
 then install the module to your local user folder by
 ```
-    python3 setup.py install --user
+python3 setup.py install --user
 ```
 or, if you prefer, install to the system folder for all users by
 ```
-    sudo python3 setup.py install
+sudo python3 setup.py install
 ```
 Please replace `python` by `python3` if you want to install it for Python 3.x instead of 2.x.
 
 Instead of installing the module, you can also import the jdata module directly from 
 your local copy by cd the root folder of the unzipped pyjdata package, and run
 ```
-   import jdata as jd
+import jdata as jd
 ```
 
 ## How to use

jdata/__init__.py

@@ -49,7 +49,22 @@
     jdlink,
     jext,
 )
-from .jdata import encode, decode, jdtype, jsonfilter
+from .jdata import (
+    encode,
+    decode,
+    jdtype,
+    jsonfilter,
+    zlibencode,
+    zlibdecode,
+    gzipencode,
+    gzipdecode,
+    lzmaencode,
+    lzmadecode,
+    lz4encode,
+    lz4decode,
+    base64encode,
+    base64decode,
+)
 from .jpath import jsonpath
 from .jnifti import (
     nii2jnii,
@@ -102,6 +117,16 @@
     "niiformat",
     "loadh5",
     "saveh5",
+    "zlibencode",
+    "zlibdecode",
+    "gzipencode",
+    "gzipdecode",
+    "lzmaencode",
+    "lzmadecode",
+    "lz4encode",
+    "lz4decode",
+    "base64encode",
+    "base64decode",
 ]
 __license__ = """Apache license 2.0, Copyright (c) 2019-2024 Qianqian Fang"""
 

jdata/jdata.py

@@ -5,7 +5,22 @@
 Copyright (c) 2019-2024 Qianqian Fang <q.fang at neu.edu>
 """
 
-__all__ = ["encode", "decode", "jdtype", "jsonfilter"]
+__all__ = [
+    "encode",
+    "decode",
+    "jdtype",
+    "jsonfilter",
+    "zlibencode",
+    "zlibdecode",
+    "gzipencode",
+    "gzipdecode",
+    "lzmaencode",
+    "lzmadecode",
+    "lz4encode",
+    "lz4decode",
+    "base64encode",
+    "base64decode",
+]
 
 ##====================================================================================
 ## dependent libraries
@@ -67,7 +82,7 @@
 ##====================================================================================
 
 
-def encode(d, opt={}):
+def encode(d, opt={}, **kwargs):
     """@brief Encoding a Python data structure to portable JData-annotated dict constructs
 
     This function converts complex data types (usually not JSON-serializable) into
@@ -82,6 +97,7 @@ def encode(d, opt={}):
     """
 
     opt.setdefault("inplace", False)
+    opt.update(kwargs)
 
     if "compression" in opt:
         if opt["compression"] == "lzma":
@@ -166,6 +182,7 @@ def encode(d, opt={}):
             elif opt["compression"] == "gzip":
                 gzipper = zlib.compressobj(wbits=(zlib.MAX_WBITS | 16))
                 newobj["_ArrayZipData_"] = gzipper.compress(newobj["_ArrayZipData_"])
+                newobj["_ArrayZipData_"] += gzipper.flush()
             elif opt["compression"] == "lzma":
                 try:
                     newobj["_ArrayZipData_"] = lzma.compress(
@@ -224,7 +241,7 @@ def encode(d, opt={}):
 ##====================================================================================
 
 
-def decode(d, opt={}):
+def decode(d, opt={}, **kwargs):
     """@brief Decoding a JData-annotated dict construct into native Python data
 
     This function converts portable JData-annotated dict/list constructs back to native Python
@@ -237,6 +254,7 @@ def decode(d, opt={}):
 
     opt.setdefault("inplace", False)
     opt.setdefault("maxlinklevel", 0)
+    opt.update(kwargs)
 
     if (
         (isinstance(d, str) or type(d) == "unicode")
@@ -461,3 +479,112 @@ def decodelist(d0, opt={}):
 
 
 # -------------------------------------------------------------------------------------
+
+
+def zlibencode(buf):
+    return zlib.compress(buf)
+
+
+# -------------------------------------------------------------------------------------
+
+
+def gzipencode(buf):
+    gzipper = zlib.compressobj(wbits=(zlib.MAX_WBITS | 16))
+    newbuf = gzipper.compress(buf)
+    newbuf += gzipper.flush()
+    return newbuf
+
+
+# -------------------------------------------------------------------------------------
+
+
+def lzmaencode(buf):
+    try:
+        try:
+            import lzma
+        except ImportError:
+            from backports import lzma
+    except Exception:
+        raise Exception(
+            "JData",
+            'you must install "lzma" module to compress with this format',
+        )
+    return lzma.compress(buf, lzma.FORMAT_ALONE)
+
+
+# -------------------------------------------------------------------------------------
+
+
+def lz4encode(buf):
+    try:
+        import lz4.frame
+    except ImportError:
+        raise Exception(
+            "JData",
+            'you must install "lz4" module to compress with this format',
+        )
+    return lz4.compress(buf.tobytes(), lzma.FORMAT_ALONE)
+
+
+# -------------------------------------------------------------------------------------
+
+
+def base64encode(buf):
+    return base64.b64encode(buf)
+
+
+# -------------------------------------------------------------------------------------
+
+
+def zlibdecode(buf):
+    return zlib.decompress(buf)
+
+
+# -------------------------------------------------------------------------------------
+
+
+def gzipdecode(buf):
+    return zlib.decompress(bytes(buf), zlib.MAX_WBITS | 32)
+
+
+# -------------------------------------------------------------------------------------
+
+
+def lzmadecode(buf):
+    try:
+        try:
+            import lzma
+        except ImportError:
+            from backports import lzma
+    except Exception:
+        raise Exception(
+            "JData",
+            'you must install "lzma" module to compress with this format',
+        )
+    newbuf = bytearray(buf)  # set length to -1 (unknown) if EOF appears
+    newbuf[5:13] = b"\xff\xff\xff\xff\xff\xff\xff\xff"
+    return lzma.decompress(newbuf, lzma.FORMAT_ALONE)
+
+
+# -------------------------------------------------------------------------------------
+
+
+def lz4decode(buf):
+    try:
+        import lz4.frame
+    except ImportError:
+        raise Exception(
+            "JData",
+            'you must install "lz4" module to compress with this format',
+        )
+    return lz4.frame.decompress(bytes(buf))
+
+
+# -------------------------------------------------------------------------------------
+
+
+def base64decode(buf):
+    return base64.b64decode(buf)
+
+
+# -------------------------------------------------------------------------------------