QuLab 2.10.10__cp313-cp313-win_amd64.whl

qulab/storage/models/record.py

@@ -0,0 +1,161 @@
+from datetime import date, datetime
+from typing import Sequence
+
+import dill
+from sqlalchemy import Column, DateTime, ForeignKey, Integer, String
+from sqlalchemy.orm import Session, relationship
+
+from .base import Base
+from .config import Config
+from .tag import get_object_with_tags, has_tags, tag
+
+
+@has_tags
+class Record(Base):
+    __tablename__ = 'records'
+
+    id = Column(Integer, primary_key=True)
+    ctime = Column(DateTime, default=datetime.utcnow)
+    mtime = Column(DateTime, default=datetime.utcnow)
+    atime = Column(DateTime, default=datetime.utcnow)
+    name = Column(String)
+    datafile_id = Column(Integer, ForeignKey('files.id'))
+    configfile_id = Column(Integer, ForeignKey('files.id'))
+    meta_id = Column(Integer, ForeignKey('files.id'))
+
+    datafile = relationship("File", foreign_keys=[datafile_id])
+    configfile = relationship("File", foreign_keys=[configfile_id])
+    metafile = relationship("File", foreign_keys=[meta_id])
+
+    @property
+    def data(self) -> dict:
+        result = dill.loads(self.datafile.read())
+        result['meta'] = self.meta
+        result['meta']['config'] = self.config
+        return result
+
+    @data.setter
+    def data(self, data: dict):
+        meta = data.pop('meta', {})
+        self.meta = meta
+        self.datafile.write(dill.dumps(data))
+
+    @property
+    def config(self) -> dict:
+        return dill.loads(self.configfile.read())
+
+    @config.setter
+    def config(self, data: dict):
+        self.configfile.write(dill.dumps(data))
+
+    @property
+    def meta(self) -> dict:
+        meta = dill.loads(self.metafile.read())
+        meta['id'] = self.id
+        meta['name'] = self.name
+        meta['ctime'] = self.ctime
+        meta['mtime'] = self.mtime
+        meta['atime'] = self.atime
+        return meta
+
+    @meta.setter
+    def meta(self, data: dict):
+        if 'config' in data:
+            config = data.pop('config', {})
+            self.config = config
+        self.metafile.write(dill.dumps(data))
+
+    def export(self, path):
+        with open(path, 'wb') as f:
+            f.write(self.data)
+
+    def __init__(self, name: str, data: bytes) -> None:
+        self.name = name
+        self.data = data
+
+    def __str__(self) -> str:
+        return self.name
+
+    def __repr__(self) -> str:
+        return f'Record({self.name!r})'
+
+
+def query_record(
+        session: Session,
+        offset: int = 0,
+        limit: int = 10,
+        name: str | None = None,
+        tags: Sequence[str] = (),
+        before: datetime | date | None = None,
+        after: datetime | date | None = None) -> tuple[int, dict, dict]:
+    from waveforms.dicttree import foldDict
+
+    local_tm = datetime.fromtimestamp(0)
+    utc_tm = datetime.utcfromtimestamp(0)
+    tz_offset = local_tm - utc_tm
+    table = {'header': ['ID', 'Name', 'tags', 'created time'], 'body': []}
+    name_lst = sorted(
+        set([
+            n for n, *_ in get_object_with_tags(session.query(Record.name),
+                                                Record, *tags).all()
+        ]))
+    name_tr = foldDict(dict([(name, None) for name in name_lst]))
+
+    query = get_object_with_tags(session, Record, *tags)
+
+    if name is not None:
+        if name.endswith('*'):
+            query = query.filter(Record.name.like(name[:-1] + '%'))
+        else:
+            query = query.filter(Record.name == name)
+    if before is not None:
+        if isinstance(before, date):
+            before = datetime(before.year, before.month, before.day)
+        query = query.filter(Record.ctime <= before - tz_offset)
+    if after is not None:
+        if isinstance(after, date):
+            after = datetime(after.year, after.month, after.day)
+        query = query.filter(Record.ctime >= after - tz_offset)
+    total = query.count()
+    for r in query.order_by(Record.ctime.desc()).limit(limit).offset(offset):
+        tags = sorted([t.text for t in r.tags])
+        ctime = r.ctime + tz_offset
+        row = [r.id, r.name, tags, ctime]
+        table['body'].append(row)
+
+    return total, name_tr, table
+
+
+def update_tags(session: Session,
+                record_id: int,
+                tags: Sequence[str],
+                append: bool = False):
+    record = session.get(Record, record_id)
+    if record is None:
+        return False
+    if append:
+        old = [t.text for t in record.tags]
+        for t in old:
+            if t not in tags:
+                tags.append(t)
+    record.tags = [tag(session, t) for t in tags]
+    try:
+        session.commit()
+    except Exception:
+        session.rollback()
+        return False
+    return True
+
+
+def remove_tags(session: Session, record_id: int, tags: Sequence[str]):
+    record = session.get(Record, record_id)
+    if record is None:
+        return False
+    old = [t.text for t in record.tags]
+    record.tags = [tag(session, t) for t in old if t not in tags]
+    try:
+        session.commit()
+    except Exception:
+        session.rollback()
+        return False
+    return True

qulab/storage/models/report.py

@@ -0,0 +1,22 @@
+from .base import Base
+from .tag import Tag, has_tags
+from sqlalchemy import Column, DateTime, ForeignKey, Integer, String
+from sqlalchemy.orm import relationship
+from datetime import datetime
+
+@has_tags
+class Report(Base):
+    __tablename__ = 'reports'
+
+    id = Column(Integer, primary_key=True)
+    ctime = Column(DateTime, default=datetime.utcnow)
+    mtime = Column(DateTime, default=datetime.utcnow)
+
+    name = Column(String)
+    datafile_id = Column(Integer, ForeignKey('files.id'))
+    configfile_id = Column(Integer, ForeignKey('files.id'))
+    meta_id = Column(Integer, ForeignKey('files.id'))
+
+    datafile = relationship("File", foreign_keys=[datafile_id])
+    configfile = relationship("File", foreign_keys=[configfile_id])
+    metafile = relationship("File", foreign_keys=[meta_id])

qulab/storage/models/tag.py

@@ -0,0 +1,93 @@
+from typing import Type
+
+from sqlalchemy import Column, ForeignKey, Integer, String, Table
+from sqlalchemy.orm import Query, Session, aliased, relationship
+from sqlalchemy.orm.exc import NoResultFound
+
+from . import Base
+
+
+class Tag(Base):
+    __tablename__ = 'tags'
+
+    id = Column(Integer, primary_key=True)
+    name = Column(String, unique=True)
+
+    def __init__(self, name: str) -> None:
+        self.name = name
+
+    def __str__(self) -> str:
+        return self.name
+
+    def __repr__(self) -> str:
+        return f'Tag({self.name!r})'
+
+
+def has_tags(cls: Type[Base]) -> Type[Base]:
+    table = Table(
+        f'{cls.__tablename__}_tags', Base.metadata,
+        Column('item_id',
+               ForeignKey(f'{cls.__tablename__}.id'),
+               primary_key=True),
+        Column('tag_id', ForeignKey('tags.id'), primary_key=True))
+
+    cls.tags = relationship("Tag", secondary=table, backref=cls.__tablename__)
+
+    def add_tag(self, tag: Tag):
+        if tag not in self.tags:
+            self.tags.append(tag)
+
+    def remove_tag(self, tag: Tag):
+        if tag in self.tags:
+            self.tags.remove(tag)
+
+    cls.add_tag = add_tag
+    cls.remove_tag = remove_tag
+
+    return cls
+
+
+def tag(session: Session, tag_text: str) -> Tag:
+    """Get a tag from the database or create a new if not exists."""
+    try:
+        return session.query(Tag).filter(Tag.text == tag_text).one()
+    except NoResultFound:
+        tag = Tag(text=tag_text)
+        return tag
+
+
+def get_object_with_tags(session: Session, cls: Type[Base],
+                         *tags: str) -> Query:
+    """
+    Query objects with the given tags.
+
+    Parameters
+    ----------
+    session : :class:`sqlalchemy.orm.Session`
+        The database session.
+    cls : :class:`sqlalchemy.orm.Mapper`
+        The object class.
+    tags : str
+        The tags.
+
+    Returns
+    -------
+    :class:`sqlalchemy.orm.Query`
+        The query.
+    """
+    if isinstance(session, Query):
+        q = session
+    else:
+        q = session.query(cls)
+    if not hasattr(cls, 'tags'):
+        return []
+
+    aliase = {tag: aliased(Tag) for tag in tags}
+
+    for tag, a in aliase.items():
+        q = q.join(a, cls.tags)
+        if '*' in tag:
+            q = q.filter(a.text.like(tag.replace('*', '%')))
+        else:
+            q = q.filter(a.text == tag)
+    return q

qulab/storage/storage.py

@@ -0,0 +1,95 @@
+import shutil
+from abc import ABC, abstractmethod
+from datetime import date, datetime
+from pathlib import Path
+from typing import Any
+from uuid import UUID, uuid1, uuid5
+
+from .file import load
+
+
+class BaseStorage(ABC):
+
+    @abstractmethod
+    def _create_dataset(self) -> UUID:
+        """Create a new dataset and return its id"""
+        pass
+
+    @abstractmethod
+    def _delet_dataset(self, id: UUID):
+        """Delete a dataset"""
+        pass
+
+    @abstractmethod
+    def _dataset_getitem(self, id: UUID, key: str):
+        """Get a dataset item"""
+        pass
+
+    @abstractmethod
+    def _dataset_setitem(self, id: UUID, key: str, value: Any):
+        """Set a dataset item"""
+        pass
+
+    @abstractmethod
+    def _dataset_delitem(self, id: UUID, key: str):
+        """Delete a dataset item"""
+        pass
+
+    @abstractmethod
+    def _dataset_keys(self, id: UUID):
+        """Get dataset keys"""
+        pass
+
+    @abstractmethod
+    def _dataset_append(self, id: UUID, dataframe: dict[str, Any]):
+        """Append a dataframe to a dataset"""
+        pass
+
+    @abstractmethod
+    def _dataset_item_append(self, id: UUID, key: str, value: Any):
+        """Append a value to a dataset item"""
+        pass
+
+
+class Storage(BaseStorage):
+
+    def __init__(self, base: Path | str):
+        if isinstance(base, str):
+            base = Path(base)
+        self.base = base
+        self.namespace = uuid5(UUID('f89f735a-791e-5a43-9ba6-f28d58601544'),
+                               base.as_posix())
+
+    def clear(self):
+        shutil.rmtree(self.base)
+        self.base.mkdir(parents=True)
+
+    def uuid(self,
+             name: str | None = None,
+             namespace: UUID | None = None,
+             seq: int = 0) -> UUID:
+        if name is None:
+            name = str(uuid1())
+        if namespace is None:
+            return uuid5(self.namespace, f"{name}{seq}")
+        else:
+            return uuid5(namespace, f"{name}{seq}")
+
+    def uuid_to_path(self, uuid: UUID) -> Path:
+        return self.base / uuid.hex[:2] / uuid.hex[2:4] / uuid.hex[4:]
+
+    def create_dataset(self, title: str, tags: list[str] = []):
+        from .dataset import Dataset
+        id = self.uuid()
+        return Dataset(id, self)
+
+    def get_dataset(self, id: UUID):
+        from .dataset import Dataset
+        return Dataset(id, self)
+
+    def remove_dataset(self, id: UUID):
+        shutil.rmtree(self.uuid_to_path(id))
+
+    def query(self, title_pattern: str, tags: list[str],
+              before: datetime | date, after: datetime | date):
+        pass

qulab/sys/__init__.py

@@ -0,0 +1,2 @@
+from .device import (BaseDevice, VisaDevice, action, create_device, delete,
+                     exclude, get, post, set)