geometallurgy 0.4.13__py3-none-any.whl → 0.4.15__py3-none-any.whl

elphick/geomet/utils/parallel.py

@@ -1,29 +1,29 @@
-from joblib import Parallel
-from tqdm import tqdm
-
-
-class TqdmParallel(Parallel):
-    def __init__(self, *args, **kwargs):
-        self._desc = kwargs.pop('desc', None)  # Get the description from kwargs
-        self._tqdm = tqdm(total=kwargs.pop('total', None), desc=self._desc)  # Pass the description to tqdm
-        super().__init__(*args, **kwargs)
-
-    def __call__(self, iterable):
-        iterable = list(iterable)
-        self._tqdm.total = len(iterable)
-        result = super().__call__(iterable)
-        self._tqdm.close()
-        return result
-
-    def _print(self, msg, *msg_args):
-        return
-
-    def print_progress(self):
-        self._tqdm.update()
-
-    def _dispatch(self, batch):
-        job_idx = super()._dispatch(batch)
-        return job_idx
-
-    def _collect(self, output):
-        return super()._collect(output)
+from joblib import Parallel
+from tqdm import tqdm
+
+
+class TqdmParallel(Parallel):
+    def __init__(self, *args, **kwargs):
+        self._desc = kwargs.pop('desc', None)  # Get the description from kwargs
+        self._tqdm = tqdm(total=kwargs.pop('total', None), desc=self._desc)  # Pass the description to tqdm
+        super().__init__(*args, **kwargs)
+
+    def __call__(self, iterable):
+        iterable = list(iterable)
+        self._tqdm.total = len(iterable)
+        result = super().__call__(iterable)
+        self._tqdm.close()
+        return result
+
+    def _print(self, msg, *msg_args):
+        return
+
+    def print_progress(self):
+        self._tqdm.update()
+
+    def _dispatch(self, batch):
+        job_idx = super()._dispatch(batch)
+        return job_idx
+
+    def _collect(self, output):
+        return super()._collect(output)

elphick/geomet/utils/partition.py

@@ -1,63 +1,63 @@
-import importlib
-from functools import partial
-
-import numpy as np
-import pandas as pd
-
-
-def perfect(x: np.ndarray, d50: float) -> np.ndarray:
-    """A perfect partition
-    
-    Args:
-        x: The input dimension, e.g. size or density
-        d50: The cut-point
-
-    Returns:
-
-    """
-    pn: np.ndarray = np.where(x >= d50, 1.0, 0.0)
-    return pn
-
-
-def napier_munn(x: np.ndarray, d50: float, ep: float) -> np.ndarray:
-    """The Napier-Munn partition (1998)
-
-    REF: https://www.sciencedirect.com/science/article/pii/S1474667016453036
-
-    Args:
-        x: The input dimension, e.g. size or density
-        d50: The cut-point
-        ep: The Escarte Probable
-
-    Returns:
-
-    """
-    pn: np.ndarray = 1 / (1 + np.exp(1.099 * (d50 - x) / ep))
-    return pn
-
-
-def napier_munn_size(size: np.ndarray, d50: float, ep: float) -> np.ndarray:
-    return napier_munn(size, d50, ep)
-
-
-def napier_munn_density(density: np.ndarray, d50: float, ep: float) -> np.ndarray:
-    return napier_munn(density, d50, ep)
-
-
-napier_munn_size_1mm = partial(napier_munn_size, d50=1.0, ep=0.1)
-
-
-def load_partition_function(module_name, function_name):
-    module = importlib.import_module(module_name)
-    return getattr(module, function_name)
-
-# if __name__ == '__main__':
-#     da = np.arange(0, 10)
-#     PN = perfect(da, d50=6.3)
-#     df = pd.DataFrame([da, PN], index=['da', 'pn']).T
-#     print(df)
-#
-#     da = np.arange(0, 10)
-#     PN = napier_munn(da, d50=6.3, ep=0.1)
-#     df = pd.DataFrame([da, PN], index=['da', 'pn']).T
-#     print(df)
+import importlib
+from functools import partial
+
+import numpy as np
+import pandas as pd
+
+
+def perfect(x: np.ndarray, d50: float) -> np.ndarray:
+    """A perfect partition
+    
+    Args:
+        x: The input dimension, e.g. size or density
+        d50: The cut-point
+
+    Returns:
+
+    """
+    pn: np.ndarray = np.where(x >= d50, 1.0, 0.0)
+    return pn
+
+
+def napier_munn(x: np.ndarray, d50: float, ep: float) -> np.ndarray:
+    """The Napier-Munn partition (1998)
+
+    REF: https://www.sciencedirect.com/science/article/pii/S1474667016453036
+
+    Args:
+        x: The input dimension, e.g. size or density
+        d50: The cut-point
+        ep: The Escarte Probable
+
+    Returns:
+
+    """
+    pn: np.ndarray = 1 / (1 + np.exp(1.099 * (d50 - x) / ep))
+    return pn
+
+
+def napier_munn_size(size: np.ndarray, d50: float, ep: float) -> np.ndarray:
+    return napier_munn(size, d50, ep)
+
+
+def napier_munn_density(density: np.ndarray, d50: float, ep: float) -> np.ndarray:
+    return napier_munn(density, d50, ep)
+
+
+napier_munn_size_1mm = partial(napier_munn_size, d50=1.0, ep=0.1)
+
+
+def load_partition_function(module_name, function_name):
+    module = importlib.import_module(module_name)
+    return getattr(module, function_name)
+
+# if __name__ == '__main__':
+#     da = np.arange(0, 10)
+#     PN = perfect(da, d50=6.3)
+#     df = pd.DataFrame([da, PN], index=['da', 'pn']).T
+#     print(df)
+#
+#     da = np.arange(0, 10)
+#     PN = napier_munn(da, d50=6.3, ep=0.1)
+#     df = pd.DataFrame([da, PN], index=['da', 'pn']).T
+#     print(df)

elphick/geomet/utils/size.py

@@ -1,51 +1,51 @@
-from typing import Union
-
-import numpy as np
-from pandas import IntervalIndex
-from pandas.arrays import IntervalArray
-
-
-def mean_size(size_intervals: Union[IntervalArray, IntervalIndex]) -> np.ndarray:
-    """Geometric mean size
-
-    Size calculations are performed using the geometric mean, not the arithmetic mean
-
-    NOTE: If geometric mean is used for the pan fraction (0.0mm retained) it will return zero, which is an
-    edge size not mean size.  So the mean ratio of the geometric mean to the arithmetic mean for all other
-    fractions is used for the bottom fraction.
-
-
-    Args:
-        size_intervals: A pandas IntervalArray or IntervalIndex
-
-    Returns:
-
-    """
-
-    intervals = size_intervals.copy()
-    res = np.array((intervals.left * intervals.right) ** 0.5)
-
-    geomean_mean_ratio: float = float(np.mean((res[0:-1] / intervals.mid[0:-1])))
-
-    if np.isclose(size_intervals.min().left, 0.0):
-        res[np.isclose(size_intervals.left, 0.0)] = size_intervals.min().mid * geomean_mean_ratio
-
-    return res
-
-
-# REF: https://www.globalgilson.com/blog/sieve-sizes
-
-sizes_iso_565 = [63.0, 56.0, 53.0, 50.0, 45.0, 40.0, 37.5, 35.5, 31.5, 28.0, 26.5, 25.0, 22.4, 20.0,
-                 19.0, 18.0, 16.0, 14.0, 13.2, 12.5, 11.2, 10.0, 9.5, 9.0, 8.0, 7.1, 6.7, 6.3, 5.6,
-                 5.0, 4.75, 4.5, 4.0, 3.55, 3.35, 3.15, 2.8, 2.5, 2.36, 2.0, 1.8, 1.7, 1.6, 1.4, 1.25,
-                 1.18, 1.12, 1.0, 0.900, 0.850, 0.800, 0.710, 0.630, 0.600, 0.560, 0.500, 0.450, 0.425,
-                 0.400, 0.355, 0.315, 0.300, 0.280, 0.250, 0.224, 0.212, 0.200, 0.180, 0.160, 0.150, 0.140,
-                 0.125, 0.112, 0.106, 0.100, 0.090, 0.080, 0.075, 0.071, 0.063, 0.056, 0.053, 0.050, 0.045,
-                 0.040, 0.038, 0.036, 0.032, 0.025, 0.020, 0.0]
-
-sizes_astm_e11 = [100.0, 90.0, 75.0, 63.0, 53.0, 50.0, 45.0, 37.5, 31.5, 26.5, 25.0, 22.4, 19.0, 16.0,
-                  13.2, 12.5, 11.2, 9.5, 8.0, 6.7, 6.3, 5.6, 4.75, 4.0, 3.35, 2.8, 2.36, 2.0, 1.7, 1.4,
-                  1.18, 1.0, 0.850, 0.710, 0.600, 0.500, 0.425, 0.355, 0.300, 0.250, 0.212, 0.180, 0.150,
-                  0.125, 0.106, 0.090, 0.075, 0.063, 0.053, 0.045, 0.038, 0.032, 0.025, 0.020, 0.0]
-
-sizes_all = sorted(list(set(sizes_astm_e11).union(set(sizes_iso_565))), reverse=True)
+from typing import Union
+
+import numpy as np
+from pandas import IntervalIndex
+from pandas.arrays import IntervalArray
+
+
+def mean_size(size_intervals: Union[IntervalArray, IntervalIndex]) -> np.ndarray:
+    """Geometric mean size
+
+    Size calculations are performed using the geometric mean, not the arithmetic mean
+
+    NOTE: If geometric mean is used for the pan fraction (0.0mm retained) it will return zero, which is an
+    edge size not mean size.  So the mean ratio of the geometric mean to the arithmetic mean for all other
+    fractions is used for the bottom fraction.
+
+
+    Args:
+        size_intervals: A pandas IntervalArray or IntervalIndex
+
+    Returns:
+
+    """
+
+    intervals = size_intervals.copy()
+    res = np.array((intervals.left * intervals.right) ** 0.5)
+
+    geomean_mean_ratio: float = float(np.mean((res[0:-1] / intervals.mid[0:-1])))
+
+    if np.isclose(size_intervals.min().left, 0.0):
+        res[np.isclose(size_intervals.left, 0.0)] = size_intervals.min().mid * geomean_mean_ratio
+
+    return res
+
+
+# REF: https://www.globalgilson.com/blog/sieve-sizes
+
+sizes_iso_565 = [63.0, 56.0, 53.0, 50.0, 45.0, 40.0, 37.5, 35.5, 31.5, 28.0, 26.5, 25.0, 22.4, 20.0,
+                 19.0, 18.0, 16.0, 14.0, 13.2, 12.5, 11.2, 10.0, 9.5, 9.0, 8.0, 7.1, 6.7, 6.3, 5.6,
+                 5.0, 4.75, 4.5, 4.0, 3.55, 3.35, 3.15, 2.8, 2.5, 2.36, 2.0, 1.8, 1.7, 1.6, 1.4, 1.25,
+                 1.18, 1.12, 1.0, 0.900, 0.850, 0.800, 0.710, 0.630, 0.600, 0.560, 0.500, 0.450, 0.425,
+                 0.400, 0.355, 0.315, 0.300, 0.280, 0.250, 0.224, 0.212, 0.200, 0.180, 0.160, 0.150, 0.140,
+                 0.125, 0.112, 0.106, 0.100, 0.090, 0.080, 0.075, 0.071, 0.063, 0.056, 0.053, 0.050, 0.045,
+                 0.040, 0.038, 0.036, 0.032, 0.025, 0.020, 0.0]
+
+sizes_astm_e11 = [100.0, 90.0, 75.0, 63.0, 53.0, 50.0, 45.0, 37.5, 31.5, 26.5, 25.0, 22.4, 19.0, 16.0,
+                  13.2, 12.5, 11.2, 9.5, 8.0, 6.7, 6.3, 5.6, 4.75, 4.0, 3.35, 2.8, 2.36, 2.0, 1.7, 1.4,
+                  1.18, 1.0, 0.850, 0.710, 0.600, 0.500, 0.425, 0.355, 0.300, 0.250, 0.212, 0.180, 0.150,
+                  0.125, 0.106, 0.090, 0.075, 0.063, 0.053, 0.045, 0.038, 0.032, 0.025, 0.020, 0.0]
+
+sizes_all = sorted(list(set(sizes_astm_e11).union(set(sizes_iso_565))), reverse=True)

elphick/geomet/utils/timer.py

@@ -1,80 +1,80 @@
-"""
-REF: https://ankitbko.github.io/blog/2021/04/logging-in-python/
-"""
-
-import functools
-import logging
-from datetime import datetime
-from typing import Union
-
-
-class MyLogger:
-    def __init__(self):
-        logging.basicConfig(level=logging.DEBUG,
-                            format=' %(asctime)s - %(levelname)s - %(message)s')
-
-    def get_logger(self, name=None):
-        return logging.getLogger(name)
-
-
-def get_default_logger():
-    return MyLogger().get_logger()
-
-
-def log_timer(_func=None, *, my_logger: Union[MyLogger, logging.Logger] = None):
-    def decorator_log(func):
-        @functools.wraps(func)
-        def wrapper(*args, **kwargs):
-            logger = get_default_logger()
-            try:
-                if my_logger is None:
-                    first_args = next(iter(args), None)  # capture first arg to check for `self`
-                    logger_params = [  # does kwargs have any logger
-                                        x
-                                        for x in kwargs.values()
-                                        if isinstance(x, logging.Logger) or isinstance(x, MyLogger)
-                                    ] + [  # # does args have any logger
-                                        x
-                                        for x in args
-                                        if isinstance(x, logging.Logger) or isinstance(x, MyLogger)
-                                    ]
-                    if hasattr(first_args, "__dict__"):  # is first argument `self`
-                        logger_params = logger_params + [
-                            x
-                            for x in first_args.__dict__.values()  # does class (dict) members have any logger
-                            if isinstance(x, logging.Logger)
-                               or isinstance(x, MyLogger)
-                        ]
-                    h_logger = next(iter(logger_params), MyLogger())  # get the next/first/default logger
-                else:
-                    h_logger = my_logger  # logger is passed explicitly to the decorator
-
-                if isinstance(h_logger, MyLogger):
-                    logger = h_logger.get_logger(func.__name__)
-                else:
-                    logger = h_logger
-
-                # args_repr = [repr(a) for a in args]
-                # kwargs_repr = [f"{k}={v!r}" for k, v in kwargs.items()]
-                # signature = ", ".join(args_repr + kwargs_repr)
-                # logger.debug(f"function {func.__name__} called with args {signature}")
-
-            except Exception:
-                pass
-
-            try:
-                _tic = datetime.now()
-                result = func(*args, **kwargs)
-                _toc = datetime.now()
-                logger.info(f"Elapsed time for {func.__name__}: {_toc - _tic}")
-                return result
-            except Exception as e:
-                logger.exception(f"Exception raised in {func.__name__}. exception: {str(e)}")
-                raise e
-
-        return wrapper
-
-    if _func is None:
-        return decorator_log
-    else:
-        return decorator_log(_func)
+"""
+REF: https://ankitbko.github.io/blog/2021/04/logging-in-python/
+"""
+
+import functools
+import logging
+from datetime import datetime
+from typing import Union
+
+
+class MyLogger:
+    def __init__(self):
+        logging.basicConfig(level=logging.DEBUG,
+                            format=' %(asctime)s - %(levelname)s - %(message)s')
+
+    def get_logger(self, name=None):
+        return logging.getLogger(name)
+
+
+def get_default_logger():
+    return MyLogger().get_logger()
+
+
+def log_timer(_func=None, *, my_logger: Union[MyLogger, logging.Logger] = None):
+    def decorator_log(func):
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            logger = get_default_logger()
+            try:
+                if my_logger is None:
+                    first_args = next(iter(args), None)  # capture first arg to check for `self`
+                    logger_params = [  # does kwargs have any logger
+                                        x
+                                        for x in kwargs.values()
+                                        if isinstance(x, logging.Logger) or isinstance(x, MyLogger)
+                                    ] + [  # # does args have any logger
+                                        x
+                                        for x in args
+                                        if isinstance(x, logging.Logger) or isinstance(x, MyLogger)
+                                    ]
+                    if hasattr(first_args, "__dict__"):  # is first argument `self`
+                        logger_params = logger_params + [
+                            x
+                            for x in first_args.__dict__.values()  # does class (dict) members have any logger
+                            if isinstance(x, logging.Logger)
+                               or isinstance(x, MyLogger)
+                        ]
+                    h_logger = next(iter(logger_params), MyLogger())  # get the next/first/default logger
+                else:
+                    h_logger = my_logger  # logger is passed explicitly to the decorator
+
+                if isinstance(h_logger, MyLogger):
+                    logger = h_logger.get_logger(func.__name__)
+                else:
+                    logger = h_logger
+
+                # args_repr = [repr(a) for a in args]
+                # kwargs_repr = [f"{k}={v!r}" for k, v in kwargs.items()]
+                # signature = ", ".join(args_repr + kwargs_repr)
+                # logger.debug(f"function {func.__name__} called with args {signature}")
+
+            except Exception:
+                pass
+
+            try:
+                _tic = datetime.now()
+                result = func(*args, **kwargs)
+                _toc = datetime.now()
+                logger.info(f"Elapsed time for {func.__name__}: {_toc - _tic}")
+                return result
+            except Exception as e:
+                logger.exception(f"Exception raised in {func.__name__}. exception: {str(e)}")
+                raise e
+
+        return wrapper
+
+    if _func is None:
+        return decorator_log
+    else:
+        return decorator_log(_func)

elphick/geomet/utils/viz.py

@@ -1,56 +1,56 @@
-from typing import Optional
-
-import pandas as pd
-
-import plotly.graph_objects as go
-
-
-def plot_parallel(data: pd.DataFrame, color: Optional[str] = None, title: Optional[str] = None) -> go.Figure:
-    """Create an interactive parallel plot
-
-    Useful to explore multi-dimensional data like mass-composition data
-
-    Args:
-        data: Dataframe to plot
-        color: Optional color variable
-        title: Optional plot title
-
-    Returns:
-
-    """
-
-    # Kudos: https://stackoverflow.com/questions/72125802/parallel-coordinate-plot-in-plotly-with-continuous-
-    # and-categorical-data
-
-    categorical_columns = data.select_dtypes(include=['category', 'object'])
-    col_list = []
-
-    for col in data.columns:
-        if col in categorical_columns:  # categorical columns
-            values = data[col].unique()
-            value2dummy = dict(zip(values, range(
-                len(values))))  # works if values are strings, otherwise we probably need to convert them
-            data[col] = [value2dummy[v] for v in data[col]]
-            col_dict = dict(
-                label=col,
-                tickvals=list(value2dummy.values()),
-                ticktext=list(value2dummy.keys()),
-                values=data[col],
-            )
-        else:  # continuous columns
-            col_dict = dict(
-                range=(data[col].min(), data[col].max()),
-                label=col,
-                values=data[col],
-            )
-        col_list.append(col_dict)
-
-    if color is None:
-        fig = go.Figure(data=go.Parcoords(dimensions=col_list))
-    else:
-        fig = go.Figure(data=go.Parcoords(dimensions=col_list, line=dict(color=data[color])))
-
-    fig.update_layout(title=title)
-
-    return fig
-
+from typing import Optional
+
+import pandas as pd
+
+import plotly.graph_objects as go
+
+
+def plot_parallel(data: pd.DataFrame, color: Optional[str] = None, title: Optional[str] = None) -> go.Figure:
+    """Create an interactive parallel plot
+
+    Useful to explore multi-dimensional data like mass-composition data
+
+    Args:
+        data: Dataframe to plot
+        color: Optional color variable
+        title: Optional plot title
+
+    Returns:
+
+    """
+
+    # Kudos: https://stackoverflow.com/questions/72125802/parallel-coordinate-plot-in-plotly-with-continuous-
+    # and-categorical-data
+
+    categorical_columns = data.select_dtypes(include=['category', 'object'])
+    col_list = []
+
+    for col in data.columns:
+        if col in categorical_columns:  # categorical columns
+            values = data[col].unique()
+            value2dummy = dict(zip(values, range(
+                len(values))))  # works if values are strings, otherwise we probably need to convert them
+            data[col] = [value2dummy[v] for v in data[col]]
+            col_dict = dict(
+                label=col,
+                tickvals=list(value2dummy.values()),
+                ticktext=list(value2dummy.keys()),
+                values=data[col],
+            )
+        else:  # continuous columns
+            col_dict = dict(
+                range=(data[col].min(), data[col].max()),
+                label=col,
+                values=data[col],
+            )
+        col_list.append(col_dict)
+
+    if color is None:
+        fig = go.Figure(data=go.Parcoords(dimensions=col_list))
+    else:
+        fig = go.Figure(data=go.Parcoords(dimensions=col_list, line=dict(color=data[color])))
+
+    fig.update_layout(title=title)
+
+    return fig
+