guidepost 0.2.18__tar.gz → 0.2.19__tar.gz

{guidepost-0.2.18/guidepost.egg-info → guidepost-0.2.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: guidepost
-Version: 0.2.18
+Version: 0.2.19
 Summary: Guidepost. An overview visualization for understanding supercomputer queue data.
 Home-page: https://github.com/cscully-allison/guidepost
 Author: Connor Scully-Allison
@@ -8,7 +8,7 @@ Author-email: cscullyallison@sci.utah.edu
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.6
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy

{guidepost-0.2.18 → guidepost-0.2.19}/guidepost/__init__.py

@@ -1,2 +1,2 @@
 from .guidepost import Guidepost
-
+from .trailmark import Trailmark

guidepost-0.2.19/guidepost/guidepost.py

@@ -0,0 +1,80 @@
+import anywidget
+import traitlets
+import pandas as pd
+import numpy as np
+import json
+import os
+import sys
+from .utils import validate_and_clean_dataframe, extract_summary_statistics
+
+class Guidepost(anywidget.AnyWidget):
+    
+    _esm = os.path.join(os.path.dirname(__file__), "static",  "guidepost.js")
+    records = None
+    _vis_data = traitlets.Dict({}).tag(sync=True)
+
+    vis_configs = None
+    _vis_configs = traitlets.Unicode("{}").tag(sync=True)
+    cached_records_df = None
+    
+    selected_records = traitlets.Unicode("[]").tag(sync=True)
+    records_df = pd.DataFrame()
+    selection = None
+
+    _summary_stats = traitlets.Dict({}).tag(sync=True)
+
+    suppress_warnings = False
+
+    @property
+    def vis_configs(self):
+        return json.loads(self._vis_configs)
+    
+    @vis_configs.setter
+    def vis_configs(self, config_dict):
+        self._vis_configs = json.dumps(config_dict)
+
+    @property
+    def records(self):
+        return self._vis_data
+
+    @records.setter
+    def records(self, df):
+        self._vis_data = self.load_data(df)
+
+    def load_data(self, in_df):
+        '''
+            Load dataframe in a safe way.
+            Drop NAs, remove time deltas, report warnings
+        '''
+
+        in_cpy = in_df.copy()
+        in_cpy.insert(0, 'gp_idx', range(0, len(in_cpy)))
+        self.cached_records_df = in_cpy
+
+        if sys.version_info.major < 3 or sys.version_info.minor < 12:
+            warn_supported_version = False
+
+        o_df, report = validate_and_clean_dataframe(in_cpy, self.suppress_warnings)
+        
+        self._summary_stats = extract_summary_statistics(o_df)
+        # Replace NaN with None so JSON serialization yields null (valid JSON), not NaN
+        safe_df = o_df.astype(object).where(pd.notna(o_df), None)
+        self._vis_data = safe_df.to_dict()
+        return safe_df.to_dict()
+        
+    @property
+    def selection(self):
+        return self.retrieve_selected_data()
+
+    def retrieve_selected_data(self):
+        if self.cached_records_df is None:
+            raise ValueError("No data has been loaded yet. Please call load_data() first.")
+        elif len(self.selected_records) == 0:
+            return pd.DataFrame()  # Return empty DataFrame if no selection
+
+        selected_records_idx = json.loads(self.selected_records)
+        
+        self.records_df = self.cached_records_df[self.cached_records_df['gp_idx'].isin(selected_records_idx)]
+        
+        #remove synthetic index
+        return self.records_df.drop('gp_idx', axis=1)

guidepost-0.2.19/guidepost/trailmark.py

@@ -0,0 +1,65 @@
+import anywidget
+import traitlets
+import pandas as pd
+import numpy as np
+import warnings
+import json
+import os
+import sys
+from pandas.api import types as ptypes
+from .utils import convert_to_float, validate_and_clean_dataframe, extract_summary_statistics
+
+class Trailmark(anywidget.AnyWidget):
+    _esm = os.path.join(os.path.dirname(__file__), "static", "trailmark.js")
+    _vis_data = traitlets.Dict({}).tag(sync=True)
+    records = None
+    vis_configs = traitlets.Dict({}).tag(sync=True)
+
+    suppress_warnings = False
+    
+
+    @property
+    def records(self):
+        return self._vis_data
+    
+    @records.setter
+    def records(self, df):
+        self._vis_data = self.load_data(df)
+
+    def load_data(self, in_df):
+        '''
+            Load dataframe and extract summary statistics for visualization.
+        '''
+        
+        # validate / coerce dataframe
+        if not isinstance(in_df, pd.DataFrame):
+            try:
+                in_df = pd.DataFrame(in_df)
+            except Exception:
+                raise ValueError("in_df must be a pandas DataFrame or convertible to one")
+
+        if not self.suppress_warnings and in_df.empty:
+            warnings.warn("load_data called with an empty DataFrame")
+
+        o_df, report = validate_and_clean_dataframe(in_df, self.suppress_warnings)
+
+        self.vis_data = extract_summary_statistics(o_df)
+        
+        
+        self.vis_configs = {
+            "n_rows": len(o_df),
+            "n_columns": len(o_df.columns),
+            "type_counts": type_counts,
+        }
+
+        # print("Data loaded: {} rows, {} columns".format(len(in_df), len(in_df.columns)))
+        # print("Column types: {} continuous, {} ordinal, {} categorical".format(
+        #     type_counts["continuous"],
+        #     type_counts["ordinal"],
+        #     type_counts["categorical"]
+        # ))
+        return self.vis_data
+        
+        
+    # def retrieve_configuration_selection(self):
+        # 

guidepost-0.2.19/guidepost/utils.py

@@ -0,0 +1,178 @@
+import pandas as pd
+import numpy as np
+import warnings
+import os
+import sys
+from pandas.api import types as ptypes
+
+def convert_to_float(value):
+    if pd.isna(value):
+        return np.nan
+    elif value.endswith('K'):
+        return float(value[:-1]) * 1e3
+    if value.endswith('M'):
+        return float(value[:-1]) * 1e6
+    elif value.endswith('B'):
+        return float(value[:-1]) * 1e9
+    return float(value)
+
+
+def validate_and_clean_dataframe(in_cpy, supress_warnings=False):
+    _warn_skips = (os.path.dirname('.'),)
+    warn_supported_version = False
+    
+    original_cols = in_cpy.columns
+    o_df = in_cpy.dropna(axis=1, how='all')
+
+    error_report = {}
+    
+
+    #remove columns with only nans
+    col_diff = original_cols.difference(o_df.columns)
+    if(len(col_diff)>0):
+        rmvd_cols = ', '.join(col_diff)
+        report = {"na_columns": col_diff}
+        if(not supress_warnings):
+            if warn_supported_version:
+                warnings.warn("The following columns were dropped because they contained entirely 'na' values which guidepost does not support:[{}]".format(rmvd_cols), skip_file_prefixes=_warn_skips)
+            else:
+                print("Warning: The following columns were dropped because they contained entirely 'na' values which guidepost does not support:[{}]".format(rmvd_cols))
+        original_cols = o_df.columns
+        
+    # report per-column null counts but keep the rows; downstream JS handles nulls per-axis
+    null_counts = {col: int(o_df[col].isna().sum()) for col in o_df.columns if o_df[col].isna().any()}
+    if null_counts:
+        error_report["na_column_counts"] = null_counts
+        if(not supress_warnings):
+            print("Warning: The following columns contain null values which will be skipped per-axis at render time: {}".format(null_counts))
+    
+    #drop columns which are timedelta type
+    o_df = o_df.select_dtypes(exclude=['timedelta64[ns]'])
+    col_diff = original_cols.difference(o_df.columns)
+    if(len(col_diff)>0):
+        rmvd_cols = ', '.join(col_diff)
+        report = {"timedelta_columns": col_diff}
+
+        if(not supress_warnings):
+            if warn_supported_version:
+                warnings.warn("The following columns were dropped because they contained 'timedelta' values which guidepost does not support:[{}]. Consider converting these to an interger representation.".format(rmvd_cols), skip_file_prefixes=_warn_skips)
+            else:
+                print("Warning: The following columns were dropped because they contained 'timedelta' values which guidepost does not support:[{}]. Consider converting these to an interger representation.".format(rmvd_cols))
+        original_cols = o_df.columns
+    
+    #drop arrays/complex datatypes
+    col_diff = []
+    for col in o_df.columns:
+        if(type(o_df[col].iloc[0]) == type(np.ndarray([]))):
+            col_diff.append(col)
+            o_df = o_df.drop(col, axis=1)
+            
+    if(len(col_diff)>0):
+        rmvd_cols = ', '.join(col_diff)
+        report = {"array_columns": col_diff}
+
+        if(not supress_warnings):
+            if warn_supported_version:
+                warnings.warn("The following columns were dropped because they contained array values in cells which guidepost does not support:[{}]".format(rmvd_cols), skip_file_prefixes=_warn_skips)
+            else:
+                print("Warning: The following columns were dropped because they contained array values in cells which guidepost does not support:[{}]".format(rmvd_cols))
+        original_cols = o_df.columns
+        
+            
+    #add synthetic index
+    if(o_df.shape[0]>250_000):
+        if(not supress_warnings):
+            if warn_supported_version:
+                warnings.warn("Your dataframe is very large. You may experience performance issues. Consider subsampling or reducing the data down to below 200,000 rows to enhance performance.", skip_file_prefixes=_warn_skips)
+            else:
+                print("Warning: Your dataframe is very large. You may experience performance issues. Consider subsampling or reducing the data down to below 200,000 rows to enhance performance.") 
+
+    return o_df, report
+
+def extract_summary_statistics(o_df):
+        summary = {}
+        type_counts = {"continuous": 0, "ordinal": 0, "categorical": 0}
+
+        for col in o_df.columns:
+            s = o_df[col]
+            n_rows = len(s)
+            n_missing = int(s.isna().sum())
+            pct_missing = float(n_missing) / n_rows if n_rows > 0 else 0.0
+            n_unique = int(s.nunique(dropna=True))
+
+            # determine semantic type
+            if ptypes.is_categorical_dtype(s.dtype):
+                semantic = "ordinal" if getattr(s.dtype, "ordered", False) else "categorical"
+            elif ptypes.is_bool_dtype(s.dtype):
+                semantic = "categorical"
+            elif ptypes.is_numeric_dtype(s.dtype):
+                # heuristic: small-integer domains likely ordinal (e.g., ratings)
+                if ptypes.is_integer_dtype(s.dtype) or n_unique < 20:
+                    semantic = "ordinal"
+                else:
+                    semantic = "continuous"
+            else:
+                # object, string, datetime, etc.
+                # treat datetimes separately as continuous-like
+                if ptypes.is_datetime64_any_dtype(s.dtype) or ptypes.is_timedelta64_dtype(s.dtype):
+                    semantic = "continuous"
+                else:
+                    # Check if categorical values are numbers with suffixes M, K, or B
+                    if s.dropna().astype(str).str.fullmatch(r'\d+(\.\d+)?[MKB]').all():
+                        s = s.map(convert_to_float)
+                        semantic = "continuous"
+                    else:
+                        semantic = "categorical"
+
+            type_counts[semantic] += 1
+
+            col_summary = {
+            "dtype": str(s.dtype),
+            "semantic_type": semantic,
+            "n_rows": n_rows,
+            "n_missing": n_missing,
+            "pct_missing": pct_missing,
+            "n_unique": n_unique,
+            }
+
+            if semantic == "continuous":
+                # compute robust numeric summaries (skip NA)
+                ser = pd.to_numeric(s, errors="coerce")
+                col_summary.update({
+                    "count": int(ser.count()),
+                    "mean": None if ser.count() == 0 else float(ser.mean()),
+                    "std": None if ser.count() == 0 else float(ser.std()),
+                    "min": None if ser.count() == 0 else float(ser.min()),
+                    "25%": None if ser.count() == 0 else float(ser.quantile(0.25)),
+                    "50%": None if ser.count() == 0 else float(ser.quantile(0.5)),
+                    "75%": None if ser.count() == 0 else float(ser.quantile(0.75)),
+                    "IQR": None if ser.count() == 0 else float(ser.quantile(0.75) - ser.quantile(0.25)),
+                    "max": None if ser.count() == 0 else float(ser.max()),
+                    "var": None if ser.count() == 0 else float(ser.var())
+                })
+            else:
+                # categorical / ordinal: top categories and frequencies
+                vc = s.astype(object).value_counts(dropna=True)
+                top = vc.index[0] if len(vc) > 0 else None
+                top_freq = int(vc.iloc[0]) if len(vc) > 0 else 0
+
+                # include up to 20 most frequent values
+                top_items = []
+                for k, v in vc.iloc[:10].items():
+                    # convert numpy types to native python types for JSON serialization
+                    try:
+                        key = k.item() if hasattr(k, "item") else k
+                    except Exception:
+                        key = str(k)
+                    top_items.append({"value": key, "count": int(v)})
+                col_summary.update({
+                    "top": top,
+                    "top_freq": top_freq,
+                    "top_values": top_items
+                })
+
+            summary[col] = col_summary
+
+        # store results in widget traits for frontend sync
+        return summary
+

guidepost-0.2.19/guidepost/version.py

@@ -0,0 +1,2 @@
+__version_info__ = ("0", "2", "19")
+__version__ = ".".join(__version_info__)

{guidepost-0.2.18 → guidepost-0.2.19/guidepost.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: guidepost
-Version: 0.2.18
+Version: 0.2.19
 Summary: Guidepost. An overview visualization for understanding supercomputer queue data.
 Home-page: https://github.com/cscully-allison/guidepost
 Author: Connor Scully-Allison
@@ -8,7 +8,7 @@ Author-email: cscullyallison@sci.utah.edu
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.6
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy

{guidepost-0.2.18 → guidepost-0.2.19}/guidepost.egg-info/SOURCES.txt

@@ -4,8 +4,9 @@ README.md
 pyproject.toml
 setup.py
 guidepost/__init__.py
-guidepost/guidepost.js
 guidepost/guidepost.py
+guidepost/trailmark.py
+guidepost/utils.py
 guidepost/version.py
 guidepost.egg-info/PKG-INFO
 guidepost.egg-info/SOURCES.txt

{guidepost-0.2.18 → guidepost-0.2.19}/setup.py

@@ -28,14 +28,14 @@ setup(
         'pandas',
         'scikit-learn',
         'anywidget',
-        'traitlets'
+        'traitlets',
     ],
     classifiers=[
         'Programming Language :: Python :: 3',
         'License :: OSI Approved :: MIT License',
         'Operating System :: OS Independent',
     ],
-    python_requires='>=3.6',
+    python_requires='>=3.10',
     include_package_data=True,
     package_data={
         'guidepost': ['guidepost.js'],