apmtools 0.2.15__tar.gz → 0.2.17__tar.gz

{apmtools-0.2.15 → apmtools-0.2.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: apmtools
-Version: 0.2.015
+Version: 0.2.017
 Summary: A collection of tools for processing air pollution monitoring data
 Project-URL: Homepage, https://github.com/federlorenz/apmtools
 Author-email: Federico Lorenzetti <lorenzetti.federico@gmail.com>

{apmtools-0.2.15 → apmtools-0.2.17}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "apmtools"
-version = "0.2.015"
+version = "0.2.017"
 authors = [
   { name="Federico Lorenzetti", email="lorenzetti.federico@gmail.com" },
 ]

{apmtools-0.2.15 → apmtools-0.2.17}/src/apmtools/shiny/summary.py

@@ -9,12 +9,14 @@ import pandas as pd
 
 
 PLOT_TYPES = {
-    "line": "Line",
     "bar": "Bar",
-    "histogram": "Histogram",
     "box": "Boxplot",
+    "histogram": "Histogram",
+    "line": "Line",
+    "scatter": "Scatter",
 }
 
+
 # ``None`` means row-level plotting.  The other values are passed directly to
 # Summary.group_stat(frequency=...).
 FREQUENCIES = {
@@ -28,13 +30,13 @@ FREQUENCIES = {
 }
 
 AGGREGATES = {
+    "Count": "count",
+    "Maximum": "max",
     "Mean": "mean",
     "Median": "median",
-    "Sum": "sum",
     "Minimum": "min",
-    "Maximum": "max",
-    "Count": "count",
     "Standard deviation": "std",
+    "Sum": "sum",
 }
 
 def _default_x(data: pd.DataFrame) -> str:
@@ -55,26 +57,15 @@ def _default_group(data: pd.DataFrame) -> str | None:
 
 def _numeric_columns(data: pd.DataFrame) -> list[str]:
     """Return numeric column names as strings."""
-    return [
+    return sorted([
         str(column)
         for column in data.columns
         if pd.api.types.is_numeric_dtype(data[column])
-    ]
-
-def _normalise_y(data: pd.DataFrame, x: str, y: str | Sequence[str] | None) -> list[str]:
-    """Validate and normalise an initial Y selection."""
-    numeric = _numeric_columns(data)
-    if y is None:
-        return [column for column in numeric if column != x][:1]
-    values = [y] if isinstance(y, str) else list(y)
-    missing = [column for column in values if column not in data.columns]
-    if missing:
-        raise ValueError(f"Unknown y column(s): {missing}")
-    return [str(column) for column in values]
+    ])
 
 
 def _categorical_columns(data: pd.DataFrame) -> list[str]:
-    """Return columns suitable for a boxplot categorical X axis."""
+    """Return categorical column names as strings."""
     return sorted(
         [
             str(column)
@@ -86,6 +77,41 @@ def _categorical_columns(data: pd.DataFrame) -> list[str]:
     )
 
 
+def _datetime_columns(data: pd.DataFrame) -> list[str]:
+    """Return datetime column names as strings."""
+    return sorted(
+        [
+            str(column)
+            for column in data.columns
+            if pd.api.types.is_datetime64_any_dtype(data[column])
+        ],
+        key=str.casefold,
+    )
+
+
+def _timedelta_columns(data: pd.DataFrame) -> list[str]:
+    """Return timedelta column names as strings."""
+    return sorted(
+        [
+            str(column)
+            for column in data.columns
+            if pd.api.types.is_timedelta64_dtype(data[column])
+        ],
+        key=str.casefold,
+    )
+
+def _default_y(data: pd.DataFrame, x: str, y: str | Sequence[str] | None) -> list[str]:
+    """Validate and normalise an initial Y selection."""
+    numeric = _numeric_columns(data)
+    if y is None:
+        return [column for column in numeric if column != x][:1]
+    values = [y] if isinstance(y, str) else list(y)
+    missing = [column for column in values if column not in data.columns]
+    if missing:
+        raise ValueError(f"Unknown y column(s): {missing}")
+    return [str(column) for column in values]
+
+
 def _alphabetical(values) -> list[str]:
     """Return string values sorted alphabetically, case-insensitively."""
     return sorted((str(value) for value in values), key=str.casefold)
@@ -274,13 +300,16 @@ def create_summary_app(
     columns = _alphabetical(summary.columns)
     column_map = {str(c): c for c in summary.columns}
     numeric_columns = _alphabetical(_numeric_columns(summary))
-    categorical_columns = _categorical_columns(summary)
+    categorical_columns = _alphabetical(_categorical_columns(summary))
+    datetime_columns = _alphabetical(_datetime_columns(summary))
+    timedelta_columns = _alphabetical(_timedelta_columns(summary))
+
 
     x = _default_x(summary) if x is None else str(x)
     if x not in column_map:
         raise ValueError(f"Unknown x column: {x!r}")
 
-    initial_y = _normalise_y(summary, x, y)
+    initial_y = _default_y(summary, x, y)
     if group_by is None:
         initial_groups = [_default_group(summary)] if _default_group(
             summary) is not None else []
@@ -340,8 +369,11 @@ def create_summary_app(
                 "datetime_end", "End datetime",
                 value="", placeholder="YYYY-MM-DD or YYYY-MM-DD HH:MM:SS",
             ),
-            ui.input_numeric("bins", "Histogram bins",
-                             value=30, min=1, max=200, step=1),
+            ui.panel_conditional(
+                "input.plot_type === 'histogram'",
+                ui.input_numeric("bins", "Histogram bins",
+                                 value=30, min=1, max=200, step=1),
+            ),
             ui.input_text("title", "Plot title", value=title),
             ui.help_text(
                 "Subset and datetime filters are applied before aggregation. "
@@ -358,39 +390,53 @@ def create_summary_app(
     def server(input, output, session):
         @render.ui
         def x_control():
-            """Use categorical X choices for boxplots; all columns otherwise."""
-            if input.plot_type() == "box":
-                if not categorical_columns:
-                    return ui.help_text(
-                        "Boxplots require at least one categorical column for the X axis."
-                    )
-                selected = x if x in categorical_columns else categorical_columns[0]
-                return ui.input_select(
-                    "x", "X-axis / category",
-                    choices={c: c for c in categorical_columns},
-                    selected=selected,
+            kind = input.plot_type()
+            if kind in ("box", "bar"):
+                choices = categorical_columns
+                multiple = True
+            elif kind == "line":
+                choices = datetime_columns
+                multiple = False
+            else:
+                choices = numeric_columns
+                multiple = False
+
+            if not choices:
+                return ui.help_text(f"No compatible X variables for {kind}.")
+            selected = [x] if x in choices else [choices[0]]
+            if multiple:
+                return ui.input_selectize(
+                    "x", "X-axis / categories",
+                    choices={c: c for c in choices},
+                    selected=selected, multiple=True,
                 )
             return ui.input_select(
-                "x", "X-axis / category",
-                choices={c: c for c in columns},
-                selected=x,
+                "x", "X-axis / variable",
+                choices={c: c for c in choices},
+                selected=selected[0],
             )
 
         @render.ui
         def y_control():
-            """Boxplots accept one numeric Y variable; other plots accept many."""
-            if input.plot_type() == "box":
-                selected = initial_y[0] if initial_y else (
-                    numeric_columns[0] if numeric_columns else None)
+            kind = input.plot_type()
+            if kind == "histogram":
+                return ui.div()
+            if not numeric_columns:
+                return ui.help_text("No numeric Y variables available.")
+            selected = next(
+                (v for v in initial_y if v in numeric_columns), numeric_columns[0])
+            if kind in ("box", "bar", "scatter"):
                 return ui.input_select(
                     "y", "Y-axis / variable",
                     choices={c: c for c in numeric_columns},
                     selected=selected,
                 )
             return ui.input_selectize(
-                "y", "Y-axis / variable",
+                "y", "Y-axis / variables",
                 choices={c: c for c in numeric_columns},
-                selected=initial_y, multiple=True,
+                selected=[v for v in initial_y if v in numeric_columns] or [
+                    selected],
+                multiple=True,
             )
 
         @render.ui
@@ -450,89 +496,92 @@ def create_summary_app(
         @reactive.calc
         def selected_data():
             current = filtered_summary()
-            y_input = input.y()
-            selected_y = ([y_input] if isinstance(
-                y_input, str) else list(y_input or []))
-            if not selected_y:
+            kind = input.plot_type()
+            x_input = input.x()
+            selected_x = ([x_input] if isinstance(
+                x_input, str) else list(x_input or []))
+            if not selected_x:
+                return pd.DataFrame()
+
+            if kind == "histogram":
+                value_names = selected_x
+            else:
+                y_input = input.y()
+                value_names = ([y_input] if isinstance(
+                    y_input, str) else list(y_input or []))
+            if not value_names:
                 return pd.DataFrame()
 
-            y_columns = [column_map[c] for c in selected_y]
             selected_groups = list(input.group_by())
             grouping_by = [column_map[c] for c in selected_groups]
             frequency = FREQUENCIES[input.frequency()]
             aggregate = AGGREGATES[input.aggregate()]
-
-            # A boxplot's categorical X must survive group_stat(). Include it
-            # as a statistical grouping key when frequency aggregation is used,
-            # without turning it into a colour/group selection in the UI.
-            if input.plot_type() == "box":
-                selected_x = input.x()
-                if selected_x in column_map:
-                    box_x = column_map[selected_x]
-                    if box_x not in grouping_by:
-                        grouping_by = [*grouping_by, box_x]
-
-            # All selected grouping columns are passed directly to
-            # Summary.group_stat() when a frequency is selected.
+            value_columns = [column_map[c] for c in value_names]
+
+            if kind in ("box", "bar"):
+                for c in selected_x:
+                    if column_map[c] not in grouping_by:
+                        grouping_by.append(column_map[c])
+            if kind == "scatter" and frequency is not None:
+                # Both numerical axes must be aggregated on the same rows.
+                value_columns = list(dict.fromkeys(
+                    [column_map[selected_x[0]], *value_columns]
+                ))
             if frequency is not None:
-                current = _aggregate(current, y_columns,
-                                     frequency, grouping_by, aggregate)
-
+                current = _aggregate(
+                    current, value_columns, frequency, grouping_by, aggregate
+                )
             return current
 
         @render_plotly
         def plot():
             plot_df = selected_data()
             selected_plot = input.plot_type()
-            selected_x = input.x()
-            y_input = input.y()
+            x_input = input.x()
+            selected_x = ([x_input] if isinstance(
+                x_input, str) else list(x_input or []))
+            y_input = None if selected_plot == "histogram" else input.y()
             selected_y = ([y_input] if isinstance(
                 y_input, str) else list(y_input or []))
             selected_groups = list(input.group_by())
             frequency = FREQUENCIES[input.frequency()]
 
-            if plot_df.empty or not selected_y:
+            if plot_df.empty or not selected_x or (
+                selected_plot != "histogram" and not selected_y
+            ):
                 return px.scatter(title="No data for the selected filters")
 
-            # Keep the original selected Y columns separate from the columns
-            # produced by group_stat().  For example, selecting ``pm25`` and
-            # hourly means produces ``pm25_mean`` in the aggregated result.
-            selected_y_columns = [column_map[c] for c in selected_y]
+            aggregate = AGGREGATES[input.aggregate()]
 
-            # Summary.group_stat() creates the frequency column itself.
-            # For example, frequency="hour" creates an ``hour`` column,
-            # while an aggregate such as mean creates ``pm25_mean``.
-            # Therefore the aggregated frequency column replaces the
-            # originally selected X-axis column.
-            if frequency is not None:
-                aggregate = AGGREGATES[input.aggregate()]
-                y_columns = _aggregated_value_columns(
-                    plot_df, selected_y_columns, aggregate
-                )
-                if selected_plot == "box":
-                    if selected_x not in column_map:
-                        return px.scatter(title="Select a categorical X variable for the boxplot")
-                    x_column = column_map[selected_x]
-                else:
-                    x_column = frequency
+            def mapped(column):
+                original = column_map[column]
+                return f"{original}_{aggregate}" if frequency is not None else original
 
-                if x_column not in plot_df.columns:
-                    return px.scatter(
-                        title=(
-                            f"Aggregation did not produce the expected "
-                            f"'{x_column}' column"
-                        )
-                    )
+            if selected_plot == "histogram":
+                x_column = mapped(selected_x[0])
+                y_columns = []
+            elif selected_plot in ("box", "bar"):
+                x_columns = [column_map[c] for c in selected_x]
+                x_column = x_columns[0]
+                y_columns = [mapped(selected_y[0])]
+            elif selected_plot == "scatter":
+                x_column = mapped(selected_x[0])
+                y_columns = [mapped(selected_y[0])]
             else:
-                y_columns = [
-                    c for c in selected_y_columns if c in plot_df.columns
-                ]
-                x_column = column_map[selected_x]
-
-            if not y_columns:
-                return px.scatter(
-                    title="Selected variables are not available after aggregation"
-                )
+                x_column = frequency if frequency is not None else column_map[selected_x[0]]
+                y_columns = [mapped(c) for c in selected_y]
+
+            required = [x_column, *y_columns]
+            if selected_plot in ("box", "bar"):
+                required.extend(x_columns)
+            if any(c not in plot_df.columns for c in required):
+                return px.scatter(title="Selected variables are unavailable after aggregation")
+
+            if selected_plot in ("box", "bar"):
+                plot_df = plot_df.copy()
+                plot_df["__plot_category"] = plot_df[x_columns].astype(
+                    str).agg(" | ".join, axis=1)
+                x_column = "__plot_category"
 
             # Multiple grouping columns are supported by group_stat(). For
             # plotting, Plotly needs one color/category column, so combine the
@@ -546,74 +595,31 @@ def create_summary_app(
                 )
 
             if selected_plot == "histogram":
-                if group_columns:
-                    # With grouping, overlay one histogram per group on the
-                    # same axes.  ``group`` is the color dimension rather
-                    # than the selected variable, so each group gets its own
-                    # histogram.  Transparency makes overlapping groups
-                    # directly comparable.
-                    group_column = "__plot_group"
-                    long_df = plot_df[[group_column, *y_columns]].melt(
-                        id_vars=[group_column],
-                        var_name="variable",
-                        value_name="value",
-                    )
-                    fig = px.histogram(
-                        long_df,
-                        x="value",
-                        color=group_column,
-                        nbins=int(input.bins()),
-                        barmode="overlay",
-                        opacity=0.45,
-                        facet_row=("variable" if len(y_columns) > 1 else None),
-                    )
-                    # Keep the groups as the legend entries rather than the
-                    # selected Y variables.
-                    fig.update_traces(marker_line_width=0)
-                else:
-                    long_df = plot_df[y_columns].melt(
-                        var_name="variable", value_name="value"
-                    )
-                    fig = px.histogram(
-                        long_df,
-                        x="value",
-                        color="variable",
-                        nbins=int(input.bins()),
-                        barmode="overlay" if len(
-                            y_columns) > 1 else "relative",
-                        opacity=0.65 if len(y_columns) > 1 else 1.0,
-                    )
+                fig = px.histogram(
+                    plot_df,
+                    x=x_column,
+                    color="__plot_group" if group_columns else None,
+                    nbins=int(input.bins()),
+                    barmode="overlay",
+                    opacity=0.45 if group_columns else 1.0,
+                )
             elif selected_plot == "box":
-                # Boxplots are distributions of one numerical variable across
-                # categories. X is therefore always the selected categorical
-                # column and Y is exactly one numerical variable.
-                if x_column not in categorical_columns:
-                    return px.scatter(
-                        title="Boxplots require a categorical variable on the X axis"
-                    )
-                y_column = y_columns[0]
-                if group_columns:
-                    fig = px.box(
-                        plot_df, x=x_column, y=y_column,
-                        color="__plot_group", points="outliers",
-                    )
-                else:
-                    fig = px.box(
-                        plot_df, x=x_column, y=y_column, points="outliers"
-                    )
+                fig = px.box(
+                    plot_df, x=x_column, y=y_columns[0],
+                    color="__plot_group" if group_columns else None,
+                    points="outliers",
+                )
             elif selected_plot == "bar":
-                if not group_columns:
-                    fig = px.bar(plot_df, x=x_column,
-                                 y=y_columns, barmode="group")
-                else:
-                    group_column = "__plot_group"
-                    long_df = plot_df[[x_column, group_column, *y_columns]].melt(
-                        id_vars=[x_column, group_column], var_name="variable", value_name="value",
-                    )
-                    fig = px.bar(
-                        long_df, x=x_column, y="value", color=group_column,
-                        facet_row="variable" if len(y_columns) > 1 else None, barmode="group",
-                    )
+                fig = px.bar(
+                    plot_df, x=x_column, y=y_columns[0],
+                    color="__plot_group" if group_columns else None,
+                    barmode="group",
+                )
+            elif selected_plot == "scatter":
+                fig = px.scatter(
+                    plot_df, x=x_column, y=y_columns[0],
+                    color="__plot_group" if group_columns else None,
+                )
             else:
                 # ``identifier`` identifies an individual input monitor.  It
                 # must therefore be used as Plotly's line-group key even when

apmtools-0.2.17/src/apmtools/units.py

@@ -0,0 +1,386 @@
+upas_units = {'AccelComplianceCnt': '#',
+ 'AccelComplianceHrs': 'hrs',
+ 'AccelT': '°C',
+ 'AccelX': 'mg',
+ 'AccelXMax': 'mg',
+ 'AccelXMin': 'mg',
+ 'AccelXVar': 'mg',
+ 'AccelY': 'mg',
+ 'AccelYMax': 'mg',
+ 'AccelYMin': 'mg',
+ 'AccelYVar': 'mg',
+ 'AccelZ': 'mg',
+ 'AccelZMax': 'mg',
+ 'AccelZMin': 'mg',
+ 'AccelZVar': 'mg',
+ 'AtmoAlt': 'm',
+ 'AtmoDensity': 'g L-1',
+ 'AtmoP': 'hPa',
+ 'AtmoRH': '%',
+ 'AtmoT': '°C',
+ 'BCS1': 'bool',
+ 'BCS2': 'bool',
+ 'BC_NPG': 'bool',
+ 'BFGenergy': 'integer',
+ 'BattVolt': 'V',
+ 'BatteryCharge': '%',
+ 'CO2': 'ppm',
+ 'Charging': 'bool',
+ 'DateTimeUTC': 'HH:MM:SS',
+ 'Dead': 'bool',
+ 'ExtPow': '-',
+ 'FLOWCTL': 's',
+ 'FdpT': '°C',
+ 'FilterDP': 'Pa',
+ 'GPSQual': '-',
+ 'GPSRT': 's',
+ 'GPSalt': 'm',
+ 'GPShDOP': '-',
+ 'GPSlat': 'decimalDegree',
+ 'GPSlon': 'decimalDegree',
+ 'GPSsat': '#',
+ 'GPSspeed': 'm s-1',
+ 'HighVisRaw': '-',
+ 'IRRaw': '-',
+ 'LUX': 'lux',
+ 'LowVisRaw': '-',
+ 'MFSVout': 'V',
+ 'MassFlow': 'g min-1',
+              'MassFlowFactory': 'g min-1',
+ 'NOXRaw': '-',
+              'OverallFlowFactory': 'L min-1',
+              'OverallFlowOffset': 'L min-1',
+ 'OverallFlowRate': 'L min-1)',
+ 'PCB1T': '°C',
+ 'PCB2P': 'hPa',
+ 'PCB2T': '°C',
+ 'PM0_5NC': '# cm-3',
+ 'PM0_5NCVar': '# cm-3',
+ 'PM10MC': 'µg m-3',
+ 'PM10MCVar': 'µg m-3',
+ 'PM10NC': '# cm-3',
+ 'PM10NCVar': '# cm-3',
+ 'PM1MC': 'µg m-3',
+ 'PM1MCVar': 'µg m-3',
+ 'PM1NC': '# cm-3',
+ 'PM1NCVar': '# cm-3',
+ 'PM2_5MC': 'μg/m3',
+ 'PM2_5MCVar': 'µg m-3',
+ 'PM2_5NC': '# cm-3',
+ 'PM2_5NCVar': '# cm-3',
+ 'PM2_5SampledMass': 'µg',
+              'PM2_5SampledMassFactory': 'μg',
+              'PM2_5SampledMassOffset': 'μg',
+ 'PM4MC': 'µg m-3',
+ 'PM4MCVar': 'µg m-3',
+ 'PM4NC': '# cm-3',
+ 'PM4NCVar': '# cm-3',
+ 'PMFanErrorCnt': '#',
+ 'PMFanSpeedWarn': '#',
+ 'PMLaserErrorCnt': '#',
+ 'PMMeasCnt': '#',
+ 'PMReadingErrorCnt': '#',
+ 'PMtypicalParticleSize': 'µm',
+ 'PMtypicalParticleSizeVar': 'µm',
+ 'PT100R': 'Ω',
+ 'PumpPow1': 'integer',
+ 'PumpPow2': 'integer',
+ 'PumpV': 'V',
+              'PumpingFlowFactory': 'L min-1',
+              'PumpingFlowOffset': 'L min-1',
+ 'PumpingFlowRate': 'L min-1)',
+ 'PumpsON': 'bool',
+ 'RotX': 'mdeg s-1',
+ 'RotXMax': 'mdeg s-1',
+ 'RotXMin': 'mdeg s-1',
+ 'RotXVar': 'mdeg s-1',
+ 'RotY': 'mdeg s-1',
+ 'RotYMax': 'mdeg s-1',
+ 'RotYMin': 'mdeg s-1',
+ 'RotYVar': 'mdeg s-1',
+ 'RotZ': 'mdeg s-1',
+ 'RotZMax': 'mdeg s-1',
+ 'RotZMin': 'mdeg s-1',
+ 'RotZVar': 'mdeg s-1',
+ 'SCDRH': '%',
+ 'SCDT': '°C',
+ 'SD_DATAW': 's',
+ 'SD_HEADW': 's',
+ 'SampleTime': '',
+ 'SampledVolume': 'L',
+ 'SampledVolumeFactory': 'L',
+ 'SampledVolumeOffset': 'L',
+ 'StepCount': '#',
+ 'TPumpsOFF': 's',
+ 'TPumpsON': 's',
+              'U12T': '°C',
+              'U29P': '°C',
+              'U29T': '°C',
+ 'UVRaw': '-',
+ 'UVindex': '-',
+ 'UnixTime': 's',
+ 'VOCRaw': '-',
+ 'XDown': '%',
+ 'Xup': '%',
+ 'Ydown': '%',
+ 'Yup': '%',
+ 'Zdown': '%',
+ 'Zup': '%',
+ 'cartridgeid': '-',
+ 'end': 'YYYY-MM-DDTHH:MM:SS',
+ 'index': '-',
+              'length': 'days HH:MM:SS',
+              'pm25': 'µg m-3',
+              'pm25correctedrh': 'µg m-3',
+              'start': 'YYYY-MM-DDTHH:MM:SS',
+              'time': 'YYYY-MM-DDTHH:MM:SS',
+ 'upasid': '-',
+ 'v3_3': 'V',
+ 'v5': 'V'}
+
+upas_datatype = {'AccelComplianceCnt': 'integer',
+                 'AccelComplianceHrs': 'timedelta',
+                 'AccelT': 'numeric',
+                 'AccelX': 'numeric',
+                 'AccelXMax': 'numeric',
+                 'AccelXMin': 'numeric',
+                 'AccelXVar': 'numeric',
+                 'AccelY': 'numeric',
+                 'AccelYMax': 'numeric',
+                 'AccelYMin': 'numeric',
+                 'AccelYVar': 'numeric',
+                 'AccelZ': 'numeric',
+                 'AccelZMax': 'numeric',
+                 'AccelZMin': 'numeric',
+                 'AccelZVar': 'numeric',
+                 'AtmoAlt': 'numeric',
+                 'AtmoDensity': 'numeric',
+                 'AtmoP': 'numeric',
+                 'AtmoRH': 'numeric',
+                 'AtmoT': 'numeric',
+                 'BCS1': 'bool',
+                 'BCS2': 'bool',
+                 'BC_NPG': 'bool',
+                 'BFGenergy': 'integer',
+                 'BattVolt': 'numeric',
+                 'BatteryCharge': '%',
+                 'CO2': 'numeric',
+                 'Charging': 'bool',
+                 'DateTimeUTC': 'datetime',
+                 'Dead': 'bool',
+                 'ExtPow': 'bool',
+                 'FLOWCTL': 'timedelta',
+                 'FdpT': 'numeric',
+                 'FilterDP': 'numeric',
+                 'GPSQual': 'text',
+                 'GPSRT': 'timedelta',
+                 'GPSalt': 'numeric',
+                 'GPShDOP': '',
+                 'GPSlat': 'numeric',
+                 'GPSlon': 'numeric',
+                 'GPSsat': 'integer',
+                 'GPSspeed': 'numeric',
+                 'HighVisRaw': '',
+                 'IRRaw': '',
+                 'LUX': 'numeric',
+                 'LowVisRaw': '',
+                 'MFSVout': 'numeric',
+                 'MassFlow': 'numeric',
+                 'MassFlowFactory': 'numeric',
+                 'NOXRaw': 'numeric',
+                 'OverallFlowFactory': 'numeric',
+                 'OverallFlowOffset': 'numeric',
+                 'OverallFlowRate': 'numeric',
+                 'PCB1T': 'numeric',
+                 'PCB2P': 'numeric',
+                 'PCB2T': 'numeric',
+                 'PM0_5NC': 'integer',
+                 'PM0_5NCVar': 'numeric',
+                 'PM10MC': 'numeric',
+                 'PM10MCVar': 'numeric',
+                 'PM10NC': 'numeric',
+                 'PM10NCVar': 'numeric',
+                 'PM1MC': 'numeric',
+                 'PM1MCVar': 'numeric',
+                 'PM1NC': 'numeric',
+                 'PM1NCVar': 'numeric',
+                 'PM2_5MC': 'numeric',
+                 'PM2_5MCVar': 'numeric',
+                 'PM2_5NC': 'numeric',
+                 'PM2_5NCVar': 'numeric',
+                 'PM2_5SampledMass': 'numeric',
+                 'PM2_5SampledMassFactory': 'numeric',
+                 'PM2_5SampledMassOffset': 'numeric',
+                 'PM4MC': 'numeric',
+                 'PM4MCVar': 'numeric',
+                 'PM4NC': 'numeric',
+                 'PM4NCVar': 'numeric',
+                 'PMFanErrorCnt': 'numeric',
+                 'PMFanSpeedWarn': 'bool',
+                 'PMLaserErrorCnt': 'numeric',
+                 'PMMeasCnt': 'numeric',
+                 'PMReadingErrorCnt': 'numeric',
+                 'PMtypicalParticleSize': 'numeric',
+                 'PMtypicalParticleSizeVar': 'numeric',
+                 'PT100R': 'numeric',
+                 'PumpPow1': 'numeric',
+                 'PumpPow2': 'numeric',
+                 'PumpV': 'numeric',
+                 'PumpingFlowFactory': 'numeric',
+                 'PumpingFlowOffset': 'numeric',
+                 'PumpingFlowRate': 'numeric',
+                 'PumpsON': 'bool',
+                 'RotX': 'numeric',
+                 'RotXMax': 'numeric',
+                 'RotXMin': 'numeric',
+                 'RotXVar': 'numeric',
+                 'RotY': 'numeric',
+                 'RotYMax': 'numeric',
+                 'RotYMin': 'numeric',
+                 'RotYVar': 'numeric',
+                 'RotZ': 'numeric',
+                 'RotZMax': 'numeric',
+                 'RotZMin': 'numeric',
+                 'RotZVar': 'numeric',
+                 'SCDRH': 'numeric',
+                 'SCDT': 'numeric',
+                 'SD_DATAW': 'timedelta',
+                 'SD_HEADW': 'timedelta',
+                 'SampleTime': 'datetime',
+                 'SampledVolume': 'numeric',
+                 'SampledVolumeFactory': 'numeric',
+                 'SampledVolumeOffset': 'numeric',
+                 'StepCount': 'numeric',
+                 'TPumpsOFF': 'bool',
+                 'TPumpsON': 'bool',
+                 'U12T': 'numeric',
+                 'U29P': 'numeric',
+                 'U29T': 'numeric',
+                 'UVRaw': 'numeric',
+                 'UVindex': 'numeric',
+                 'UnixTime': 'datetime',
+                 'VOCRaw': 'numeric',
+                 'XDown': 'numeric',
+                 'Xup': 'numeric',
+                 'Ydown': 'numeric',
+                 'Yup': 'numeric',
+                 'Zdown': 'numeric',
+                 'Zup': 'numeric',
+                 'end': 'datetime',
+                 'length': 'timedelta',
+                 'pm25': 'numeric',
+                 'pm25correctedrh': 'numeric',
+                 'start': 'datetime',
+                 'time': 'datetime',
+                 'v3_3': 'numeric',
+                 'v5': 'numeric'}
+
+lascar_units = {"CO(ppm)":"ppm"}
+
+lascar_datatype = {"CO(ppm)": "numeric",
+                   'start': "datetime",
+                   'end': "datetime",
+                   'length': "timedelta",
+                   'time': "datetime"}
+
+purple_units = {'mac_address':"-",
+          'firmware_ver':"-",
+          'hardware':"-",
+          'current_temp_f':"F",
+          'current_humidity':"%",
+          'current_dewpoint_f':"F",
+          'pressure':"mBar",
+          'adc':"",
+          'mem':"",
+          'rssi':"",
+          'uptime':"",
+                'pm1_0_cf_1': "μg m-3",
+                'pm2_5_cf_1': "μg m-3",
+                'pm10_0_cf_1': "μg m-3",
+                'pm1_0_atm': "μg m-3",
+                'pm2_5_atm': "μg m-3",
+                'pm10_0_atm': "μg m-3",
+                'pm2.5_aqi_cf_1': "μg m-3",
+                'pm2.5_aqi_atm': "μg m-3",
+          'p_0_3_um':"#",
+          'p_0_5_um':"#",
+          'p_1_0_um':"#",
+          'p_2_5_um':"#",
+          'p_5_0_um':"#",
+          'p_10_0_um':"#",
+                'pm1_0_cf_1_b': "μg m-3",
+                'pm2_5_cf_1_b': "μg m-3",
+                'pm10_0_cf_1_b': "μg m-3",
+                'pm1_0_atm_b': "μg m-3",
+                'pm2_5_atm_b': "μg m-3",
+                'pm10_0_atm_b': "μg m-3",
+                'pm2.5_aqi_cf_1_b': "μg m-3",
+                'pm2.5_aqi_atm_b': "μg m-3",
+          'p_0_3_um_b':"#",
+          'p_0_5_um_b':"#",
+          'p_1_0_um_b':"#",
+          'p_2_5_um_b':"#",
+          'p_5_0_um_b':"#",
+          'p_10_0_um_b':"#",
+          'gas':"",
+          'pm_adj': "μg m-3"}
+
+purple_datatype = {'mac_address': "text",
+                'firmware_ver': "text",
+                'hardware': "text",
+                'current_temp_f': "numeric",
+                'current_humidity': "numeric",
+                'current_dewpoint_f': "numeric",
+                'pressure': "numeric",
+                'adc': "text",
+                'mem': "text",
+                'rssi': "text",
+                'uptime': "text",
+                   'pm1_0_c': "numeric",
+                 'PumpingFlowFactory': 'numeric',
+                 'PumpingFlowOffset': 'numeric',
+                 'PumpingFlowRate': 'numeric',
+                 'PumpsON': 'bool',
+                 'RotX': 'numeric',
+                 'RotXMax': 'numeric',
+                 'RotXMin': 'numeric',
+                 'RotXVar': 'numeric',
+                 'RotY': 'numeric',
+                 'RotYMax': 'numeric',
+                 'RotYMin': 'numeric',
+                 'RotYVar': 'numeric',
+                 'RotZ': 'numeric',
+                 'pm1_0_cf_1': "numeric",
+                   'pm2_5_cf_1': "numeric",
+                   'pm10_0_cf_1': "numeric",
+                'pm1_0_atm': "numeric",
+                'pm2_5_atm': "numeric",
+                   'pm10_0_atm': "numeric",
+                'pm2.5_aqi_cf_1': "numeric",
+                   'pm2.5_aqi_atm': "numeric",
+                'p_0_3_um': "numeric",
+                'p_0_5_um': "numeric",
+                   'p_1_0_um': "numeric",
+                'p_2_5_um': "numeric",
+                   'p_5_0_um': "numeric",
+                'p_10_0_um': "numeric",
+                   'pm1_0_cf_1_b': "numeric",
+                   'pm2_5_cf_1_b': "numeric",
+                   'pm10_0_cf_1_b': "numeric",
+                   'pm1_0_atm_b': "numeric",
+                   'pm2_5_atm_b': "numeric",
+                   'pm10_0_atm_b': "numeric",
+                'pm2.5_aqi_cf_1_b': "numeric",
+                'pm2.5_aqi_atm_b': "numeric",
+                'p_0_3_um_b': "numeric",
+                'p_0_5_um_b': "numeric",
+                   'p_1_0_um_b': "numeric",
+                'p_2_5_um_b': "numeric",
+                'p_5_0_um_b': "numeric",
+                   'p_10_0_um_b': "numeric",
+                'gas': "text",
+                   'pm_adj': "numeric",
+                   'start':"datetime",
+                   'end':"datetime",
+                   'length':"timedelta",
+                   'time':"datetime"}

apmtools-0.2.15/src/apmtools/units.py

@@ -1,155 +0,0 @@
-upas_units= {'PumpingFlowRate':"",
-              'OverallFlowRate':"",
-              'SampledVolume':"",
-              'FilterDP':"",
-              'BatteryCharge':"",
-              'AtmoT':"",
-              'AtmoP':"",
-              'AtmoRH':"",
-              'AtmoDensity':"",
-              'AtmoAlt':"",
-              'GPSQual':"",
-              'GPSlat':"",
-              'GPSlon':"",
-              'GPSalt':"",
-              'GPSsat':"",
-              'GPSspeed':"",
-              'GPShDOP':"",
-              'AccelX':"",
-              'AccelXVar':"",
-              'AccelXMin':"",
-              'AccelXMax':"",
-              'AccelY':"",
-              'AccelYVar':"",
-              'AccelYMin':"",
-              'AccelYMax':"",
-              'AccelZ':"",
-              'AccelZVar':"",
-              'AccelZMin':"",
-              'AccelZMax':"",
-              'RotX':"",
-              'RotXVar':"",
-              'RotXMin':"",
-              'RotXMax':"",
-              'RotY':"",
-              'RotYVar':"",
-              'RotYMin':"",
-              'RotYMax':"",
-              'RotZ':"",
-              'RotZVar':"",
-              'RotZMin':"",
-              'RotZMax':"",
-              'Xup':"",
-              'XDown':"",
-              'Yup':"",
-              'Ydown':"",
-              'Zup':"",
-              'Zdown':"",
-              'StepCount':"",
-              'LUX':"",
-              'UVindex':"",
-              'HighVisRaw':"",
-              'LowVisRaw':"",
-              'IRRaw':"",
-              'UVRaw':"",
-              'PMMeasCnt':"",
-              'PM1MC':"",
-              'PM1MCVar':"",
-              'PM2_5MC': "μg/m3",
-              'PM2_5MCVar':"",
-              'PM4MC':"",
-              'PM4MCVar':"",
-              'PM10MC':"",
-              'PM10MCVar':"",
-              'PM0_5NC':"",
-              'PM0_5NCVar':"",
-              'PM1NC':"",
-              'PM1NCVar':"",
-              'PM2_5NC':"",
-              'PM2_5NCVar':"",
-              'PM4NC':"",
-              'PM4NCVar':"",
-              'PM10NC':"",
-              'PM10NCVar':"",
-              'PMtypicalParticleSize':"",
-              'PMtypicalParticleSizeVar':"",
-              'PM2_5SampledMass':"",
-              'PMReadingErrorCnt':"",
-              'PMFanErrorCnt':"",
-              'PMLaserErrorCnt':"",
-              'PMFanSpeedWarn':"",
-              'PCB1T':"",
-              'PCB2T':"",
-              'FdpT':"",
-              'AccelT':"",
-              'PT100R':"",
-              'PCB2P':"",
-              'PumpPow1':"",
-              'PumpPow2':"",
-              'PumpV':"",
-              'MassFlow':"",
-              'MFSVout':"",
-              'BFGenergy':"",
-              'BattVolt':"",
-              'v3_3':"",
-              'v5':"",
-              'PumpsON':"",
-              'Dead':"",
-              'BCS1':"",
-              'BCS2':"",
-              'BC_NPG':"",
-              'FLOWCTL':"",
-              'GPSRT':"",
-              'SD_DATAW':"",
-              'SD_HEADW':"",
-              'TPumpsOFF':"",
-              'TPumpsON':"",
-              'CO2':"",
-              'SCDT':"",
-              'SCDRH':"",
-              'VOCRaw':"",
-              'NOXRaw':""}
-
-lascar_units = {"CO(ppm)":"ppm"}
-
-purple_units = {'mac_address':"",
-          'firmware_ver':"",
-          'hardware':"",
-          'current_temp_f':"",
-          'current_humidity':"",
-          'current_dewpoint_f':"",
-          'pressure':"",
-          'adc':"",
-          'mem':"",
-          'rssi':"",
-          'uptime':"",
-          'pm1_0_cf_1':"",
-          'pm2_5_cf_1':"",
-          'pm10_0_cf_1':"",
-          'pm1_0_atm':"",
-          'pm2_5_atm':"",
-          'pm10_0_atm':"",
-          'pm2.5_aqi_cf_1':"",
-          'pm2.5_aqi_atm':"",
-          'p_0_3_um':"",
-          'p_0_5_um':"",
-          'p_1_0_um':"",
-          'p_2_5_um':"",
-          'p_5_0_um':"",
-          'p_10_0_um':"",
-          'pm1_0_cf_1_b':"",
-          'pm2_5_cf_1_b':"",
-          'pm10_0_cf_1_b':"",
-          'pm1_0_atm_b':"",
-          'pm2_5_atm_b':"",
-          'pm10_0_atm_b':"",
-          'pm2.5_aqi_cf_1_b':"",
-          'pm2.5_aqi_atm_b':"",
-          'p_0_3_um_b':"",
-          'p_0_5_um_b':"",
-          'p_1_0_um_b':"",
-          'p_2_5_um_b':"",
-          'p_5_0_um_b':"",
-          'p_10_0_um_b':"",
-          'gas':"",
-          'pm_adj': "μg/m3"}