oceanproc 0.1.0__py3-none-any.whl

oceanproc/utils.py

@@ -0,0 +1,224 @@
+import sys
+import logging
+from pathlib import Path
+import json
+from types import SimpleNamespace
+
+logger = logging.getLogger(__name__)
+
+default_log_format = "%(levelname)s:%(asctime)s:%(module)s: %(message)s"
+
+flags = SimpleNamespace(debug = False)
+
+def takes_arguments(decorator):
+    """
+    A meta-decorator to use on decorators that take in other
+    arguments than just the function they are applied to
+    """
+    def wrapper(*args, **kwargs):
+        def replacement(func):
+            return decorator(func, *args, **kwargs)
+        return replacement
+    return wrapper
+
+
+def debug_logging(func):
+    """
+    A decorator function that debug logs a function call
+    and the arguments used in the call. Can log with a 
+    specified logger or this module's logger if one is 
+    not supplied
+
+    :param func: function this decorator is applied to
+    :type func: function
+    :param this_logger: a logger to use for logging the function call
+    :type this_logger: logging.Logger object
+    :return: a function that is the input function wrapped by this decorator
+    :rtype: function
+    """
+    def inner(*args, **kwargs):
+        log_linebreak()
+        logger.debug(
+            f"calling - {func.__module__}:{func.__name__}({', '.join([str(a) for a in args] + [f'{k}={v}' for k,v in kwargs.items()])})\n"
+        )
+        return func(*args, **kwargs)
+    return inner
+
+
+def exit_program_early(msg:str, 
+                       exit_func=None):
+    """
+    Exit the program while printing parameter 'msg'. If an exit
+    function is sepcified, it will be called before the program
+    exits
+
+    :param msg: error message to display.
+    :type msg: str
+    :param exit_func: function to be called before program exit (no required arguments)
+    :type exit_func: function
+
+    """
+    log_linebreak()
+    logger.error(f"---[ERROR]: {msg} \nExiting the program now...\n")
+    if exit_func and callable(exit_func):
+        exit_func()
+    sys.exit(1)
+
+
+def prompt_user_continue(msg:str) -> bool:
+    """
+    Prompt the user to continue with a custom message.
+
+    :param msg: prompt message to display.
+    :type msg: str
+
+    """
+    prompt_msg = f"{msg} \n\t---(press 'y' for yes, other input will mean no)"
+    user_continue = input(prompt_msg+"\n")
+    ans = (user_continue.lower() == "y")
+    logger.debug(f"User Prompt: {prompt_msg}")
+    logger.debug(f"User Response:  {user_continue} ({ans})")
+    return ans
+
+
+def make_option(value, 
+                key: str=None, 
+                delimeter: str=" ", 
+                convert_underscore: bool=False):
+    """
+    Generate a string, representing an option that gets fed into a subprocess or script.
+
+    For example, if a key is 'option' and its value is True, the option string it will generate would be:
+
+        --option
+
+    If value is equal to some string 'value', then the string would be:
+
+        --option value
+
+    If value is a list of strings:
+
+        --option value1 value2 ... valuen
+    :param value: Value to pass in along with the 'key' param.
+    :type value: any
+    :param key: Name of option, without any hyphen at the beginning.
+    :type key: str
+    :param delimeter: character to separate the key and the value in the option string. Default is a space.
+    :type delimeter: str
+    :param convert_underscore: flag to indicate that underscores should be replaced with '-'
+    :type convert_underscore: bool
+    :return: String to pass as an option into a subprocess call.
+    :rtype: str
+    """
+    second_part = None
+    if key and convert_underscore:
+        key = key.replace("_", "-")
+    if not value:
+        return ""
+    elif type(value) == bool and value:
+        second_part = " "
+    elif type(value) == list:
+        second_part = f"{delimeter}{' '.join([str(v) for v in value])}"
+    else:
+        second_part = f"{delimeter}{str(value)}"
+    return f"--{key}{second_part}" if key else second_part
+
+
+def add_file_handler(this_logger: logging.Logger, 
+                     log_path: Path, 
+                     format_str: str=default_log_format):
+    """
+    Adds a file handler with the input file path and input message formatting to the input logger.
+    The default message formatting in defined at the top of this file.
+
+    :param this_logger: A logger object to add the file handler to
+    :type this_logger: logging.Logger object
+    :param log_path: A path to the output file for the file handler
+    :type log_path: pathlib.Path
+    :param format_str: a string representing the desired message formatting for the file_handler. (See logging.Formatter class for more detail)
+    :type format_str: str
+    """
+    file_handler = logging.FileHandler(log_path)
+    file_handler.setFormatter(logging.Formatter(format_str))
+    this_logger.addHandler(file_handler)
+
+
+def prepare_subprocess_logging(this_logger, 
+                               stop=False):
+    """
+    Prepares a logger for piping subprocess outputs to its handlers. This function removes 
+    newlines from all of the logger's handlers and simplifies the message format to cleaning 
+    display subprocess outputs. If 'stop' is True, the logger handlers are restored to defaults
+
+    :param this_logger: A logger object to change formatting for
+    :type this_logger: logging.Logger object
+    :param stop: A flag to indicate if subprocessing logging should end
+    :type stop: bool
+    """
+    if stop:
+        while this_logger != None:
+            for h in this_logger.handlers:
+                h.setFormatter(logging.Formatter(default_log_format))
+                h.terminator = "\n"
+            this_logger = this_logger.parent
+    else:
+        while this_logger != None:
+            for h in this_logger.handlers:
+                h.setFormatter(logging.Formatter("%(message)s"))
+                h.terminator = ""
+            this_logger = this_logger.parent
+
+
+def log_linebreak():
+    """
+    Logs a single blank line using this module's logger.
+    Changes the formatter for each handler to be a empty, logs
+    a single blank line, then changes each formatter back to 
+    the default format
+    """
+    traverse_logger = logger
+    while traverse_logger != None:
+        for h in traverse_logger.handlers:
+            h.setFormatter(logging.Formatter(""))
+        traverse_logger = traverse_logger.parent
+    logger.info("")
+    traverse_logger = logger
+    while traverse_logger != None:
+        for h in traverse_logger.handlers:
+            h.setFormatter(logging.Formatter(default_log_format))
+        traverse_logger = traverse_logger.parent
+
+
+def export_args_to_file(args, 
+                        argument_group, 
+                        file_path: Path):
+    """
+    Takes the arguments in the argument group, and exports their names and values in the 'args'
+    namespace to a file specified at 'file_path'. The input 'file_path' can either be a txt
+    file or a json file.
+
+    :param args: an argument namespace to pull input values from
+    :type args: argparse.Namespace
+    :param argument_group: The argument group representing the subset of inputs to save to a file
+    :type argument_group: argparse._ArgumentGroup
+    :param file_path: a path to a file where the arguments should be saved
+    :type file_path: pathlib.Path
+    """
+
+    all_opts = dict(args._get_kwargs())
+    opts_to_save = dict()
+    for a in argument_group._group_actions:
+        if a.dest in all_opts and all_opts[a.dest]:
+            if type(all_opts[a.dest]) == bool:
+                opts_to_save[a.option_strings[0]] = ""
+                continue
+            elif isinstance(all_opts[a.dest], Path):
+                opts_to_save[a.option_strings[0]] = str(all_opts[a.dest])
+                continue
+            opts_to_save[a.option_strings[0]] = all_opts[a.dest]
+    with open(file_path, "w") as f:
+        if file_path.suffix == ".json":
+            f.write(json.dumps(opts_to_save, indent=4))
+        else:
+            for k,v in opts_to_save.items():
+                f.write(f"{k}{make_option(value=v)}\n")

oceanproc/web/TODO.md

@@ -0,0 +1,4 @@
+- [ ] Add a file explorer for all of the path-related options
+- [ ] Implement the POST request to begin an oceanproc instance with the formdata
+- [ ] Style everything better
+- [ ] Add method of tracking current oceanproc instances through the web frontend, brainstorm ways to do this

oceanproc/web/app.py

@@ -0,0 +1,78 @@
+import subprocess
+from pathlib import Path
+import os
+import re
+from flask import Flask, render_template, request, jsonify
+
+app = Flask(__name__)
+root_dir = Path(os.environ['DATA1'])
+
+@app.route('/')
+def oceanproc():
+    return "<h1>Hello, world!</h1>"
+
+@app.route('/files/')
+@app.route('/files/<path:subpath>')
+def get_filesystem(subpath=""):
+    app.logger.debug(f"path: {subpath}")
+    full_path = Path(os.path.realpath(f"{root_dir.as_posix()}/{subpath}"))
+    if not full_path.is_dir():
+        return render_template('filesystem_fail.html', nonexistant_path=full_path.as_posix())
+    dirs, files = [], []
+    for f in full_path.iterdir():
+        file_obj = {}
+        file_obj["isdir"] = True if f.is_dir() else False
+        file_obj["basename"] = f.name
+        file_obj["realpath"] = f.resolve().as_posix()
+        file_obj["pathfromroot"] = f.relative_to(root_dir)
+        dirs.append(file_obj) if f.is_dir() else files.append(file_obj)
+    dirs = sorted(dirs, key=lambda f: f['basename'])
+    files = sorted(files, key=lambda f: f['basename'])
+    file_list = dirs + files
+    if full_path != root_dir:
+        app.logger.info("here")
+        file_list.insert(0, {"isdir": True, "basename": "..", "realpath": full_path.as_posix(), "pathfromroot": re.sub(r'(.*)/.*', r'\1', full_path)})
+    return render_template('filesystem.html', 
+                           cur_dir=full_path,
+                           file_list=file_list)
+
+@app.route('/api/get_filesystem/', methods=['GET'])
+@app.route('/api/get_filesystem/<path:subpath>', methods=['GET'])
+def get_filesystem_json(subpath=""):
+    full_path = Path(os.path.realpath(f"{root_dir.as_posix()}/{subpath}"))
+    dirs, files = [], []
+    for f in full_path.iterdir():
+        file_obj = {}
+        file_obj["isdir"] = True if f.is_dir() else False
+        file_obj["basename"] = f.name
+        file_obj["realpath"] = f.resolve().as_posix()
+        file_obj["pathfromroot"] = f.relative_to(root_dir).as_posix()
+        dirs.append(file_obj) if f.is_dir() else files.append(file_obj)
+    dirs = sorted(dirs, key=lambda f: f['basename'])
+    files = sorted(files, key=lambda f: f['basename'])
+    file_list = dirs + files
+    if full_path != root_dir:
+        app.logger.info("here")
+        file_list.insert(0, {'isdir': True,
+                             'basename': "..",
+                             'realpath': full_path.resolve().as_posix(),
+                             'pathfromroot': full_path.parents[0].relative_to(root_dir).as_posix()})
+    return jsonify({'cur_dir': full_path.as_posix(),
+                    'file_list': file_list}), 200
+
+
+@app.route('/api/get_parser_args/', methods=['GET'])
+def get_parser_args():
+    from .get_parser_json import generate_json_from_parser_options
+    parser_args = generate_json_from_parser_options()
+    return jsonify(parser_args), 200
+
+
+@app.route('/formtest/', methods=['GET'])
+def formtest():
+    return render_template('oceanproc_form.html'), 200
+
+        
+    
+      
+

oceanproc/web/config.json

@@ -0,0 +1,7 @@
+{
+	"options_script_path": "../ocean_proc.py",
+	"parser_group_names": [
+		"session_arguments",
+		"config_arguments"
+	]
+}

oceanproc/web/get_parser_json.py

@@ -0,0 +1,58 @@
+import ast
+import asttokens
+from html import escape
+import codecs
+import json
+import os
+import re
+import re
+import subprocess
+import sys
+from textwrap import dedent
+
+def _create_argument_dicts(path: str, parser_group_names: list[dict]):
+    def get_opt(node):
+        toklist = list(script_ast.get_tokens(node))
+        optname = [re.sub(r'\"--(.*)\"', r'\1', t.string) for t in toklist if 
+                   t.type == 3 and 
+                   ('--' in t.string or '-' not in t.string)][0]
+        equalindices = [idx for idx in range(len(toklist)) if toklist[idx].string == "="]
+        optsettingkeys = [toklist[idx-1].string for idx in equalindices]
+        optsettingvals = []
+        for startidx in equalindices: # Generate string representing value of kwarg, even if the value is longer than one token
+            optsettingval = ""
+            idx = startidx + 1
+            while toklist[idx].string != "," and idx < len(toklist) - 1:
+                optsettingval += re.sub(r'^[\"\'](.*)[\"\']$', r'\1', toklist[idx].string) # Remove outer quotes in string repr defined by ast
+                idx += 1
+            optsettingvals.append(optsettingval)
+        option = {optname: {k: v for (k, v) in zip(optsettingkeys, optsettingvals)}}
+        return option
+    arguments = []
+    with open(path) as f:
+        script_ast = asttokens.ASTTokens(f.read(), parse=True)
+        for node in ast.walk(script_ast.tree):
+            if isinstance(node, ast.Call):
+                if (isinstance(node.func, ast.Attribute) and
+                isinstance(node.func.value, ast.Name) and
+                node.func.value.id in parser_group_names and
+                isinstance(node.func.attr, str) and
+                node.func.attr == 'add_argument'):
+                    arguments.append(get_opt(node))
+    return arguments
+
+def generate_json_from_parser_options(config_path: str = 'config.json') -> list[dict]:
+    """
+    Returns a list of Python dicts, which will be interpreted in JSON format by a React component for generating an HTML form corresponding to command-line arguments.
+
+    :return: A Python dict containing two fields: 'option', the name of the argparse option, and 'html_type', a string containing the corresponding HTML <input> type field. 
+    :rtype: list[dict]
+    """
+    with open(config_path) as f:
+        config = json.load(f)
+    options_script_path = config["options_script_path"]
+    if not os.path.isfile(options_script_path):
+        raise RuntimeError(f"ERROR: script at {options_script_path} does not exist.")
+    parser_group_names = config["parser_group_names"]
+    argument_dicts = _create_argument_dicts(options_script_path, parser_group_names)
+    return argument_dicts

oceanproc/web/static/components/ArgparseForm.js

@@ -0,0 +1,9 @@
+import { html } from 'htm/preact';
+import { render } from 'preact';
+import { useState, useEffect, useRef, useMemo } from 'preact/hooks';
+import { FileBrowser } from './FileBrowser.js';
+
+export function ArgparseForm(props) {
+	function sortByInputType(a, b){
+	}
+}

oceanproc/web/static/components/ArgparseFormEntry.js

@@ -0,0 +1,52 @@
+import { html } from 'htm/preact';
+import { useState, useEffect, useRef, useMemo } from 'preact/hooks';
+import { FileBrowser } from './FileBrowser.js';
+
+export function ArgparseFormEntry(props) {		
+	const [optName, setOptName] = useState("")
+	const [optObj, setOptObj] = useState({})
+	const [optHtml, setOptHtml] = useState(html``)
+
+	useEffect(() => {
+		setOptName(Object.keys(props.obj)[0])
+		setOptObj(props.obj[Object.keys(props.obj)[0]])
+	}, [])
+
+	useEffect(() => {
+		switch (optObj.action) {
+			case "store_true":
+				setOptHtml(html`
+					<div class="form-check">
+						<input class="form-check-input" type=checkbox id="${optName}Input" name="${props.formName}"></input>
+						<label class="form-check-label" for=${optName}>${optName}</label>
+					</div>
+				`)
+				break;
+			default:
+				setOptHtml(html`
+					<div class="form-group argparseFormTextInput">
+						<label for=${optName}>${optName}</label>
+						<input class="form-control" type=text id="${optName}Input" name="${props.formName}"></input>
+					</div>
+				`)
+		}
+		if (optObj.type !== undefined && optObj.type.includes("Path")) {
+				setOptHtml(html`
+					<div class="form-group argparseFormTextInput">
+						<p>${optName}</p>
+						<button type="button" 
+						class="btn btn-primary" 
+						data-toggle="modal" 
+						data-target="#${optName}Modal">Select path for ${optName}</button>
+						<${FileBrowser}
+						modalId="${optName}Modal"
+						submitBtnText="Choose directory"
+						browserTitle="Select path for ${optName}"
+						handleSubmit=${(path) => console.log(path)}><//>
+					</div>
+				`)
+		}
+	}, [optObj])
+	return optHtml
+}
+

oceanproc/web/static/components/DirIcon.js

@@ -0,0 +1,11 @@
+import { html } from 'htm/preact';
+import { render } from 'preact';
+import { useState, useEffect, useRef } from 'preact/hooks';
+
+export function DirIcon() {
+	return html`
+	<svg style="margin-right:8px;" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke-width="1.5" stroke="currentColor" class="size-6" width="10px" height="10px">
+  		<path stroke-linecap="round" stroke-linejoin="round" d="M2.25 12.75V12A2.25 2.25 0 0 1 4.5 9.75h15A2.25 2.25 0 0 1 21.75 12v.75m-8.69-6.44-2.12-2.12a1.5 1.5 0 0 0-1.061-.44H4.5A2.25 2.25 0 0 0 2.25 6v12a2.25 2.25 0 0 0 2.25 2.25h15A2.25 2.25 0 0 0 21.75 18V9a2.25 2.25 0 0 0-2.25-2.25h-5.379a1.5 1.5 0 0 1-1.06-.44Z" />
+	</svg>
+	`	
+}

oceanproc/web/static/components/FileBrowser.js

@@ -0,0 +1,85 @@
+import { html } from 'htm/preact';
+import { render } from 'preact';
+import { useState, useEffect, useRef } from 'preact/hooks';
+import { FileEntry } from './FileEntry.js';
+
+export function FileBrowser(props) {
+	const [filepaths, setFilepaths] = useState({})
+	const [changedDir, setChangedDir] = useState('')
+	const [curChosenDir, setCurChosenDir] = useState('')
+	const [submittedDir, setSubmittedDir] = useState('')
+	const buttonRef = useRef(null)
+
+	useEffect(() => {
+		const xhr = new XMLHttpRequest();
+		xhr.open('GET', '/api/get_filesystem/')
+		xhr.onload = () => {
+			if (xhr.status === 200) {
+				setFilepaths(JSON.parse(xhr.responseText))
+			}
+		}
+		xhr.send()
+	}, [])
+	
+	// Refresh on dir change
+	useEffect(() => {
+		if (changedDir !== '') {
+			const xhr = new XMLHttpRequest();
+			xhr.open('GET', `/api/get_filesystem/${changedDir}`)
+			xhr.onload = () => {
+				if (xhr.status === 200) {
+					setFilepaths(JSON.parse(xhr.responseText))
+				}
+			}
+			xhr.send()
+			setChangedDir('')
+			setCurChosenDir('')
+		}
+	}, [changedDir])
+
+	// Enable submit button on chosen radio button
+	useEffect(() => {
+		if (buttonRef.current !== null){
+			if (curChosenDir !== '') {
+				buttonRef.current.disabled = false
+			} else {
+				buttonRef.current.disabled = true
+			}
+		}
+	}, [curChosenDir])
+	
+	if (JSON.stringify(filepaths) !== '{}') {
+		return html`
+			<div class="modal fade" id="${props.modalId}" tabindex="-1" role="dialog" aria-labelledby="${props.modalId}Title" aria-hidden="true">
+				<div class="modal-dialog" role="document">
+					<div class="modal-content">
+						<div class="modal-header text-light bg-primary">
+							<h5 class="modal-title" id="${props.modalId}Title">${props.browserTitle}</h5>
+							<button type="button" class="close" data-dismiss="modal" aria-label="Close">
+          						<span aria-hidden="true">X</span>
+        					</button>
+						</div>
+						<div class="modal-body text-light bg-dark">
+							<ul class="fileEntryList" >
+								${filepaths.file_list.map(file => html`
+									<${FileEntry} file=${file} key=${file} setChangedDir=${setChangedDir} setCurChosenDir=${setCurChosenDir}><//>
+								`)}
+							</ul>
+						</div>
+						<div class="modal-footer">
+							<button ref=${buttonRef} class="btn btn-primary" data-dismiss="modal" onClick=${() => props.handleSubmit(curChosenDir)} disabled>${props.submitBtnText}</button>
+						</div>
+					</div>
+				</div>
+			</div>
+		`
+	} else {
+		return html`
+			<div class="modal FileBrowserContainer" id="${props.modalId}" tabindex="-1" role="dialog" aria-labelledby="${props.modalId}Title" aria-hidden="true">
+				<div class="spinner-border" role="status" style="width: 10rem; height: 10rem;">
+					<span class="sr-only">Loading...</span>
+				</div>
+			</div>
+		`
+	}
+}

oceanproc/web/static/components/FileBrowserOpenBtn.js

@@ -0,0 +1,12 @@
+import { html } from 'htm/preact';
+import { render } from 'preact';
+import { useState, useEffect, useRef } from 'preact/hooks';
+
+export function FileBrowserOpenBtn(props) {
+	function handleClick() {
+						
+	}
+	return html`
+		<button onClick=${() => handleClick()} class='fileBrowserModalToggleBtn'>${props.buttonText}</button>
+	`
+}

oceanproc/web/static/components/FileEntry.js

@@ -0,0 +1,32 @@
+import { html } from 'htm/preact';
+import { render } from 'preact';
+import { useState, useEffect, useRef } from 'preact/hooks';
+import { DirIcon } from './DirIcon.js'
+import { FileIcon } from './FileIcon.js'
+
+export function FileEntry(props) {
+	function handleClick(path) {
+		props.setChangedDir(path)		
+	}
+
+	if (props.file.isdir){
+		return html`
+			<div class="fileEntryContainer">
+				<input type="radio" name="dirchoice" value=${props.file.realpath} onClick=${() => props.setCurChosenDir(props.file.realpath)}></input>
+				<div class="fileLinkContainer" onClick=${() => handleClick(props.file.pathfromroot)}>
+					<${DirIcon}><//>
+					<li key=${props.key}>${props.file.basename}</li>
+				</div>
+			</div>
+		`
+	} else {
+		return html`
+			<div class="fileEntryContainer">
+				<div class="fileNonlinkContainer">
+					<${FileIcon}><//>
+					<li key=${props.key}>${props.file.basename}</li>
+				</div>
+			</div>
+		`
+	}
+}

oceanproc/web/static/components/FileIcon.js

@@ -0,0 +1,11 @@
+import { html } from 'htm/preact';
+import { render } from 'preact';
+import { useState, useEffect, useRef } from 'preact/hooks';
+
+export function FileIcon() {
+	return html`
+	<svg style="margin-right:8px;" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke-width="1.5" stroke="currentColor" class="size-6" width="10px" height="10px">
+	  <path stroke-linecap="round" stroke-linejoin="round" d="M19.5 14.25v-2.625a3.375 3.375 0 0 0-3.375-3.375h-1.5A1.125 1.125 0 0 1 13.5 7.125v-1.5a3.375 3.375 0 0 0-3.375-3.375H8.25m2.25 0H5.625c-.621 0-1.125.504-1.125 1.125v17.25c0 .621.504 1.125 1.125 1.125h12.75c.621 0 1.125-.504 1.125-1.125V11.25a9 9 0 0 0-9-9Z" />
+	</svg>
+	`	
+}

oceanproc/web/static/components/OceanprocForm.js

@@ -0,0 +1,53 @@
+import { html } from 'htm/preact';
+import { render } from 'preact';
+import { useState, useEffect, useRef, useMemo } from 'preact/hooks';
+import { FileBrowser } from './FileBrowser.js'
+import { ArgparseFormEntry } from './ArgparseFormEntry.js'
+
+export function OceanprocForm(props) {
+	const [displayRestOfForm, setDisplayRestOfForm] = useState(false)
+	const [argparseArgObjects, setArgparseArgObjects] = useState(null)
+	const [bidsPath, setBidsPath] = useState("")
+	
+	useEffect(() => {
+		const xhr = new XMLHttpRequest();
+		xhr.open('GET', '/api/get_parser_args/')
+		xhr.onload = () => {
+			if (xhr.status === 200) {
+				setArgparseArgObjects(JSON.parse(xhr.responseText))
+			}
+		}
+		xhr.send()
+	}, [])
+	useEffect(() => {
+		if (bidsPath !== "") {
+			setDisplayRestOfForm(true)
+		} else {
+			setDisplayRestOfForm(false)
+		}
+	}, [bidsPath])
+
+	return html`
+		<div class="formContainer">
+			<button type="button" class="btn btn-primary" data-toggle="modal" data-target="#bidsDirForm">
+				Select your BIDS directory
+			</button>
+			<p>${bidsPath}</p>
+			<${FileBrowser} 
+			modalId="bidsDirForm" 
+			submitBtnText="Choose directory" 
+			browserTitle="Choose a BIDS directory (click on a directory name to go into it, check the radio button to select it)"
+			handleSubmit=${(curChosenDir) => setBidsPath(curChosenDir)}><//>
+			<form>
+				${displayRestOfForm && argparseArgObjects !== null && html`
+					${argparseArgObjects.map(obj => html`
+						<${ArgparseFormEntry} 
+						obj=${obj} 
+						formName="restOfForm"
+						ignoredOptNames=${["bids_path"]}><//>
+					`)}	
+				`}
+			</form>
+		</div>
+	`
+}