nmcp-precomputed 3.0.7__tar.gz → 3.1.0__tar.gz

{nmcp_precomputed-3.0.7 → nmcp_precomputed-3.1.0}/.github/workflows/publish.yml

@@ -37,10 +37,8 @@ jobs:
         with:
           version: 3.x
           repo-token: ${{ secrets.GITHUB_TOKEN }}
-      - name: Set up Node.js
-        uses: actions/setup-node@v3
-        with:
-          node-version: "18.x"
+      - name: Install uv
+        uses: astral-sh/setup-uv@v6
       - name: Login to Github Packages
         uses: docker/login-action@v2
         with:

nmcp_precomputed-3.1.0/Dockerfile

@@ -0,0 +1,14 @@
+FROM python:3.10
+
+# Supplied by the Taskfile from pyproject.toml; selects the wheel `uv build` wrote for this version.
+ARG VERSION
+
+WORKDIR /app
+
+COPY --chmod=755 docker-entry.sh ./
+
+COPY dist/nmcp_precomputed-${VERSION}-py3-none-any.whl ./
+
+RUN pip install --no-cache-dir "./nmcp_precomputed-${VERSION}-py3-none-any.whl[numerics,api]"
+
+CMD ["./docker-entry.sh"]

{nmcp_precomputed-3.0.7 → nmcp_precomputed-3.1.0}/PKG-INFO

@@ -1,18 +1,22 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: nmcp-precomputed
-Version: 3.0.7
+Version: 3.1.0
 Summary: Neuron Morphology Community Portal Precomputed Toolbox
 License: MIT
 Requires-Python: <3.13,>=3.10
 Requires-Dist: gql[requests]
+Provides-Extra: api
+Requires-Dist: fastapi>=0.162.2; extra == 'api'
+Requires-Dist: uvicorn>=0.54.0; extra == 'api'
 Provides-Extra: numerics
 Requires-Dist: allensdk; extra == 'numerics'
 Requires-Dist: cloud-files; extra == 'numerics'
 Requires-Dist: cloud-volume; extra == 'numerics'
-Requires-Dist: numpy<1.24; extra == 'numerics'
+Requires-Dist: numpy<2,>=1.23.5; extra == 'numerics'
 Requires-Dist: pandas; extra == 'numerics'
 Provides-Extra: publish
 Requires-Dist: build; extra == 'publish'
 Requires-Dist: twine; extra == 'publish'
 Provides-Extra: test
+Requires-Dist: httpx>=0.28.1; extra == 'test'
 Requires-Dist: pytest==8.2.0; extra == 'test'

nmcp_precomputed-3.1.0/README.md

@@ -0,0 +1,150 @@
+# NMCP Precomputed
+The NMCP Precomputed service generates reconstruction skeletons in Neuroglancer's precomputed format.  It periodically
+polls the API service for reconstructions that are ready for new or updated skeletons.
+
+Given the current behavior or Neuroglancer layers and the NMCP viewer feature requirements, the service currently
+generated separate data sources for the full reconstruction, as well as axon-only and dendrite-only versions.
+
+The service uses the chunked API for acquiring reconstruction data and should be compatible with dense reconstruction
+sources.
+
+## Local Development
+A local S3-compatible service may be used during local development to avoid AWS or other cloud service storage charges.
+
+_Note that at this time, cloud-files only appears to support this option from Linux, WSL, or MacOS._
+
+One functional option is to run a local [MinIO](https://www.min.io/) Docker container.  The following steps describe the
+process (and assume the default configuration of port 9000 for MinIO).  For additional details see either the MinIO
+documentation, [cloud-files](https://github.com/seung-lab/cloud-files), and 
+[cloud-volume](https://github.com/seung-lab/cloud-volume).
+
+A preconfigured instance is defined in `docker-compose.yml` that can be started with the following script
+
+```bash
+docker compose -p nmcp up -d
+```
+
+Attach to the running container to configure the precomputed bucket.
+
+Find the container id
+```bash
+docker ps
+```
+
+Attach to the instance
+```bash
+docker exec -it <container-id> /bin/bash
+```
+
+Define an `mc` alias for the server, create the bucket, and allow public access for the Neuroglancer viewer.  The 
+following assumes the username/password defined in `docker-compose.yml`.  This is performed in the container after
+attaching above, not on the host (unless you choose to install the `mc` tools on your host machine).
+```bash
+mc alias set myminio http://localhost:9000 root password
+mc mb myminio/aind-neuron-morphology-community-portal-local/ngv01/
+mc anonymous set public myminio/aind-neuron-morphology-community-portal-local/ngv01
+```
+
+Exit the container instance.  On the host (in the Python environment created for this project w/cloud-files installed),
+create an alias for the server.
+
+```bash
+cloudfiles alias add minio s3://http://127.0.0.1:9000/
+```
+
+Add the username and password as a secrets file in `~/.cloudvolume/secrets/minio-secret.json` (assumes defaults used
+in the compose file).
+```json
+{
+	"AWS_ACCESS_KEY_ID": "root",
+	"AWS_SECRET_ACCESS_KEY": "password"
+}
+```
+
+Although the bucket is set for public access in this development example, adding the authentication when generating
+the precomputed data mimics the typical behavior in actual deployments.
+
+When running the precomputed worker, pass the alias as the precomputed output argument, _e.g._, `-o minio://aind-neuron-morphology-community-portal-local/ngv01`
+
+Here the current standard path is used as the base location (`ngv01`), however anything can used so long as it is also
+used in the `NMCP_PRECOMPUTED_OUTPUT` environment variable for `nmcp-client`.
+
+## On-Demand API
+In addition to polling, the service exposes an HTTP API that converts a posted portal-format reconstruction into a
+complete, self-contained precomputed dataset (one Neuroglancer layer holding a single skeleton) at a location chosen by
+the caller. It uses the same conversion as the worker, so the skeleton output is identical.
+
+The API runs in the same process as the polling worker. API requests run concurrently with worker generations and never
+wait for one to finish; they are serialized only with other API requests.
+
+### Startup
+`python -m nmcp` (and therefore `docker-entry.sh`) starts both. Before either runs, it:
+
+1. validates and normalizes the worker output location (`-o`, required);
+2. loads the Allen structure tree used for soma-location tags.
+
+If either step fails, the process exits so the container restarts it. After the first successful load, the tree is
+read from allensdk's `mouse_connectivity/` cache, so later restarts do not need network access.
+
+The worker output location is normalized at startup: protocol-only (`s3://`, `gs://`, `file://` or a configured
+cloud-files alias), with no trailing slash and no `precomputed://` prefix or `|precomputed:` suffix. The worker writes
+under the normalized location, and a warning is logged when the configured value differed from it. Set
+`NMCP_PRECOMPUTED_OUTPUT` in normalized form, because `nmcp-client` composes its own dataset paths (`<value>/full`, …)
+from the same value and must read the same datasets the worker writes.
+
+| Environment variable | Default | Purpose |
+|---|---|---|
+| `NMCP_PRECOMPUTED_API_HOST` | `0.0.0.0` | Interface the API listens on |
+| `NMCP_PRECOMPUTED_API_PORT` | `5000` | Port the API listens on |
+
+### Endpoints
+`GET /` returns `"NMCP Precomputed API"`.
+
+`POST /generateskeleton` takes the output location, an optional segment id (default `1`, range `1` to `2^64 - 1`) and
+the reconstruction in the portal export format:
+
+```json
+{
+  "location": "s3://bucket/path/to/dataset",
+  "segmentId": 1,
+  "reconstruction": {
+    "id": "…",
+    "neuron": {"label": "N004", "specimen": {"label": "648434", "genotype": "Dbh-Cre_KI"}},
+    "nodes": [{"index": 1, "structure": 1, "x": 0.0, "y": 0.0, "z": 0.0, "radius": 1.0, "parentIndex": -1, "atlasStructure": 202}]
+  }
+}
+```
+
+It returns once the dataset is written:
+
+```json
+{
+  "serviceVersion": "3.0.7",
+  "reconstructionId": "…",
+  "result": {"location": "s3://bucket/path/to/dataset", "segmentId": 1, "nodeCount": 9, "edgeCount": 8},
+  "errorKind": null, "errorDescription": null, "errorInfo": null
+}
+```
+
+Every request the service handles returns 200. On failure `result` is null and `errorKind` is one of:
+
+- `InvalidLocation`: the location cannot be parsed, has no explicit protocol, or names a format other than
+  precomputed.
+- `ProtectedLocation`: the location is the worker's output location or lies under it. Locations are compared after
+  resolving cloud-files aliases, trailing slashes, the precomputed prefix and suffix, and local symlinks.
+- `GenerationError`: writing the dataset failed; `errorInfo` holds the exception type and message.
+
+A body that fails validation (a missing field, a segment id of 0) gets FastAPI's standard 422 response.
+
+The dataset is written over whatever already exists at the location without clearing it first. Skeleton files from
+earlier calls with other segment ids remain, though the segment properties list only the latest segment.
+
+### Running Locally
+```bash
+uv sync --extra numerics --extra api --extra test
+uv run python -m nmcp -u <graphql-url> -a <key> -o <worker-output>
+```
+
+```bash
+curl -s -X POST localhost:5000/generateskeleton -H "Content-Type: application/json" -d @body.json
+```

{nmcp_precomputed-3.0.7 → nmcp_precomputed-3.1.0}/Taskfile.dist.yaml

@@ -5,7 +5,7 @@ vars:
   IMAGE: allenneuraldynamics/nmcp-precomputed-worker
   REPOIMAGE: "{{.REPOSITORY}}/{{.IMAGE}}"
   VERSION:
-    sh: jq -r .version version.json
+    sh: uv version --short
   MAJOR:
     sh: string={{.VERSION}} && arr=(${string//"."/ }) && echo ${arr[0]}
   MINOR:
@@ -18,9 +18,13 @@ vars:
   IMAGELATEST: "{{.REPOIMAGE}}:latest"
 
 tasks:
+  module:
+    cmds:
+      - uv build --wheel
   build:
     cmds:
-      - docker build --platform linux/amd64 --tag {{.IMAGEWITHVERSION}} .
+      - task: module
+      - docker build --platform linux/amd64 --build-arg VERSION={{.VERSION}} --tag {{.IMAGEWITHVERSION}} .
       - docker tag {{.IMAGEWITHVERSION}} {{.IMAGEWITHMINORVERSION}}
       - docker tag {{.IMAGEWITHMINORVERSION}} {{.IMAGEWITHREVERSION}}
       - docker tag {{.IMAGEWITHREVERSION}} {{.IMAGELATEST}}

{nmcp_precomputed-3.0.7 → nmcp_precomputed-3.1.0}/Test.Dockerfile

@@ -8,6 +8,6 @@ COPY pyproject.toml ./
 
 COPY src ./src
 
-RUN pip install --no-cache-dir .
+RUN pip install --no-cache-dir ".[numerics,api]"
 
 CMD ["./docker-entry.sh"]

{nmcp_precomputed-3.0.7 → nmcp_precomputed-3.1.0}/pyproject.toml

@@ -12,7 +12,7 @@ exclude = [
 
 [project]
 name = "nmcp-precomputed"
-version = "3.0.7"
+version = "3.1.0"
 description = "Neuron Morphology Community Portal Precomputed Toolbox"
 license = { text = "MIT" }
 requires-python = ">=3.10,<3.13"
@@ -22,7 +22,7 @@ dependencies = [
 
 [project.optional-dependencies]
 numerics = [
-    "numpy<1.24",
+    "numpy>=1.23.5,<2",
     "pandas",
     "allensdk",
     "cloud-volume",
@@ -30,13 +30,18 @@ numerics = [
 ]
 
 test = [
-    "pytest==8.2.0"
+    "httpx>=0.28.1",
+    "pytest==8.2.0",
 ]
 
 publish = [
     "build",
     "twine"
 ]
+api = [
+    "fastapi>=0.162.2",
+    "uvicorn>=0.54.0",
+]
 
 [tool.pytest.ini_options]
 addopts = ["-W ignore::DeprecationWarning"]

{nmcp_precomputed-3.0.7 → nmcp_precomputed-3.1.0}/src/nmcp/__init__.py

@@ -1,5 +1,6 @@
 from .export import ExportFormat, ReconstructionSpace
 from .data import RemoteDataClient, PrecomputedEntry
 from .precomputed import SegmentInfo, SegmentProperty, SegmentTagProperty, SomaSegmentTagProperty, SegmentPropertyValues
-from .precomputed import (ensure_bucket_folders, create_from_json_files, create_from_reconstruction, remove_skeleton,
+from .precomputed import (ensure_bucket_folders, create_from_json_files, create_from_reconstruction,
+                          create_standalone_from_reconstruction, default_cloudvolume_info, remove_skeleton,
                           list_skeletons)

{nmcp_precomputed-3.0.7 → nmcp_precomputed-3.1.0}/src/nmcp/__main__.py

@@ -1,13 +1,13 @@
 import argparse
 
-from .precomputed_worker import start
+from .service import run
 
 parser = argparse.ArgumentParser()
 
 parser.add_argument("-u", "--url", help="URL of the GraphQL service")
 parser.add_argument("-a", "--authkey", help="authorization header for GraphQL service")
-parser.add_argument("-o", "--output", help="the output cloud volume location")
+parser.add_argument("-o", "--output", required=True, help="the output cloud volume location")
 
 args = parser.parse_args()
 
-start(args.url, args.authkey, args.output)
+run(args.url, args.authkey, args.output)

nmcp_precomputed-3.1.0/src/nmcp/api/__init__.py

@@ -0,0 +1 @@
+from .app import create_app, serve

nmcp_precomputed-3.1.0/src/nmcp/api/app.py

@@ -0,0 +1,90 @@
+import importlib.metadata
+import logging
+import os
+import threading
+from typing import cast
+
+import uvicorn
+from fastapi import FastAPI
+
+from .models import ErrorKind, SkeletonRequest, SkeletonResponse, SkeletonResult
+from .output_location import parse_output_location
+from ..data.portal_reconstruction import PortalReconstruction
+from ..precomputed import create_standalone_from_reconstruction, default_cloudvolume_info
+
+logger = logging.getLogger(__name__)
+
+_SERVICE_NAME = "NMCP Precomputed API"
+
+_SERVICE_VERSION = importlib.metadata.version("nmcp-precomputed")
+
+
+def create_app(worker_output: str) -> FastAPI:
+    protected = parse_output_location(worker_output, require_protocol=False)
+
+    generation_lock = threading.Lock()
+
+    app = FastAPI(title=_SERVICE_NAME)
+
+    @app.get("/")
+    def read_root() -> str:
+        return _SERVICE_NAME
+
+    # A plain `def`, so FastAPI runs the blocking generation in its threadpool rather than on the event loop.
+    @app.post("/generateskeleton")
+    def generate_skeleton(request: SkeletonRequest) -> SkeletonResponse:
+        reconstruction_id = request.reconstruction.id
+
+        def response(**kwargs) -> SkeletonResponse:
+            return SkeletonResponse(service_version=_SERVICE_VERSION, reconstruction_id=reconstruction_id, **kwargs)
+
+        logger.info(f"received on-demand skeleton request for reconstruction {reconstruction_id} "
+                    f"({len(request.reconstruction.nodes)} nodes, segment {request.segment_id}) at "
+                    f"'{request.location}'")
+
+        try:
+            location = parse_output_location(request.location)
+        except ValueError as ex:
+            logger.warning(f"rejected on-demand skeleton for reconstruction {reconstruction_id}: invalid output "
+                           f"location '{request.location}': {ex}")
+            return response(error_kind=ErrorKind.INVALID_LOCATION,
+                            error_description=f"Invalid output location for reconstruction {reconstruction_id}",
+                            error_info=str(ex))
+
+        if location.is_at_or_under(protected):
+            logger.warning(f"rejected on-demand skeleton for reconstruction {reconstruction_id} at "
+                           f"{location.cloudpath}: at or under the worker output {protected.cloudpath}")
+            return response(error_kind=ErrorKind.PROTECTED_LOCATION,
+                            error_description=f"The output location for reconstruction {reconstruction_id} is at "
+                                              f"or under the worker's output location",
+                            error_info=location.cloudpath)
+
+        # Chosen here so an optional request argument can replace it without touching the generation code.
+        dataset_info = default_cloudvolume_info()
+
+        reconstruction = cast(PortalReconstruction, request.reconstruction.model_dump(by_alias=True))
+
+        try:
+            with generation_lock:
+                skeleton = create_standalone_from_reconstruction(reconstruction, location.cloudpath,
+                                                                 request.segment_id, cloud_files_info=dataset_info)
+        except Exception as ex:
+            logger.exception(f"failed to generate on-demand skeleton for reconstruction {reconstruction_id} at "
+                             f"{location.cloudpath}")
+            return response(error_kind=ErrorKind.GENERATION_ERROR,
+                            error_description=f"Error generating precomputed skeleton for reconstruction "
+                                              f"{reconstruction_id}",
+                            error_info=f"{type(ex).__name__}: {ex}")
+
+        logger.info(f"generated on-demand skeleton {request.segment_id} for reconstruction {reconstruction_id} at "
+                    f"{location.cloudpath}")
+
+        return response(result=SkeletonResult(location=location.cloudpath, segment_id=request.segment_id,
+                                              node_count=len(skeleton.vertices), edge_count=len(skeleton.edges)))
+
+    return app
+
+
+def serve(app: FastAPI) -> None:
+    uvicorn.run(app, host=os.environ.get("NMCP_PRECOMPUTED_API_HOST", "0.0.0.0"),
+                port=int(os.environ.get("NMCP_PRECOMPUTED_API_PORT", "5000")), access_log=False)

nmcp_precomputed-3.1.0/src/nmcp/api/models.py

@@ -0,0 +1,68 @@
+from enum import Enum
+
+from pydantic import AliasGenerator, BaseModel, ConfigDict, Field
+from pydantic.alias_generators import to_camel
+
+
+class _RequestModel(BaseModel):
+    model_config = ConfigDict(alias_generator=to_camel)
+
+
+class _ResponseModel(BaseModel):
+    model_config = ConfigDict(alias_generator=AliasGenerator(serialization_alias=to_camel))
+
+
+class PortalSpecimenInput(_RequestModel):
+    label: str
+    genotype: str | None = None
+
+
+class PortalNeuronInput(_RequestModel):
+    label: str
+    specimen: PortalSpecimenInput
+
+
+class PortalNodeInput(_RequestModel):
+    index: int
+    structure: int
+    x: float
+    y: float
+    z: float
+    radius: float
+    parent_index: int
+    atlas_structure: int | None = None
+
+
+class ReconstructionInput(_RequestModel):
+    id: str
+    neuron: PortalNeuronInput
+    nodes: list[PortalNodeInput]
+
+
+class SkeletonRequest(_RequestModel):
+    location: str
+    # 0 is Neuroglancer's background segment, and segment ids are uint64.
+    segment_id: int = Field(default=1, ge=1, le=2 ** 64 - 1)
+    reconstruction: ReconstructionInput
+
+
+class ErrorKind(str, Enum):
+    INVALID_LOCATION = "InvalidLocation"
+    PROTECTED_LOCATION = "ProtectedLocation"
+    GENERATION_ERROR = "GenerationError"
+
+
+class SkeletonResult(_ResponseModel):
+    location: str
+    segment_id: int
+    node_count: int
+    edge_count: int
+
+
+class SkeletonResponse(_ResponseModel):
+    service_version: str
+    reconstruction_id: str
+    result: SkeletonResult | None = None
+    error_kind: ErrorKind | None = None
+    error_description: str | None = None
+    error_info: str | None = None

nmcp_precomputed-3.1.0/src/nmcp/api/output_location.py

@@ -0,0 +1,80 @@
+import os
+from dataclasses import dataclass
+
+from cloudfiles import paths
+
+_PRECOMPUTED_PREFIX = "precomputed://"
+
+
+@dataclass(frozen=True)
+class OutputLocation:
+    cloudpath: str
+    """Protocol-only location to write to: no `precomputed://` prefix or `|precomputed:` suffix, no trailing slash."""
+    protocol: str
+    host: str | None
+    bucket: str | None
+    path: str
+    """Comparison path: no trailing slash, and symlinks resolved for `file` locations."""
+
+    def is_at_or_under(self, other: "OutputLocation") -> bool:
+        if (self.protocol, self.host, self.bucket) != (other.protocol, other.host, other.bucket):
+            return False
+
+        if self.protocol == "file":
+            # Root-aware where a string-prefix test is not: a protected "/" covers every local path.
+            return os.path.commonpath([self.path, other.path]) == other.path
+
+        return other.path == "" or self.path == other.path or self.path.startswith(f"{other.path}/")
+
+
+def parse_output_location(location: str, require_protocol: bool = True) -> OutputLocation:
+    """
+    Parse a cloud-files location the way CloudFiles itself resolves it, so that comparisons see the destination that
+    will actually be written to rather than the caller's spelling. Raises `ValueError` for anything unusable.
+    """
+    stripped = _remove_precomputed_prefix(location.strip())
+
+    if len(stripped) == 0:
+        raise ValueError("the output location is empty")
+
+    try:
+        fmt, protocol, _, _, _ = paths.extract_format_protocol(stripped, allow_defaults=False)
+        normalized = paths.normalize(stripped)
+        extracted = paths.extract(normalized)
+    except Exception as ex:
+        raise ValueError(f"unsupported location '{location}': {ex}") from ex
+
+    if fmt not in (None, "precomputed"):
+        raise ValueError(f"unsupported format '{fmt}' in location '{location}'; only precomputed is supported")
+
+    # cloud-files treats an unknown or mis-cased scheme, or a bare path, as a path relative to the working directory.
+    if require_protocol and protocol is None:
+        raise ValueError(f"the location '{location}' has no recognized protocol (e.g. s3://, gs://, file://)")
+
+    if extracted.protocol == "file":
+        comparison_path = os.path.realpath(extracted.path)
+    else:
+        comparison_path = extracted.path.rstrip("/")
+
+    return OutputLocation(_to_cloudpath(normalized), extracted.protocol, extracted.host, extracted.bucket,
+                          comparison_path)
+
+
+def _remove_precomputed_prefix(location: str) -> str:
+    if location.startswith(_PRECOMPUTED_PREFIX):
+        return location[len(_PRECOMPUTED_PREFIX):]
+
+    return location
+
+
+def _to_cloudpath(normalized: str) -> str:
+    # `normalize` turns the `…|precomputed:` tail spelling into a `precomputed://` prefix, and the generation code
+    # adds its own, so it is removed here as well as from the raw input.
+    scheme, separator, rest = _remove_precomputed_prefix(normalized).partition("://")
+
+    trimmed = rest.rstrip("/")
+
+    if len(trimmed) == 0 and rest.startswith("/"):
+        trimmed = "/"
+
+    return f"{scheme}{separator}{trimmed}"

{nmcp_precomputed-3.0.7 → nmcp_precomputed-3.1.0}/src/nmcp/data/remote_data_client.py

@@ -1,6 +1,7 @@
 import logging
 from datetime import datetime
 from enum import IntEnum
+from urllib.parse import urlparse
 
 from typing_extensions import List
 
@@ -23,8 +24,31 @@ class PrecomputedStatus(IntEnum):
     FailedToGenerate = 400
 
 
+class _GraphQLRetryFilter(logging.Filter):
+    """
+    Drops urllib3's per-attempt "Retrying" warnings for GraphQL requests. The worker already logs one warning per
+    outage with the final reason, and every poll during an outage would otherwise add one line per retry. Requests to
+    other paths, such as cloud-files uploads, keep theirs.
+    """
+
+    def __init__(self, path: str):
+        super().__init__()
+        self._path = path
+
+    def filter(self, record: logging.LogRecord) -> bool:
+        # urllib3 logs `"Retrying (%r) after connection broken by '%r': %s", retries, err, url`, where url is the
+        # request path.
+        is_retry = isinstance(record.msg, str) and record.msg.startswith("Retrying")
+
+        return not (is_retry and isinstance(record.args, tuple) and len(record.args) > 0 and
+                    record.args[-1] == self._path)
+
+
 class RemoteDataClient:
     def __init__(self, url: str, auth_key: str):
+        # requests sends "/" for a URL with no path.
+        logging.getLogger("urllib3.connectionpool").addFilter(_GraphQLRetryFilter(urlparse(url).path or "/"))
+
         transport = RequestsHTTPTransport(
             url=url,
             verify=True,

{nmcp_precomputed-3.0.7 → nmcp_precomputed-3.1.0}/src/nmcp/precomputed/__init__.py

@@ -1,6 +1,7 @@
 from .segment_property import SegmentProperty
-from .segment_tag_property import SegmentTagProperty, SomaSegmentTagProperty
+from .segment_tag_property import SegmentTagProperty, SomaSegmentTagProperty, load_structure_tree
 from .segment_info import SegmentInfo, SegmentPropertyValues
 from .neuron_structure import NeuronStructure
 from .nmcp_precomputed import (ensure_bucket_folders, create_from_json_files, create_from_reconstruction,
-                               remove_skeleton, list_skeletons)
+                               create_standalone_from_reconstruction, default_cloudvolume_info, remove_skeleton,
+                               list_skeletons)