ONE-api 3.0b5__py3-none-any.whl → 3.1.1__py3-none-any.whl

one/__init__.py

@@ -1,2 +1,2 @@
 """The Open Neurophysiology Environment (ONE) API."""
-__version__ = '3.0b5'
+__version__ = '3.1.1'

one/alf/cache.py

@@ -22,11 +22,12 @@ from functools import partial
 from pathlib import Path
 import warnings
 import logging
+from copy import deepcopy
 
 import pandas as pd
 import numpy as np
 from packaging import version
-from iblutil.util import Bunch
+from iblutil.util import Bunch, ensure_list
 from iblutil.io import parquet
 from iblutil.io.hashfile import md5
 
@@ -35,8 +36,9 @@ from one.alf.io import iter_sessions
 from one.alf.path import session_path_parts, get_alf_path
 
 __all__ = [
-    'make_parquet_db', 'patch_tables', 'merge_tables', 'QC_TYPE', 'remove_table_files',
-    'remove_missing_datasets', 'load_tables', 'EMPTY_DATASETS_FRAME', 'EMPTY_SESSIONS_FRAME']
+    'make_parquet_db', 'load_tables', 'patch_tables', 'merge_tables',
+    'remove_table_files', 'remove_missing_datasets', 'default_cache',
+    'QC_TYPE', 'EMPTY_DATASETS_FRAME', 'EMPTY_SESSIONS_FRAME']
 _logger = logging.getLogger(__name__)
 
 # -------------------------------------------------------------------------------------------------
@@ -259,6 +261,36 @@ def _make_datasets_df(root_dir, hash_files=False) -> pd.DataFrame:
     return pd.DataFrame(rows, columns=DATASETS_COLUMNS).astype(DATASETS_COLUMNS)
 
 
+def default_cache(origin=''):
+    """Returns an empty cache dictionary with the default tables.
+
+    Parameters
+    ----------
+    origin : str, optional
+        The origin of the cache (e.g. a computer name or database name).
+
+    Returns
+    -------
+    Bunch
+        A Bunch object containing the loaded cache tables and associated metadata.
+
+    """
+    table_meta = _metadata(origin)
+    # The origin is now a set, however we leave _metadata as Alyx relies on this and sets
+    # can't be serialized to JSON
+    table_meta['origin'] = set(filter(None, [origin]))
+    return Bunch({
+            'datasets': EMPTY_DATASETS_FRAME.copy(),
+            'sessions': EMPTY_SESSIONS_FRAME.copy(),
+            '_meta': {
+                'created_time': None,
+                'loaded_time': None,
+                'modified_time': None,
+                'saved_time': None,
+                'raw': {k: deepcopy(table_meta) for k in ('datasets', 'sessions')}}
+        })
+
+
 def make_parquet_db(root_dir, out_dir=None, hash_ids=True, hash_files=False, lab=None):
     """Given a data directory, index the ALF datasets and save the generated cache tables.
 
@@ -375,17 +407,8 @@ def load_tables(tables_dir, glob_pattern='*.pqt'):
         A Bunch object containing the loaded cache tables and associated metadata.
 
     """
-    meta = {
-        'created_time': None,
-        'loaded_time': None,
-        'modified_time': None,
-        'saved_time': None,
-        'raw': {}
-    }
-    caches = Bunch({
-            'datasets': EMPTY_DATASETS_FRAME.copy(),
-            'sessions': EMPTY_SESSIONS_FRAME.copy(),
-            '_meta': meta})
+    caches = default_cache()
+    meta = caches['_meta']
     INDEX_KEY = '.?id'
     for cache_file in Path(tables_dir).glob(glob_pattern):
         table = cache_file.stem
@@ -416,6 +439,10 @@ def load_tables(tables_dir, glob_pattern='*.pqt'):
         if not cache.index.is_monotonic_increasing:
             cache.sort_index(inplace=True)
 
+        # Ensure origin is a set (supports multiple origins)
+        meta['raw'][table]['origin'] = set(
+            filter(None, ensure_list(meta['raw'][table].get('origin', 'unknown'))))
+
         caches[table] = cache
 
     created = [datetime.datetime.fromisoformat(x['date_created'])
@@ -425,9 +452,12 @@ def load_tables(tables_dir, glob_pattern='*.pqt'):
     return caches
 
 
-def merge_tables(cache, strict=False, **kwargs):
+def merge_tables(cache, strict=False, origin=None, **kwargs):
     """Update the cache tables with new records.
 
+    Note: A copy of the tables in cache may be returned if the original tables are immutable.
+    This can happen when tables are loaded from a parquet file.
+
     Parameters
     ----------
     dict
@@ -435,6 +465,8 @@ def merge_tables(cache, strict=False, **kwargs):
     strict : bool
         If not True, the columns don't need to match.  Extra columns in input tables are
         dropped and missing columns are added and filled with np.nan.
+    origin : str
+        The origin of the cache (e.g. a computer name or database name).
     kwargs
         pandas.DataFrame or pandas.Series to insert/update for each table.
 
@@ -488,13 +520,31 @@ def merge_tables(cache, strict=False, **kwargs):
         records = records.astype(cache[table].dtypes)
         # Update existing rows
         to_update = records.index.isin(cache[table].index)
-        cache[table].loc[records.index[to_update], :] = records[to_update]
+        try:
+            cache[table].loc[records.index[to_update], :] = records[to_update]
+        except ValueError as e:
+            if 'assignment destination is read-only' in str(e):
+                # NB: nullable integer and categorical dtypes may be backed by immutable arrays
+                # after loading from parquet and therefore must be copied before assignment
+                cache[table] = cache[table].copy()
+                cache[table].loc[records.index[to_update], :] = records[to_update]
+            else:
+                raise e  # pragma: no cover
+
         # Assign new rows
         to_assign = records[~to_update]
         frames = [cache[table], to_assign]
         # Concatenate and sort
         cache[table] = pd.concat(frames).sort_index()
         updated = datetime.datetime.now()
+        # Update the table metadata with the origin
+        if origin is not None:
+            table_meta = cache['_meta']['raw'].get(table, {})
+            if 'origin' not in table_meta:
+                table_meta['origin'] = set(origin)
+            else:
+                table_meta['origin'].add(origin)
+            cache['_meta']['raw'][table] = table_meta
     cache['_meta']['modified_time'] = updated
     return updated
 

one/api.py

@@ -31,7 +31,7 @@ import one.alf.exceptions as alferr
 from one.alf.path import ALFPath
 from .alf.cache import (
     make_parquet_db, load_tables, remove_table_files, merge_tables,
-    EMPTY_DATASETS_FRAME, EMPTY_SESSIONS_FRAME, cast_index_object)
+    default_cache, cast_index_object)
 from .alf.spec import is_uuid, is_uuid_string, QC, to_alf
 from . import __version__
 from one.converters import ConversionMixin, session_record2path, ses2records, datasets2records
@@ -49,7 +49,7 @@ class One(ConversionMixin):
     """An API for searching and loading data on a local filesystem."""
 
     _search_terms = (
-        'dataset', 'date_range', 'laboratory', 'number',
+        'datasets', 'date_range', 'laboratory', 'number',
         'projects', 'subject', 'task_protocol', 'dataset_qc_lte'
     )
 
@@ -113,16 +113,7 @@ class One(ConversionMixin):
 
     def _reset_cache(self):
         """Replace the cache object with a Bunch that contains the right fields."""
-        self._cache = Bunch({
-            'datasets': EMPTY_DATASETS_FRAME.copy(),
-            'sessions': EMPTY_SESSIONS_FRAME.copy(),
-            '_meta': {
-                'created_time': None,
-                'loaded_time': None,
-                'modified_time': None,
-                'saved_time': None,
-                'raw': {}}  # map of original table metadata
-        })
+        self._cache = default_cache()
 
     def _remove_table_files(self, tables=None):
         """Delete cache tables on disk.
@@ -143,20 +134,25 @@ class One(ConversionMixin):
         tables = tables or filter(lambda x: x[0] != '_', self._cache)
         return remove_table_files(self._tables_dir, tables)
 
-    def load_cache(self, tables_dir=None, **kwargs):
+    def load_cache(self, tables_dir=None, clobber=True, **kwargs):
         """Load parquet cache files from a local directory.
 
         Parameters
         ----------
         tables_dir : str, pathlib.Path
             An optional directory location of the parquet files, defaults to One._tables_dir.
+        clobber : bool
+            If true, the cache is loaded without merging with existing table files.
 
         Returns
         -------
         datetime.datetime
             A timestamp of when the cache was loaded.
         """
-        self._reset_cache()
+        if clobber:
+            self._reset_cache()
+        else:
+            raise NotImplementedError('clobber=False not implemented yet')
         self._tables_dir = Path(tables_dir or self._tables_dir or self.cache_dir)
         self._cache = load_tables(self._tables_dir)
 
@@ -169,7 +165,7 @@ class One(ConversionMixin):
         # prompt the user to delete them to improve load times
         raw_meta = self._cache['_meta'].get('raw', {}).values() or [{}]
         tagged = any(filter(None, flatten(x.get('database_tags') for x in raw_meta)))
-        origin = set(x['origin'] for x in raw_meta if 'origin' in x)
+        origin = set(filter(None, flatten(ensure_list(x.get('origin', [])) for x in raw_meta)))
         older = (self._cache['_meta']['created_time'] or datetime.now()) < datetime(2025, 2, 13)
         remote = not self.offline and self.mode == 'remote'
         if remote and origin == {'alyx'} and older and not self._web_client.silent and not tagged:
@@ -216,11 +212,21 @@ class One(ConversionMixin):
             caches = load_tables(save_dir)
             merge_tables(
                 caches, **{k: v for k, v in self._cache.items() if not k.startswith('_')})
+            # Ensure we use the minimum created date for each table
+            for table in caches['_meta']['raw']:
+                raw_meta = [x['_meta']['raw'].get(table, {}) for x in (caches, self._cache)]
+                created = filter(None, (x.get('date_created') for x in raw_meta))
+                if any(created := list(created)):
+                    created = min(map(datetime.fromisoformat, created))
+                    created = created.isoformat(sep=' ', timespec='minutes')
+                    meta['raw'][table]['date_created'] = created
 
         with FileLock(save_dir, log=_logger, timeout=TIMEOUT, timeout_action='delete'):
             _logger.info('Saving cache tables...')
             for table in filter(lambda x: not x[0] == '_', caches.keys()):
                 metadata = meta['raw'].get(table, {})
+                if isinstance(metadata.get('origin'), set):
+                    metadata['origin'] = list(metadata['origin'])
                 metadata['date_modified'] = modified.isoformat(sep=' ', timespec='minutes')
                 filename = save_dir.joinpath(f'{table}.pqt')
                 # Cast indices to str before saving
@@ -319,10 +325,8 @@ class One(ConversionMixin):
 
         Parameters
         ----------
-        dataset : str, list
-            One or more dataset names. Returns sessions containing all these datasets.
-            A dataset matches if it contains the search string e.g. 'wheel.position' matches
-            '_ibl_wheel.position.npy'.
+        datasets : str, list
+            One or more (exact) dataset names. Returns sessions containing all of these datasets.
         dataset_qc_lte : str, int, one.alf.spec.QC
             A dataset QC value, returns sessions with datasets at or below this QC value, including
             those with no QC set.  If `dataset` not passed, sessions with any passing QC datasets
@@ -370,7 +374,9 @@ class One(ConversionMixin):
 
         Search for sessions on a given date, in a given lab, containing trials and spike data.
 
-        >>> eids = one.search(date='2023-01-01', lab='churchlandlab', dataset=['trials', 'spikes'])
+        >>> eids = one.search(
+        ...    date='2023-01-01', lab='churchlandlab',
+        ...    datasets=['trials.table.pqt', 'spikes.times.npy'])
 
         Search for sessions containing trials and spike data where QC for both are WARNING or less.
 
@@ -397,13 +403,14 @@ class One(ConversionMixin):
 
         def all_present(x, dsets, exists=True):
             """Returns true if all datasets present in Series."""
-            return all(any(x.str.contains(y, regex=self.wildcards) & exists) for y in dsets)
+            name = x.str.rsplit('/', n=1, expand=True).iloc[:, -1]
+            return all(any(name.str.fullmatch(y) & exists) for y in dsets)
 
         # Iterate over search filters, reducing the sessions table
         sessions = self._cache['sessions']
 
         # Ensure sessions filtered in a particular order, with datasets last
-        search_order = ('date_range', 'number', 'dataset')
+        search_order = ('date_range', 'number', 'datasets')
 
         def sort_fcn(itm):
             return -1 if itm[0] not in search_order else search_order.index(itm[0])
@@ -430,12 +437,15 @@ class One(ConversionMixin):
                 query = ensure_list(value)
                 sessions = sessions[sessions[key].isin(map(int, query))]
             # Dataset/QC check is biggest so this should be done last
-            elif key == 'dataset' or (key == 'dataset_qc_lte' and 'dataset' not in queries):
+            elif key == 'datasets' or (key == 'dataset_qc_lte' and 'datasets' not in queries):
                 datasets = self._cache['datasets']
                 qc = QC.validate(queries.get('dataset_qc_lte', 'FAIL')).name  # validate value
                 has_dset = sessions.index.isin(datasets.index.get_level_values('eid'))
+                if not has_dset.any():
+                    sessions = sessions.iloc[0:0]  # No datasets for any sessions
+                    continue
                 datasets = datasets.loc[(sessions.index.values[has_dset], ), :]
-                query = ensure_list(value if key == 'dataset' else '')
+                query = ensure_list(value if key == 'datasets' else '')
                 # For each session check any dataset both contains query and exists
                 mask = (
                     (datasets
@@ -1025,7 +1035,7 @@ class One(ConversionMixin):
         """
         query_type = query_type or self.mode
         datasets = self.list_datasets(
-            eid, details=True, query_type=query_type, keep_eid_index=True, revision=revision)
+            eid, details=True, query_type=query_type, keep_eid_index=True)
 
         if len(datasets) == 0:
             raise alferr.ALFObjectNotFound(obj)
@@ -1692,7 +1702,8 @@ class OneAlyx(One):
         tag = tag or current_tags[0]  # For refreshes take the current tag as default
         different_tag = any(x != tag for x in current_tags)
         if not (clobber or different_tag):
-            super(OneAlyx, self).load_cache(tables_dir)  # Load any present cache
+            # Load any present cache
+            super(OneAlyx, self).load_cache(tables_dir, clobber=True)
             cache_meta = self._cache.get('_meta', {})
             raw_meta = cache_meta.get('raw', {}).values() or [{}]
 
@@ -1711,7 +1722,13 @@ class OneAlyx(One):
             remote_created = datetime.fromisoformat(cache_info['date_created'])
             local_created = cache_meta.get('created_time', None)
             fresh = local_created and (remote_created - local_created) < timedelta(minutes=1)
-            if fresh and not different_tag:
+            # The local cache may have been created locally more recently, but if it doesn't
+            # contain the same tag or origin, we need to download the remote one.
+            origin = cache_info.get('origin', 'unknown')
+            local_origin = (x.get('origin', []) for x in raw_meta)
+            local_origin = set(flatten(map(ensure_list, local_origin)))
+            different_origin = origin not in local_origin
+            if fresh and not (different_tag or different_origin):
                 _logger.info('No newer cache available')
                 return cache_meta['loaded_time']
 
@@ -1725,19 +1742,27 @@ class OneAlyx(One):
                 self._tables_dir = self._tables_dir or self.cache_dir
 
             # Check if the origin has changed. This is to warn users if downloading from a
-            # different database to the one currently loaded.
-            prev_origin = list(set(filter(None, (x.get('origin') for x in raw_meta))))
-            origin = cache_info.get('origin', 'unknown')
-            if prev_origin and origin not in prev_origin:
+            # different database to the one currently loaded. When building the cache from
+            # remote queries the origin is set to the Alyx database URL. If the cache info
+            # origin name and URL are different, warn the user.
+            if different_origin and local_origin and self.alyx.base_url not in local_origin:
                 warnings.warn(
                     'Downloading cache tables from another origin '
-                    f'("{origin}" instead of "{", ".join(prev_origin)}")')
+                    f'("{origin}" instead of "{", ".join(local_origin)}")')
 
             # Download the remote cache files
             _logger.info('Downloading remote caches...')
             files = self.alyx.download_cache_tables(cache_info.get('location'), self._tables_dir)
             assert any(files)
-            return super(OneAlyx, self).load_cache(self._tables_dir)  # Reload cache after download
+            # Reload cache after download
+            loaded_time = super(OneAlyx, self).load_cache(self._tables_dir)
+            # Add db URL to origin set so we know where the cache came from
+            for raw_meta in self._cache['_meta']['raw'].values():
+                table_origin = set(filter(None, ensure_list(raw_meta.get('origin', []))))
+                if origin in table_origin:
+                    table_origin.add(self.alyx.base_url)
+                raw_meta['origin'] = table_origin
+            return loaded_time
         except (requests.exceptions.HTTPError, wc.HTTPError, requests.exceptions.SSLError) as ex:
             _logger.debug(ex)
             _logger.error(f'{type(ex).__name__}: Failed to load the remote cache file')
@@ -1847,7 +1872,8 @@ class OneAlyx(One):
             return self._cache['datasets'].iloc[0:0] if details else []  # Return empty
         session, datasets = ses2records(self.alyx.rest('sessions', 'read', id=eid))
         # Add to cache tables
-        merge_tables(self._cache, sessions=session, datasets=datasets.copy())
+        merge_tables(
+            self._cache, sessions=session, datasets=datasets.copy(), origin=self.alyx.base_url)
         if datasets is None or datasets.empty:
             return self._cache['datasets'].iloc[0:0] if details else []  # Return empty
         assert set(datasets.index.unique('eid')) == {eid}
@@ -1999,7 +2025,7 @@ class OneAlyx(One):
         rec = self.alyx.rest('insertions', 'read', id=str(pid))
         return UUID(rec['session']), rec['name']
 
-    def eid2pid(self, eid, query_type=None, details=False):
+    def eid2pid(self, eid, query_type=None, details=False, **kwargs) -> (UUID, str, list):
         """Given an experiment UUID (eID), return the probe IDs and labels (i.e. ALF collection).
 
         NB: Requires a connection to the Alyx database.
@@ -2013,6 +2039,8 @@ class OneAlyx(One):
             Query mode - options include 'remote', and 'refresh'.
         details : bool
             Additionally return the complete Alyx records from insertions endpoint.
+        kwargs
+            Additional parameters to filter insertions Alyx endpoint.
 
         Returns
         -------
@@ -2023,6 +2051,15 @@ class OneAlyx(One):
         list of dict (optional)
             If details is true, returns the Alyx records from insertions endpoint.
 
+        Examples
+        --------
+        Get the probe IDs and details for a given session ID
+
+        >>> pids, labels, recs = one.eid2pid(eid, details=True)
+
+        Get the probe ID for a given session ID and label
+
+        >>> (pid,), _ = one.eid2pid(eid, details=False, name='probe00')
         """
         query_type = query_type or self.mode
         if query_type == 'local' and 'insertions' not in self._cache.keys():
@@ -2030,7 +2067,7 @@ class OneAlyx(One):
         eid = self.to_eid(eid)  # Ensure we have a UUID str
         if not eid:
             return (None,) * (3 if details else 2)
-        recs = self.alyx.rest('insertions', 'list', session=eid)
+        recs = self.alyx.rest('insertions', 'list', session=eid, **kwargs)
         pids = [UUID(x['id']) for x in recs]
         labels = [x['name'] for x in recs]
         if details:
@@ -2173,7 +2210,8 @@ class OneAlyx(One):
         # Build sessions table
         session_records = (x['session_info'] for x in insertions_records)
         sessions_df = pd.DataFrame(next(zip(*map(ses2records, session_records))))
-        return merge_tables(self._cache, insertions=df, sessions=sessions_df)
+        return merge_tables(
+            self._cache, insertions=df, sessions=sessions_df, origin=self.alyx.base_url)
 
     def search(self, details=False, query_type=None, **kwargs):
         """Searches sessions matching the given criteria and returns a list of matching eids.
@@ -2192,10 +2230,8 @@ class OneAlyx(One):
 
         Parameters
         ----------
-        dataset : str
-            A (partial) dataset name. Returns sessions containing matching datasets.
-            A dataset matches if it contains the search string e.g. 'wheel.position' matches
-            '_ibl_wheel.position.npy'. C.f. `datasets` argument.
+        datasets : str, list
+            One or more (exact) dataset names. Returns sessions containing all of these datasets.
         date_range : str, list, datetime.datetime, datetime.date, pandas.timestamp
             A single date to search or a list of 2 dates that define the range (inclusive).  To
             define only the upper or lower date bound, set the other element to None.
@@ -2222,11 +2258,12 @@ class OneAlyx(One):
             A str or list of lab location (as per Alyx definition) name.
             Note: this corresponds to the specific rig, not the lab geographical location per se.
         dataset_types : str, list
-            One or more of dataset_types.
-        datasets : str, list
-            One or more (exact) dataset names. Returns sessions containing all of these datasets.
+            One or more of dataset_types. Unlike with `datasets`, the dataset types for the
+            sessions returned may not be reachable (i.e. for recent sessions the datasets may not
+            yet be available).
         dataset_qc_lte : int, str, one.alf.spec.QC
-            The maximum QC value for associated datasets.
+            The maximum QC value for associated datasets. NB: Without `datasets`, not all
+            associated datasets with the matching QC values are guarenteed to be reachable.
         details : bool
             If true also returns a dict of dataset details.
         query_type : str, None
@@ -2271,6 +2308,9 @@ class OneAlyx(One):
         - In default and local mode, when the one.wildcards flag is True (default), queries are
           interpreted as regular expressions. To turn this off set one.wildcards to False.
         - In remote mode regular expressions are only supported using the `django` argument.
+        - In remote mode, only the `datasets` argument returns sessions where datasets are
+          registered *and* exist. Using `dataset_types` or `dataset_qc_lte` without `datasets`
+          will not check that the datasets are reachable.
 
         """
         query_type = query_type or self.mode
@@ -2340,7 +2380,7 @@ class OneAlyx(One):
 
         """
         df = pd.DataFrame(next(zip(*map(ses2records, session_records))))
-        return merge_tables(self._cache, sessions=df)
+        return merge_tables(self._cache, sessions=df, origin=self.alyx.base_url)
 
     def _download_datasets(self, dsets, **kwargs) -> List[ALFPath]:
         """Download a single or multitude of datasets if stored on AWS.

one/remote/globus.py

@@ -1211,7 +1211,7 @@ class Globus(DownloadClient):
     async def task_wait_async(self, task_id, polling_interval=10, timeout=10):
         """Asynchronously wait until a Task is complete or fails, with a time limit.
 
-        If the task status is ACTIVE after timout, returns False, otherwise returns True.
+        If the task status is ACTIVE after timeout, returns False, otherwise returns True.
 
         Parameters
         ----------

one/webclient.py

@@ -1155,7 +1155,8 @@ class AlyxClient:
             assert endpoint_scheme[action]['action'] == 'get'
             # add to url data if it is a string
             if id:
-                # this is a special case of the list where we query a uuid. Usually read is better
+                # this is a special case of the list where we query a uuid
+                # usually read is better but list may return fewer data and therefore be faster
                 if 'django' in kwargs.keys():
                     kwargs['django'] = kwargs['django'] + ','
                 else:
@@ -1163,6 +1164,9 @@ class AlyxClient:
                 kwargs['django'] = f"{kwargs['django']}pk,{id}"
             # otherwise, look for a dictionary of filter terms
             if kwargs:
+                # if django arg is present but is None, server will return a cryptic 500 status
+                if 'django' in kwargs and kwargs['django'] is None:
+                    del kwargs['django']
                 # Convert all lists in query params to comma separated list
                 query_params = {k: ','.join(map(str, ensure_list(v))) for k, v in kwargs.items()}
                 url = update_url_params(url, query_params)

{ONE_api-3.0b5.dist-info → one_api-3.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: ONE-api
-Version: 3.0b5
+Version: 3.1.1
 Summary: Open Neurophysiology Environment
 Author: IBL Staff
 License: MIT
@@ -21,6 +21,7 @@ Requires-Dist: iblutil>=1.14.0
 Requires-Dist: packaging
 Requires-Dist: boto3
 Requires-Dist: pyyaml
+Dynamic: license-file
 
 # Open Neurophysiology Environment
 [![Coverage Status](https://coveralls.io/repos/github/int-brain-lab/ONE/badge.svg?branch=main)](https://coveralls.io/github/int-brain-lab/ONE?branch=main)

{ONE_api-3.0b5.dist-info → one_api-3.1.1.dist-info}/RECORD

@@ -1,12 +1,12 @@
-one/__init__.py,sha256=nInf_OtC7ZRulDTsGaWoCYJCQdioyk1iYSfMN-_fbMU,76
-one/api.py,sha256=IWAjCBhw4DCLmfxcwVkOl0bgRlu2RXIV6Nyfey8HNas,131576
+one/__init__.py,sha256=w5ArMDExoOvziPE_Nix7Iafegwtcr75LLiks1Yl0Cl0,76
+one/api.py,sha256=YypYLcHsGEJ-gY7TEx5YR3NNT4AF5uIpZ0-H05ydFlQ,134054
 one/converters.py,sha256=icKlwPyxf3tJtyOFBj_SG06QDLIZLdTGalCSk1-cAvk,30733
 one/params.py,sha256=zwR0Yq09ztROfH3fJsCUc-IDs_PBixT3WU3dm1vX728,15050
 one/registration.py,sha256=cWvQFAzCF04wMZJjdOzBPJkYOJ3BO2KEgqtVG7qOlmA,36177
 one/util.py,sha256=NUG_dTz3_4GXYG49qSql6mFCBkaVaq7_XdecRPRszJQ,20173
-one/webclient.py,sha256=CfHKn6eZu-woed_VEeY8DV6WTzb49u41-lBTRe-EYnM,50132
+one/webclient.py,sha256=s7O5S9DhGnxj6g2xMfq1NsyvoBXd_Zz9UEw74A9VnBE,50409
 one/alf/__init__.py,sha256=DaFIi7PKlurp5HnyNOpJuIlY3pyhiottFpJfxR59VsY,70
-one/alf/cache.py,sha256=NDN-Ii8E19C6IH1C7EQEIIgPFah3AtM9jhjLeHuBIjM,22735
+one/alf/cache.py,sha256=09NDLGIUA6GcCJgzbDxSFpgq9sU6gyCuHIF8c7zHAMM,24814
 one/alf/exceptions.py,sha256=6Gw8_ZObLnuYUpY4i0UyU4IA0kBZMBnJBGQyzIcDlUM,3427
 one/alf/io.py,sha256=7mmd1wJwh7qok0WKkpGzkLxEuw4WSnaQ6EkGVvaODLI,30798
 one/alf/path.py,sha256=LpB0kdTPBzuEdAWGe5hFDWCKSq4FgCdiDk8LwVzv-T0,46793
@@ -14,7 +14,7 @@ one/alf/spec.py,sha256=eWW4UDMsyYO52gzadZ-l09X2adVbXwpRKUBtd7NlYMw,20711
 one/remote/__init__.py,sha256=pasT1r9t2F2_-hbx-5EKlJ-yCM9ItucQbeDHUbFJcyA,40
 one/remote/aws.py,sha256=DurvObYa8rgyYQMWeaq1ol7PsdJoE9bVT1NnH2rxRRE,10241
 one/remote/base.py,sha256=cmS5TwCPjlSLuoN2UN995O9N-4Zr8ZHz3in_iRopMgs,4406
-one/remote/globus.py,sha256=3a3r5n0j5KuwNs-khu9hRoNjFx4ODoZfuHgrgToEEgM,47510
+one/remote/globus.py,sha256=GZTuORKFGKmuO9a71YcaURXIozmjIj_--mD5hqsZmLw,47511
 one/tests/fixtures/datasets.pqt,sha256=oYfOoGJfT1HN_rj-zpAaNpzzJsneekvDqg4zQ6XOQgk,29918
 one/tests/fixtures/sessions.pqt,sha256=KmBvSi_o0fhSnFhOjQOTq1BHemZsbn89BcSVw4Ecp60,6916
 one/tests/fixtures/test_dbs.json,sha256=Dq6IBOjofB6YdsEJEZDSDe6Gh4WebKX4Erx7Hs2i8WQ,310
@@ -30,8 +30,8 @@ one/tests/fixtures/rest_responses/6dc96f7e9bcc6ac2e7581489b9580a6cd3f28293,sha25
 one/tests/fixtures/rest_responses/db1731fb8df0208944ae85f76718430813a8bf50,sha256=Dki7cTDg1bhbtPkuiv9NPRsuhM7TuicxoLcGtRD4D8g,209
 one/tests/fixtures/rest_responses/dcce48259bb929661f60a02a48563f70aa6185b3,sha256=skaKl6sPgTyrufCIGNVNJfccXM-jSjYvAdyqNS3HXuA,416
 one/tests/fixtures/rest_responses/f530d6022f61cdc9e38cc66beb3cb71f3003c9a1,sha256=EOqhNIVcmZ7j7aF09g5StFY434f2xbxwZLHwfeM4tug,22530
-ONE_api-3.0b5.dist-info/LICENSE,sha256=W6iRQJcr-tslNfY4gL98IWvPtpe0E3tcWCFOD3IFUqg,1087
-ONE_api-3.0b5.dist-info/METADATA,sha256=V71vo5_2W9rsjtyhah07thKb0zXKS0VkM53Zw3eYRu8,4148
-ONE_api-3.0b5.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-ONE_api-3.0b5.dist-info/top_level.txt,sha256=LIsI2lzmA5jh8Zrw5dzMdE3ydLgmq-WF6rpoxSVDSAY,4
-ONE_api-3.0b5.dist-info/RECORD,,
+one_api-3.1.1.dist-info/licenses/LICENSE,sha256=W6iRQJcr-tslNfY4gL98IWvPtpe0E3tcWCFOD3IFUqg,1087
+one_api-3.1.1.dist-info/METADATA,sha256=DtcBaq4qRm80sgWhjnQKvIC2yle_bdSTope6U8iAv7M,4170
+one_api-3.1.1.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+one_api-3.1.1.dist-info/top_level.txt,sha256=LIsI2lzmA5jh8Zrw5dzMdE3ydLgmq-WF6rpoxSVDSAY,4
+one_api-3.1.1.dist-info/RECORD,,

{ONE_api-3.0b5.dist-info → one_api-3.1.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.0)
+Generator: setuptools (80.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any