ONE-api 3.1.1__tar.gz → 3.2.0__tar.gz

{one_api-3.1.1 → one_api-3.2.0/ONE_api.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ONE-api
-Version: 3.1.1
+Version: 3.2.0
 Summary: Open Neurophysiology Environment
 Author: IBL Staff
 License: MIT

{one_api-3.1.1/ONE_api.egg-info → one_api-3.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ONE-api
-Version: 3.1.1
+Version: 3.2.0
 Summary: Open Neurophysiology Environment
 Author: IBL Staff
 License: MIT

{one_api-3.1.1 → one_api-3.2.0}/one/__init__.py

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

{one_api-3.1.1 → one_api-3.2.0}/one/alf/path.py

@@ -859,6 +859,36 @@ class PureALFPath(pathlib.PurePath):  # py3.12 supports direct subclassing
         """tuple of str: the full ALF path parts, with empty strings for missing parts."""
         return tuple(p or '' for p in self.parse_alf_path(as_dict=False))
 
+    @property
+    def lab(self):
+        """str: The lab part of the ALF path, or an empty str if not present."""
+        return self.session_parts[0]
+
+    @property
+    def subject(self):
+        """str: The subject part of the ALF path, or an empty str if not present."""
+        return self.session_parts[1]
+
+    @property
+    def date(self):
+        """str: The date part of the ALF path, or an empty str if not present."""
+        return self.session_parts[2]
+
+    @property
+    def sequence(self):
+        """str: The number part of the ALF path, or an empty str if not present."""
+        return self.session_parts[3]
+
+    @property
+    def collection(self):
+        """str: The collection part of the ALF path, or an empty str if not present."""
+        return self.alf_parts[4]
+
+    @property
+    def revision(self):
+        """str: The revision part of the ALF path, or an empty str if not present."""
+        return self.alf_parts[5]
+
     @property
     def namespace(self):
         """str: The namespace part of the ALF name, or and empty str if not present."""
@@ -884,6 +914,134 @@ class PureALFPath(pathlib.PurePath):  # py3.12 supports direct subclassing
         """str: The extra part of the ALF name, or and empty str if not present."""
         return self.dataset_name_parts[4]
 
+    def with_lab(self, lab, strict=False):
+        """Return a new path with the ALF lab changed.
+
+        Parameters
+        ----------
+        lab : str
+            An ALF lab name part to use.
+        strict : bool, optional
+            If True, the lab part must be present in the path, otherwise the lab/Subjects/ part
+            is added if not present.
+
+        Returns
+        -------
+        PureALFPath
+            The same file path but with the lab part replaced with the input.
+
+        Raises
+        ------
+        ValueError
+            The lab name is invalid.
+        ALFInvalid
+            The path is not a valid ALF session path, or the lab part is not present in the path
+            when strict is True.
+
+        """
+        if not (lab and spec.regex('^{lab}$').match(lab)):
+            raise ValueError(f'Invalid lab name: {lab}')
+        if not self.subject or (strict and not self.lab):  # FIXME check logic
+            raise ALFInvalid(str(self))
+
+        pattern = spec.regex(SESSION_SPEC)
+        repl = fr'{lab}/Subjects/\g<subject>/\g<date>/\g<number>'
+        return self.__class__(pattern.sub(repl, self.as_posix(), count=1))
+
+    def with_subject(self, subject):
+        """Return a new path with the ALF subject changed.
+
+        Parameters
+        ----------
+        subject : str
+            An ALF subject name part to use.
+
+        Returns
+        -------
+        PureALFPath
+            The same file path but with the subject part replaced with the input.
+
+        Raises
+        ------
+        ValueError
+            The subject name is invalid.
+        ALFInvalid
+            The path is not a valid ALF session path.
+
+        """
+        if not (subject and spec.regex('^{subject}$').match(subject)):
+            raise ValueError(f'Invalid subject name: {subject}')
+        if not self.subject:
+            raise ALFInvalid(str(self))
+
+        pattern = spec.regex('{subject}/{date}/{number}')
+        repl = fr'{subject}/\g<date>/\g<number>'
+        return self.__class__(pattern.sub(repl, self.as_posix()), count=1)
+
+    def with_date(self, date):
+        """Return a new path with the ALF date changed.
+
+        Parameters
+        ----------
+        date : str, datetime.datetime, datetime.date
+            An ALF date part to use, in YYYY-MM-DD format.
+
+        Returns
+        -------
+        PureALFPath
+            The same file path but with the date part replaced with the input.
+
+        Raises
+        ------
+        ValueError
+            The date is not in YYYY-MM-DD format.
+        ALFInvalid
+            The path is not a valid ALF session path.
+
+        """
+        if date and not isinstance(date, str):
+            date = str(date)[:10]
+        if not (date and spec.regex('^{date}$').match(date)):
+            raise ValueError(f'Invalid date: {date}')
+        if not self.date:
+            raise ALFInvalid(str(self))
+
+        pattern = spec.regex('{subject}/{date}/{number}')
+        repl = fr'\g<subject>/{date}/\g<number>'
+        return self.__class__(pattern.sub(repl, self.as_posix()), count=1)
+
+    def with_sequence(self, number):
+        """Return a new path with the ALF number changed.
+
+        Parameters
+        ----------
+        number : str, int
+            An ALF number part to use, as a string or integer.
+
+        Returns
+        -------
+        PureALFPath
+            The same file path but with the number part replaced with the input.
+
+        Raises
+        ------
+        ValueError
+            The number is not a valid ALF number.
+        ALFInvalid
+            The path is not a valid ALF session path.
+
+        """
+        if isinstance(number, str):
+            number = int(number.strip())
+        if number is None or not spec.regex('^{number}$').match(str(number)):
+            raise ValueError(f'Invalid number: {number}')
+        if not self.sequence:
+            raise ALFInvalid(str(self))
+
+        pattern = spec.regex('{subject}/{date}/{number}')
+        repl = fr'\g<subject>/\g<date>/{number:03d}'
+        return self.__class__(pattern.sub(repl, self.as_posix()), count=1)
+
     def with_object(self, obj):
         """Return a new path with the ALF object changed.
 
@@ -1084,6 +1242,58 @@ class PureALFPath(pathlib.PurePath):  # py3.12 supports direct subclassing
         """
         return padded_sequence(path)
 
+    def with_collection(self, collection):
+        """Return a new path with the ALF collection part added/changed.
+
+        NB: The ALFPath must include the session parts (subject/date/number) for this to work.
+
+        Parameters
+        ----------
+        collection : str
+            An ALF collection part to use.
+
+        Returns
+        -------
+        PureALFPath
+            The same file path but with the collection part added or replaced with the input.
+
+        Raises
+        ------
+        ValueError
+            The collection name is invalid.
+            The path does not include the session parts (subject/date/number).
+        ALFInvalid
+            The path is not a valid ALF session path.
+
+        """
+        collection = pathlib.PurePath(collection or '').as_posix().strip('/')
+        if not (collection and spec.regex('^{collection}$').match(collection)):
+            raise ValueError(f'Invalid collection name: {collection}')
+        # Check path contains session parts
+        if not self.session_path():
+            raise ValueError(
+                'Cannot add collection to a path without session parts, e.g. subject/date/number'
+            )
+        # If the path is a session path, simply append the collection to it
+        if self.is_session_path():
+            return self.joinpath(collection)
+        # Otherwise substitute the collection with regex
+        string = self.as_posix()
+        if not self.is_dataset():
+            cpat = spec.regex(f'^{COLLECTION_SPEC}$')
+            if cpat.match(self.relative_to_session().as_posix() + '/'):
+                string += '/'  # ensure trailing slash for matching folder paths
+            else:
+                raise ALFInvalid(str(self))
+        # Replace the collection part in the path
+        # NB: We don't use SESSION_SPEC here to avoid handling optional lab part
+        pattern = spec.regex('{subject}/{date}/{number}/' + COLLECTION_SPEC)
+        match = pattern.search(string)
+        repl = fr'\g<subject>/\g<date>/\g<number>/{collection}/'
+        if match.groupdict()['revision']:
+            repl += r'#\g<revision>#/'
+        return self.__class__(pattern.sub(repl, string), count=1)
+
     def with_revision(self, revision):
         """Return a new path with the ALF revision part added/changed.
 

{one_api-3.1.1 → one_api-3.2.0}/one/api.py

@@ -39,7 +39,7 @@ from one import util
 
 _logger = logging.getLogger(__name__)
 __all__ = ['ONE', 'One', 'OneAlyx']
-SAVE_ON_DELETE = (os.environ.get('ONE_SAVE_ON_DELETE') or '1').casefold() in ('true', '1')
+SAVE_ON_DELETE = (os.environ.get('ONE_SAVE_ON_DELETE') or '0').casefold() in ('true', '1')
 """bool: Whether to save modified cache tables on delete."""
 
 _logger.debug('ONE_SAVE_ON_DELETE: %s', SAVE_ON_DELETE)
@@ -221,7 +221,7 @@ class One(ConversionMixin):
                     created = created.isoformat(sep=' ', timespec='minutes')
                     meta['raw'][table]['date_created'] = created
 
-        with FileLock(save_dir, log=_logger, timeout=TIMEOUT, timeout_action='delete'):
+        with FileLock(save_dir / '.ONE', 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, {})

{one_api-3.1.1 → one_api-3.2.0}/one/webclient.py

@@ -77,7 +77,7 @@ class _JSONEncoder(json.JSONEncoder):
 
 
 def _cache_response(method):
-    """Decorator for the generic request method for caching REST reponses.
+    """Decorator for the generic request method for caching REST responses.
 
     Caches the result of the query and on subsequent calls, returns cache instead of hitting the
     database.