pyqttoolkit 0.9.1__py3-none-any.whl

pyqttoolkit/data/cache.py

@@ -0,0 +1,64 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+from collections import deque
+
+class Cache:
+    def __init__(self, size):
+        self._storage = deque(maxlen=size)
+    
+    def __contains__(self, key):
+        for k, v in self._storage:
+            if k == key:
+                return True
+        return False
+
+    def __getitem__(self, key):
+        for k, v in self._storage:
+            if k == key:
+                return v
+        raise KeyError(key)
+    
+    def __setitem__(self, key, value):
+        if key in self:
+            del self[key]
+        self._storage.append((key, value))
+
+    def __delitem__(self, key):
+        if key not in self:
+            raise KeyError(key)
+        for k, v in self._storage:
+            if k == key:
+                self._storage.remove((key, v))
+                return
+    
+    def delete_group(self, group):
+        to_remove = []
+        for k, v in self._storage:
+            if k.startswith(group):
+                to_remove.append((k, v))
+        for v in to_remove:
+            self._storage.remove(v)
+            
+    def setdefault(self, key, default_factory):
+        if key in self:
+            return self[key]
+        value = default_factory()
+        self[key] = value
+        return value
+    
+    def clear(self):
+        self._storage.clear()

pyqttoolkit/data/interval.py

@@ -0,0 +1,26 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+import pandas as pd
+
+def calculate_interval(values, sort=True):
+    if len(values) < 2:
+        return None
+    values_series = pd.Series(values)
+    if sort:
+        values_series = values_series.sort_values()
+    # We want to ensure that the calculated interval is accurate for 90% of values to avoid mistakenly losing values
+    return (values_series - values_series.shift(1)).quantile(0.1)

pyqttoolkit/data/message.py

@@ -0,0 +1,29 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+from enum import Enum, IntEnum
+
+class MessageType(Enum):
+    validation_error = 0
+    confirmation = 1
+    application_exception = 2
+
+class MessageResponse(IntEnum):
+    ok = 1
+    cancel = 2
+    save = 4
+    discard = 8
+    ignore = 16

pyqttoolkit/data/names.py

@@ -0,0 +1,24 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+
+def get_next_available_name(name_basis, names):
+    i = 1
+    while True:
+        next_name = f'{name_basis} {i}' if i > 1 else name_basis
+        if next_name not in names:
+            return next_name
+        i += 1

pyqttoolkit/datetime/__init__.py

@@ -0,0 +1,16 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA

pyqttoolkit/datetime/datetime.py

@@ -0,0 +1,51 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+from datetime import datetime, timedelta
+from dateutil.parser import parse as parse_datetime
+
+def isoformat_to_datetime(isoformat: str):
+    if isoformat is None:
+        return None
+    return parse_datetime(isoformat)
+
+def round_timedelta(delta, resolution):
+    if resolution is None:
+        return delta
+    days = delta.days - (delta.days % resolution.days) if resolution.days else delta.days
+    seconds = delta.seconds - (delta.seconds % resolution.seconds) if resolution.seconds else delta.seconds
+    return timedelta(days=days, seconds=seconds)
+
+def round_datetime(time, resolution):
+    if resolution is None:
+        return time
+    day = time.day - (time.day % resolution.days) if resolution.days else time.day
+    hour = time.hour - (time.hour % resolution.seconds // 3600) if resolution.seconds // 3600 else time.hour
+    minute = time.minute - (time.minute % ((resolution.seconds // 60) % 60)) if (resolution.seconds // 60) % 60 else time.minute
+    second = time.second - (time.second % resolution.seconds) if resolution.seconds else time.second
+    microsecond = time.microsecond - (time.microsecond % resolution.microseconds) if resolution.microseconds else time.microsecond
+    return datetime(year=time.year, month=time.month, day=day, hour=hour, minute=minute, second=second, microsecond=microsecond, tzinfo=time.tzinfo)
+
+def iso_year_start(iso_year):
+    "The gregorian calendar date of the first day of the given ISO year"
+    fourth_jan = datetime(iso_year, 1, 4)
+    delta = timedelta(fourth_jan.isoweekday()-1)
+    return fourth_jan - delta 
+
+def iso_to_gregorian(iso_year, iso_week, iso_day):
+    "Gregorian calendar date for the given ISO year, week and day"
+    year_start = iso_year_start(iso_year)
+    return year_start + timedelta(days=iso_day-1, weeks=iso_week-1)

pyqttoolkit/datetime/qdatetime.py

@@ -0,0 +1,53 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+from datetime import datetime, timedelta
+from .datetime import round_timedelta
+
+import pandas as pd
+
+from PyQt5.QtCore import QDateTime, QDate, QTime
+
+def q_datetime_to_datetime(q_datetime: QDateTime):
+    if q_datetime is None or not q_datetime.isValid():
+        return None
+
+    return datetime(
+        q_datetime.date().year(), q_datetime.date().month(), q_datetime.date().day(),
+        q_datetime.time().hour(), q_datetime.time().minute(), q_datetime.time().second(),
+        q_datetime.time().msec() * 1000
+    )
+
+
+def pd_timestamp_to_q_datetime(pd_timestamp: datetime):
+    if pd_timestamp is None or pd.isna(pd_timestamp):
+        return QDateTime()
+    return QDateTime(
+        QDate(pd_timestamp.year, pd_timestamp.month, pd_timestamp.day),
+        QTime(pd_timestamp.hour, pd_timestamp.minute, pd_timestamp.second, pd_timestamp.microsecond // 1000)
+    )
+
+def step_qdatetime(control, fraction, interval, range_start, range_end):
+    date_from = q_datetime_to_datetime(control.dateFrom)
+    date_to = q_datetime_to_datetime(control.dateTo)
+    range_start = q_datetime_to_datetime(range_start)
+    range_end = q_datetime_to_datetime(range_end)
+    delta = round_timedelta((date_to - date_from) * fraction, interval)
+    date_from = max(date_from + delta, range_start)
+    date_to = min(date_to + delta, range_end)
+    if date_to - date_from > timedelta(0):
+        control.dateTo = QDateTime(date_to)
+        control.dateFrom = QDateTime(date_from)

pyqttoolkit/dependencies/__init__.py

@@ -0,0 +1,56 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+import inspect
+
+class MissingDependency(Exception):
+    def __init__(self, object_type, dependency_name):
+        Exception.__init__(self, object_type, dependency_name)
+
+class DependencyContainer:
+    def __init__(self):
+        self._instances = {}
+        self._types = {}
+
+    def register_instance(self, name, value):
+        self._instances[name] = value
+    
+    def register_type(self, type_for, base_type, result_type):
+        self._types.setdefault(type_for, {})[base_type] = result_type
+
+    def get_instance(self, name):
+        return self._instances[name]
+
+    def resolve(self, type_, extras=None, none_for_missing=False):
+        args = self._get_args(type_)
+        all_dependencies = {**self._instances, **(extras or {})}
+        for arg_name, arg in args.items():
+            if arg_name not in all_dependencies:
+                if arg.default != inspect.Parameter.empty:
+                    all_dependencies[arg_name] = arg.default
+                elif none_for_missing:
+                    all_dependencies[arg_name] = None
+                else:
+                    raise MissingDependency(type_, arg_name)
+        return type_(**{a: all_dependencies[a] for a in args})
+    
+    def resolve_for(self, type_for, base_type, extras=None):
+        type_to_resolve = self._types[type_for][base_type]
+        return self.resolve(type_to_resolve, extras)
+    
+    @staticmethod
+    def _get_args(type_):
+        return inspect.signature(type_).parameters

pyqttoolkit/errors/__init__.py

@@ -0,0 +1,19 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+class InvalidDataError(Exception):
+    def __init__(self, name, error):
+        Exception.__init__(self, f'{name}: {error}')

pyqttoolkit/exceptions/__init__.py

@@ -0,0 +1,18 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+class TaskCancelled(Exception):
+    pass

pyqttoolkit/filesystem/__init__.py

@@ -0,0 +1,24 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+from PyQt5.QtCore import QUrl
+#pylint: enable=no-name-in-module
+
+def sanitise_filename(maybe_qurl_filename):
+    return (
+        QUrl(maybe_qurl_filename).toLocalFile() if 'file://' in maybe_qurl_filename
+        else maybe_qurl_filename
+    )

pyqttoolkit/logs/__init__.py

@@ -0,0 +1,140 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+from typing import Callable
+from io import StringIO
+import logging
+from logging import handlers
+from functools import wraps
+from os import path, makedirs
+from enum import Enum
+import appdirs
+
+class CustomLogLevel(Enum):
+    TRACE = 5
+
+TRACE = CustomLogLevel.TRACE.value
+
+LOG_DIR = None
+LOG_FILE = None
+
+def get_log_dir():
+    global LOG_DIR
+    if LOG_DIR is None:
+        LOG_DIR = path.join(path.dirname(appdirs.AppDirs('PyQtToolkit', roaming=True).user_data_dir), 'logs')
+    return LOG_DIR
+
+def get_log_file(log_dir):
+    global LOG_FILE, LOG_DIR
+    if LOG_FILE is None:
+        LOG_FILE = 'app.log'
+    return path.join(LOG_DIR, LOG_FILE)
+
+def configure_logging(log_level, console, log_filter=None, log_file=None):
+    global LOG_DIR, LOG_FILE
+    if log_file is not None:
+        log_file = path.abspath(path.normpath(log_file))
+        LOG_DIR = path.dirname(log_file)
+        LOG_FILE = path.basename(log_file)
+
+    logging.addLevelName(TRACE, 'TRACE')
+
+    numeric_level = getattr(logging, log_level.upper(), None)
+    if not isinstance(numeric_level, int):
+        enum_level = getattr(CustomLogLevel, log_level.upper(), None)
+        if isinstance(enum_level, CustomLogLevel):
+            numeric_level = enum_level.value
+        else:
+            numeric_level = logging.INFO
+
+    logging.getLogger().setLevel(numeric_level)
+
+    rollover_bytes = 100 * 1024
+    dir_name = get_log_dir()
+    if not path.isdir(dir_name):
+        makedirs(dir_name)
+    
+    log_file = get_log_file(dir_name)
+
+    do_rollover = path.isfile(log_file)
+
+    file_handler = handlers.RotatingFileHandler(
+        get_log_file(dir_name),
+        mode='w',
+        maxBytes=rollover_bytes,
+        backupCount=10
+    )
+    if do_rollover:
+        file_handler.doRollover()
+    file_handler.setLevel(numeric_level)
+    if log_filter:
+        file_handler.addFilter(log_filter)
+    file_formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+    file_handler.setFormatter(file_formatter)
+    logging.getLogger().addHandler(file_handler)
+
+    if console:
+        console_handler = logging.StreamHandler()
+        console_handler.setLevel(numeric_level)
+        console_handler.setFormatter(file_formatter)
+        if log_filter:
+            console_handler.addFilter(log_filter)
+        logging.getLogger().addHandler(console_handler)
+
+def log_debug(_f):
+    return logf(logging.DEBUG)
+
+def logf(level, log_args=True):
+    def logf_decorator(f):
+        @wraps(f)
+        def _(*args, **kwargs):
+            logger = logging.getLogger(f.__name__)
+            if log_args:
+                logger.log(level, 'Entering, args: %s, kwargs: %s', args, kwargs)
+            else:
+                logger.log(level, f'Entering')
+            result = f(*args, **kwargs)
+            logger.log(level, 'Exiting')
+            return result
+        return _
+    return logf_decorator
+
+
+class LogStream:
+    def __init__(self, notify_update: Callable = None):
+        self._buffer = StringIO()
+        self._notify_update = notify_update
+
+    def __iadd__(self, other):
+        self.write(other)
+        return self
+
+    def write(self, message):
+        self._buffer.write(message)
+        if self._notify_update:
+            self._notify_update()
+
+    def flush(self):
+        self._buffer.flush()
+
+    def getvalue(self):
+        return self._buffer.getvalue()
+
+    def clear(self):
+        self._buffer.close()
+        self._buffer = StringIO()
+        if self._notify_update:
+            self._notify_update()

pyqttoolkit/metadata/__init__.py

@@ -0,0 +1,23 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+from .dict_metadata_manager import DictMetadataManager
+from .id_generator import next_id
+try:
+    from .dataframe_metadata_manager import DataframeMetadataManager
+except ImportError:
+    import warnings
+    warnings.warn('Unable to import DataframeMetadataManager - please ensure pandas is installed', ImportWarning)

pyqttoolkit/metadata/dataframe_metadata_manager.py

@@ -0,0 +1,105 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+from enum import Enum
+from copy import deepcopy
+import json
+
+import pandas as pd
+
+from .metadata_manager_base import MetadataManagerBase
+
+class DataframeMetadataManager(MetadataManagerBase):
+    def __init__(self, project_manager):
+        MetadataManagerBase.__init__(self, project_manager)
+
+    def get_property(self, id_, property_):
+        if not isinstance(property_, Enum):
+            raise TypeError('Property must be enum type')
+        property_type = type(property_)
+        property_type_key = self._get_property_type_key(property_type)
+        if property_type_key not in self.metadata:
+            return None
+        if id_ not in self.metadata[property_type_key].index:
+            return None
+        if property_.name not in self.metadata[property_type_key].columns:
+            return None
+        value_read = deepcopy(self.metadata[property_type_key].loc[id_, property_.name])
+        if isinstance(value_read, str) and value_read.startswith('json:'):
+            return json.loads(value_read.replace('json:', ''))
+        return value_read
+        
+    def set_property(self, id_, property_, value):
+        if not isinstance(property_, Enum):
+            raise TypeError('Property must be enum type')
+        if id_ is None:
+            raise ValueError('Must specify an ID')
+        property_type = type(property_)
+        property_type_key = self._get_property_type_key(property_type)
+        if not property_type_key in self.metadata:
+            self.metadata[property_type_key] = pd.DataFrame(columns=self.columns(property_type))
+        if not id_ in self.metadata[property_type_key].index:
+            self.metadata[property_type_key].loc[id_, :] = None
+        if not property_.name in self.metadata[property_type_key].columns:
+            self.metadata[property_type_key].loc[:, property_.name] = None
+        self.metadata[property_type_key].loc[id_, property_.name] = self._get_value_to_store(value)
+    
+    def get_properties(self, id_, property_type):
+        property_type_key = self._get_property_type_key(property_type)
+        if property_type_key not in self.metadata:
+            return None
+        if id_ not in self.metadata[property_type_key].index:
+            return None
+        return self.metadata[property_type_key].loc[id_].to_dict()
+    
+    def add_properties(self, id_, property_type, properties=None):
+        if id_ is None:
+            raise ValueError('Must specify an ID')
+        property_type_key = self._get_property_type_key(property_type)
+        if property_type_key not in self.metadata:
+            self.metadata[property_type_key] = pd.DataFrame(columns=self.columns(property_type))
+        if id_ not in self.metadata[property_type_key].index:
+            self.metadata[property_type_key].loc[id_, :] = None
+            if properties:
+                for p, v in properties.items():
+                    self.metadata[property_type_key].loc[id_, p] = self._get_value_to_store(v)
+        
+    def delete_properties(self, id_, property_type):
+        if id_ is None:
+            raise ValueError('Must specify an ID')
+        metadata = self.metadata.get(self._get_property_type_key(property_type), {})
+        if id_ in metadata.index:
+            metadata.drop(id_, inplace=True)
+    
+    def get_metadata(self, property_type):
+        property_type_key = self._get_property_type_key(property_type)
+        if property_type_key not in self.metadata:
+            return None
+        return self.metadata[property_type_key].T.to_dict()
+    
+    def set_metadata(self, property_type, value):
+        property_type_key = self._get_property_type_key(property_type)
+        self.metadata[property_type_key] = pd.DataFrame(value).T
+
+    @staticmethod
+    def columns(property_type):
+        return [pt.name for pt in property_type]
+    
+    def _get_value_to_store(self, value):
+        value_to_store = deepcopy(value)
+        if isinstance(value_to_store, dict) or isinstance(value_to_store, list):
+            value_to_store = 'json:' + json.dumps(value_to_store)
+        return value_to_store