girder-jsonforms 2.1.1__tar.gz → 2.1.2__tar.gz

{girder_jsonforms-2.1.1/girder_jsonforms.egg-info → girder_jsonforms-2.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: girder-jsonforms
-Version: 2.1.1
+Version: 2.1.2
 Summary: Girder plugin adding forms based on JSON-editor
 License: BSD-3-Clause
 Classifier: Development Status :: 4 - Beta

{girder_jsonforms-2.1.1 → girder_jsonforms-2.1.2}/girder_jsonforms/lib/jq.py

@@ -1,3 +1,4 @@
+from collections.abc import Iterator
 from typing import Any
 
 
@@ -43,6 +44,73 @@ def get_value(json_data: dict, key: str) -> dict:
     return json_data
 
 
+class JqPathError(ValueError):
+    """A path that does not fit the shape of the data it was applied to."""
+
+
+def iter_values(json_data: Any, key: str) -> Iterator[tuple[str, Any]]:
+    """Resolve a path that may contain ``[]`` ("for each element").
+
+    Yields ``(path, value)`` pairs, where ``path`` is ``key`` with every ``[]``
+    replaced by the index it matched, in the same spelling ``find_key_paths``
+    emits (``a.[0].b``), so an emitted path can be fed straight back into
+    ``get_value``. A path with no ``[]`` yields at most one pair, which makes
+    this a generalization of ``get_value`` rather than a separate notion.
+
+    Nested iteration is supported: ``a.[].b.[].c`` iterates the outer array and
+    then the inner one for each outer element.
+
+    Missing data is skipped: an element that lacks the trailing key, or an
+    explicit index past the end of a list, yields nothing while its siblings
+    still yield, with their original indices intact. A path that disagrees with
+    the shape of the data -- ``[]`` or ``[3]`` applied to anything that is not a
+    list -- raises ``JqPathError`` instead, because no amount of data fixes it.
+
+    Zero matches is therefore not an error here, and a typo'd key is
+    indistinguishable from an empty array at this layer. Callers that care
+    should report how many of the elements they expected actually matched.
+    """
+    yield from _iter_values(json_data, key.split("."), "")
+
+
+def _join(prefix: str, segment: str) -> str:
+    return f"{prefix}.{segment}" if prefix else segment
+
+
+def _iter_values(
+    node: Any, segments: list[str], prefix: str
+) -> Iterator[tuple[str, Any]]:
+    if not segments:
+        yield prefix, node
+        return
+
+    head, rest = segments[0], segments[1:]
+
+    if head == "[]":
+        if not isinstance(node, list):
+            raise JqPathError(
+                f"{prefix or '<root>'} is a {type(node).__name__}, not a list, "
+                "so [] cannot iterate it"
+            )
+        for index, item in enumerate(node):
+            yield from _iter_values(item, rest, _join(prefix, f"[{index}]"))
+        return
+
+    if head.startswith("[") and head.endswith("]"):
+        if not isinstance(node, list):
+            raise JqPathError(
+                f"{prefix or '<root>'} is a {type(node).__name__}, not a list, "
+                f"so {head} cannot index it"
+            )
+        index = int(head[1:-1])
+        if index < len(node):
+            yield from _iter_values(node[index], rest, _join(prefix, head))
+        return
+
+    if isinstance(node, dict) and head in node:
+        yield from _iter_values(node[head], rest, _join(prefix, head))
+
+
 def set_value(json_data: dict, key: str, value: Any) -> None:
     for path in key.split(".")[:-1]:
         if path.startswith("["):

{girder_jsonforms-2.1.1 → girder_jsonforms-2.1.2}/girder_jsonforms/models/project.py

@@ -63,6 +63,28 @@ project_schema = {
                     "lastName": {"type": "string"},
                     "orcidId": {"type": "string"},
                     "email": {"type": "string", "format": "email"},
+                    # Day-to-day contact. Defaults to the PI in the UI but can be
+                    # moved to anyone, so it is its own flag rather than derived
+                    # from `role`.
+                    "isPointOfContact": {"type": "boolean"},
+                    # Whether this person is physically coming to AIMD-L; some
+                    # members only take part remotely.
+                    "onSite": {"type": "boolean"},
+                    # Career stage. Orthogonal to `role`, which is the access
+                    # level (see _role_to_access_level in lib/events.py).
+                    "status": {
+                        "type": "string",
+                        "enum": [
+                            "faculty",
+                            "staff",
+                            "postdoc",
+                            "grad",
+                            "undergrad",
+                            "other",
+                        ],
+                    },
+                    # Only set when it differs from the project's organization.
+                    "institution": {"type": "string"},
                 },
                 "required": ["email", "role"],
                 "additionalProperties": False,
@@ -93,8 +115,93 @@ project_schema = {
             "enum": ["integrated", "singleInstrument", "development"],
             "default": "integrated",
         },
-        "priority": {
-            "type": "number",
+        # Affiliation of the applicant. Unranked: the numbering of the `priority`
+        # list it replaces implied an ordering the lab never allocated on.
+        "accessCategory": {
+            "type": "string",
+            "enum": [
+                "jhu",
+                "external-academic",
+                "external-corporate",
+                "external-government",
+                "external-foreign",
+            ],
+        },
+        # Home institution/company. Asked of external applicants only.
+        "organization": {"type": "string"},
+        # How the data this project generates has to be handled -- it describes
+        # the material coming into the lab, not the proposal documents. Advisory:
+        # access still defaults to the project's own members (lib/events.py).
+        "dataClassification": {
+            "type": "string",
+            "enum": [
+                "open",
+                "confidential-proprietary",
+                "confidential-controlled",
+                "opt-out",
+            ],
+        },
+        "assistanceRequired": {"type": "boolean"},
+        # Free text on purpose: "3 days", "2 half-days", "~1 week".
+        "daysRequested": {"type": "string"},
+        # The single-instrument proposal, written inline instead of uploaded.
+        "experimentPlan": {"type": "string"},
+        "safety": {
+            "type": "object",
+            "properties": {
+                "sampleHazards": {
+                    "type": "array",
+                    "items": {
+                        "type": "string",
+                        "enum": [
+                            "none",
+                            "toxic",
+                            "flammable",
+                            "energetic",
+                            "biosafety",
+                            "radioactive",
+                            "other",
+                        ],
+                    },
+                    "default": [],
+                },
+                "otherHazards": {
+                    "type": "array",
+                    "items": {
+                        "type": "string",
+                        "enum": [
+                            "none",
+                            "laser",
+                            "high-temperature",
+                            "high-voltage",
+                            "user-equipment",
+                        ],
+                    },
+                    "default": [],
+                },
+                "description": {"type": "string"},
+            },
+            "additionalProperties": False,
+        },
+        "funding": {
+            "type": "object",
+            "properties": {
+                "grants": {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "agency": {"type": "string"},
+                            "grantNumber": {"type": "string"},
+                        },
+                        "additionalProperties": False,
+                    },
+                    "default": [],
+                },
+                # JHU internal budget/IO number.
+                "internalBudgetNumber": {"type": "string"},
+            },
+            "additionalProperties": False,
         },
         "status": {
             "type": "string",
@@ -181,20 +288,27 @@ class Project(AccessControlledModel):
             level=AccessType.READ,
             fields=(
                 "_id",
+                "accessCategory",
+                "assistanceRequired",
                 "created",
                 "creatorId",
+                "dataClassification",
+                "daysRequested",
                 "description",
+                "experimentPlan",
                 "files",
+                "funding",
                 "instruments",
                 "name",
                 "metadata",
                 "members",
                 "orcidResourceUrl",
-                "priority",
+                "organization",
                 "projectId",
                 "projectType",
                 "public",
                 "publicFlags",
+                "safety",
                 "samples",
                 "submissionFolderId",
                 "status",
@@ -231,10 +345,6 @@ class Project(AccessControlledModel):
             doc["instruments"] = []
         if "projectType" not in doc:
             doc["projectType"] = "integrated"
-        try:
-            doc["priority"] = int(doc.get("priority", 0))
-        except (ValueError, TypeError):
-            raise ValidationException("Priority must be an integer")
         try:
             self.validator(project_schema).validate(doc)
         except jsonschema.ValidationError as ve:

{girder_jsonforms-2.1.1 → girder_jsonforms-2.1.2}/girder_jsonforms/rest/aimdl.py

@@ -544,7 +544,7 @@ class BaseLabResource(Resource):
     @filtermodel(model=Item)
     @autoDescribeRoute(
         Description("Get a list of items with a specific data type.")
-        .param("dataType", "The data type to filter items by.", required=True)
+        .param("dataType", "The data type to filter items by.", required=False)
         .param(
             "baseParentId",
             "The ID of the parent collection to count items in.",
@@ -596,8 +596,9 @@ class BaseLabResource(Resource):
         base_parent = self._get_base_parent(baseParentType, baseParentId, user)
         q = {
             "meta.igsn": {"$exists": True},
-            "meta.data_type": dataType,
         }
+        if dataType:
+            q["meta.data_type"] = dataType
         filters = filters or {}
         try:
             filters = sanitize_query(filters)