mipi-datamanager 1.4.7__tar.gz

mipi_datamanager-1.4.7/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: mipi_datamanager
+Version: 1.4.7
+Summary: 
+Author: murphy-sean1
+Author-email: murphy-sean1@cooperhealth.edu
+Requires-Python: >=3.12,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: flask (>=3.0.3,<4.0.0)
+Requires-Dist: flask-bcrypt (>=1.0.1,<2.0.0)
+Requires-Dist: flask-restful (>=0.3.10,<0.4.0)
+Requires-Dist: jinja2 (>=3.1.2,<4.0.0)
+Requires-Dist: jinjasql2 (>=0.1.12,<0.2.0)
+Requires-Dist: mkdocs (>=1.6.0,<2.0.0)
+Requires-Dist: mkdocs-material (>=9.5.33,<10.0.0)
+Requires-Dist: mkdocstrings[python] (>=0.26.1,<0.27.0)
+Requires-Dist: openpyxl (>=3.1.5,<4.0.0)
+Requires-Dist: pandas (>=2.2.2,<3.0.0)
+Requires-Dist: pylint (>=3.3.3,<4.0.0)
+Requires-Dist: pymdown-extensions (>=10.11.2,<11.0.0)
+Requires-Dist: pyodbc (>=5.1.0,<6.0.0)
+Requires-Dist: pytest (>=8.3.2,<9.0.0)
+Requires-Dist: pytest-coverage (>=0.0,<0.1)
+Requires-Dist: sqlalchemy (>=2.0.35,<3.0.0)
+Requires-Dist: textual-dev (>=1.7.0,<2.0.0)
+Requires-Dist: textual[syntax] (>=3.2.0,<4.0.0)
+Description-Content-Type: text/markdown
+
+# mipi_datamanager
+
+Python utilities and pipelines for the MiPi Data Manager. See docs and usage in the repo.
+

mipi_datamanager-1.4.7/README.md

@@ -0,0 +1,3 @@
+# mipi_datamanager
+
+Python utilities and pipelines for the MiPi Data Manager. See docs and usage in the repo.

mipi_datamanager-1.4.7/pyproject.toml

@@ -0,0 +1,40 @@
+[tool.poetry]
+name = "mipi_datamanager"
+version = "1.4.7"
+description = ""
+authors = ["murphy-sean1 <murphy-sean1@cooperhealth.edu>"]
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.12"
+pandas = "^2.2.2"
+jinja2 = "^3.1.2"
+pytest = "^8.3.2"
+pyodbc = "^5.1.0"
+openpyxl = "^3.1.5"
+pytest-coverage = "^0.0"
+mkdocs = "^1.6.0"
+mkdocs-material = "^9.5.33"
+flask = "^3.0.3"
+flask-restful = "^0.3.10"
+flask-bcrypt = "^1.0.1"
+sqlalchemy = "^2.0.35"
+mkdocstrings = {extras = ["python"], version = "^0.26.1"}
+pymdown-extensions = "^10.11.2"
+pylint = "^3.3.3"
+textual = {extras = ["syntax"], version = "^3.2.0"}
+textual-dev = "^1.7.0"
+jinjasql2 = "^0.1.12"
+
+
+[tool.poetry.group.dev.dependencies]
+pandas-stubs = "^2.2.3.250308"
+bump-my-version = "^1.2.1"
+pytest-mock = "^3.15.0"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry.scripts]
+mipi-app = "mipi_datamanager.core.file_search_gui:main"

mipi_datamanager-1.4.7/src/mipi_datamanager/__init__.py

@@ -0,0 +1,14 @@
+from mipi_datamanager.core.data_managers import DataManager
+from mipi_datamanager.core.jinja import JinjaLibrary, JinjaRepo, exc
+from mipi_datamanager.core.file_search import FileSearch
+
+__all__ = ['DataManager', 'JinjaLibrary', 'JinjaRepo', 'FileSearch', "exc"]
+
+# import doc pages for mkdocstrings
+from mipi_datamanager.core.docs import (
+    setup,
+    getting_started,
+    contribute,
+    patch_notes,
+    install
+)

mipi_datamanager-1.4.7/src/mipi_datamanager/connection.py

@@ -0,0 +1,54 @@
+import datetime as dt
+from sqlalchemy import create_engine
+
+class Odbc:
+    """
+    Creates an Odbc connection object that can be used in any MiPi function that queries a database. This function
+    automatically handles setup and taredown of the connection even if there is an error.
+
+    Args:
+        dsn: The DSN name used to configure the connection
+    """
+
+    def __init__(self, dsn:str = None, driver = None, server = None, database = None, uid = None, pwd = None, trusted_connection = "yes", dialect = "mssql"):
+
+        self.dsn = dsn
+        self.driver = driver
+        self.server = server
+        self.database = database
+        self.uid = uid
+        self.pwd = pwd
+        self.trusted_connection = trusted_connection
+        self.dialect = dialect
+
+        self.name = self.dsn or self.database
+
+
+    @property
+    def connection_string(self):
+        params = {self.dsn:"?odbc_connect=DSN",
+                  self.driver:"DRIVER",
+                  self.server:"SERVER",
+                  self.database:"DATABASE",
+                  self.uid:"UID",
+                  self.pwd:"PWD",
+                  self.trusted_connection:"Trusted_Connection"}
+        con_str = f"mssql+pyodbc:///"
+        for param,key in params.items():
+            if param:
+                con_str += f"{key}={param};"
+
+        return con_str
+
+    def __enter__(self):
+        self.engine = create_engine(self.connection_string)
+        self.con = self.engine.connect()
+        self.start = dt.datetime.now()
+        print(f"\nConnection Established: {self.name} @ {self.start}")
+        return self.con
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.con.close()
+        end = dt.datetime.now()
+        print(f"Connection Terminated:  {self.name} @ {end}")
+        print(f"Connection Open For:    {end - self.start}")

mipi_datamanager-1.4.7/src/mipi_datamanager/core/common.py

@@ -0,0 +1,183 @@
+from typing import Any, Sequence
+from pathlib import Path
+
+def read_text_file(file: str | Path, encoding ="utf-8") -> str:
+    with open(file, "r",encoding = encoding) as f:
+        contents = f.read()
+    return contents
+
+
+def _maybe_add_lists(list_of_lists):
+    if not isinstance(list_of_lists, list):
+        _list_of_lists = [list_of_lists]
+
+    final_list = []
+    for list_i in list_of_lists:
+        final_list += list_i
+
+    return final_list
+
+
+def _maybe_convert_tuple_to_list(val: list | tuple):
+    if isinstance(val, tuple):
+        return list(val)
+    elif isinstance(val, list):
+        return val
+    else:
+        raise TypeError(f'Expected tuple or list, got {type(val)}')
+
+
+def ensure_list(val: Any) -> list:
+    """
+    Wrap a single value in a list, or convert a list-like object into a list if it isnt one
+    """
+    if isinstance(val, list):
+        return val
+    if isinstance(val, Sequence) and not isinstance(val, (str, bytes)):
+        return list(val)
+    return [val]
+
+
+def dict_to_string(dictionary: dict):
+    """
+
+    creates a clean string representation of a dictionary
+
+    Args:
+        dictionary: any dictionary
+        block_pad: int: number of lines to pad top and bottom of output
+
+    Returns: Clean string representation of the dictionary
+
+    """
+
+    max_key_length = max(len(str(key)) for key in dictionary.keys())
+    max_value_length = max(len(str(value)) for value in dictionary.values())
+
+    output = ""
+    for i, (key, value) in enumerate(dictionary.items()):
+        if i != 0:
+            output += ","
+        output += f"{str(key):<{max_key_length}} : {str(value):>{max_value_length}}\n"
+
+    return output
+
+def _maybe_rename_values(value: str|list, rename:dict):
+    if rename is None:
+        _rename = {}
+    else:
+        _rename = rename
+
+    if isinstance(value, str):
+        if value in _rename:
+            return rename[value]
+        else:
+            return value
+    elif isinstance(value, list):
+        return [_rename[i] if i in _rename else i for i in value]
+    else:
+        raise TypeError(f"expected type string or list got {type(value)}")
+
+def _columns_to_dict(df):
+    return {f"'{col}'": None for col in df.columns.tolist()}
+
+def _dict_to_string(dictionary: dict):
+    """
+
+    creates a clean string representation of a dictionary
+
+    Args:
+        dictionary: any dictionary
+        block_pad: int: number of lines to pad top and bottom of output
+
+    Returns: Clean string representation of the dictionary
+
+    """
+    if not isinstance(dictionary, dict):
+        raise TypeError(f"expected dict got {type(dictionary)}")
+
+    if len(dictionary) == 0:
+        raise ValueError("Dictionary is empty")
+
+    max_key_length = max(len(str(key)) for key in dictionary.keys())
+    max_value_length = max(len(str(value)) for value in dictionary.values())
+
+    output = ""
+    for i, (key, value) in enumerate(dictionary.items()):
+        if i != 0:
+            output += ","
+        output += f"{str(key):<{max_key_length}} : {str(value):>{max_value_length}}\n"
+
+    return output
+
+class IndexedDict(dict):
+    """
+    A dictionary object that allows you to access items by their key index.
+    The key index is the suffix of the key.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        for key in self.keys():
+            self._validate_key(key)
+
+    def _validate_key(self, key):
+        if not isinstance(key, str):
+            raise TypeError('Key must be a string')
+
+        suffix = key.split("_")[-1]
+        prefix = key.split("_")[0]
+
+        if not suffix.isnumeric() or "_" not in key or len(prefix) == 0:
+            raise ValueError('Key must have a string name followed by an underscored numeric suffix "{keyname}_{index_number}"')
+
+        if suffix in [k.split("_")[-1] for k in self.keys() if k != key]:
+            raise ValueError('A key with that suffix already exists')
+
+
+    def __setitem__(self, key, value):
+        self._validate_key(key)
+        super().__setitem__(key, value)
+
+    def __getitem__(self, key):
+        if isinstance(key, str):
+            return super().__getitem__(key)
+        if isinstance(key, int):
+            ks = [k for k in self.keys() if k.endswith(str(key))]
+            assert len(ks) == 1, f"Assertion filed, multiple Keys exist for index{key}"
+            k = ks[0]
+            return super().__getitem__(k)
+    def update(self, other, **kwargs):
+        if isinstance(other, dict):
+            for key in other.keys():
+                self._validate_key(key)
+        for key in kwargs.keys():
+            self._validate_key(key)
+        super().update(other, **kwargs)
+    def get(self, key, default=None):
+        if isinstance(key, str):
+            return super().get(key, default)
+        if isinstance(key, int):
+            ks = [k for k in self.keys() if k.endswith(str(key))]
+            if len(ks) == 1:
+                return super().__getitem__(ks[0])
+            return default
+
+class EnsureList:
+    def __set_name__(self, owner: type, name: str):
+        # called once, per attribute, at class creation time
+        self.private_name = f"_{name}"
+
+    def __get__(self, instance, owner: type):
+        if instance is None:
+            return self
+        # if not yet set, default to empty list
+        return getattr(instance, self.private_name, [])
+
+    def __set__(self, instance, value: Any):
+        if value is None:
+            set_val = []
+        else:
+            set_val = ensure_list(value)
+        setattr(instance, self.private_name, set_val)
+