girder-jsonforms 2.0.0__tar.gz

girder_jsonforms-2.0.0/.github/workflows/release.yml

@@ -0,0 +1,102 @@
+name: Publish Python 🐍 distribution 📦 to PyPI and TestPyPI
+
+on: push
+
+jobs:
+  build:
+    name: Build distribution 📦
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: "3.x"
+    - name: Set up Node.js
+      uses: actions/setup-node@v4
+      with:
+        node-version: "18"
+    - name: Install pypa/build
+      run: >-
+        python3 -m
+        pip install
+        build
+        --user
+    - name: Build js component in package/web_client
+      run: >-
+        cd $(find . -maxdepth 2 -mindepth 2 -type d -name web_client)
+        && npm ci
+        && npm run build
+    - name: Build a binary wheel and a source tarball
+      run: python3 -m build
+    - name: install check-manifest
+      run: >-
+        python3 -m
+        pip install
+        check-manifest
+        --user
+    - name: Check the package manifest
+      run: check-manifest -vvv
+    - name: Store the distribution packages
+      uses: actions/upload-artifact@v4
+      with:
+        name: python-package-distributions
+        path: dist/
+
+  publish-to-pypi:
+    name: >-
+      Publish Python 🐍 distribution 📦 to PyPI
+    if: startsWith(github.ref, 'refs/tags/')  # only publish to PyPI on tag pushes
+    needs:
+    - build
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/girder-jsonforms
+    permissions:
+      id-token: write  # IMPORTANT: mandatory for trusted publishing
+
+    steps:
+    - name: Download all the dists
+      uses: actions/download-artifact@v4
+      with:
+        name: python-package-distributions
+        path: dist/
+    - name: Publish distribution 📦 to PyPI
+      uses: pypa/gh-action-pypi-publish@release/v1
+
+  github-release:
+    name: >-
+      Sign the Python 🐍 distribution 📦 with Sigstore
+      and upload them to GitHub Release
+    needs:
+    - publish-to-pypi
+    runs-on: ubuntu-latest
+
+    permissions:
+      contents: write  # IMPORTANT: mandatory for making GitHub Releases
+      id-token: write  # IMPORTANT: mandatory for sigstore
+
+    steps:
+    - name: Download all the dists
+      uses: actions/download-artifact@v4
+      with:
+        name: python-package-distributions
+        path: dist/
+    - name: Sign the dists with Sigstore
+      uses: sigstore/gh-action-sigstore-python@v3.0.0
+      with:
+        inputs: >-
+          ./dist/*.tar.gz
+          ./dist/*.whl
+    - name: Upload artifact signatures to GitHub Release
+      env:
+        GITHUB_TOKEN: ${{ github.token }}
+      # Upload to GitHub Release using the `gh` CLI.
+      # `dist/` contains the built packages, and the
+      # sigstore-produced signatures and certificates.
+      run: >-
+        gh release upload
+        '${{ github.ref_name }}' dist/**
+        --repo '${{ github.repository }}'

girder_jsonforms-2.0.0/.gitignore

@@ -0,0 +1,133 @@
+Testing
+
+*ala*
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+node_modules/

girder_jsonforms-2.0.0/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2024, data-exp-lab
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of girder_wholetale nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

girder_jsonforms-2.0.0/PKG-INFO

@@ -0,0 +1,33 @@
+Metadata-Version: 2.2
+Name: girder-jsonforms
+Version: 2.0.0
+Summary: Girder plugin adding forms based on JSON-editor
+License: BSD-3-Clause
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Web Environment
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: girder>=5.0.0a5.dev0
+Requires-Dist: google-api-python-client
+Requires-Dist: google-auth-oauthlib
+Requires-Dist: pandas
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+### Girder JSONForms Plugin
+
+This plugin provides a JSON Forms support for Girder. It is based on the [json-editor](https://github.com/json-editor/json-editor) library. The plugin allows to create JSON forms for data input and editing.
+
+## Usage
+
+The plugin extends girder with two models: `Form` and `FormEntry` (with REST routes `/form` and `/entry` respectively). The `Form` model is used to define the form schema and the `FormEntry` model is used to store the form data. `FormEntries` are primarily kept in girder's mongo database, but can also be stored as JSON dumps in girder hierarchy and/or in Google Drive. The plugin provides a REST API to create, update, delete and retrieve forms and form entries. The plugin also provides a web UI component to fill and view form entries. Form schema is expected to have a single unique key field, which is used to identify the form entry (`uniqueField` key on a Form).

girder_jsonforms-2.0.0/README.md

@@ -0,0 +1,7 @@
+### Girder JSONForms Plugin
+
+This plugin provides a JSON Forms support for Girder. It is based on the [json-editor](https://github.com/json-editor/json-editor) library. The plugin allows to create JSON forms for data input and editing.
+
+## Usage
+
+The plugin extends girder with two models: `Form` and `FormEntry` (with REST routes `/form` and `/entry` respectively). The `Form` model is used to define the form schema and the `FormEntry` model is used to store the form data. `FormEntries` are primarily kept in girder's mongo database, but can also be stored as JSON dumps in girder hierarchy and/or in Google Drive. The plugin provides a REST API to create, update, delete and retrieve forms and form entries. The plugin also provides a web UI component to fill and view form entries. Form schema is expected to have a single unique key field, which is used to identify the form entry (`uniqueField` key on a Form).

girder_jsonforms-2.0.0/girder_jsonforms/__init__.py

@@ -0,0 +1,83 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+import json
+import logging
+import os
+
+from girder import events
+from girder.constants import AccessType
+from girder.models.file import File
+from girder.models.item import Item
+from girder.plugin import GirderPlugin, registerPluginStaticContent
+from girder.utility.model_importer import ModelImporter
+
+from .lib.google_drive import authenticate_gdrive, upload_file_to_gdrive
+from .models.entry import FormEntry as FormEntryModel
+from .models.form import Form as FormModel
+from .rest.entry import FormEntry
+from .rest.form import Form
+
+GDRIVE_SERVICE = None
+logger = logging.getLogger(__name__)
+
+
+def annotate_uploads(event):
+    info = event.info
+    if "reference" not in info:
+        return
+
+    try:
+        reference = json.loads(info["reference"])
+    except (ValueError, TypeError):
+        return
+
+    if reference.get("annotate"):
+        parent = Item().load(
+            info["file"]["itemId"], level=AccessType.WRITE, user=info["currentUser"]
+        )
+        reference.pop("file", None)
+        reference.pop("annotate", None)
+        Item().setMetadata(parent, reference)
+
+
+def upload_to_gdrive(event):
+    global GDRIVE_SERVICE
+    info = event.info
+    file = info["file"]
+
+    with File().open(file) as fh:
+        gdrive_file_id = upload_file_to_gdrive(
+            GDRIVE_SERVICE,
+            info["gdriveFolderId"],
+            info["path"],
+            fh,
+            mimetype=file["mimeType"],
+        )
+    parent = Item().load(
+        file["itemId"], level=AccessType.WRITE, user=info["currentUser"]
+    )
+    Item().setMetadata(parent, {"gdriveFileId": gdrive_file_id})
+
+
+class JSONFormsPlugin(GirderPlugin):
+    DISPLAY_NAME = "JSON Forms"
+
+    def load(self, info):
+        ModelImporter.registerModel("form", FormModel, plugin="jsonforms")
+        ModelImporter.registerModel("entry", FormEntryModel, plugin="jsonforms")
+        global GDRIVE_SERVICE
+        try:
+            GDRIVE_SERVICE = authenticate_gdrive()
+        except ValueError:
+            logger.exception("Failed to authenticate with Google Drive")
+        info["apiRoot"].form = Form()
+        info["apiRoot"].entry = FormEntry()
+        events.bind("data.process", "jsonforms", annotate_uploads)
+        events.bind("gdrive.upload", "jsonforms", upload_to_gdrive)
+        registerPluginStaticContent(
+            plugin="jsonforms",
+            css=["/style.css"],
+            js=["/girder-plugin-jsonforms.umd.cjs"],
+            staticDir=os.path.join(os.path.dirname(__file__), "web_client", "dist"),
+            tree=info["serverRoot"],
+        )

girder_jsonforms-2.0.0/girder_jsonforms/lib/google_drive.py

@@ -0,0 +1,157 @@
+import os
+import pickle
+import logging
+
+from google.auth.transport.requests import Request
+
+# from google_auth_oauthlib.flow import InstalledAppFlow
+from googleapiclient.discovery import build
+from googleapiclient.http import MediaIoBaseUpload
+
+logger = logging.getLogger("google_drive")
+logprint = logger
+# If modifying these scopes, delete the file token.pickle.
+SCOPES = ["https://www.googleapis.com/auth/drive"]
+
+
+def get_credentials():
+    """Gets valid user credentials from storage.
+
+    If nothing has been stored, or if the stored credentials are invalid,
+    the OAuth2 flow is completed to obtain the new credentials.
+
+    Returns:
+        Credentials, the obtained credential.
+    """
+    creds = None
+    # The file token.pickle stores the user's access and refresh tokens, and is
+    # created automatically when the authorization flow completes for the first
+    # time.
+
+    path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "token.pickle")
+
+    if os.path.exists(path):
+        with open(path, "rb") as token:
+            creds = pickle.load(token)
+    # If there are no (valid) credentials available, let the user log in.
+    if not creds or not creds.valid:
+        if creds and creds.expired and creds.refresh_token:
+            creds.refresh(Request())
+        else:
+            raise ValueError("No valid credentials found")
+            # flow = InstalledAppFlow.from_client_secrets_file("credentials.json", SCOPES)
+            # creds = flow.run_local_server(port=0)
+        # Save the credentials for the next run
+        with open(path, "wb") as token:
+            pickle.dump(creds, token)
+    return creds
+
+
+def authenticate_gdrive():
+    # Load credentials from a file or any other secure source
+    # Replace 'path_to_credentials.json' with the actual path to your credentials file
+    credentials = get_credentials()
+    return build("drive", "v3", credentials=credentials)
+
+
+def create_folders(service, folder_id, path):
+    if service is None:
+        logger.exception("Service not initialized. Failed to create folder.")
+        return
+    current_folder_id = folder_id
+    folders = path.split("/")
+    for folder in folders:
+        if folder:
+            # Check if folder already exists
+            query = f"'{current_folder_id}' in parents and mimeType='application/vnd.google-apps.folder' and name='{folder}' and trashed=false"
+            response = (
+                service.files()
+                .list(
+                    q=query,
+                    fields="files(id)",
+                    includeItemsFromAllDrives=True,
+                    supportsAllDrives=True,
+                )
+                .execute()
+            )
+            existing_folders = response.get("files", [])
+            if existing_folders:
+                logprint.error(f"Folder '{folder}' already exists")
+                logprint.error(response)
+                current_folder_id = existing_folders[0]["id"]
+            else:
+                logprint.error(f"Creating folder '{folder}'")
+                file_metadata = {
+                    "name": folder,
+                    "mimeType": "application/vnd.google-apps.folder",
+                    "parents": [current_folder_id],
+                }
+                folder_result = (
+                    service.files()
+                    .create(body=file_metadata, fields="id", supportsAllDrives=True)
+                    .execute()
+                )
+                logprint.error(
+                    f"Folder '{folder}' created with ID: {folder_result['id']}"
+                )
+                current_folder_id = folder_result["id"]
+
+    return current_folder_id
+
+
+def upload_file_to_gdrive(service, folder_id, path, file_handle, mimetype="text/plain"):
+    if service is None:
+        logger.exception("Service not initialized. Failed to upload file.")
+        return
+    file_path, file_name = os.path.split(path)
+    folder_id = create_folders(service, folder_id, file_path)
+    logprint.error(f"Uploading file '{file_name}' to folder '{folder_id}'")
+
+    # Check if file already exists in the folder
+    query = f"'{folder_id}' in parents and name='{file_name}' and trashed=false"
+    response = (
+        service.files()
+        .list(
+            q=query,
+            fields="files(id)",
+            includeItemsFromAllDrives=True,
+            supportsAllDrives=True,
+        )
+        .execute()
+    )
+    existing_files = response.get("files", [])
+    media = MediaIoBaseUpload(file_handle, mimetype=mimetype)
+    if existing_files:
+        file_id = existing_files[0]["id"]
+        file_result = (
+            service.files()
+            .update(fileId=file_id, media_body=media, supportsAllDrives=True)
+            .execute()
+        )
+        logprint.error(f'File {file_name} updated with ID: {file_result["id"]}')
+    else:
+        file_metadata = {"name": file_name, "parents": [folder_id]}
+        file_result = (
+            service.files()
+            .create(
+                body=file_metadata,
+                media_body=media,
+                fields="id",
+                supportsAllDrives=True,
+            )
+            .execute()
+        )
+        logprint.error(
+            f'File {file_metadata["name"]} uploaded with ID: {file_result["id"]}'
+        )
+    return file_result["id"]
+
+
+# Example usage
+if __name__ == "__main__":
+    # folder_id = "1WgY3HJ0bxzQc-IA_dBdiwb9Hvq6ho3HS"  # Replace with the actual folder ID
+    folder_id = "13u4Citrr09FETrPDn2gJmBHWeaO0ylji"
+    path = "subfolder/subfolder2/subfolder4/file.txt"
+    file_handle = open("file.txt", "rb")  # Replace 'file.txt' with the actual file path
+    service = authenticate_gdrive()
+    file_id = upload_file_to_gdrive(service, folder_id, path, file_handle)

girder_jsonforms-2.0.0/girder_jsonforms/lib/jq.py

@@ -0,0 +1,134 @@
+from typing import Any
+
+# find all occurences of a key in a nested json
+def find_key_paths(json_data: dict, key: str, path: str = "") -> list[str]:
+    results = []
+    # Check if the input is a dictionary
+    if isinstance(json_data, dict):
+        # If the key is found, return the path to it
+        if key in json_data:
+            results.append(path + key)
+        # Recursively search through each value in the dictionary
+        for k, v in json_data.items():
+            results.extend(find_key_paths(v, key, path + k + "."))
+    # Check if the input is a list
+    elif isinstance(json_data, list):
+        # Recursively search through each item in the list
+        for i, item in enumerate(json_data):
+            if isinstance(item, dict):
+                results.extend(find_key_paths(item, key, path + f"[{i}]."))
+            elif isinstance(item, list):
+                for j, sub_item in enumerate(item):
+                    results.extend(find_key_paths(sub_item, key, path + f"[{i}][{j}]."))
+    # Return None if the key is not found
+    return results
+
+
+# method to change the value of the key using key notation .[]
+def get_value(json_data: dict, key: str) -> dict:
+    for path in key.split("."):
+        if path.startswith("["):
+            index = int(path[1:-1])
+            json_data = json_data[index]
+        else:
+            json_data = json_data[path]
+    return json_data
+
+
+def set_value(json_data: dict, key: str, value: Any) -> None:
+    for path in key.split(".")[:-1]:
+        if path.startswith("["):
+            index = int(path[1:-1])
+            json_data = json_data[index]
+        else:
+            json_data = json_data[path]
+    path = key.split(".")[-1]
+    json_data[path] = value
+
+
+def convert_to_jq_notation(data: dict, parent_key: str = "", sep: str = ".") -> dict:
+    """
+    Convert a nested dictionary or list into a flat dictionary with jq-style keys.
+
+    Args:
+        data (dict or list): The nested dictionary or list to flatten.
+        parent_key (str): The base key for recursion (used internally).
+        sep (str): The separator to use for keys (default is ".").
+
+    Returns:
+        dict: A flattened dictionary with jq-like notation keys.
+    """
+    items = []
+
+    if isinstance(data, dict):
+        for key, value in data.items():
+            new_key = f"{parent_key}{sep}{key}" if parent_key else key
+            items.extend(convert_to_jq_notation(value, new_key, sep).items())
+    elif isinstance(data, list):
+        for index, value in enumerate(data):
+            new_key = f"{parent_key}{sep}[{index}]"
+            items.extend(convert_to_jq_notation(value, new_key, sep).items())
+    else:
+        items.append((parent_key, data))
+
+    return dict(items)
+
+
+def parse_jq_notation(input_dict: dict) -> dict:
+    """
+    Convert a dictionary with jq-style keys into a nested dictionary.
+
+    Args:
+        input_dict (dict): The dictionary with jq-style keys.
+
+    Returns:
+        dict: A nested dictionary.
+    """
+
+    def is_array_index(key):
+        return key.startswith("[") and key.endswith("]") and key[1:-1].isdigit()
+
+    output = {}
+
+    for key, value in input_dict.items():
+        keys = key.split(".")
+        current = output
+
+        for i, part in enumerate(keys[:-1]):
+            if is_array_index(part):
+                # Convert string digits to integers for lists
+                part = int(part.strip("[]"))
+
+            if "nestedlist" in key:
+                print(current, key, part)
+            if isinstance(part, int):
+                # If current is not a list, convert it into one
+                if not isinstance(current, list):
+                    current[keys[i - 1]] = []
+                    current = current[keys[i - 1]]
+                # Extend the list to ensure the index exists
+
+                if i + 1 <= len(keys[:-1]) and is_array_index(keys[i+1]):
+                    append_object = []
+                else:
+                    append_object = {}
+
+                while len(current) <= part:
+                    # It has to be a placeholder for dictionary or list
+                    current.append(append_object)
+                current = current[part]
+            else:
+                if part not in current:
+                    # Create a list if the next key is a digit
+                    next_part = keys[i + 1]
+                    current[part] = [] if is_array_index(next_part) else {}
+                current = current[part]
+
+        # Handle the last key
+        last_key = keys[-1]
+        if is_array_index(last_key):
+            current.append(value)
+        else:
+            current[last_key] = value
+
+    return output