np_codeocean 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

np_codeocean/utils.py

@@ -1,94 +1,452 @@
-from __future__ import annotations
-
-import configparser
-import json
-import os
-import pathlib
-from typing import Literal
-
-import np_config
-
-CONFIG = np_config.fetch('/projects/np_codeocean')
-"""Config for this project"""
-
-AWS_CONFIG: dict[Literal['aws_access_key_id', 'aws_secret_access_key'], str] = np_config.fetch('/projects/np_codeocean/aws')['config']
-"""Config for connecting to AWS/S3 via awscli/boto3"""
-
-AWS_CREDENTIALS: dict[Literal['domain', 'token'], str]  = np_config.fetch('/projects/np_codeocean/aws')['credentials']
-"""Config for connecting to AWS/S3 via awscli/boto3"""
-
-CODEOCEAN_CONFIG: dict[Literal['region'], str] = np_config.fetch('/projects/np_codeocean/codeocean')['credentials']
-"""Config for connecting to CodeOcean via http API"""
-
-
-def get_home() -> pathlib.Path:
-    if os.name == 'nt':
-        return pathlib.Path(os.environ['USERPROFILE'])
-    return pathlib.Path(os.environ['HOME'])
-
-def get_aws_files() -> dict[Literal['config', 'credentials'], pathlib.Path]:
-    return {
-        'config': get_home() / '.aws' / 'config',
-        'credentials': get_home() / '.aws' / 'credentials',
-    }
-
-def get_codeocean_files() -> dict[Literal['credentials'], pathlib.Path]:
-    return {
-        'credentials': get_home() / '.codeocean' / 'credentials.json',
-    }
-
-def verify_ini_config(path: pathlib.Path, contents: dict, profile: str = 'default') -> None:
-    config = configparser.ConfigParser()
-    if path.exists():
-        config.read(path)
-    if not all(k in config[profile] for k in contents):
-        raise ValueError(f'Profile {profile} in {path} exists but is missing some keys required for codeocean or s3 access.')
-    
-def write_or_verify_ini_config(path: pathlib.Path, contents: dict, profile: str = 'default') -> None:
-    config = configparser.ConfigParser()
-    if path.exists():
-        config.read(path)
-        try:    
-            verify_ini_config(path, contents, profile)
-        except ValueError:
-            pass
-        else:   
-            return
-    config[profile] = contents
-    path.parent.mkdir(parents=True, exist_ok=True)
-    path.touch(exist_ok=True)
-    with path.open('w') as f:
-        config.write(f)
-    verify_ini_config(path, contents, profile)
-
-def verify_json_config(path: pathlib.Path, contents: dict) -> None:
-    config = json.loads(path.read_text())
-    if not all(k in config for k in contents):
-        raise ValueError(f'{path} exists but is missing some keys required for codeocean or s3 access.')
-    
-def write_or_verify_json_config(path: pathlib.Path, contents: dict) -> None:
-    if path.exists():
-        try:
-            verify_json_config(path, contents)
-        except ValueError:
-            contents = np_config.merge(json.loads(path.read_text()), contents)
-        else:   
-            return
-    path.parent.mkdir(parents=True, exist_ok=True)
-    path.touch(exist_ok=True)
-    path.write_text(json.dumps(contents, indent=4))
-    
-def ensure_credentials() -> None:
-    for file, contents in (
-        (get_aws_files()['config'], AWS_CONFIG),
-        (get_aws_files()['credentials'], AWS_CREDENTIALS),
-    ):
-        write_or_verify_ini_config(file, contents, profile='default')
-    
-    for file, contents in (
-        (get_codeocean_files()['credentials'], CODEOCEAN_CONFIG),
-    ):
-        write_or_verify_json_config(file, contents)
-
-if __name__ == '__main__':
-    ensure_credentials()
+from __future__ import annotations
+
+import contextlib
+import csv
+import datetime
+import functools
+import itertools
+import json
+import logging
+import os
+import pathlib
+from typing import Any, Generator, Iterable, Literal
+import typing_extensions
+
+import aind_data_transfer_models.core
+import aind_slurm_rest.models
+import np_config
+import np_tools
+import npc_ephys
+import npc_sync
+import npc_session
+import numpy as np
+import polars as pl
+import requests
+
+logger = logging.getLogger(__name__)
+
+AINDPlatform = Literal['ecephys', 'behavior']
+
+AIND_DATA_TRANSFER_SERVICE = "http://aind-data-transfer-service"
+DEV_SERVICE = "http://aind-data-transfer-service-dev"
+HPC_UPLOAD_JOB_EMAIL = "ben.hardcastle@alleninstitute.org"
+ACQ_DATETIME_FORMAT = "%Y-%m-%d %H:%M:%S"
+
+AIND_METADATA_NAMES: tuple[str, ...] = ('session', 'data_description', 'procedures', 'processing', 'rig', 'subject')
+
+DEFAULT_EPHYS_SLURM_SETTINGS = aind_slurm_rest.models.V0036JobProperties(
+    environment=dict(),  # JonY: set this to an empty dictionary
+    time_limit = 15 * 60,
+    minimum_cpus_per_node=12, # 6 probes * (lfp + ap)
+)
+"""Increased timelimit and cpus for running ephys compression on the hpc"""
+
+class SyncFileNotFoundError(FileNotFoundError):
+    pass
+
+@functools.cache
+def get_project_config() -> dict[str, Any]:
+    """Config for this project"""
+    return np_config.fetch('/projects/np_codeocean')
+
+def set_npc_lims_credentials() -> None:
+    creds = np_config.fetch('/projects/np_codeocean/npc_lims')
+    for k, v in creds.items():
+        os.environ.setdefault(k, v)
+        
+def get_home() -> pathlib.Path:
+    if os.name == 'nt':
+        return pathlib.Path(os.environ['USERPROFILE'])
+    return pathlib.Path(os.environ['HOME'])
+
+def is_behavior_video_file(path: pathlib.Path) -> bool:
+    if path.is_dir() or path.suffix not in ('.mp4', '.avi', '.json'):
+        return False
+    with contextlib.suppress(ValueError):
+        _ = npc_session.extract_mvr_camera_name(path.as_posix())
+        return True
+    return False
+    
+def is_surface_channel_recording(path_name: str) -> bool:
+    """
+    >>> import np_session
+    >>> session = np_session.Session("//allen/programs/mindscope/workgroups/dynamicrouting/PilotEphys/Task 2 pilot/DRpilot_690706_20231129_surface_channels")
+    >>> is_surface_channel_recording(session.npexp_path.as_posix())
+    True
+    """
+    return 'surface_channels' in path_name.lower()
+
+def cleanup_ephys_symlinks(toplevel_dir: pathlib.Path) -> None:
+    """After creating symlinks to the ephys data, run this to make any necessary 
+    modifications prior to upload.
+    
+    Provided dir path should be a directory containing all ephys data in
+    subfolders (e.g. directory containing "Record Node 10x" folders)
+    
+    Only deletes symlinks or writes new files in place of symlinks - does not
+    modify original data.
+    
+    Rules:
+    - if any continuous.dat files are unreadable: remove them and their containing folders
+    - if any probes were recorded on multiple record nodes: just keep the first
+    - if continuous.dat files are missing (ie. excluded because probes weren't
+      inserted, or we removed symlinks in previous steps): update metadata files
+    """
+    remove_unreadable_ephys_data(toplevel_dir)
+    remove_duplicate_ephys_data(toplevel_dir)
+    cleanup_ephys_metadata(toplevel_dir)
+
+def remove_unreadable_ephys_data(toplevel_dir: pathlib.Path) -> None:
+    
+    for continuous_dir in ephys_continuous_dir_generator(toplevel_dir):
+        events_dir = continuous_dir.parent.parent / 'events' / continuous_dir.name / 'TTL'
+        filenames = ('continuous.dat', 'timestamps.npy', 'sample_numbers.npy')    
+        dirs = (continuous_dir, ) + ((events_dir,) if events_dir.exists() else ())
+        mark_for_removal = False
+        for d in dirs:
+            if not d.exists():
+                continue
+            for filename in filenames:
+                if filename == 'continuous.dat' and d.name == 'TTL':
+                    continue # no continuous.dat expected in TTL events
+                file = d / filename
+                if not (file.is_symlink() or file.exists()):
+                    logger.warning(f'Critical file not found {file}, insufficient data for processing')
+                    mark_for_removal = True
+                    break
+                try:
+                    data = np.memmap(decode_symlink_path(file), dtype="int16" if 'timestamps' not in file.name else "float64", mode="r")
+                except Exception as exc:
+                    logger.warning(f'Failed to read {file}: {exc!r}')
+                    mark_for_removal = True
+                    break
+                if data.size == 0:
+                    logger.warning(f'Empty file {file}')
+                    mark_for_removal = True
+                    break
+                logger.debug(f'Found readable, non-empty data in {file}')
+            if mark_for_removal:
+                break
+        if mark_for_removal:
+            logger.warning(f'Removing {continuous_dir} and its contents')
+            remove_folder_of_symlinks(continuous_dir)
+            logger.warning(f'Removing {events_dir.parent} and its contents')
+            remove_folder_of_symlinks(events_dir.parent)
+            
+def remove_duplicate_ephys_data(toplevel_dir: pathlib.Path) -> None:
+    previous_recording_name = ''
+    for continuous_dir in ephys_continuous_dir_generator(toplevel_dir):
+        recording_name = continuous_dir.parent.parent.name
+        if recording_name != previous_recording_name:
+            # reset probes list for each new recording
+            probes = []
+        try:
+            probe = npc_session.ProbeRecord(continuous_dir.name)
+        except ValueError:
+            continue
+        suffix = continuous_dir.name.split('-')[-1]
+        assert suffix in ('AP', 'LFP')
+        recording_name = f"{probe}-{suffix}"
+        if recording_name in probes:
+            logger.info(f'Duplicate {recording_name = } found in {continuous_dir.parent.parent} - removing')
+            remove_folder_of_symlinks(continuous_dir)
+        else:
+            probes.append(recording_name)
+            
+def remove_folder_of_symlinks(folder: pathlib.Path) -> None:
+    """Recursive deletion of all files in dir tree, with a check that each is a
+    symlink."""
+    for path in folder.rglob('*'):
+        if path.is_dir():
+            remove_folder_of_symlinks(path)
+        else:
+            assert path.is_symlink(), f'Expected {path} to be a symlink'
+            path.unlink(missing_ok=True)
+    with contextlib.suppress(FileNotFoundError):
+        folder.rmdir()
+
+def ephys_recording_dir_generator(toplevel_dir: pathlib.Path) -> Generator[pathlib.Path, None, None]:
+    for recording_dir in toplevel_dir.rglob('recording[0-9]*'):
+        if recording_dir.is_dir():
+            yield recording_dir
+            
+def ephys_continuous_dir_generator(toplevel_dir: pathlib.Path) -> Generator[pathlib.Path, None, None]:
+    for recording_dir in ephys_recording_dir_generator(toplevel_dir):
+        parent = recording_dir / 'continuous'
+        if not parent.exists():
+            continue
+        for continuous_dir in parent.iterdir():
+            if continuous_dir.is_dir():
+                yield continuous_dir
+
+def ephys_structure_oebin_generator(toplevel_dir: pathlib.Path) -> Generator[pathlib.Path, None, None]:
+    for recording_dir in ephys_recording_dir_generator(toplevel_dir):
+        oebin_path = recording_dir / 'structure.oebin'
+        if not (oebin_path.is_symlink() or oebin_path.exists()): 
+            # symlinks that are created for the hpc use posix paths, and aren't
+            # readable on windows, so .exists() returns False: use .is_symlink() instead
+            logger.warning(f'No structure.oebin found in {recording_dir}')
+            continue
+        yield oebin_path
+        
+def cleanup_ephys_metadata(toplevel_dir: pathlib.Path) -> None:
+    logger.debug('Checking structure.oebin for missing folders...')
+    for oebin_path in ephys_structure_oebin_generator(toplevel_dir):
+        oebin_obj = np_tools.read_oebin(decode_symlink_path(oebin_path))
+        logger.debug(f'Checking {oebin_path} against actual folders...')
+        any_removed = False
+        for subdir_name in ('events', 'continuous'):    
+            subdir = oebin_path.parent / subdir_name
+            # iterate over copy of list so as to not disrupt iteration when elements are removed
+            for device in [device for device in oebin_obj[subdir_name]]:
+                if not (subdir / device['folder_name']).exists():
+                    logger.info(f'{device["folder_name"]} not found in {subdir}, removing from structure.oebin')
+                    oebin_obj[subdir_name].remove(device)
+                    any_removed = True
+        if any_removed:
+            oebin_path.unlink()
+            oebin_path.write_text(json.dumps(oebin_obj, indent=4))
+            logger.debug('Overwrote symlink to structure.oebin with corrected structure.oebin')
+
+def write_corrected_ephys_timestamps(
+    ephys_dir: pathlib.Path,
+    behavior_dir: pathlib.Path,
+) -> None:
+    for path in itertools.chain(behavior_dir.glob('*.h5'), behavior_dir.glob('*.sync')):
+        with contextlib.suppress(Exception):
+            sync_dataset = npc_sync.SyncDataset(path)
+            _ = sync_dataset.line_labels
+            logger.info(f'Found valid sync file {path.as_posix()}')
+            break
+    else:
+        raise SyncFileNotFoundError(f'No valid sync file found in {behavior_dir.as_posix()}')
+    
+    timing_on_pxi = (
+        timing
+        for timing in npc_ephys.get_ephys_timing_on_pxi(
+            ephys_dir.glob("**/experiment*/recording*"),
+        )
+    )
+    timing_on_sync = (
+        npc_ephys.get_ephys_timing_on_sync(
+            sync=sync_dataset,
+            devices=timing_on_pxi,
+        )
+    )
+    npc_ephys.overwrite_timestamps(timing_on_sync)
+    logger.info(f'Corrected timestamps in {ephys_dir}')
+    
+def decode_symlink_path(oebin_path: pathlib.Path) -> pathlib.Path:
+    if not oebin_path.is_symlink():
+        return oebin_path
+    return np_config.normalize_path(oebin_path.readlink())
+
+def is_csv_in_hpc_upload_queue(csv_path: pathlib.Path, upload_service_url: str = AIND_DATA_TRANSFER_SERVICE) -> bool:
+    """Check if an upload job has been submitted to the hpc upload queue.
+
+    - currently assumes one job per csv
+    - does not check status (job may be FINISHED rather than RUNNING)
+
+    >>> is_csv_in_hpc_upload_queue("//allen/programs/mindscope/workgroups/np-exp/codeocean/DRpilot_664851_20231114/upload.csv")
+    False
+    """
+    # get subject-id, acq-datetime from csv
+    df = pl.read_csv(csv_path, eol_char='\r')
+    for col in df.get_columns():
+        if col.name.startswith('subject') and col.name.endswith('id'):
+            subject = npc_session.SubjectRecord(col[0])
+            continue
+        if col.name.startswith('acq') and 'datetime' in col.name.lower():
+            dt = npc_session.DatetimeRecord(col[0])
+            continue
+        if col.name == 'platform':
+            platform = col[0]
+            continue
+    return is_session_in_hpc_queue(subject=subject, acq_datetime=dt.dt, platform=platform, upload_service_url=upload_service_url)
+
+def is_session_in_hpc_queue(subject: int | str, acq_datetime: str | datetime.datetime, platform: str | None = None, upload_service_url: str = AIND_DATA_TRANSFER_SERVICE) -> bool:
+    """
+    >>> is_session_in_hpc_queue(366122, datetime.datetime(2023, 11, 14, 0, 0, 0))
+    False
+    >>> is_session_in_hpc_queue(702136, datetime.datetime(2024, 3, 4, 13, 21, 35))
+    True
+    """
+    if not isinstance(acq_datetime, datetime.datetime):
+        acq_datetime = datetime.datetime.strptime(acq_datetime, ACQ_DATETIME_FORMAT)
+    partial_session_id = f"{subject}_{acq_datetime.strftime(ACQ_DATETIME_FORMAT).replace(' ', '_').replace(':', '-')}"
+    if platform:
+        partial_session_id = f"{platform}_{partial_session_id}"
+        
+    jobs_response = requests.get(f"{upload_service_url}/jobs")
+    jobs_response.raise_for_status()
+    return partial_session_id in jobs_response.content.decode()
+
+def is_job_in_hpc_upload_queue(job: aind_data_transfer_models.core.BasicUploadJobConfigs, upload_service_url: str = AIND_DATA_TRANSFER_SERVICE) -> bool:
+    return is_session_in_hpc_queue(job.subject_id, job.acq_datetime, job.platform, upload_service_url)
+
+def write_upload_csv(
+    content: dict[str, Any],
+    output_path: pathlib.Path,
+) -> pathlib.Path:
+    logger.info(f'Creating upload job file {output_path}')
+    with open(output_path, 'w') as f:
+        w = csv.writer(f, lineterminator='')
+        w.writerow(content.keys())
+        w.writerow('\n')
+        w.writerow(content.values())
+    return output_path
+
+def get_job_models_from_csv(
+    path: pathlib.Path,
+    ephys_slurm_settings: aind_slurm_rest.models.V0036JobProperties = DEFAULT_EPHYS_SLURM_SETTINGS,
+    user_email: str = HPC_UPLOAD_JOB_EMAIL,
+    **extra_BasicUploadJobConfigs_params: Any,
+) -> tuple[aind_data_transfer_models.core.BasicUploadJobConfigs, ...]:
+    jobs = pl.read_csv(path, eol_char='\r').with_columns(
+        pl.col('subject-id').cast(str),
+    ).to_dicts()
+    jobs = jobs
+    models = []
+    for job in jobs.copy():
+        modalities = []
+        for modality_column in (k for k in job.keys() if k.startswith('modality') and ".source" not in k):
+            modality_name = job[modality_column]
+            modalities.append(
+                aind_data_transfer_models.core.ModalityConfigs(
+                    modality=modality_name,
+                    source=job[f"{modality_column}.source"],
+                    slurm_settings = ephys_slurm_settings if modality_name == 'ecephys' else None,
+                    ),
+                )
+        for k in (k for k in job.copy().keys() if k.startswith('modality')):
+            del job[k]
+        for k, v in job.items():
+            if isinstance(v, str) and '\n' in v:
+                job[k] = v.replace('\n', '')
+        models.append(
+            aind_data_transfer_models.core.BasicUploadJobConfigs(
+                **{k.replace('-', '_'): v for k,v in job.items()},
+                modalities=modalities,
+                user_email=user_email,
+                **extra_BasicUploadJobConfigs_params,
+            )
+        )
+    return tuple(models)
+
+def put_jobs_for_hpc_upload(
+    upload_jobs: aind_data_transfer_models.core.BasicUploadJobConfigs | Iterable[aind_data_transfer_models.core.BasicUploadJobConfigs],
+    upload_service_url: str = AIND_DATA_TRANSFER_SERVICE,
+    user_email: str = HPC_UPLOAD_JOB_EMAIL,
+    email_notification_types: Iterable[str | aind_data_transfer_models.core.EmailNotificationType] = ('fail',),
+    dry_run: bool = False,
+    save_path: pathlib.Path | None = None,
+    **extra_model_kwargs: Any,
+) -> None:
+    """Submit one or more jobs to the aind-data-transfer-service, for
+    upload to S3 on the hpc.
+    
+    - accepts one or more aind_data_schema BasicUploadJobConfigs models
+    - assembles a SubmitJobRequest model
+    - excludes jobs for sessions that are already in the upload queue
+    - accepts additional parameters for SubmitHpcJobRequest as kwargs
+    - submits json via http request
+    - optionally saves the json file as a record
+    """
+    if not isinstance(upload_jobs, Iterable):
+        upload_jobs = (upload_jobs, )
+    submit_request = aind_data_transfer_models.core.SubmitJobRequest(
+        upload_jobs=[job for job in upload_jobs if not is_job_in_hpc_upload_queue(job)],
+        user_email=user_email,
+        email_notification_types=email_notification_types,
+        **extra_model_kwargs,
+    )
+    post_request_content = json.loads(
+        submit_request.model_dump_json(round_trip=True, exclude_none=True)
+    ) #! round_trip required for s3 bucket suffix to work correctly
+    if save_path:
+        save_path.write_text(submit_request.model_dump_json(round_trip=True, indent=4), errors='ignore')
+    if dry_run:
+        logger.warning(f'Dry run: not submitting {len(upload_jobs)} upload job(s) to {upload_service_url}')
+        return
+    post_json_response: requests.Response = requests.post(
+        url=f"{upload_service_url}/api/v1/submit_jobs",
+        json=post_request_content,
+    )
+    logger.info(f"Submitted {len(upload_jobs)} upload job(s) to {upload_service_url}")
+    post_json_response.raise_for_status()
+
+@typing_extensions.deprecated("Uses old, pre-v1 endpoints: use put_jobs_for_hpc_upload in combination with get_job_models_from_csv")
+def put_csv_for_hpc_upload(
+    csv_path: pathlib.Path,
+    upload_service_url: str = AIND_DATA_TRANSFER_SERVICE,
+    hpc_upload_job_email: str =  HPC_UPLOAD_JOB_EMAIL,
+    dry_run: bool = False,
+) -> None:
+    """Submit a single job upload csv to the aind-data-transfer-service, for
+    upload to S3 on the hpc.
+    
+    - gets validated version of csv
+    - checks session is not already being uploaded
+    - submits csv via http request
+    """
+    def _raise_for_status(response: requests.Response) -> None:
+        """pydantic validation errors are returned as strings that can be eval'd
+        to get the real error class + message."""
+        if response.status_code != 200:
+            try:
+                response.json()['data']['errors']
+            except (KeyError, IndexError, requests.exceptions.JSONDecodeError, SyntaxError) as exc1:
+                try:
+                    response.raise_for_status()
+                except requests.exceptions.HTTPError as exc2:
+                    raise exc2 from exc1
+                
+    with open(csv_path, 'rb') as f:
+        validate_csv_response = requests.post(
+            url=f"{upload_service_url}/api/validate_csv", 
+            files=dict(file=f),
+            )
+    _raise_for_status(validate_csv_response)
+    logger.debug(f"Validated response: {validate_csv_response.json()}")
+    if is_csv_in_hpc_upload_queue(csv_path, upload_service_url):
+        logger.warning(f"Job already submitted for {csv_path}")
+        return
+    if dry_run:
+        logger.info(f'Dry run: not submitting {csv_path} to hpc upload queue at {upload_service_url}.')
+        return
+    post_csv_response = requests.post(
+        url=f"{upload_service_url}/api/submit_hpc_jobs", 
+        json=dict(
+            jobs=[
+                    dict(
+                        hpc_settings=json.dumps({"time_limit": 60 * 15, "mail_user": hpc_upload_job_email}),
+                        upload_job_settings=validate_csv_response.json()["data"]["jobs"][0],
+                        script="",
+                    )
+                ]
+        ),
+    )
+    logger.info(f"Submitted {csv_path} to hpc upload queue at {upload_service_url}")
+    _raise_for_status(post_csv_response)
+
+
+def ensure_posix(path: str | pathlib.Path) -> str:
+    posix = pathlib.Path(path).as_posix()
+    if posix.startswith('//'):
+        posix = posix[1:]
+    return posix
+
+
+def convert_symlinks_to_posix(toplevel_dir: str | pathlib.Path) -> None:
+    """Convert all symlinks in `root_dir` (recursively) to POSIX paths. This is a
+    necessary last step before submitting uploads to run on the HPC.
+    """
+    for path in pathlib.Path(toplevel_dir).rglob('*'):
+        if path.is_symlink():
+            posix_target = path.readlink().as_posix().removeprefix('//?/UNC')
+            path.unlink()
+            np_tools.symlink(src=ensure_posix(posix_target), dest=path)
+            
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod(optionflags=doctest.ELLIPSIS | doctest.NORMALIZE_WHITESPACE | doctest.IGNORE_EXCEPTION_DETAIL)

{np_codeocean-0.2.0.dist-info → np_codeocean-0.3.0.dist-info}/METADATA

@@ -1,8 +1,8 @@
 Metadata-Version: 2.1
 Name: np_codeocean
-Version: 0.2.0
+Version: 0.3.0
 Summary: Tools for uploading and interacting with Mindscope Neuropixels experiments on Code Ocean
-Author-Email: Ben Hardcastle <ben.hardcastle@alleninstitute.org>
+Author-Email: Ben Hardcastle <ben.hardcastle@alleninstitute.org>, Chris Mochizuki <chrism@alleninstitute.org>, Arjun Sridhar <arjun.sridhar@alleninstitute.org>
 License: MIT
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9
@@ -13,16 +13,25 @@ Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: POSIX :: Linux
 Project-URL: Source, https://github.com/AllenInstitute/np_codeocean
 Project-URL: Issues, https://github.com/AllenInstitute/np_codeocean/issues
-Requires-Python: >=3.9
-Requires-Dist: np_session>=0.6.4
-Requires-Dist: np-tools>=0.1.21
-Requires-Dist: np-config>=0.4.24
+Requires-Python: >=3.10
+Requires-Dist: np_session>=0.6.44
+Requires-Dist: np-tools>=0.1.23
+Requires-Dist: np-config>=0.4.33
 Requires-Dist: requests>=2.31.0
 Requires-Dist: npc-session>=0.1.34
 Requires-Dist: polars>=0.20.16
+Requires-Dist: npc-lims>=0.1.168
+Requires-Dist: npc-ephys>=0.1.28
+Provides-Extra: dev
 Requires-Dist: bump>=1.3.2; extra == "dev"
 Requires-Dist: pdm>=2.4.9; extra == "dev"
-Provides-Extra: dev
+Provides-Extra: dynamic-routing-metadata
+Requires-Dist: np-aind-metadata>=0.1.17; extra == "dynamic-routing-metadata"
+Requires-Dist: npc-lims>=0.1.154; extra == "dynamic-routing-metadata"
+Requires-Dist: npc-sessions>=0.0.253; extra == "dynamic-routing-metadata"
+Requires-Dist: aind-data-transfer-models>=0.13.1; extra == "dynamic-routing-metadata"
+Requires-Dist: aind-codeocean-pipeline-monitor[full]>=0.5.0; extra == "dynamic-routing-metadata"
+Requires-Dist: aind-metadata-mapper==0.18.2; extra == "dynamic-routing-metadata"
 Description-Content-Type: text/markdown
 
 # np_codeocean

np_codeocean-0.3.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+np_codeocean-0.3.0.dist-info/METADATA,sha256=LdDu8xF8-r2bQMp5xf5WbFDa78CRYWB11wByNNPkwfQ,3177
+np_codeocean-0.3.0.dist-info/WHEEL,sha256=thaaA2w1JzcGC48WYufAs8nrYZjJm8LqNfnXFOFyCC4,90
+np_codeocean-0.3.0.dist-info/entry_points.txt,sha256=p32aRkIjrFa4KtUbq2E6ZMYBVNRUw3U8ZIarvwNkK1E,250
+np_codeocean/__init__.py,sha256=ED7YOu-3AIQIEML9jPT9bQ690lfhYZNiOB4QhnJ8r8U,76
+np_codeocean/np_session_utils.py,sha256=yRz62ybX7k192Qr_viRPOL3saIPh5EH60KakAva5Wck,16659
+np_codeocean/scripts/fix_ephys_data_on_s3.py,sha256=c5jHZmFLjMCRGb3YSmefCZRO_telZ7dB-mXGIG5ncYk,560
+np_codeocean/scripts/upload_dynamic_routing_behavior.py,sha256=mc_dRF_sllvIlaDiCvWBMY8XZGji3dqsMJBJzykdS8M,17190
+np_codeocean/scripts/upload_dynamic_routing_ecephys.py,sha256=ywlemwzY8IFK7h-s759tNsKW2av9CQsZBRerUibtUd4,9934
+np_codeocean/scripts/upload_ethan_analysis_files.py,sha256=MaJRVk0CfzEMkwMmmXRmnRCqYpo6mGNWtROfZLavgGw,1019
+np_codeocean/scripts/upload_split_recordings_example.py,sha256=1_aqoBxAkB_VpRKYqyPsEQBDGvgyAHXAkIJA0ZT2Vb0,1490
+np_codeocean/utils.py,sha256=Pni1c8iKIe94lPLOTBha8MLlSYPqUluWXXVCNyOsGbw,19971
+np_codeocean-0.3.0.dist-info/RECORD,,

{np_codeocean-0.2.0.dist-info → np_codeocean-0.3.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: pdm-backend (2.1.8)
+Generator: pdm-backend (2.4.3)
 Root-Is-Purelib: true
 Tag: py3-none-any

np_codeocean-0.3.0.dist-info/entry_points.txt

@@ -0,0 +1,7 @@
+[console_scripts]
+upload_dr_behavior = np_codeocean.scripts.upload_dynamic_routing_behavior:main
+upload_dr_ecephys = np_codeocean.scripts.upload_dynamic_routing_ecephys:main
+upload_sessions = np_codeocean.scripts.upload_sessions:main
+
+[gui_scripts]
+