qcodespp 0.1.0__py3-none-any.whl

qcodespp/data/io.py

@@ -0,0 +1,241 @@
+"""
+IO managers for QCodespp.
+
+IO managers wrap whatever physical storage layer the user wants to use
+in an interface mimicking the built-in <open> context manager, with
+some restrictions to minimize the overhead in creating new IO managers.
+
+The main thing these managers need to implement is the open context manager:
+
+- Only the context manager needs to be implemented, not separate
+  open function and close methods.
+
+- open takes the standard parameters:
+
+    - filename: (string)
+    - mode: (string) only 'r' (read), 'w' (write), and 'a' (append) are
+      expected to be implemented. As with normal file objects, the only
+      difference between write and append is that write empties the file
+      before adding new data, and append leaves the existing contents in
+      place but starts writing at the end.
+    - encoding: If a special output encoding is desired. i.e. 'utf8
+
+- the file-like object returned should implement a minimal set of operations.
+
+  In read mode:
+    - read([size]): read to the end or at most size bytes into a string
+    - readline([size]): read until a newline or up to size bytes, into a string
+    - iter(): usually return self, but can be any iterator over lines
+    - next(): assuming iter() returns self, this yields the next line.
+
+  In write or append mode:
+    - write(s): add string s to the end of the file.
+    - writelines(seq): add a sequence of strings
+
+IO managers should also implement:
+
+- a join method, ala ``os.path.join(*args)``.
+- a list method, that returns all objects matching location
+- a remove method, ala os.remove(path) except that it will remove directories
+  as well as files, since we're allowing "locations" to be directories
+  or files.
+"""
+
+from contextlib import contextmanager
+import os
+import re
+import shutil
+from fnmatch import fnmatch
+
+ALLOWED_OPEN_MODES = ('r', 'w', 'a')
+
+
+class DiskIO:
+
+    """
+    Simple IO object to wrap disk operations with a custom base location.
+
+    Also accepts both forward and backward slashes at any point, and
+    normalizes both to the OS we are currently on.
+
+    Args:
+        base_location (str): a path to the root data folder.
+            Converted to an absolute path immediately, so even if you supply a
+            relative path, later changes to the OS working directory will not
+            affect data paths.
+    """
+
+    def __init__(self, base_location):
+        if base_location is None:
+            self.base_location = None
+        else:
+            base_location = self._normalize_slashes(base_location)
+            self.base_location = os.path.abspath(base_location)
+
+    @contextmanager
+    def open(self, filename, mode, encoding=None):
+        """
+        Mimic the interface of the built in open context manager.
+
+        Args:
+            filename (str): path relative to base_location.
+
+            mode (str): 'r' (read), 'w' (write), or 'a' (append).
+                Other open modes are not supported because we don't want
+                to force all IO managers to support others.
+
+        Returns:
+            context manager yielding the open file
+        """
+        if mode not in ALLOWED_OPEN_MODES:
+            raise ValueError('mode {} not allowed in IO managers'.format(mode))
+
+        filepath = self.to_path(filename)
+
+        # make directories if needed
+        dirpath = os.path.dirname(filepath)
+        if not os.path.exists(dirpath):
+            os.makedirs(dirpath)
+
+        # normally we'd construct this context manager with try/finally, but
+        # here we already have a context manager for open so we just wrap it
+        with open(filepath, mode, encoding=encoding) as f:
+            yield f
+
+    def _normalize_slashes(self, location):
+        # note that this is NOT os.path.join - the difference is os.path.join
+        # discards empty strings, so if you use it on a re.split absolute
+        # path you will get a relative path!
+        return os.sep.join(re.split('[\\\\/]', location)).rstrip(r'\\')
+
+    def to_path(self, location):
+        """
+        Convert a location string into a path on the local file system.
+
+        For DiskIO this just fixes slashes and prepends the base location,
+        doing nothing active with the file. But for other io managers that
+        refer to remote storage, this method may actually fetch the file and
+        put it at a temporary local path.
+
+        Args:
+            location (str): A location string for a complete dataset or
+                a file within it.
+
+        Returns:
+            path (str): The path on disk to which this location maps.
+        """
+        location = self._normalize_slashes(location)
+        if self.base_location:
+            return os.path.join(self.base_location, location)
+        else:
+            return location
+
+    def to_location(self, path):
+        """
+        Convert a local filesystem path into a location string.
+
+        Args:
+            path (str): a path on the local file system.
+
+        Returns:
+            location (str): the location string corresponding to this path.
+        """
+        if self.base_location:
+            return os.path.join(self.base_location, path)
+        else:
+            return path
+
+    def __repr__(self):
+        """Show the base location in the repr."""
+        return '<DiskIO, base_location={}>'.format(repr(self.base_location))
+
+    def join(self, *args):
+        """Context-dependent os.path.join for this io manager."""
+        return os.path.join(*list(map(self._normalize_slashes, args)))
+
+    def isfile(self, location):
+        """Check whether this location matches a file."""
+        path = self.to_path(location)
+        return os.path.isfile(path)
+
+    def list(self, location, maxdepth=1, include_dirs=False):
+        """
+        Return all files that match location.
+
+        This is either files whose names match up to an arbitrary extension,
+        or any files within an exactly matching directory name.
+
+        Args:
+            location (str): the location to match.
+                May contain the usual path wildcards * and ?
+
+            maxdepth (int, optional): maximum levels of directory nesting to
+                recurse into looking for files. Default 1.
+
+            include_dirs (bool, optional): whether to allow directories in
+                the results or just files. Default False.
+
+        Returns:
+            A list of matching files and/or directories, as locations
+            relative to our base_location.
+        """
+        location = self._normalize_slashes(location)
+        search_dir, pattern = os.path.split(location)
+        path = self.to_path(search_dir)
+
+        if not os.path.isdir(path):
+            return []
+
+        matches = [fn for fn in os.listdir(path) if fnmatch(fn, pattern + '*')]
+        out = []
+
+        for match in matches:
+            matchpath = self.join(path, match)
+            if os.path.isdir(matchpath) and fnmatch(match, pattern):
+                if maxdepth > 0:
+                    # exact directory match - walk down to maxdepth
+                    for root, dirs, files in os.walk(matchpath, topdown=True):
+                        depth = root[len(path):].count(os.path.sep)
+                        if depth == maxdepth:
+                            dirs[:] = []  # don't recurse any further
+
+                        for fn in files + (dirs if include_dirs else []):
+                            out.append(self.to_location(self.join(root, fn)))
+
+                elif include_dirs:
+                    out.append(self.join(search_dir, match))
+
+            elif (os.path.isfile(matchpath) and
+                  (fnmatch(match, pattern) or
+                   fnmatch(os.path.splitext(match)[0], pattern))):
+                # exact filename match, or match up to an extension
+                # note that we need fnmatch(match, pattern) in addition to the
+                # splitext test to cover the case of the base filename itself
+                # containing a dot.
+                out.append(self.join(search_dir, match))
+
+        return out
+
+    def remove(self, filename):
+        """Delete a file or folder and prune the directory tree."""
+        path = self.to_path(filename)
+        if os.path.isdir(path):
+            shutil.rmtree(path)
+        else:
+            os.remove(path)
+
+        filepath = os.path.split(path)[0]
+        try:
+            os.removedirs(filepath)
+        except OSError:
+            # directory was not empty - good that we're not removing it!
+            pass
+
+    def remove_all(self, location):
+        """
+        Delete all files/directories in the dataset at this location.
+
+        Afterward prunes the directory tree.
+        """
+        for fn in self.list(location):
+            self.remove(fn)

qcodespp/data/location.py

@@ -0,0 +1,171 @@
+"""Standard location_provider class(es) for creating DataSetPP locations."""
+from datetime import datetime
+import re
+import string
+
+from qcodes import config
+
+class SafeFormatter(string.Formatter):
+
+    """Modified string formatter that doesn't complain about missing keys."""
+
+    def get_value(self, key, args, kwargs):
+        """Missing keys just get left as they were: '{key}'."""
+        try:
+            return super().get_value(key, args, kwargs)
+        except:
+            return '{{{}}}'.format(key)
+
+
+class FormatLocation:
+
+    """
+    This is the default DataSetPP Location provider.
+
+    It provides a callable that returns a new (not used by another DataSetPP)
+    location string, based on a format string ``fmt`` and a dict ``record`` of
+    information to pass to ``fmt``.
+
+    Default record items are ``date``, ``time``, and ``counter``
+    Record item priority from lowest to highest (double items will be
+    overwritten):
+
+    - current ``date``, and ``time``
+    - record dict from ``__init__``
+    - record dict from ``__call__``
+    - automatic ``counter``
+
+    For example if any record dict contains a `date` keyword, it will no longer
+    be auto-generated.
+
+    Uses ``io.list`` to search for existing data at a matching location.
+
+    ``counter`` must NOT be provided in the record. If ``fmt`` contains
+    '{counter}', we look for existing files matching everything BEFORE this,
+    then find the highest counter (integer) among those files and use the next
+    value.
+
+    If the format string does not contain ``{counter}`` but the location we
+    would return is occupied, we add ``'_{counter}'`` to the end.
+
+    Usage::
+
+        loc_provider = FormatLocation(
+            fmt='{date}/#{counter}_{time}_{name}_{label}')
+        loc = loc_provider(DiskIO('.'),
+                           record={'name': 'Rainbow', 'label': 'test'})
+        loc
+        > '2016-04-30/#001_13-28-15_Rainbow_test'
+
+    Args:
+        fmt (str, optional): a format string that all the other info will be
+            inserted into. Default '{date}/{time}', or '{date}/{time}_{name}'
+            if there is a ``name`` in the record.
+
+        fmt_date (str, optional): a ``datetime.strftime`` format string,
+            should only use the date part. The result will be inserted in
+            '{date}' in ``fmt``. Default '%Y-%m-%d'.
+
+        fmt_time (str, optional): a ``datetime.strftime`` format string,
+            should only use the time part. The result will be inserted in
+            '{time}' in ``fmt``. Default '%H-%M-%S'.
+
+        fmt_counter (str, optional): a format string for the counter (integer)
+            which is automatically generated from existing DataSetPPs that the
+            io manager can see. Default '{03}'.
+
+        record (dict, optional): A dict of default values to provide when
+            calling the location_provider. Values provided later will
+            override these values.
+
+    Note:
+        Do not include date/time or number formatting in ``fmt`` itself, such
+        as '{date:%Y-%m-%d}' or '{counter:03}'
+    """
+
+    default_fmt = config['core']['default_fmt']
+
+    def __init__(self, fmt=None, fmt_date=None, fmt_time=None,
+                 fmt_counter=None, record=None):
+        # TODO(giulioungaretti) this should be
+        # FormatLocation.default_fmt
+        self.fmt = fmt or self.default_fmt
+        self.fmt_date = fmt_date or '%Y-%m-%d'
+        self.fmt_time = fmt_time or '%H-%M-%S'
+        self.fmt_counter = fmt_counter or '{:03}'
+        self.base_record = record
+        self.formatter = SafeFormatter()
+
+        self.counter = 0
+        for testval in (1, 23, 456, 7890):
+            if self._findint(self.fmt_counter.format(testval)) != testval:
+                raise ValueError('fmt_counter must produce a correct integer '
+                                 'representation of its argument (eg "{:03}")',
+                                 fmt_counter)
+
+    def _findint(self, s):
+        try:
+            return int(re.findall(r'\d+', s)[0])
+        except:
+            return 0
+
+    def __call__(self, io, record=None):
+        """
+        Call the location provider to get a new location.
+
+        Args:
+            io (io manager): where we intend to put the new DataSetPP.
+
+            record (dict, optional): information to insert in the format string
+                Any key provided here will override the default record
+        """
+        loc_fmt = self.fmt
+
+        time_now = datetime.now()
+        date = time_now.strftime(self.fmt_date)
+        time = time_now.strftime(self.fmt_time)
+        format_record = {'date': date, 'time': time}
+
+        if self.base_record:
+            format_record.update(self.base_record)
+        if record:
+            format_record.update(record)
+
+        if 'counter' in format_record:
+            raise KeyError('you must not provide a counter in your record.',
+                           format_record)
+
+        if ('name' in format_record) and ('{name}' not in loc_fmt):
+            loc_fmt += '_{name}'
+
+        if '{counter}' not in loc_fmt:
+            location = self.formatter.format(loc_fmt, **format_record)
+            if io.list(location):
+                loc_fmt += '_{counter}'
+                # redirect to the counter block below, but starting from 2
+                # because the already existing file counts like 1
+                existing_count = 1
+            else:
+                return location
+        else:
+            # if counter is already in loc_fmt, start from 1
+            existing_count = 0
+
+        # now search existing files for the next allowed counter
+
+        head_fmt = loc_fmt.split('{counter}', 1)[0]
+        # io.join will normalize slashes in head to match the locations
+        # returned by io.list
+        head = io.join(self.formatter.format(head_fmt, **format_record))
+
+        file_list = io.list(head + '*', maxdepth=0, include_dirs=True)
+
+        for f in file_list:
+            cnt = self._findint(f[len(head):])
+            existing_count = max(existing_count, cnt)
+
+        self.counter = existing_count + 1
+        format_record['counter'] = self.fmt_counter.format(self.counter)
+        location = self.formatter.format(loc_fmt, **format_record)
+
+        return location

qcodespp/instrument_drivers/Keysight/Keysight_34450A.py

@@ -0,0 +1,9 @@
+from .private.Keysight_344xxA import _Keysight_344xxA
+
+class Keysight_34450A(_Keysight_344xxA):
+    """
+    This is the qcodes driver for the Keysight 34450A Multimeter
+    """
+    def __init__(self, name, address, silent=False,
+                 **kwargs):
+        super().__init__(name, address, silent, **kwargs)