diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 0000000..8c84881 --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,25 @@ +# Changelog + +Observes [Semantic Versioning](https://semver.org/spec/v2.0.0.html) standard and +[Keep a Changelog](https://keepachangelog.com/en/1.0.0/) convention. + + +## 0.2.0 - 2022-07-11 ++ Update - Docker and Compose files ++ Update - Requirements for latest releases of Elements ++ Update - Workflow pipeline, ingestion, and populate scripts ++ Update - Pytests ++ Add - Code of conduct + +## 0.1.0 - 2022-04-30 ++ Add - Analysis schema and Jupyter notebook for event-aligned calcium activity ++ Add - Data exploration Jupyter notebook ++ Add - Docker and Compose files ++ Update - Pytests ++ Update - README + +## 0.1.0a2 - 2021-10-18 ++ Update - Change version to reflect release phase + +## 0.1.1 - 2021-04-01 ++ Add - Version diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md new file mode 100644 index 0000000..684cf81 --- /dev/null +++ b/CODE_OF_CONDUCT.md @@ -0,0 +1,133 @@ + +# Contributor Covenant Code of Conduct + +## Our Pledge + +We as members, contributors, and leaders pledge to make participation in our +community a harassment-free experience for everyone, regardless of age, body +size, visible or invisible disability, ethnicity, sex characteristics, gender +identity and expression, level of experience, education, socio-economic status, +nationality, personal appearance, race, caste, color, religion, or sexual +identity and orientation. + +We pledge to act and interact in ways that contribute to an open, welcoming, +diverse, inclusive, and healthy community. + +## Our Standards + +Examples of behavior that contributes to a positive environment for our +community include: + +* Demonstrating empathy and kindness toward other people +* Being respectful of differing opinions, viewpoints, and experiences +* Giving and gracefully accepting constructive feedback +* Accepting responsibility and apologizing to those affected by our mistakes, + and learning from the experience +* Focusing on what is best not just for us as individuals, but for the overall + community + +Examples of unacceptable behavior include: + +* The use of sexualized language or imagery, and sexual attention or advances of + any kind +* Trolling, insulting or derogatory comments, and personal or political attacks +* Public or private harassment +* Publishing others' private information, such as a physical or email address, + without their explicit permission +* Other conduct which could reasonably be considered inappropriate in a + professional setting + +## Enforcement Responsibilities + +Community leaders are responsible for clarifying and enforcing our standards of +acceptable behavior and will take appropriate and fair corrective action in +response to any behavior that they deem inappropriate, threatening, offensive, +or harmful. + +Community leaders have the right and responsibility to remove, edit, or reject +comments, commits, code, wiki edits, issues, and other contributions that are +not aligned to this Code of Conduct, and will communicate reasons for moderation +decisions when appropriate. + +## Scope + +This Code of Conduct applies within all community spaces, and also applies when +an individual is officially representing the community in public spaces. +Examples of representing our community include using an official e-mail address, +posting via an official social media account, or acting as an appointed +representative at an online or offline event. + +## Enforcement + +Instances of abusive, harassing, or otherwise unacceptable behavior may be +reported to the community leaders responsible for enforcement at +[Support@DataJoint.com](mailto:support@datajoint.com). +All complaints will be reviewed and investigated promptly and fairly. + +All community leaders are obligated to respect the privacy and security of the +reporter of any incident. + +## Enforcement Guidelines + +Community leaders will follow these Community Impact Guidelines in determining +the consequences for any action they deem in violation of this Code of Conduct: + +### 1. Correction + +**Community Impact**: Use of inappropriate language or other behavior deemed +unprofessional or unwelcome in the community. + +**Consequence**: A private, written warning from community leaders, providing +clarity around the nature of the violation and an explanation of why the +behavior was inappropriate. A public apology may be requested. + +### 2. Warning + +**Community Impact**: A violation through a single incident or series of +actions. + +**Consequence**: A warning with consequences for continued behavior. No +interaction with the people involved, including unsolicited interaction with +those enforcing the Code of Conduct, for a specified period of time. This +includes avoiding interactions in community spaces as well as external channels +like social media. Violating these terms may lead to a temporary or permanent +ban. + +### 3. Temporary Ban + +**Community Impact**: A serious violation of community standards, including +sustained inappropriate behavior. + +**Consequence**: A temporary ban from any sort of interaction or public +communication with the community for a specified period of time. No public or +private interaction with the people involved, including unsolicited interaction +with those enforcing the Code of Conduct, is allowed during this period. +Violating these terms may lead to a permanent ban. + +### 4. Permanent Ban + +**Community Impact**: Demonstrating a pattern of violation of community +standards, including sustained inappropriate behavior, harassment of an +individual, or aggression toward or disparagement of classes of individuals. + +**Consequence**: A permanent ban from any sort of public interaction within the +community. + +## Attribution + +This Code of Conduct is adapted from the [Contributor Covenant][homepage], +version 2.1, available at +[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1]. + +Community Impact Guidelines were inspired by +[Mozilla's code of conduct enforcement ladder][Mozilla CoC]. + +For answers to common questions about this code of conduct, see the FAQ at +[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at +[https://www.contributor-covenant.org/translations][translations]. + +[homepage]: https://www.contributor-covenant.org +[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html +[Mozilla CoC]: https://github.com/mozilla/diversity +[FAQ]: https://www.contributor-covenant.org/faq +[translations]: https://www.contributor-covenant.org/translations diff --git a/README.md b/README.md index 773e819..a9b26a0 100644 --- a/README.md +++ b/README.md @@ -19,9 +19,13 @@ convention, and directory lookup methods (see [workflow_miniscope/ingest.py](workflow_miniscope/ingest.py)) 3. Processing results. -See the [Element Miniscope documentation](https://elements.datajoint.org/description/miniscope/) for the background information and development timeline. +See the +[Element Miniscope documentation](https://elements.datajoint.org/description/miniscope/) + for the background information and development timeline. -For more information on the DataJoint Elements project, please visit https://elements.datajoint.org. This work is supported by the National Institutes of Health. +For more information on the DataJoint Elements project, please visit +https://elements.datajoint.org. This work is supported by the National Institutes of +Health. ## Workflow architecture @@ -41,21 +45,35 @@ DataJoint Elements ([element-lab](https://github.com/datajoint/element-lab), ## Interacting with the DataJoint workflow ++ Our [YouTube tutorial](https://www.youtube.com/watch?v=nWUcPFZOSVw) walks through all + the key details of this workflow. + + Please refer to the following workflow-specific [Jupyter notebooks](/notebooks) for an in-depth explanation of how to run the workflow ([03-process.ipynb](notebooks/03-process.ipynb)) and explore the data ([05-explore.ipynb](notebooks/05-explore.ipynb)). + ## Citation -+ If your work uses DataJoint and DataJoint Elements, please cite the respective Research Resource Identifiers (RRIDs) and manuscripts. ++ If your work uses DataJoint and DataJoint Elements, please cite the respective + Research Resource Identifiers (RRIDs) and manuscripts. + DataJoint for Python or MATLAB - + Yatsenko D, Reimer J, Ecker AS, Walker EY, Sinz F, Berens P, Hoenselaar A, Cotton RJ, Siapas AS, Tolias AS. DataJoint: managing big scientific data using MATLAB or Python. bioRxiv. 2015 Jan 1:031658. doi: https://doi.org/10.1101/031658 + + Yatsenko D, Reimer J, Ecker AS, Walker EY, Sinz F, Berens P, Hoenselaar A, Cotton + RJ, Siapas AS, Tolias AS. DataJoint: managing big scientific data using MATLAB or + Python. bioRxiv. 2015 Jan 1:031658. doi: https://doi.org/10.1101/031658 - + DataJoint ([RRID:SCR_014543](https://scicrunch.org/resolver/SCR_014543)) - DataJoint for `` (version + ``) + DataJoint Elements - + Yatsenko D, Nguyen T, Shen S, Gunalan K, Turner CA, Guzman R, Sasaki M, Sitonic D, Reimer J, Walker EY, Tolias AS. DataJoint Elements: Data Workflows for Neurophysiology. bioRxiv. 2021 Jan 1. doi: https://doi.org/10.1101/2021.03.30.437358 - - + DataJoint Elements ([RRID:SCR_021894](https://scicrunch.org/resolver/SCR_021894)) - Element Miniscope (version ``) \ No newline at end of file + + Yatsenko D, Nguyen T, Shen S, Gunalan K, Turner CA, Guzman R, Sasaki M, Sitonic D, + Reimer J, Walker EY, Tolias AS. DataJoint Elements: Data Workflows for + Neurophysiology. bioRxiv. 2021 Jan 1. doi: + https://doi.org/10.1101/2021.03.30.437358 + + + DataJoint Elements ( + [RRID:SCR_021894](https://scicrunch.org/resolver/SCR_021894)) - Element Miniscope + (version ``) diff --git a/docker/Dockerfile.dev b/docker/Dockerfile.dev index 17cef9f..cc72d00 100644 --- a/docker/Dockerfile.dev +++ b/docker/Dockerfile.dev @@ -16,16 +16,18 @@ RUN python caimanmanager.py install --inplace WORKDIR /main RUN mkdir /main/element-lab \ - /main/element-animal \ - /main/element-session \ - /main/element-interface \ - /main/element-miniscope \ - /main/workflow-miniscope + /main/element-animal \ + /main/element-session \ + /main/element-event \ + /main/element-interface \ + /main/element-miniscope \ + /main/workflow-miniscope # Copy user's local fork of elements and workflow COPY --chown=anaconda:anaconda ./element-lab /main/element-lab COPY --chown=anaconda:anaconda ./element-animal /main/element-animal COPY --chown=anaconda:anaconda ./element-session /main/element-session +COPY --chown=anaconda:anaconda ./element-event /main/element-event COPY --chown=anaconda:anaconda ./element-interface /main/element-interface COPY --chown=anaconda:anaconda ./element-miniscope /main/element-miniscope COPY --chown=anaconda:anaconda ./workflow-miniscope /main/workflow-miniscope @@ -34,6 +36,7 @@ COPY --chown=anaconda:anaconda ./workflow-miniscope /main/workflow-miniscope RUN pip install -e /main/element-lab RUN pip install -e /main/element-animal RUN pip install -e /main/element-session +RUN pip install -e /main/element-event RUN pip install -e /main/element-interface RUN pip install -e /main/element-miniscope RUN pip install -e /main/workflow-miniscope @@ -41,4 +44,4 @@ RUN pip install -r /main/workflow-miniscope/requirements_test.txt WORKDIR /main/workflow-miniscope -ENTRYPOINT ["tail", "-f", "/dev/null"] \ No newline at end of file +ENTRYPOINT ["tail", "-f", "/dev/null"] diff --git a/docker/Dockerfile.test b/docker/Dockerfile.test index 6d04352..aa6c9c4 100644 --- a/docker/Dockerfile.test +++ b/docker/Dockerfile.test @@ -1,58 +1,50 @@ FROM datajoint/djbase:py3.9-debian-8eb1715 +ARG GITHUB_USERNAME=datajoint USER anaconda:anaconda -COPY ./workflow-miniscope/docker/apt_requirements.txt /tmp/ +COPY ./docker/apt_requirements.txt /tmp/ RUN /entrypoint.sh echo "Installed dependencies." # Install CaImAn -RUN git clone --branch master https://github.com/kabilar/CaImAn +WORKDIR /main +RUN git clone --branch master https://github.com/kabilar/CaImAn WORKDIR /main/CaImAn RUN conda install -n base -c conda-forge -y mamba -RUN /bin/bash -c 'mamba env update --n base --file environment.yml' +RUN /bin/bash -c 'mamba env update --n base --file environment-minimal.yml' RUN pip install . RUN python caimanmanager.py install --inplace -WORKDIR /main - -# Option 1 - Install DataJoint's remote fork of the workflow and elements -# RUN git clone https://github.com/datajoint/workflow-miniscope.git /main/ - -# Option 2 - Install user's remote fork of element and workflow -# or an unreleased version of the element -# RUN pip install git+https://github.com//element-lab.git -# RUN pip install git+https://github.com//element-animal.git -# RUN pip install git+https://github.com//element-session.git -# RUN pip install "element-interface@git+https://github.com//element-interface" -# RUN pip install git+https://github.com//element-miniscope.git -# RUN git clone https://github.com//workflow-miniscope.git /main/workflow-miniscope - -# Option 3 - Install user's local fork of element and workflow -RUN mkdir /main/element-lab \ - /main/element-animal \ - /main/element-session \ - /main/element-interface \ - /main/element-miniscope \ - /main/workflow-miniscope - -COPY --chown=anaconda:anaconda ./element-lab /main/element-lab -COPY --chown=anaconda:anaconda ./element-animal /main/element-animal -COPY --chown=anaconda:anaconda ./element-session /main/element-session -COPY --chown=anaconda:anaconda ./element-interface /main/element-interface -COPY --chown=anaconda:anaconda ./element-miniscope /main/element-miniscope -COPY --chown=anaconda:anaconda ./workflow-miniscope /main/workflow-miniscope - -RUN pip install -e /main/element-lab -RUN pip install -e /main/element-animal -RUN pip install -e /main/element-session -RUN pip install -e /main/element-interface -RUN pip install -e /main/element-miniscope -RUN rm -f /main/workflow-miniscope/dj_local_conf.json - -# Install the workflow -RUN pip install /main/workflow-miniscope -RUN pip install -r /main/workflow-miniscope/requirements_test.txt - -RUN pip uninstall datajoint -RUN pip install git+ WORKDIR /main/workflow-miniscope + +# 1. Install Elements from github user +RUN pip install --no-deps "element-interface@git+https://github.com/${GITHUB_USERNAME}/element-interface" +RUN pip install --no-deps "djarchive-client@git+https://github.com/${GITHUB_USERNAME}/djarchive-client" +RUN pip install git+https://github.com/${GITHUB_USERNAME}/element-lab.git +RUN pip install git+https://github.com/${GITHUB_USERNAME}/element-animal.git +RUN pip install git+https://github.com/${GITHUB_USERNAME}/element-session.git +RUN pip install git+https://github.com/${GITHUB_USERNAME}/element-event.git +RUN pip install git+https://github.com/${GITHUB_USERNAME}/element-miniscope.git +# RUN pip install git+https://github.com/${GITHUB_USERNAME}/workflow-miniscope.git +# end 1 + +# 2. Install local fork of element and workflow +# COPY --chown=anaconda:anaconda ../element-lab /main/ +# COPY --chown=anaconda:anaconda ../element-animal /main/ +# COPY --chown=anaconda:anaconda ../element-session /main/ +# COPY --chown=anaconda:anaconda ../element-event /main/ +# COPY --chown=anaconda:anaconda ../element-interface /main/ +# COPY --chown=anaconda:anaconda ../element-miniscope /main/ +COPY --chown=anaconda:anaconda . ./ +# RUN pip install -e /main/element-lab +# RUN pip install -e /main/element-animal +# RUN pip install -e /main/element-session +# RUN pip install -e /main/element-event +# RUN pip install -e /main/element-interface +# RUN pip install -e /main/element-miniscope +RUN pip install -e . +# end 2 + +# Permission denied on rm +RUN mv ./dj_local_conf.json ./dj_local_conf-Unused.json +RUN pip install -r ./requirements_test.txt diff --git a/docker/apt_requirements.txt b/docker/apt_requirements.txt index 3984b23..3766711 100644 --- a/docker/apt_requirements.txt +++ b/docker/apt_requirements.txt @@ -5,4 +5,4 @@ ffmpeg libsm6 libxext6 libhdf5-dev -pkg-config \ No newline at end of file +pkg-config diff --git a/docker/docker-compose-dev.yaml b/docker/docker-compose-dev.yaml index 1fb5cde..8df98e4 100644 --- a/docker/docker-compose-dev.yaml +++ b/docker/docker-compose-dev.yaml @@ -35,4 +35,4 @@ services: db: condition: service_healthy networks: - main: \ No newline at end of file + main: diff --git a/docker/docker-compose-test.yaml b/docker/docker-compose-test.yaml index 847e1b9..90e9bcc 100644 --- a/docker/docker-compose-test.yaml +++ b/docker/docker-compose-test.yaml @@ -1,22 +1,27 @@ -# docker-compose -f ./docker/docker-compose-test.yaml up --build -# docker-compose -f ./docker/docker-compose-test.yaml down +# docker-compose -f ./docker/docker-compose-test.yaml up --build --force-recreate --detached +# docker-compose -f ./docker/docker-compose-test.yaml down --volumes version: "2.4" -x-net: &net - networks: - - main + services: db: - <<: *net + networks: + miniscope: image: datajoint/mysql:5.7 - container_name: workflow-miniscope-test-db environment: - - MYSQL_ROOT_PASSWORD=simple + MYSQL_ROOT_PASSWORD: simple + container_name: workflow-miniscope-test-db + volumes: + - mysql-miniscope:/var/lib/mysql + workflow: - <<: *net + networks: + miniscope: build: - context: ../../ - dockerfile: ./workflow-miniscope/docker/Dockerfile.test + context: ../. + dockerfile: ./docker/Dockerfile.test + args: + - GITHUB_USERNAME=datajoint env_file: .env image: workflow-miniscope-test:0.1.0 container_name: workflow-miniscope-test @@ -24,7 +29,7 @@ services: - DJ_HOST=db - DJ_USER=root - DJ_PASS=simple - - MINISCOPE_ROOT_DATA_DIR=/main/test_data + - MINISCOPE_ROOT_DATA_DIR=/main/test_data/ - DATABASE_PREFIX=test_ command: - bash @@ -35,15 +40,29 @@ services: tail -f /dev/null volumes: - ${TEST_DATA_DIR}:/main/test_data - - ./apt_requirements.txt:/tmp/apt_requirements.txt - - ../../element-lab:/main/element-lab - - ../../element-animal:/main/element-animal - - ../../element-session:/main/element-session - - ../../element-interface:/main/element-interface - - ../../element-miniscope:/main/element-miniscope + # - ./apt_requirements.txt:/tmp/apt_requirements.txt + # - ../element-lab:/main/element-lab + # - ../element-animal:/main/element-animal + # - ../element-session:/main/element-session + # - ../element-event:/main/element-event + # - ../element-interface:/main/element-interface + # - ../element-miniscope:/main/element-miniscope - ..:/main/workflow-miniscope depends_on: db: - condition: service_healthy + condition: service_started + + adminer: + networks: + miniscope: + image: adminer + restart: always + ports: + - 8082:8080 + networks: - main: \ No newline at end of file + miniscope: + name: workflow-miniscope-network + +volumes: + mysql-miniscope: diff --git a/notebooks/00-data-download-optional.ipynb b/notebooks/00-data-download-optional.ipynb index e473653..9363581 100644 --- a/notebooks/00-data-download-optional.ipynb +++ b/notebooks/00-data-download-optional.ipynb @@ -146,9 +146,9 @@ "formats": "ipynb,py_scripts//py" }, "kernelspec": { - "display_name": "venv-nwb", + "display_name": "Python 3.8.11 ('ele')", "language": "python", - "name": "venv-nwb" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -161,6 +161,11 @@ "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.8.11" + }, + "vscode": { + "interpreter": { + "hash": "61456c693db5d9aa6731701ec9a9b08ab88a172bee0780139a3679beb166da16" + } } }, "nbformat": 4, diff --git a/notebooks/01-configure.ipynb b/notebooks/01-configure.ipynb index fb2b9e8..6e7e990 100644 --- a/notebooks/01-configure.ipynb +++ b/notebooks/01-configure.ipynb @@ -201,8 +201,9 @@ "main_language": "python" }, "kernelspec": { - "display_name": "Python 3.7.9 64-bit ('workflow-calcium-imaging': conda)", - "name": "python379jvsc74a57bd01a512f474e195e32ad84236879d3bb44800a92b431919ef0b10d543f5012a23c" + "display_name": "Python 3.8.11 ('ele')", + "language": "python", + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -214,7 +215,12 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.9" + "version": "3.8.11" + }, + "vscode": { + "interpreter": { + "hash": "61456c693db5d9aa6731701ec9a9b08ab88a172bee0780139a3679beb166da16" + } } }, "nbformat": 4, diff --git a/notebooks/02-workflow-structure-optional.ipynb b/notebooks/02-workflow-structure-optional.ipynb index 36a195e..0c5b74d 100644 --- a/notebooks/02-workflow-structure-optional.ipynb +++ b/notebooks/02-workflow-structure-optional.ipynb @@ -24,7 +24,7 @@ "outputs": [], "source": [ "import os\n", - "if os.path.basename(os.getcwd())=='notebooks': os.chdir('..')" + "os.chdir('..')" ] }, { @@ -47,14 +47,11 @@ ] }, { - "cell_type": "code", - "execution_count": null, - "id": "693929a9", - "metadata": { - "title": "Each module contains a schema object that enables interaction with the schema in the database." - }, - "outputs": [], - "source": [] + "cell_type": "markdown", + "metadata": {}, + "source": [ + "+ Each module contains a schema object that enables interaction with the schema in the database." + ] }, { "cell_type": "code", @@ -68,14 +65,11 @@ ] }, { - "cell_type": "code", - "execution_count": null, - "id": "d0ee126a", - "metadata": { - "title": "The table classes in the module corresponds to a table in the schema in the database." - }, - "outputs": [], - "source": [] + "cell_type": "markdown", + "metadata": {}, + "source": [ + "+ The table classes in the module corresponds to a table in the schema in the database." + ] }, { "cell_type": "code", @@ -96,9 +90,9 @@ "title": "The first time importing the modules, empty schemas and tables will be created in the database." }, "source": [ - "# + By importing the modules for the first time, the schemas and tables will be created inside the database.\n", + "+ By importing the modules for the first time, the schemas and tables will be created inside the database.\n", "\n", - "# + Once created, importing modules will not create schemas and tables again, but the existing schemas/tables can be accessed and manipulated by the modules." + "+ Once created, importing modules will not create schemas and tables again, but the existing schemas/tables can be accessed and manipulated by the modules." ] }, { @@ -110,7 +104,7 @@ "source": [ "## DataJoint tools to explore schemas and tables\n", "\n", - "# + `dj.list_schemas()`: list all schemas a user has access to in the current database" + "+ `dj.list_schemas()`: list all schemas a user has access to in the current database" ] }, { @@ -125,14 +119,11 @@ ] }, { - "cell_type": "code", - "execution_count": null, - "id": "687dbcb3", - "metadata": { - "title": "`dj.Diagram()`: plot tables and dependencies in a schema." - }, - "outputs": [], - "source": [] + "cell_type": "markdown", + "metadata": {}, + "source": [ + "+ `dj.Diagram()`: plot tables and dependencies in a schema. " + ] }, { "cell_type": "code", @@ -214,7 +205,7 @@ "title": "`heading`:" }, "source": [ - "# + `describe()`: show table definition with foreign key references." + "+ `describe()`: show table definition with foreign key references." ] }, { @@ -227,14 +218,11 @@ ] }, { - "cell_type": "code", - "execution_count": null, - "id": "08837864", - "metadata": { - "title": "`heading`: show attribute definitions regardless of foreign key references" - }, - "outputs": [], - "source": [] + "cell_type": "markdown", + "metadata": {}, + "source": [ + "+ `heading`: show attribute definitions regardless of foreign key references" + ] }, { "cell_type": "code", @@ -255,7 +243,7 @@ "source": [ "# DataJoint Elements installed in `workflow-miniscope`\n", "\n", - "# + [`lab`](https://github.com/datajoint/element-lab): lab management related information, such as Lab, User, Project, Protocol, Source." + "+ [`lab`](https://github.com/datajoint/element-lab): lab management related information, such as Lab, User, Project, Protocol, Source." ] }, { @@ -267,15 +255,19 @@ "dj.Diagram(lab)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "+ [`subject`](https://github.com/datajoint/element-animal): general animal information, such as User, Genetic background." + ] + }, { "cell_type": "code", "execution_count": null, - "metadata": { - "title": "[`subject`](https://github.com/datajoint/element-animal): general animal information, such as User, Genetic background." - }, + "metadata": {}, "outputs": [], "source": [ - "\n", "dj.Diagram(subject)" ] }, @@ -290,15 +282,19 @@ "subject.Subject.describe();" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "+ [`session`](https://github.com/datajoint/element-session): General information of experimental sessions." + ] + }, { "cell_type": "code", "execution_count": null, - "metadata": { - "title": "[`session`](https://github.com/datajoint/element-session): General information of experimental sessions." - }, + "metadata": {}, "outputs": [], "source": [ - "\n", "dj.Diagram(session)" ] }, @@ -314,14 +310,11 @@ ] }, { - "cell_type": "code", - "execution_count": null, - "id": "dc175fed", - "metadata": { - "title": "[`miniscope`](https://github.com/datajoint/element-miniscope): miniscope raw recording and processed data" - }, - "outputs": [], - "source": [] + "cell_type": "markdown", + "metadata": {}, + "source": [ + "+ [`miniscope`](https://github.com/datajoint/element-miniscope): miniscope raw recording and processed data" + ] }, { "cell_type": "code", @@ -349,8 +342,7 @@ "metadata": { "jupytext": { "encoding": "# -*- coding: utf-8 -*-", - "formats": "ipynb,py_scripts//py", - "main_language": "python" + "formats": "ipynb,scripts//py" }, "kernelspec": { "display_name": "Python 3.7.9 64-bit ('workflow-calcium-imaging': conda)", diff --git a/notebooks/03-process.ipynb b/notebooks/03-process.ipynb index f7b4590..a017ef1 100644 --- a/notebooks/03-process.ipynb +++ b/notebooks/03-process.ipynb @@ -32,7 +32,8 @@ "source": [ "import os\n", "if os.path.basename(os.getcwd())=='notebooks': os.chdir('..')\n", - "import numpy as np" + "import numpy as np\n", + "import datajoint as dj" ] }, { @@ -50,9 +51,7 @@ "metadata": {}, "outputs": [], "source": [ - "import datajoint as dj\n", - "from workflow_miniscope.pipeline import subject, session, miniscope, Equipment, \\\n", - " AnatomicalLocation" + "from workflow_miniscope.pipeline import *" ] }, { @@ -118,8 +117,8 @@ "outputs": [], "source": [ "Equipment.insert1(dict(equipment='UCLA Miniscope',\n", - " modality='Miniscope',\n", - " description='V4, >1mm field of view, 1mm working distance'))" + " modality='miniscope',\n", + " description=''))" ] }, { @@ -433,7 +432,7 @@ "miniscope.ProcessingTask.insert1(dict(**recording_key,\n", " paramset_id=0,\n", " processing_output_dir='subject1/session1/caiman',\n", - " task_mode='load'))" + " task_mode='trigger'))" ] }, { @@ -580,14 +579,11 @@ } ], "metadata": { - "interpreter": { - "hash": "d4d1e4263499bec80672ea0156c357c1ee493ec2b1c70f0acce89fc37c4a6abe" - }, "jupytext": { - "formats": "ipynb,py_scripts//py" + "formats": "ipynb,scripts//py" }, "kernelspec": { - "display_name": "Python 3.7.9 64-bit ('workflow-calcium-imaging': conda)", + "display_name": "Python 3.8.11 ('ele')", "language": "python", "name": "python3" }, @@ -601,7 +597,12 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.4" + "version": "3.8.11" + }, + "vscode": { + "interpreter": { + "hash": "61456c693db5d9aa6731701ec9a9b08ab88a172bee0780139a3679beb166da16" + } } }, "nbformat": 4, diff --git a/notebooks/05-explore.ipynb b/notebooks/05-explore.ipynb index 6960e9a..16cfa8f 100644 --- a/notebooks/05-explore.ipynb +++ b/notebooks/05-explore.ipynb @@ -11,7 +11,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -75,18 +75,200 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " \n", + " \n", + " Animal Subject\n", + "
\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
\n", + "

subject

\n", + " \n", + "
\n", + "

sex

\n", + " \n", + "
\n", + "

subject_birth_date

\n", + " \n", + "
\n", + "

subject_description

\n", + " \n", + "
subject1M2021-01-01Theo
subject6M2020-01-01manuel
\n", + " \n", + "

Total: 2

\n", + " " + ], + "text/plain": [ + "*subject sex subject_birth_ subject_descri\n", + "+----------+ +-----+ +------------+ +------------+\n", + "subject1 M 2021-01-01 Theo \n", + "subject6 M 2020-01-01 manuel \n", + " (Total: 2)" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "subject.Subject()" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "
\n", + "

subject

\n", + " \n", + "
\n", + "

session_datetime

\n", + " \n", + "
subject12021-01-01 00:00:01
subject12022-04-27 12:13:01
subject62021-06-01 13:33:33
subject62021-06-02 14:04:22
\n", + " \n", + "

Total: 4

\n", + " " + ], + "text/plain": [ + "*subject *session_datet\n", + "+----------+ +------------+\n", + "subject1 2021-01-01 00:\n", + "subject1 2022-04-27 12:\n", + "subject6 2021-06-01 13:\n", + "subject6 2021-06-02 14:\n", + " (Total: 4)" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "session.Session()" ] @@ -100,11 +282,11 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ - "session_key = (session.Session & 'subject = \"subject3\"' & 'session_datetime = \"2021-04-30 12:22:15.032\"').fetch1('KEY')" + "session_key = (session.Session & 'subject = \"subject1\"' & 'session_datetime = \"2021-01-01 00:00:01\"').fetch1('KEY')" ] }, { @@ -118,29 +300,363 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
\n", + "

subject

\n", + " \n", + "
\n", + "

session_datetime

\n", + " \n", + "
\n", + "

recording_id

\n", + " \n", + "
\n", + "

equipment

\n", + " \n", + "
\n", + "

acquisition_software

\n", + " \n", + "
\n", + "

recording_directory

\n", + " relative to root data directory\n", + "
\n", + "

recording_notes

\n", + " free-notes\n", + "
subject12021-01-01 00:00:010UCLA MiniscopeMiniscope-DAQ-V4subject1/session1No notes for this session.
\n", + " \n", + "

Total: 1

\n", + " " + ], + "text/plain": [ + "*subject *session_datet *recording_id equipment acquisition_so recording_dire recording_note\n", + "+----------+ +------------+ +------------+ +------------+ +------------+ +------------+ +------------+\n", + "subject1 2021-01-01 00: 0 UCLA Miniscope Miniscope-DAQ- subject1/sessi No notes for t\n", + " (Total: 1)" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "miniscope.Recording & session_key" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " \n", + " \n", + " Store metadata about recording\n", + "
\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
\n", + "

subject

\n", + " \n", + "
\n", + "

session_datetime

\n", + " \n", + "
\n", + "

recording_id

\n", + " \n", + "
\n", + "

nchannels

\n", + " number of channels\n", + "
\n", + "

nframes

\n", + " number of recorded frames\n", + "
\n", + "

px_height

\n", + " height in pixels\n", + "
\n", + "

px_width

\n", + " width in pixels\n", + "
\n", + "

um_height

\n", + " height in microns\n", + "
\n", + "

um_width

\n", + " width in microns\n", + "
\n", + "

fps

\n", + " (Hz) frames per second\n", + "
\n", + "

gain

\n", + " recording gain\n", + "
\n", + "

spatial_downsample

\n", + " e.g. 1, 2, 4, 8. 1 for no downsampling\n", + "
\n", + "

led_power

\n", + " LED power used in the given recording\n", + "
\n", + "

time_stamps

\n", + " time stamps of each frame\n", + "
\n", + "

recording_datetime

\n", + " datetime of the recording\n", + "
\n", + "

recording_duration

\n", + " (seconds) duration of the recording\n", + "
subject12021-01-01 00:00:0101111770600600nannan20.02.015.0=BLOB=None5588.5
\n", + " \n", + "

Total: 1

\n", + " " + ], + "text/plain": [ + "*subject *session_datet *recording_id nchannels nframes px_height px_width um_height um_width fps gain spatial_downsa led_power time_stamp recording_date recording_dura\n", + "+----------+ +------------+ +------------+ +-----------+ +---------+ +-----------+ +----------+ +-----------+ +----------+ +------+ +------+ +------------+ +-----------+ +--------+ +------------+ +------------+\n", + "subject1 2021-01-01 00: 0 1 111770 600 600 nan nan 20.0 2.0 1 5.0 =BLOB= None 5588.5 \n", + " (Total: 1)" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "miniscope.RecordingInfo & session_key" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "
\n", + "

subject

\n", + " \n", + "
\n", + "

session_datetime

\n", + " \n", + "
\n", + "

recording_id

\n", + " \n", + "
\n", + "

file_id

\n", + " \n", + "
\n", + "

file_path

\n", + " relative to root data directory\n", + "
subject12021-01-01 00:00:0100subject1/session1/0.avi
\n", + " \n", + "

Total: 1

\n", + " " + ], + "text/plain": [ + "*subject *session_datet *recording_id *file_id file_path \n", + "+----------+ +------------+ +------------+ +---------+ +------------+\n", + "subject1 2021-01-01 00: 0 0 subject1/sessi\n", + " (Total: 1)" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "miniscope.RecordingInfo.Field & session_key" + "miniscope.RecordingInfo.File & session_key" ] }, { @@ -164,18 +680,218 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " \n", + " \n", + " Parameter set used for processing of miniscope data\n", + "
\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "
\n", + "

paramset_id

\n", + " \n", + "
\n", + "

processing_method

\n", + " \n", + "
\n", + "

paramset_desc

\n", + " \n", + "
\n", + "

param_set_hash

\n", + " \n", + "
\n", + "

params

\n", + " dictionary of all applicable parameters\n", + "
0caimanCalcium imaging analysis with CaImAn using default parameters7ebfca75-7997-82ce-c46b-f0cc28f69308=BLOB=
\n", + " \n", + "

Total: 1

\n", + " " + ], + "text/plain": [ + "*paramset_id processing_met paramset_desc param_set_hash params \n", + "+------------+ +------------+ +------------+ +------------+ +--------+\n", + "0 caiman Calcium imagin 7ebfca75-7997- =BLOB= \n", + " (Total: 1)" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "miniscope.ProcessingParamSet()" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
\n", + "

subject

\n", + " \n", + "
\n", + "

session_datetime

\n", + " \n", + "
\n", + "

recording_id

\n", + " \n", + "
\n", + "

paramset_id

\n", + " \n", + "
\n", + "

processing_output_dir

\n", + " relative to the root data directory\n", + "
\n", + "

task_mode

\n", + " 'load': load existing results\n", + "
\n", + "

processing_time

\n", + " generation time of processed, segmented results\n", + "
\n", + "

package_version

\n", + " \n", + "
subject12021-01-01 00:00:0100subject1/session1/caimanload2022-04-27 12:13:32
\n", + " \n", + "

Total: 1

\n", + " " + ], + "text/plain": [ + "*subject *session_datet *recording_id *paramset_id processing_out task_mode processing_tim package_versio\n", + "+----------+ +------------+ +------------+ +------------+ +------------+ +-----------+ +------------+ +------------+\n", + "subject1 2021-01-01 00: 0 0 subject1/sessi load 2022-04-27 12: \n", + " (Total: 1)" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "miniscope.ProcessingTask * miniscope.Processing & session_key" ] @@ -189,9 +905,119 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " \n", + " \n", + " Different rounds of curation performed on the processing results of the data\n", + "
\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
\n", + "

subject

\n", + " \n", + "
\n", + "

session_datetime

\n", + " \n", + "
\n", + "

recording_id

\n", + " \n", + "
\n", + "

paramset_id

\n", + " \n", + "
\n", + "

curation_id

\n", + " \n", + "
\n", + "

curation_time

\n", + " time of generation of these curated results\n", + "
\n", + "

curation_output_dir

\n", + " output directory of the curated results,\n", + "
\n", + "

manual_curation

\n", + " has manual curation been performed?\n", + "
\n", + "

curation_note

\n", + " \n", + "
subject12021-01-01 00:00:010002022-04-30 12:22:15subject1/session1/caiman0
\n", + " \n", + "

Total: 1

\n", + " " + ], + "text/plain": [ + "*subject *session_datet *recording_id *paramset_id *curation_id curation_time curation_outpu manual_curatio curation_note \n", + "+----------+ +------------+ +------------+ +------------+ +------------+ +------------+ +------------+ +------------+ +------------+\n", + "subject1 2021-01-01 00: 0 0 0 2022-04-30 12: subject1/sessi 0 \n", + " (Total: 1)" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "miniscope.Curation & session_key" ] @@ -211,7 +1037,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -220,18 +1046,147 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "{'subject': 'subject1',\n", + " 'session_datetime': datetime.datetime(2021, 1, 1, 0, 0, 1),\n", + " 'recording_id': 0,\n", + " 'paramset_id': 0,\n", + " 'curation_id': 0}" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "curation_key" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
\n", + "

subject

\n", + " \n", + "
\n", + "

session_datetime

\n", + " \n", + "
\n", + "

recording_id

\n", + " \n", + "
\n", + "

paramset_id

\n", + " \n", + "
\n", + "

curation_id

\n", + " \n", + "
\n", + "

outlier_frames

\n", + " mask with true for frames with outlier shifts\n", + "
\n", + "

y_shifts

\n", + " (pixels) y motion correction shifts\n", + "
\n", + "

x_shifts

\n", + " (pixels) x motion correction shifts\n", + "
\n", + "

y_std

\n", + " (pixels) standard deviation of\n", + "
\n", + "

x_std

\n", + " (pixels) standard deviation of\n", + "
subject12021-01-01 00:00:01000=BLOB==BLOB==BLOB=0.05619640.0570838
\n", + " \n", + "

Total: 1

\n", + " " + ], + "text/plain": [ + "*subject *session_datet *recording_id *paramset_id *curation_id outlier_fr y_shifts x_shifts y_std x_std \n", + "+----------+ +------------+ +------------+ +------------+ +------------+ +--------+ +--------+ +--------+ +-----------+ +-----------+\n", + "subject1 2021-01-01 00: 0 0 0 =BLOB= =BLOB= =BLOB= 0.0561964 0.0570838 \n", + " (Total: 1)" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "miniscope.MotionCorrection.RigidMotionCorrection & curation_key" ] @@ -278,11 +1233,121 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " \n", + " \n", + " summary images for each field and channel after corrections\n", + "
\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
\n", + "

subject

\n", + " \n", + "
\n", + "

session_datetime

\n", + " \n", + "
\n", + "

recording_id

\n", + " \n", + "
\n", + "

paramset_id

\n", + " \n", + "
\n", + "

curation_id

\n", + " \n", + "
\n", + "

ref_image

\n", + " image used as alignment template\n", + "
\n", + "

average_image

\n", + " mean of registered frames\n", + "
\n", + "

correlation_image

\n", + " correlation map\n", + "
\n", + "

max_proj_image

\n", + " max of registered frames\n", + "
subject12021-01-01 00:00:01000=BLOB==BLOB==BLOB==BLOB=
\n", + " \n", + "

Total: 1

\n", + " " + ], + "text/plain": [ + "*subject *session_datet *recording_id *paramset_id *curation_id ref_image average_im correlatio max_proj_i\n", + "+----------+ +------------+ +------------+ +------------+ +------------+ +--------+ +--------+ +--------+ +--------+\n", + "subject1 2021-01-01 00: 0 0 0 =BLOB= =BLOB= =BLOB= =BLOB= \n", + " (Total: 1)" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "miniscope.MotionCorrection.Summary & curation_key & 'field_idx=0'" + "miniscope.MotionCorrection.Summary & curation_key" ] }, { @@ -294,18 +1359,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 31, "metadata": {}, "outputs": [], "source": [ - "average_image = (miniscope.MotionCorrection.Summary & curation_key & 'field_idx=0').fetch1('average_image')" + "average_image = (miniscope.MotionCorrection.Summary & curation_key).fetch1('average_image').reshape(600,600,1)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 32, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "plt.imshow(average_image);" ] @@ -323,16 +1401,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 29, "metadata": {}, "outputs": [], "source": [ - "mask_xpix, mask_ypix = (miniscope.Segmentation.Mask * miniscope.MaskClassification.MaskType & curation_key & 'mask_center_z=0' & 'mask_npix > 130').fetch('mask_xpix','mask_ypix')" + "mask_xpix, mask_ypix = (miniscope.Segmentation.Mask * miniscope.MaskClassification.MaskType \n", + " & curation_key & 'mask_npix > 130').fetch('mask_xpix','mask_ypix')" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 33, "metadata": {}, "outputs": [], "source": [ @@ -343,12 +1422,25 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 38, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "plt.imshow(average_image);\n", - "plt.contour(mask_image, colors='white', linewidths=0.5);" + "plt.contour(mask_image.reshape(600,600), colors='white', linewidths=0.5);" ] }, { @@ -362,11 +1454,121 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 41, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
\n", + "

subject

\n", + " \n", + "
\n", + "

session_datetime

\n", + " \n", + "
\n", + "

recording_id

\n", + " \n", + "
\n", + "

paramset_id

\n", + " \n", + "
\n", + "

curation_id

\n", + " \n", + "
\n", + "

mask_classification_method

\n", + " \n", + "
\n", + "

mask_id

\n", + " \n", + "
\n", + "

mask_type

\n", + " \n", + "
\n", + "

confidence

\n", + " \n", + "
subject12021-01-01 00:00:01000caiman_default_classifier13somanan
\n", + " \n", + "

Total: 1

\n", + " " + ], + "text/plain": [ + "*subject *session_datet *recording_id *paramset_id *curation_id *mask_classifi *mask_id mask_type confidence \n", + "+----------+ +------------+ +------------+ +------------+ +------------+ +------------+ +---------+ +-----------+ +------------+\n", + "subject1 2021-01-01 00: 0 0 0 caiman_default 13 soma nan \n", + " (Total: 1)" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "miniscope.MaskClassification.MaskType & curation_key & 'mask=0'" + "miniscope.MaskClassification.MaskType & curation_key & 'mask_id=13'" ] }, { @@ -380,31 +1582,44 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 42, "metadata": {}, "outputs": [], "source": [ - "query_cells = (miniscope.Segmentation.Mask * miniscope.MaskClassification.MaskType & curation_key & 'mask_center_z=0' & 'mask_npix > 130').proj()" + "query_cells = (miniscope.Segmentation.Mask * miniscope.MaskClassification.MaskType & curation_key & 'mask_npix > 130').proj()" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 44, "metadata": {}, "outputs": [], "source": [ - "fluorescence_traces = (miniscope.Fluorescence.Trace & query_cells).fetch('fluorescence', order_by='mask')\n", + "fluorescence_traces = (miniscope.Fluorescence.Trace & query_cells).fetch('fluorescence', order_by='mask_id')\n", "\n", - "activity_traces = (miniscope.Activity.Trace & query_cells).fetch('activity_trace', order_by='mask')\n", + "activity_traces = (miniscope.Activity.Trace & query_cells).fetch('activity_trace', order_by='mask_id')\n", "\n", "sampling_rate = (miniscope.RecordingInfo & curation_key).fetch1('fps') # [Hz]" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 45, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "fig, ax = plt.subplots(1, 1, figsize=(16, 4))\n", "ax2 = ax.twinx()\n", @@ -443,8 +1658,9 @@ "formats": "ipynb,py_scripts//py" }, "kernelspec": { - "display_name": "Python 3.7.9 64-bit ('workflow-calcium-imaging': conda)", - "name": "python379jvsc74a57bd01a512f474e195e32ad84236879d3bb44800a92b431919ef0b10d543f5012a23c" + "display_name": "Python 3.8.11 ('ele')", + "language": "python", + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -456,14 +1672,19 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.9" + "version": "3.8.11" }, "metadata": { "interpreter": { "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6" } + }, + "vscode": { + "interpreter": { + "hash": "61456c693db5d9aa6731701ec9a9b08ab88a172bee0780139a3679beb166da16" + } } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } diff --git a/notebooks/06-drop-optional.ipynb b/notebooks/06-drop-optional.ipynb index fb9bfd2..e43ab8f 100644 --- a/notebooks/06-drop-optional.ipynb +++ b/notebooks/06-drop-optional.ipynb @@ -63,8 +63,7 @@ ], "metadata": { "jupytext": { - "formats": "ipynb,py_scripts//py", - "main_language": "python" + "formats": "ipynb,py_scripts//py" }, "kernelspec": { "display_name": "venv-nwb", diff --git a/notebooks/07-downstream-analysis-optional.ipynb b/notebooks/07-downstream-analysis-optional.ipynb index 2e129b6..fa2a93a 100644 --- a/notebooks/07-downstream-analysis-optional.ipynb +++ b/notebooks/07-downstream-analysis-optional.ipynb @@ -74,8 +74,7 @@ "cell_type": "markdown", "id": "1aef115b-e711-4614-a555-0319fff8ca33", "metadata": { - "incorrectly_encoded_metadata": "jp-MarkdownHeadingCollapsed=true", - "jp-MarkdownHeadingCollapsed": true, + "incorrectly_encoded_metadata": "jp-MarkdownHeadingCollapsed=true jp-MarkdownHeadingCollapsed=true", "tags": [] }, "source": [ @@ -674,8 +673,7 @@ "cell_type": "markdown", "id": "f4a64347-803f-4fab-a937-e75e5cf03eac", "metadata": { - "incorrectly_encoded_metadata": "jp-MarkdownHeadingCollapsed=true", - "jp-MarkdownHeadingCollapsed": true, + "incorrectly_encoded_metadata": "jp-MarkdownHeadingCollapsed=true jp-MarkdownHeadingCollapsed=true", "tags": [] }, "source": [ @@ -2191,8 +2189,7 @@ "cell_type": "markdown", "id": "1486add8", "metadata": { - "incorrectly_encoded_metadata": "jp-MarkdownHeadingCollapsed=true", - "jp-MarkdownHeadingCollapsed": true, + "incorrectly_encoded_metadata": "jp-MarkdownHeadingCollapsed=true jp-MarkdownHeadingCollapsed=true", "tags": [] }, "source": [ diff --git a/notebooks/py_scripts/00-data-download-optional.py b/notebooks/py_scripts/00-data-download-optional.py index 543e5b5..9aa8241 100644 --- a/notebooks/py_scripts/00-data-download-optional.py +++ b/notebooks/py_scripts/00-data-download-optional.py @@ -1,16 +1,15 @@ # --- # jupyter: # jupytext: -# formats: ipynb,py_scripts//py # text_representation: # extension: .py # format_name: light # format_version: '1.5' # jupytext_version: 1.13.7 # kernelspec: -# display_name: venv-nwb +# display_name: Python 3.8.11 ('ele') # language: python -# name: venv-nwb +# name: python3 # --- # # Download example dataset diff --git a/notebooks/py_scripts/01-configure.py b/notebooks/py_scripts/01-configure.py index 38a1bc3..e8072ac 100644 --- a/notebooks/py_scripts/01-configure.py +++ b/notebooks/py_scripts/01-configure.py @@ -1,15 +1,15 @@ # --- # jupyter: # jupytext: -# formats: ipynb,py_scripts//py # text_representation: # extension: .py # format_name: light # format_version: '1.5' # jupytext_version: 1.13.7 # kernelspec: -# display_name: 'Python 3.7.9 64-bit (''workflow-calcium-imaging'': conda)' -# name: python379jvsc74a57bd01a512f474e195e32ad84236879d3bb44800a92b431919ef0b10d543f5012a23c +# display_name: Python 3.8.11 ('ele') +# language: python +# name: python3 # --- # # Configure DataJoint connection to the database diff --git a/notebooks/py_scripts/02-workflow-structure-optional.py b/notebooks/py_scripts/02-workflow-structure-optional.py index 3bc347e..025cdb6 100644 --- a/notebooks/py_scripts/02-workflow-structure-optional.py +++ b/notebooks/py_scripts/02-workflow-structure-optional.py @@ -2,7 +2,6 @@ # --- # jupyter: # jupytext: -# formats: ipynb,py_scripts//py # text_representation: # extension: .py # format_name: light @@ -26,7 +25,7 @@ # To load the local configuration, we will change the directory to the package root. import os -if os.path.basename(os.getcwd())=='notebooks': os.chdir('..') +os.chdir('..') # ## Schemas and tables # @@ -37,30 +36,27 @@ # + Each module contains a schema object that enables interaction with the schema in the database. - # + Each module imported above corresponds to one schema inside the database. For example, `ephys` corresponds to `neuro_ephys` schema in the database. miniscope.schema # + The table classes in the module corresponds to a table in the schema in the database. - # + Each datajoint table class inside the module corresponds to a table inside the schema. For example, the class `ephys.EphysRecording` correponds to the table `_ephys_recording` in the schema `neuro_ephys` in the database. # preview columns and contents in a table miniscope.Processing() # + The first time importing the modules, empty schemas and tables will be created in the database. [markdown] -# # # + By importing the modules for the first time, the schemas and tables will be created inside the database. +# # + By importing the modules for the first time, the schemas and tables will be created inside the database. # -# # # + Once created, importing modules will not create schemas and tables again, but the existing schemas/tables can be accessed and manipulated by the modules. +# # + Once created, importing modules will not create schemas and tables again, but the existing schemas/tables can be accessed and manipulated by the modules. # + The schemas and tables will not be re-created when importing modules if they have existed. [markdown] # ## DataJoint tools to explore schemas and tables # -# # # + `dj.list_schemas()`: list all schemas a user has access to in the current database +# # + `dj.list_schemas()`: list all schemas a user has access to in the current database # + `dj.list_schemas()`: list all schemas a user could access. dj.list_schemas() -# + `dj.Diagram()`: plot tables and dependencies in a schema. - +# + `dj.Diagram()`: plot tables and dependencies in a schema. # + `dj.Diagram()`: plot tables and dependencies # plot diagram for all tables in a schema @@ -110,20 +106,19 @@ dj.Diagram(subject.Subject) + dj.Diagram(session.Session) + dj.Diagram(miniscope) # + `heading`: [markdown] -# # # + `describe()`: show table definition with foreign key references. +# # + `describe()`: show table definition with foreign key references. # - miniscope.Processing.describe(); # + `heading`: show attribute definitions regardless of foreign key references - # + `heading`: show table attributes regardless of foreign key references. miniscope.Processing.heading # + ephys [markdown] # # DataJoint Elements installed in `workflow-miniscope` # -# # # + [`lab`](https://github.com/datajoint/element-lab): lab management related information, such as Lab, User, Project, Protocol, Source. +# # + [`lab`](https://github.com/datajoint/element-lab): lab management related information, such as Lab, User, Project, Protocol, Source. # - dj.Diagram(lab) @@ -144,7 +139,6 @@ # + [`miniscope`](https://github.com/datajoint/element-miniscope): miniscope raw recording and processed data - # + [probe and ephys](https://github.com/datajoint/element-array-ephys): Neuropixel based probe and ephys tables dj.Diagram(miniscope) # - diff --git a/notebooks/py_scripts/03-process.py b/notebooks/py_scripts/03-process.py index e8805b4..5f57e9d 100644 --- a/notebooks/py_scripts/03-process.py +++ b/notebooks/py_scripts/03-process.py @@ -1,14 +1,13 @@ # --- # jupyter: # jupytext: -# formats: ipynb,py_scripts//py # text_representation: # extension: .py # format_name: light # format_version: '1.5' # jupytext_version: 1.13.7 # kernelspec: -# display_name: 'Python 3.7.9 64-bit (''workflow-calcium-imaging'': conda)' +# display_name: Python 3.8.11 ('ele') # language: python # name: python3 # --- @@ -30,14 +29,13 @@ import os if os.path.basename(os.getcwd())=='notebooks': os.chdir('..') import numpy as np +import datajoint as dj # ## `Pipeline.py` # # + This script `activates` the DataJoint `Elements` and declares other required tables. -import datajoint as dj -from workflow_miniscope.pipeline import subject, session, miniscope, Equipment, \ - AnatomicalLocation +from workflow_miniscope.pipeline import * # ## Schema diagrams # @@ -60,8 +58,8 @@ # ## Insert an entry into `lab.Equipment` Equipment.insert1(dict(equipment='UCLA Miniscope', - modality='Miniscope', - description='V4, >1mm field of view, 1mm working distance')) + modality='miniscope', + description='')) # ## Insert an entry into `session.Session` @@ -193,7 +191,7 @@ miniscope.ProcessingTask.insert1(dict(**recording_key, paramset_id=0, processing_output_dir='subject1/session1/caiman', - task_mode='load')) + task_mode='trigger')) # ## Populate `miniscope.Processing` diff --git a/notebooks/py_scripts/05-explore.py b/notebooks/py_scripts/05-explore.py index 50593d0..8ac2c6b 100644 --- a/notebooks/py_scripts/05-explore.py +++ b/notebooks/py_scripts/05-explore.py @@ -1,15 +1,15 @@ # --- # jupyter: # jupytext: -# formats: ipynb,py_scripts//py # text_representation: # extension: .py # format_name: light # format_version: '1.5' # jupytext_version: 1.13.7 # kernelspec: -# display_name: 'Python 3.7.9 64-bit (''workflow-calcium-imaging'': conda)' -# name: python379jvsc74a57bd01a512f474e195e32ad84236879d3bb44800a92b431919ef0b10d543f5012a23c +# display_name: ele-jup +# language: python +# name: ele-jup # --- # # DataJoint Workflow Miniscope @@ -58,7 +58,7 @@ # + Fetch the primary key for the session of interest which will be used later on in this notebook. -session_key = (session.Session & 'subject = "subject3"' & 'session_datetime = "2021-04-30 12:22:15.032"').fetch1('KEY') +session_key = (session.Session & 'subject = "subject1"' & 'session_datetime = "2021-01-01 00:00:01"').fetch1('KEY') # ### `Recording` and `RecordingInfo` tables # @@ -68,7 +68,7 @@ miniscope.RecordingInfo & session_key -miniscope.RecordingInfo.Field & session_key +miniscope.RecordingInfo.File & session_key # ### `ProcessingParamSet`, `ProcessingTask`, `Processing`, and `Curation` tables # @@ -122,11 +122,11 @@ # # + Maximum projection image - max of registered frames -miniscope.MotionCorrection.Summary & curation_key & 'field_idx=0' +miniscope.MotionCorrection.Summary & curation_key # + Lets fetch the `average_image` and plot it. -average_image = (miniscope.MotionCorrection.Summary & curation_key & 'field_idx=0').fetch1('average_image') +average_image = (miniscope.MotionCorrection.Summary & curation_key).fetch1('average_image').reshape(600,600,1) plt.imshow(average_image); @@ -136,31 +136,32 @@ # # + Each mask can be associated with a field by the attribute `mask_center_z`. For example, masks with `mask_center_z=0` are in the field identified with `field_idx=0` in `miniscope.RecordingInfo`. -mask_xpix, mask_ypix = (miniscope.Segmentation.Mask * miniscope.MaskClassification.MaskType & curation_key & 'mask_center_z=0' & 'mask_npix > 130').fetch('mask_xpix','mask_ypix') +mask_xpix, mask_ypix = (miniscope.Segmentation.Mask * miniscope.MaskClassification.MaskType + & curation_key & 'mask_npix > 130').fetch('mask_xpix','mask_ypix') mask_image = np.zeros(np.shape(average_image), dtype=bool) for xpix, ypix in zip(mask_xpix, mask_ypix): mask_image[ypix, xpix] = True plt.imshow(average_image); -plt.contour(mask_image, colors='white', linewidths=0.5); +plt.contour(mask_image.reshape(600,600), colors='white', linewidths=0.5); # ### `MaskClassification` table # # + This table provides the `mask_type` and `confidence` for the mask classification. -miniscope.MaskClassification.MaskType & curation_key & 'mask=0' +miniscope.MaskClassification.MaskType & curation_key & 'mask_id=13' # ### `Fluorescence` and `Activity` tables # # + Lets fetch and plot the flourescence and activity traces for one mask. -query_cells = (miniscope.Segmentation.Mask * miniscope.MaskClassification.MaskType & curation_key & 'mask_center_z=0' & 'mask_npix > 130').proj() +query_cells = (miniscope.Segmentation.Mask * miniscope.MaskClassification.MaskType & curation_key & 'mask_npix > 130').proj() # + -fluorescence_traces = (miniscope.Fluorescence.Trace & query_cells).fetch('fluorescence', order_by='mask') +fluorescence_traces = (miniscope.Fluorescence.Trace & query_cells).fetch('fluorescence', order_by='mask_id') -activity_traces = (miniscope.Activity.Trace & query_cells).fetch('activity_trace', order_by='mask') +activity_traces = (miniscope.Activity.Trace & query_cells).fetch('activity_trace', order_by='mask_id') sampling_rate = (miniscope.RecordingInfo & curation_key).fetch1('fps') # [Hz] diff --git a/notebooks/py_scripts/06-drop-optional.py b/notebooks/py_scripts/06-drop-optional.py index df00a4d..ea512f6 100644 --- a/notebooks/py_scripts/06-drop-optional.py +++ b/notebooks/py_scripts/06-drop-optional.py @@ -1,7 +1,6 @@ # --- # jupyter: # jupytext: -# formats: ipynb,py_scripts//py # text_representation: # extension: .py # format_name: light diff --git a/notebooks/py_scripts/07-downstream-analysis-optional.py b/notebooks/py_scripts/07-downstream-analysis-optional.py index cfba670..ca79f23 100644 --- a/notebooks/py_scripts/07-downstream-analysis-optional.py +++ b/notebooks/py_scripts/07-downstream-analysis-optional.py @@ -1,7 +1,6 @@ # --- # jupyter: # jupytext: -# formats: ipynb,py_scripts//py # text_representation: # extension: .py # format_name: light diff --git a/requirements.txt b/requirements.txt index f8722c7..03caaf7 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,8 +1,9 @@ datajoint>=0.13.0 -element-lab==0.1.0b0 -element-animal==0.1.0b0 -element-session==0.1.0b0 -element-miniscope==0.1.0 +element-lab>=0.1.1 +element-animal>=0.1.2 +element-session>=0.1.2 +element-event @ git+https://github.com/datajoint/element-event.git +element-miniscope @ git+https://github.com/datajoint/element-miniscope.git element-interface @ git+https://github.com/datajoint/element-interface.git djarchive-client @ git+https://github.com/datajoint/djarchive-client.git -jupytext==1.13.7 \ No newline at end of file +jupytext>=1.13.7 diff --git a/tests/__init__.py b/tests/__init__.py index 0ecaad3..6d55e00 100644 --- a/tests/__init__.py +++ b/tests/__init__.py @@ -1,15 +1,18 @@ -# run tests: pytest -sv --cov-report term-missing --cov=workflow-miniscope -p no:warnings +''' +run all tests: + pytest -sv --cov-report term-missing --cov=workflow_miniscope -p no:warnings tests/ +run one test, debug: + pytest [above options] --pdb tests/tests_name.py -k function_name +''' import os +import sys import pytest -import pandas as pd import pathlib import datajoint as dj -import importlib -import numpy as np -import sys +from contextlib import nullcontext +from element_interface.utils import find_full_path -from workflow_miniscope.paths import get_miniscope_root_data_dir # ------------------- SOME CONSTANTS ------------------- @@ -19,9 +22,22 @@ test_user_data_dir = pathlib.Path('./tests/user_data') test_user_data_dir.mkdir(exist_ok=True) +sessions_dirs = ['subject1/session1'] + # ------------------ GENERAL FUNCTIONS ------------------ +def write_csv(content, path): + """ + General function for writing strings to lines in CSV + :param path: pathlib PosixPath + :param content: list of strings, each as row of CSV + """ + with open(path, 'w') as f: + for line in content: + f.write(line+'\n') + + class QuietStdOut: """If verbose set to false, used to quiet tear_down table.delete prints""" def __enter__(self): @@ -32,25 +48,50 @@ def __exit__(self, exc_type, exc_val, exc_tb): sys.stdout.close() sys.stdout = self._original_stdout +verbose_context = nullcontext() if verbose else QuietStdOut() + # ------------------- FIXTURES ------------------- + + @pytest.fixture(autouse=True) def dj_config(): if pathlib.Path('./dj_local_conf.json').exists(): dj.config.load('./dj_local_conf.json') dj.config['safemode'] = False + dj.config["database.use_tls"] = False dj.config['custom'] = { 'database.prefix': (os.environ.get('DATABASE_PREFIX') - or dj.config['custom']['database.prefix']), + or dj.config['custom']['database.prefix']), 'miniscope_root_data_dir': (os.environ.get('MINISCOPE_ROOT_DATA_DIR') or dj.config['custom']['miniscope_root_data_dir']) } return +@pytest.fixture(autouse=True) +def test_data(dj_config): + mini_root_dirs = dj.config['custom']['miniscope_root_data_dir'] + + test_data_exists = all(find_full_path(mini_root_dirs, p).exists() + for p in sessions_dirs) + + if not test_data_exists: + import djarchive_client + from collections import abc + + if not isinstance(mini_root_dirs, abc.Sequence): + mini_root_dirs = list(mini_root_dirs) + djarchive_client.client().download('workflow-miniscope-test-set', + 'v1', + str(mini_root_dirs[0]), create_target=False) + return + + @pytest.fixture def pipeline(): """ Loads workflow_miniscope.pipeline lab, session, subject, miniscope""" - from workflow_miniscope import pipeline + with verbose_context: + from workflow_miniscope import pipeline yield {'lab': pipeline.lab, 'subject': pipeline.subject, @@ -60,14 +101,183 @@ def pipeline(): 'get_miniscope_root_data_dir': pipeline.get_miniscope_root_data_dir} if _tear_down: - if verbose: + with verbose_context: pipeline.miniscope.Recording.delete() pipeline.subject.Subject.delete() pipeline.session.Session.delete() pipeline.lab.Lab.delete() - else: - with QuietStdOut(): - pipeline.miniscope.Recording.delete() - pipeline.subject.Subject.delete() - pipeline.session.Session.delete() - pipeline.lab.Lab.delete() + + +@pytest.fixture +def subjects_csv(): + """ Create a 'subjects.csv' file""" + subject_content = ["subject,sex,subject_birth_date,subject_description", + "subject1,M,2021-01-01 00:00:01,Theo"] + subject_csv_path = pathlib.Path('./tests/user_data/subjects.csv') + write_csv(subject_content, subject_csv_path) + + yield subject_content, subject_csv_path + if _tear_down: + with verbose_context: + subject_csv_path.unlink() + + +@pytest.fixture +def ingest_subjects(pipeline, subjects_csv): + from workflow_miniscope.ingest import ingest_subjects + _, subjects_csv_path = subjects_csv + # if not tear_down, skip duplicates + skip_duplicates = not _tear_down + ingest_subjects(subjects_csv_path, verbose=verbose, skip_duplicates=skip_duplicates) + return + + +@pytest.fixture +def sessions_csv(): + """ Create a 'sessions.csv' file""" + session_csv_path = pathlib.Path('./tests/user_data/sessions.csv') + session_content = ["subject,session_dir,acquisition_software", + "subject1,subject1/session1,Miniscope-DAQ-V4"] + write_csv(session_content, session_csv_path) + + yield session_content, session_csv_path + if _tear_down: + with verbose_context: + session_csv_path.unlink() + + +@pytest.fixture +def ingest_sessions(ingest_subjects, sessions_csv): + from workflow_miniscope.ingest import ingest_sessions + _, sessions_csv_path = sessions_csv + ingest_sessions(sessions_csv_path, verbose=verbose) + return + + +@pytest.fixture +def testdata_paths(): + return { + 'caiman_2d': 'subject1/session1/0.avi' + } + + +@pytest.fixture +def caiman_paramset(pipeline): + miniscope = pipeline['miniscope'] + + params_caiman = dict(decay_time=0.4, + pw_rigid=False, + max_shifts=(5, 5), + gSig_filt=(3, 3), + strides=(48, 48), + overlaps=(24, 24), + max_deviation_rigid=3, + border_nan='copy', + method_init='corr_pnr', + K=None, + gSig=(3, 3), + gSiz=(13, 13), + merge_thr=0.7, + p=1, + tsub=2, + ssub=1, + rf=40, + stride=20, + only_init=True, + nb=0, + nb_patch=0, + method_deconvolution='oasis', + low_rank_background=None, + update_background_components=True, + min_corr=0.8, + min_pnr=10, + normalize_init=False, + center_psf=True, + ssub_B=2, + ring_size_factor=1.4, + del_duplicates=True, + border_pix=0, + min_SNR=3, + rval_thr=0.85, + use_cnn=False) + + miniscope.ProcessingParamSet.insert_new_params( + processing_method='caiman', + paramset_id=0, + paramset_desc='Calcium imaging analysis with CaImAn using default parameters', + params=params_caiman) + + yield params_caiman + + if _tear_down: + with verbose_context: + (miniscope.ProcessingParamSet & 'paramset_id = 0').delete() + + +@pytest.fixture +def recording_info(pipeline, ingest_sessions): + miniscope = pipeline['miniscope'] + + miniscope.RecordingInfo.populate() + + yield + + if _tear_down: + with verbose_context: + miniscope.RecordingInfo.delete() + + +@pytest.fixture +def processing_tasks(pipeline, caiman_paramset, recording_info): + miniscope = pipeline['miniscope'] + session = pipeline['session'] + get_miniscope_root_data_dir = pipeline['get_miniscope_root_data_dir'] + + for scan_key in (session.Session * miniscope.Recording - miniscope.ProcessingTask + ).fetch('KEY'): + scan_file = find_full_path(get_miniscope_root_data_dir(), + (miniscope.RecordingInfo.File & scan_key + ).fetch('file_path')[0]) + + recording_dir = scan_file.parent + caiman_dir = pathlib.Path(recording_dir / 'caiman') + if caiman_dir.exists(): + miniscope.ProcessingTask.insert1({**scan_key, + 'paramset_id': 0, + 'processing_output_dir': caiman_dir}) + + yield + + if _tear_down: + with verbose_context: + miniscope.ProcessingTask.delete() + + +@pytest.fixture +def processing(processing_tasks, pipeline): + miniscope = pipeline['miniscope'] + + errors = miniscope.Processing.populate(suppress_errors=True) + + if errors: + print(f'Populate ERROR: {len(errors)} errors in ' + + f'"miniscope.Processing.populate()" - {errors[0][-1]}') + + yield + + if _tear_down: + with verbose_context: + miniscope.Processing.delete() + +@pytest.fixture +def curations(processing, pipeline): + miniscope = pipeline['miniscope'] + + for key in (miniscope.Processing - miniscope.Curation).fetch('KEY'): + miniscope.Curation().create1_from_processing_task(key) + + yield + + if _tear_down: + with verbose_context: + miniscope.Curation.delete() diff --git a/tests/test_ingest.py b/tests/test_ingest.py index 5d83136..e43259e 100644 --- a/tests/test_ingest.py +++ b/tests/test_ingest.py @@ -1,45 +1,43 @@ -import pathlib +from element_interface.utils import find_full_path, find_root_directory from . import (dj_config, pipeline, subjects_csv, ingest_subjects, sessions_csv, ingest_sessions, - testdata_paths, caiman2D_paramset, caiman3D_paramset, - scan_info, processing_tasks, processing, curations) + testdata_paths, caiman_paramset, recording_info, processing_tasks, + processing, curations) + + +__all__ = ['dj_config', 'pipeline', 'subjects_csv', 'ingest_subjects', 'sessions_csv', + 'ingest_sessions', 'testdata_paths', 'caiman_paramset', + 'recording_info', 'processing_tasks', 'processing', 'curations'] def test_ingest_subjects(pipeline, ingest_subjects): subject = pipeline['subject'] - assert len(subject.Subject()) == 3 + assert len(subject.Subject()) == 1 def test_ingest_sessions(pipeline, sessions_csv, ingest_sessions): - scan = pipeline['scan'] session = pipeline['session'] - get_imaging_root_data_dir = pipeline['get_imaging_root_data_dir'] + miniscope = pipeline['miniscope'] + get_miniscope_root_data_dir = pipeline['get_miniscope_root_data_dir'] - assert len(session.Session()) == 4 - assert len(scan.Scan()) == 4 + assert len(session.Session()) == 1 + assert len(miniscope.Recording()) == 1 sessions, _ = sessions_csv - sess = sessions.iloc[3] - sess_dir = pathlib.Path(sess.session_dir).relative_to(get_imaging_root_data_dir()) + sess = sessions[1].split(",")[1] assert (session.SessionDirectory - & {'subject': sess.name}).fetch1('session_dir') == sess_dir.as_posix() + & {'subject': sessions[1].split(",")[0]} + ).fetch1('session_dir') == sess -def test_paramset_insert(caiman2D_paramset, caiman3D_paramset, pipeline): - imaging = pipeline['imaging'] - from element_calcium_imaging.imaging import dict_to_uuid - - method, desc, paramset_hash = (imaging.ProcessingParamSet & {'paramset_idx': 1}).fetch1( - 'processing_method', 'paramset_desc', 'param_set_hash') - assert method == 'caiman' - assert desc == 'Calcium imaging analysis' \ - ' with CaImAn using default CaImAn parameters for 2d planar images' - assert dict_to_uuid(caiman2D_paramset) == paramset_hash +def test_paramset_insert(caiman_paramset, pipeline): + miniscope = pipeline['miniscope'] + from element_interface.utils import dict_to_uuid - method, desc, paramset_hash = (imaging.ProcessingParamSet & {'paramset_idx': 2}).fetch1( - 'processing_method', 'paramset_desc', 'param_set_hash') + method, desc, paramset_hash = (miniscope.ProcessingParamSet & {'paramset_idx': 0} + ).fetch1('processing_method', 'paramset_desc', + 'param_set_hash') assert method == 'caiman' - assert desc == 'Calcium imaging analysis' \ - ' with CaImAn using default CaImAn parameters for 3d volumetric images' - assert dict_to_uuid(caiman3D_paramset) == paramset_hash + assert desc == 'Calcium imaging analysis with CaImAn using default parameters' + assert dict_to_uuid(caiman_paramset) == paramset_hash diff --git a/tests/test_pipeline_generation.py b/tests/test_pipeline_generation.py index fe67504..7a8b291 100644 --- a/tests/test_pipeline_generation.py +++ b/tests/test_pipeline_generation.py @@ -1,20 +1,19 @@ from . import dj_config, pipeline +__all__ = ["dj_config", "pipeline"] -def test_generate_pipeline(pipeline): - subject = pipeline['subject'] - session = pipeline['session'] - miniscope = pipeline['miniscope'] - Equipment = pipeline['Equipment'] - subject_tbl, *_ = session.Session.parents(as_objects=True) +def test_generate_pipeline(pipeline): + subject = pipeline["subject"] + session = pipeline["session"] + miniscope = pipeline["miniscope"] + Equipment = pipeline["Equipment"] # Test Element connection from lab, subject to Session - assert subject_tbl.full_table_name == subject.Subject.full_table_name + assert subject.Subject.full_table_name in session.Session.parents() # Test Element connection from Session to miniscope - session_tbl, equipment_tbl, _ = miniscope.Recording.parents(as_objects=True) - assert session_tbl.full_table_name == session.Session.full_table_name - assert equipment_tbl.full_table_name == Equipment.full_table_name - assert 'mask_npix' in miniscope.Segmentation.Mask.heading.secondary_attributes - assert 'activity_trace' in miniscope.Activity.Trace.heading.secondary_attributes + assert session.Session.full_table_name in miniscope.Recording.parents() + assert Equipment.full_table_name in miniscope.Recording.parents() + assert "mask_npix" in miniscope.Segmentation.Mask.heading.secondary_attributes + assert "activity_trace" in miniscope.Activity.Trace.heading.secondary_attributes diff --git a/tests/test_populate.py b/tests/test_populate.py index 81c6290..09371cc 100644 --- a/tests/test_populate.py +++ b/tests/test_populate.py @@ -1,39 +1,25 @@ -import numpy as np - from . import (dj_config, pipeline, subjects_csv, ingest_subjects, - sessions_csv, ingest_sessions, - testdata_paths, caiman2D_paramset, caiman3D_paramset, - scan_info, processing_tasks, processing, curations) - - -def test_scan_info_populate_scanimage_2D(testdata_paths, pipeline, scan_info): - scan = pipeline['scan'] - rel_path = testdata_paths['scanimage_2d'] - scan_key = (scan.ScanInfo & (scan.ScanInfo.ScanFile - & f'file_path LIKE "%{rel_path}%"')).fetch1('KEY') - nfields, nchannels, ndepths, nframes = (scan.ScanInfo & scan_key).fetch1( - 'nfields', 'nchannels', 'ndepths', 'nframes') + sessions_csv, ingest_sessions, testdata_paths, caiman_paramset, + recording_info, processing_tasks, processing, curations) - assert nfields == 1 - assert nchannels == 2 - assert ndepths == 1 - assert nframes == 25000 +__all__ = ['dj_config', 'pipeline', 'subjects_csv', 'ingest_subjects', 'sessions_csv', + 'ingest_sessions', 'testdata_paths', 'caiman_paramset', 'recording_info', + 'processing_tasks', 'processing', 'curations'] -def test_scan_info_populate_scanimage_3D(testdata_paths, pipeline, scan_info): - scan = pipeline['scan'] - rel_path = testdata_paths['scanimage_3d'] - scan_key = (scan.ScanInfo & (scan.ScanInfo.ScanFile - & f'file_path LIKE "%{rel_path}%"')).fetch1('KEY') - nfields, nchannels, ndepths, nframes = (scan.ScanInfo & scan_key).fetch1( - 'nfields', 'nchannels', 'ndepths', 'nframes') +def test_recording_info_populate(testdata_paths, pipeline, recording_info): + miniscope = pipeline['miniscope'] + rel_path = testdata_paths['caiman_2d'] + scan_key = (miniscope.RecordingInfo & (miniscope.RecordingInfo.File + & f'file_path LIKE "%{rel_path}%"') + ).fetch1('KEY') + nchannels, nframes = (miniscope.RecordingInfo & scan_key + ).fetch1('nchannels', 'nframes') - assert nfields == 3 - assert nchannels == 2 - assert ndepths == 3 - assert nframes == 2000 + assert nchannels == 1 + assert nframes == 111770 def test_processing_populate(processing, pipeline): - imaging = pipeline['imaging'] - assert len(imaging.Processing()) == 5 \ No newline at end of file + miniscope = pipeline['miniscope'] + assert len(miniscope.Processing()) == 1 diff --git a/user_data/subjects.csv b/user_data/subjects.csv index 91bbe23..d71c4f9 100644 --- a/user_data/subjects.csv +++ b/user_data/subjects.csv @@ -1,2 +1,2 @@ subject,sex,subject_birth_date,subject_description -subject1,M,2021-01-01 00:00:01, +subject1,M,2021-01-01 00:00:01,Theo diff --git a/workflow_miniscope/analysis.py b/workflow_miniscope/analysis.py index 0c5465d..4967959 100644 --- a/workflow_miniscope/analysis.py +++ b/workflow_miniscope/analysis.py @@ -1,7 +1,7 @@ import datajoint as dj import numpy as np -from workflow_miniscope.pipeline import db_prefix, session, miniscope, trial, event +from workflow_miniscope.pipeline import db_prefix, session, miniscope, trial schema = dj.schema(db_prefix + 'analysis') @@ -44,11 +44,11 @@ class AlignedTrialActivity(dj.Part): def make(self, key): sess_time, rec_time, nframes, frame_rate = (miniscope.RecordingInfo - * session.Session - & key - ).fetch1('session_datetime', - 'recording_datetime', - 'nframes', 'fps') + * session.Session + & key + ).fetch1('session_datetime', + 'recording_datetime', + 'nframes', 'fps') # Estimation of frame timestamps with respect to the session-start # (to be replaced by timestamps retrieved from some synchronization routine) diff --git a/workflow_miniscope/ingest.py b/workflow_miniscope/ingest.py index 392462e..65dd092 100644 --- a/workflow_miniscope/ingest.py +++ b/workflow_miniscope/ingest.py @@ -20,9 +20,9 @@ def ingest_subjects(subject_csv_path='./user_data/subjects.csv', ingest_csv_to_table(csvs, tables, skip_duplicates=skip_duplicates, verbose=verbose) -def ingest_sessions(session_csv_path='./user_data/sessions.csv'): - - print('\n---- Insert new `Session` and `Recording` ----') +def ingest_sessions(session_csv_path='./user_data/sessions.csv', verbose=True): + if verbose: + print('\n---- Insert new `Session` and `Recording` ----') with open(session_csv_path, newline='') as f: input_sessions = list(csv.DictReader(f, delimiter=',')) @@ -39,7 +39,7 @@ def ingest_sessions(session_csv_path='./user_data/sessions.csv'): session_path = find_full_path(get_miniscope_root_data_dir(), session_dir) recording_filepaths = [file_path.as_posix() for file_path - in session_path.glob('*.avi')] + in session_path.glob('*.avi')] if not recording_filepaths: raise FileNotFoundError(f'No .avi files found in ' f'{session_path}') @@ -62,7 +62,8 @@ def ingest_sessions(session_csv_path='./user_data/sessions.csv'): session_key = dict(subject=single_session['subject'], session_datetime=recording_time) if session_key not in session.Session(): - hardware_list.append(dict(acquisition_hardware=acquisition_hardware)) + hardware_list.append(dict(equipment=acquisition_hardware, + modality='Miniscope')) session_list.append(session_key) @@ -70,23 +71,28 @@ def ingest_sessions(session_csv_path='./user_data/sessions.csv'): session_dir=session_dir.as_posix())) recording_list.append(dict(**session_key, - recording_id=0, # Assumes one recording per session - acquisition_hardware=acquisition_hardware, - acquisition_software=acquisition_software, - recording_directory=session_dir.as_posix())) + recording_id=0, # Assumes 1 recording per sess + equipment=acquisition_hardware, + acquisition_software=acquisition_software, + recording_directory=session_dir.as_posix())) new_equipment_n = len(set(val for dic in hardware_list for val in dic.values())) - print(f'\n---- Insert {new_equipment_n} entry(s) into lab.Equipment ----') - Equipment.insert(hardware_list, skip_duplicates=True) + if verbose: + print(f'\n---- Insert {new_equipment_n} entry(s) into lab.Equipment ----') + Equipment.insert(hardware_list, skip_duplicates=True) # expect duplicates for equip - print(f'\n---- Insert {len(session_list)} entry(s) into session.Session ----') + if verbose: + print(f'\n---- Insert {len(session_list)} entry(s) into session.Session ----') session.Session.insert(session_list) session.SessionDirectory.insert(session_dir_list) - print(f'\n---- Insert {len(recording_list)} entry(s) into miniscope.Recording ----') + if verbose: + print(f'\n---- Insert {len(recording_list)} entry(s) into ' + + 'miniscope.Recording ----') miniscope.Recording.insert(recording_list) - print('\n---- Successfully completed ingest_sessions ----') + if verbose: + print('\n---- Successfully completed ingest_sessions ----') def ingest_events(recording_csv_path='./user_data/behavior_recordings.csv', diff --git a/workflow_miniscope/paths.py b/workflow_miniscope/paths.py index acdb7e8..4f48381 100644 --- a/workflow_miniscope/paths.py +++ b/workflow_miniscope/paths.py @@ -1,9 +1,14 @@ import datajoint as dj - +from collections import abc def get_miniscope_root_data_dir(): - return dj.config.get('custom', {}).get('miniscope_root_data_dir', None) - + mini_root_dirs = dj.config.get('custom', {}).get('miniscope_root_data_dir') + if not mini_root_dirs: + return None + elif not isinstance(mini_root_dirs, abc.Sequence): + return list(mini_root_dirs) + else: + return mini_root_dirs def get_session_directory(session_key: dict) -> str: from .pipeline import session diff --git a/workflow_miniscope/pipeline.py b/workflow_miniscope/pipeline.py index 9f260d9..54ae01c 100644 --- a/workflow_miniscope/pipeline.py +++ b/workflow_miniscope/pipeline.py @@ -17,6 +17,10 @@ db_prefix = dj.config['custom'].get('database.prefix', '') +__all__ = ['lab', 'subject', 'session', 'trial', 'event', 'miniscope', + 'Source', 'Lab', 'Protocol', 'User', 'Location', 'Project', 'Subject', + 'Session', 'get_miniscope_root_data_dir', 'get_session_directory'] + # Activate `lab`, `subject`, `session` schema ------------------------------------------ @@ -33,6 +37,7 @@ # Declare table `Equipment` and `AnatomicalLocation` for use in element_miniscope ------ + @lab.schema class Equipment(dj.Manual): definition = """ @@ -42,6 +47,7 @@ class Equipment(dj.Manual): description=null : varchar(256) """ + @lab.schema class AnatomicalLocation(dj.Manual): definition = """ @@ -52,4 +58,5 @@ class AnatomicalLocation(dj.Manual): # Activate `miniscope` schema ---------------------------------------------------------- + miniscope.activate(db_prefix + 'miniscope', linking_module=__name__) diff --git a/workflow_miniscope/populate.py b/workflow_miniscope/populate.py new file mode 100644 index 0000000..e9d935f --- /dev/null +++ b/workflow_miniscope/populate.py @@ -0,0 +1,34 @@ +from workflow_miniscope.pipeline import miniscope +import warnings + +warnings.filterwarnings('ignore') + + +def run(display_progress=True, reserve_jobs=False, suppress_errors=False, + verbose=True): + + populate_settings = {'display_progress': display_progress, + 'reserve_jobs': reserve_jobs, + 'suppress_errors': suppress_errors} + + if verbose: + print("\n---- Populate imported and computed tables ----") + + miniscope.RecordingInfo.populate(**populate_settings) + + miniscope.Processing.populate(**populate_settings) + + miniscope.MotionCorrection.populate(**populate_settings) + + miniscope.Segmentation.populate(**populate_settings) + + miniscope.Fluorescence.populate(**populate_settings) + + miniscope.Activity.populate(**populate_settings) + + if verbose: + print('\n---- Successfully completed workflow_miniscope/populate.py ----') + + +if __name__ == '__main__': + run() diff --git a/workflow_miniscope/version.py b/workflow_miniscope/version.py index fb30593..9ebd04e 100644 --- a/workflow_miniscope/version.py +++ b/workflow_miniscope/version.py @@ -1,2 +1,2 @@ """Package metadata""" -__version__ = '0.1.0' \ No newline at end of file +__version__ = '0.2.0' \ No newline at end of file