AeroViz 0.1.14__py3-none-any.whl → 0.1.16__py3-none-any.whl

AeroViz/rawDataReader/__init__.py

@@ -19,10 +19,10 @@ SIZE_RANGE_INSTRUMENTS = ['SMPS', 'APS', 'GRIMM']
 
 def RawDataReader(instrument: str,
                   path: Path | str,
-                  reset: bool = False,
+                  reset: bool | str = False,
                   qc: bool | str = True,
-                  start: datetime = None,
-                  end: datetime = None,
+                  start: datetime | str = None,
+                  end: datetime | str = None,
                   mean_freq: str = '1h',
                   size_range: tuple[float, float] | None = None,
                   suppress_warnings: bool = False,
@@ -94,9 +94,22 @@ def RawDataReader(instrument: str,
 
     Examples
     --------
+    >>> from AeroViz import RawDataReader
+    >>>
+    >>> # Using string inputs
+    >>> df_ae33 = RawDataReader(
+    ...     instrument='AE33',
+    ...     path='/path/to/your/data/folder',
+    ...     reset=True,
+    ...     qc='1MS',
+    ...     start='2024-01-01',
+    ...     end='2024-06-30',
+    ...     mean_freq='1h',
+    ... )
+
+    >>> # Using Path and datetime objects
     >>> from pathlib import Path
     >>> from datetime import datetime
-    >>> from AeroViz import RawDataReader
     >>>
     >>> df_ae33 = RawDataReader(
     ...     instrument='AE33',
@@ -130,9 +143,26 @@ def RawDataReader(instrument: str,
             raise ValueError(f"Invalid frequency: {qc}. Must be one of: "
                              f"W (week), MS (month start), QS (quarter start), YS (year start)")
 
-    # Verify input times
+    # Convert and verify input times
     if not (start and end):
         raise ValueError("Both start and end times must be provided.")
+
+    # Convert start time if it's a string
+    if isinstance(start, str):
+        try:
+            start = datetime.fromisoformat(start.replace('Z', '+00:00'))
+        except ValueError as e:
+            raise ValueError(
+                f"Invalid start time format. Please use ISO format (YYYY-MM-DD or YYYY-MM-DD HH:MM:SS): {e}")
+
+    # Convert end time if it's a string
+    if isinstance(end, str):
+        try:
+            end = datetime.fromisoformat(end.replace('Z', '+00:00'))
+        except ValueError as e:
+            raise ValueError(
+                f"Invalid end time format. Please use ISO format (YYYY-MM-DD or YYYY-MM-DD HH:MM:SS): {e}")
+
     if end <= start:
         raise ValueError(f"Invalid time range: start {start} is after end {end}")
 

AeroViz/rawDataReader/core/__init__.py

@@ -8,7 +8,7 @@ from typing import Generator
 import numpy as np
 import pandas as pd
 from rich.console import Console
-from rich.progress import Progress, TextColumn, BarColumn, TimeRemainingColumn, TaskProgressColumn
+from rich.progress import Progress, TextColumn, BarColumn, SpinnerColumn, TaskProgressColumn
 
 from AeroViz.rawDataReader.config.supported_instruments import meta
 from AeroViz.rawDataReader.core.logger import ReaderLogger
@@ -55,6 +55,7 @@ class AbstractReader(ABC):
         self.pkl_nam_raw = output_folder / f'_read_{self.nam.lower()}_raw.pkl'
         self.csv_nam_raw = output_folder / f'_read_{self.nam.lower()}_raw.csv'
         self.csv_out = output_folder / f'output_{self.nam.lower()}.csv'
+        self.report_out = output_folder / 'report.json'
 
     def __call__(self,
                  start: datetime,
@@ -79,55 +80,180 @@ class AbstractReader(ABC):
     def _QC(self, df: pd.DataFrame) -> pd.DataFrame:
         return df
 
-    def _rate_calculate(self, raw_data, qc_data) -> None:
-        def __base_rate(raw_data, qc_data):
-            period_size = len(raw_data.resample('1h').mean().index)
+    def __calculate_rates(self, raw_data, qc_data, all_keys=False, with_log=False):
+        """計算獲取率、良率和總比率
 
-            for _nam, _key in self.meta['deter_key'].items():
-                _columns_key, _drop_how = (qc_data.keys(), 'all') if _key == ['all'] else (_key, 'any')
+        Args:
+            raw_data: 原始數據
+            qc_data: QC後的數據
+            all_keys: 是否計算所有 deter_key
+            with_log: 是否輸出計算日誌
+        """
+        if raw_data.empty or qc_data.empty:
+            return {'acquisition_rate': 0, 'yield_rate': 0, 'total_rate': 0}
 
-                sample_size = len(raw_data[_columns_key].resample('1h').mean().copy().dropna(how=_drop_how).index)
-                qc_size = len(qc_data[_columns_key].resample('1h').mean().copy().dropna(how=_drop_how).index)
+        def _calculate_single_key(key_name, key_columns):
+            columns, drop_how = (qc_data.keys(), 'all') if key_columns == ['all'] else (key_columns, 'any')
 
-                # validate rate calculation
-                if period_size == 0 or sample_size == 0 or qc_size == 0:
+            # 重採樣並計算有效數據量
+            period_size = len(raw_data.resample('1h').mean().index)
+            sample_size = len(raw_data[columns].resample('1h').mean().dropna(how=drop_how).index)
+            qc_size = len(qc_data[columns].resample('1h').mean().dropna(how=drop_how).index)
+
+            # 驗證計算
+            if any([
+                period_size == 0 or sample_size == 0 or qc_size == 0,
+                period_size < sample_size,
+                sample_size < qc_size
+            ]):
+                if with_log:
                     self.logger.warning(f'\t\t No data for this period... skip')
-                    continue
-                if period_size < sample_size:
-                    self.logger.warning(f'\t\tError: Sample({sample_size}) > Period({period_size})... skip')
-                    continue
-                if sample_size < qc_size:
-                    self.logger.warning(f'\t\tError: QC({qc_size}) > Sample({sample_size})... skip')
-                    continue
-
-                else:
-                    _sample_rate = round((sample_size / period_size) * 100, 1)
-                    _valid_rate = round((qc_size / sample_size) * 100, 1)
-                    _total_rate = round((qc_size / period_size) * 100, 1)
-
-                self.logger.info(f"\t\t{self.logger.CYAN}{self.logger.ARROW} {_nam}{self.logger.RESET}")
+                return None
+
+            # 計算比率
+            sample_rate = round((sample_size / period_size) * 100, 1)
+            valid_rate = round((qc_size / sample_size) * 100, 1)
+            total_rate = round((qc_size / period_size) * 100, 1)
+
+            if with_log:
+                self.logger.info(f"\t\t> {key_name}")
                 self.logger.info(
-                    f"\t\t\t├─ {'Sample Rate':15}: {self.logger.BLUE}{_sample_rate:>6.1f}%{self.logger.RESET}")
+                    f"\t\t\t> {'Sample Rate':13}: {self.logger.BLUE}{sample_rate:>6.1f}%{self.logger.RESET}")
                 self.logger.info(
-                    f"\t\t\t├─ {'Valid  Rate':15}: {self.logger.BLUE}{_valid_rate:>6.1f}%{self.logger.RESET}")
+                    f"\t\t\t> {'Valid  Rate':13}: {self.logger.BLUE}{valid_rate:>6.1f}%{self.logger.RESET}")
                 self.logger.info(
-                    f"\t\t\t└─ {'Total  Rate':15}: {self.logger.BLUE}{_total_rate:>6.1f}%{self.logger.RESET}")
+                    f"\t\t\t> {'Total  Rate':13}: {self.logger.BLUE}{total_rate:>6.1f}%{self.logger.RESET}")
+
+            return {
+                'acquisition_rate': sample_rate,
+                'yield_rate': valid_rate,
+                'total_rate': total_rate
+            }
+
+        if all_keys:
+            # 計算所有 key 並回傳所有結果（用於日誌輸出）
+            all_results = []
+            for name, columns in self.meta['deter_key'].items():
+                result = _calculate_single_key(name, columns)
+                if result:
+                    all_results.append(result)
+
+            if not all_results:
+                return {'acquisition_rate': 0, 'yield_rate': 0, 'total_rate': 0}
+
+            # 回傳所有結果中比率最低的
+            return {
+                'acquisition_rate': min(r['acquisition_rate'] for r in all_results),
+                'yield_rate': min(r['yield_rate'] for r in all_results),
+                'total_rate': min(r['total_rate'] for r in all_results)
+            }
+        else:
+            # 計算所有 key 但只回傳最低的比率
+            min_rates = {'acquisition_rate': 200, 'yield_rate': 200, 'total_rate': 200}
 
+            for name, columns in self.meta['deter_key'].items():
+                result = _calculate_single_key(name, columns)
+                if result:
+                    min_rates['acquisition_rate'] = min(min_rates['acquisition_rate'], result['acquisition_rate'])
+                    min_rates['yield_rate'] = min(min_rates['yield_rate'], result['yield_rate'])
+                    min_rates['total_rate'] = min(min_rates['total_rate'], result['total_rate'])
+
+            # 如果沒有任何有效結果，回傳 0
+            if min_rates['acquisition_rate'] == 200 and min_rates['yield_rate'] == 200:
+                return {'acquisition_rate': 0, 'yield_rate': 0, 'total_rate': 0}
+
+            return min_rates
+
+    def _rate_calculate(self, raw_data, qc_data) -> None:
         if self.meta['deter_key'] is not None:
-            # use qc_freq to calculate each period rate
             if self.qc_freq is not None:
                 raw_data_grouped = raw_data.groupby(pd.Grouper(freq=self.qc_freq))
                 qc_data_grouped = qc_data.groupby(pd.Grouper(freq=self.qc_freq))
 
                 for (month, _sub_raw_data), (_, _sub_qc_data) in zip(raw_data_grouped, qc_data_grouped):
                     self.logger.info(
-                        f"\t{self.logger.BLUE}{self.logger.ARROW} Processing: {_sub_raw_data.index[0].strftime('%F')}"
+                        f"\t{self.logger.BLUE}> Processing: {_sub_raw_data.index[0].strftime('%F')}"
                         f" to {_sub_raw_data.index[-1].strftime('%F')}{self.logger.RESET}")
 
-                    __base_rate(_sub_raw_data, _sub_qc_data)
-
+                    self.__calculate_rates(_sub_raw_data, _sub_qc_data, all_keys=True, with_log=True)
             else:
-                __base_rate(raw_data, qc_data)
+                self.__calculate_rates(raw_data, qc_data, all_keys=True, with_log=True)
+
+            # 使用 Grouper 對數據按週和月進行分組
+            current_time = datetime.now()
+
+            # 按週分組 (使用星期一作為每週的開始)
+            weekly_raw_groups = raw_data.groupby(pd.Grouper(freq='W-MON'))
+            weekly_qc_groups = qc_data.groupby(pd.Grouper(freq='W-MON'))
+
+            # 按月分組 (使用月初作為每月的開始)
+            monthly_raw_groups = raw_data.groupby(pd.Grouper(freq='MS'))
+            monthly_qc_groups = qc_data.groupby(pd.Grouper(freq='MS'))
+
+            # 生成報告
+            self.__generate_grouped_report(
+                current_time,
+                weekly_raw_groups, weekly_qc_groups,
+                monthly_raw_groups, monthly_qc_groups
+            )
+
+    def __generate_grouped_report(self, current_time, weekly_raw_groups, weekly_qc_groups,
+                                  monthly_raw_groups, monthly_qc_groups):
+        """生成基於分組數據的獲取率和良率報告"""
+        report = {
+            "report_time": current_time.strftime('%Y-%m-%d %H:%M:%S'),
+            "instrument_info": {
+                "station": self.path.name[:2],
+                "instrument": self.nam
+            },
+            "rates": {
+                "weekly": {},
+                "monthly": {}
+            }
+        }
+
+        # 處理週數據 - 使用標準週時間範圍
+        for week_start, week_raw_data in weekly_raw_groups:
+            # 獲取對應的QC數據
+            week_qc_data = weekly_qc_groups.get_group(
+                week_start) if week_start in weekly_qc_groups.groups else pd.DataFrame()
+
+            if not week_raw_data.empty:
+                # 計算標準週結束時間（週日23:59:59）
+                week_end = week_start + pd.Timedelta(days=6, hours=23, minutes=59, seconds=59)
+
+                # 使用週的開始日期作為鍵
+                period_key = week_start.strftime('%Y-%m-%d')
+
+                report["rates"]["weekly"][period_key] = {
+                    "start_time": week_start.strftime('%Y-%m-%d %H:%M:%S'),
+                    "end_time": week_end.strftime('%Y-%m-%d %H:%M:%S'),
+                    "rates": self.__calculate_rates(week_raw_data, week_qc_data)
+                }
+
+        # 處理月數據 - 使用標準月時間範圍
+        for month_start, month_raw_data in monthly_raw_groups:
+            # 獲取對應的QC數據
+            month_qc_data = monthly_qc_groups.get_group(
+                month_start) if month_start in monthly_qc_groups.groups else pd.DataFrame()
+
+            if not month_raw_data.empty:
+                # 計算標準月結束時間（月末23:59:59）
+                next_month_start = (month_start + pd.Timedelta(days=32)).replace(day=1)
+                month_end = next_month_start - pd.Timedelta(seconds=1)
+
+                # 使用月份作為鍵
+                period_key = month_start.strftime('%Y-%m')
+
+                report["rates"]["monthly"][period_key] = {
+                    "start_time": month_start.strftime('%Y-%m-%d %H:%M:%S'),
+                    "end_time": month_end.strftime('%Y-%m-%d %H:%M:%S'),
+                    "rates": self.__calculate_rates(month_raw_data, month_qc_data)
+                }
+
+        # 寫入報告
+        with open(self.report_out, 'w') as f:
+            json.dump(report, f, indent=4)
 
     def _timeIndex_process(self, _df, user_start=None, user_end=None, append_df=None):
         """
@@ -157,13 +283,28 @@ class AbstractReader(ABC):
         # Create new time index
         new_index = pd.date_range(user_start or df_start, user_end or df_end, freq=freq, name='time')
 
-        # Process data: convert to numeric, resample, and reindex
+        # Process data: convert to numeric, resample, and reindex with controlled tolerance
         if freq in ['1min', 'min', 'T']:
-            return _df.reindex(new_index, method='nearest', tolerance='1min')
+            # 對於分鐘級數據，使用較小的tolerance，例如30秒
+            return _df.reindex(new_index, method='nearest', tolerance='30s')
         elif freq in ['1h', 'h', 'H']:
-            return _df.reindex(new_index, method='nearest', tolerance='1h')
+            # 對於小時級數據，使用30分鐘作為tolerance
+            # 這樣08:20會匹配到08:00，但不會匹配到09:00
+            return _df.reindex(new_index, method='nearest', tolerance='30min')
         else:
-            return _df.reindex(new_index, method='nearest', tolerance=freq)
+            # 對於其他頻率，tolerance設置為頻率的一半
+            if isinstance(freq, str) and freq[-1].isalpha():
+                # 如果freq格式為'數字+單位'，例如'2h'，'3min'
+                try:
+                    num = int(freq[:-1])
+                    unit = freq[-1]
+                    half_freq = f"{num // 2}{unit}" if num > 1 else f"30{'min' if unit == 'h' else 's'}"
+                    return _df.reindex(new_index, method='nearest', tolerance=half_freq)
+                except ValueError:
+                    # 無法解析freq，使用默認值
+                    return _df.reindex(new_index, method='nearest', tolerance=freq)
+            else:
+                return _df.reindex(new_index, method='nearest', tolerance=freq)
 
     def _outlier_process(self, _df):
         outlier_file = self.path / 'outlier.json'
@@ -202,15 +343,15 @@ class AbstractReader(ABC):
 
         try:
             with Progress(
-                    TextColumn("[bold blue]{task.description}", style="bold blue"),
+                    SpinnerColumn(finished_text="✓"),
                     BarColumn(bar_width=25, complete_style="green", finished_style="bright_green"),
-                    TaskProgressColumn(),
-                    TimeRemainingColumn(),
-                    TextColumn("{task.fields[filename]}", style="yellow"),
+                    TaskProgressColumn(style="bold", text_format="[bright_green]{task.percentage:>3.0f}%"),
+                    TextColumn("{task.description}", style="bold blue"),
+                    TextColumn("{task.fields[filename]}", style="bold blue"),
                     console=Console(force_terminal=True, color_system="auto", width=120),
                     expand=False
             ) as progress:
-                task = progress.add_task(f"{self.logger.ARROW} Reading {self.nam} files", total=len(files), filename="")
+                task = progress.add_task(f"Reading {self.nam} files:", total=len(files), filename="")
                 yield progress, task
         finally:
             # Restore logger method and output message
@@ -262,12 +403,12 @@ class AbstractReader(ABC):
     def _run(self, user_start, user_end):
         # read pickle if pickle file exists and 'reset=False' or process raw data or append new data
         if self.pkl_nam_raw.exists() and self.pkl_nam.exists() and not self.reset:
-            self.logger.info_box(f"Reading {self.nam} PICKLE from {user_start} to {user_end}", color_part="PICKLE")
+            self.logger.info_box(f"Reading {self.nam} PICKLE from {user_start} to {user_end}")
 
             _f_raw_done, _f_qc_done = pd.read_pickle(self.pkl_nam_raw), pd.read_pickle(self.pkl_nam)
 
             if self.append:
-                self.logger.info_box(f"Appending New data from {user_start} to {user_end}", color_part="New data")
+                self.logger.info_box(f"Appending New data from {user_start} to {user_end}")
 
                 _f_raw_new, _f_qc_new = self._read_raw_files()
                 _f_raw = self._timeIndex_process(_f_raw_done, append_df=_f_raw_new)
@@ -279,7 +420,7 @@ class AbstractReader(ABC):
                 return _f_qc if self.qc else _f_raw
 
         else:
-            self.logger.info_box(f"Reading {self.nam} RAW DATA from {user_start} to {user_end}", color_part="RAW DATA")
+            self.logger.info_box(f"Reading {self.nam} RAW DATA from {user_start} to {user_end}")
 
             _f_raw, _f_qc = self._read_raw_files()
 

AeroViz/rawDataReader/core/logger.py

@@ -8,7 +8,7 @@ from pathlib import Path
 
 
 class ReaderLogger:
-    def __init__(self, name: str, log_path: Path, log_level: str = 'WARNING'):
+    def __init__(self, name: str, log_path: Path, log_level: str = 'INFO'):
         self.name = name
         self.log_path = log_path
         self._log_level = getattr(logging, log_level)
@@ -33,16 +33,16 @@ class ReaderLogger:
             self.RESET = ''
 
         # 檢查 Unicode 支持
-        self.unicode_support = self._setup_unicode()
+        self.unicode_support = self._check_unicode_support()
 
         # 設置框架字符
         if self.unicode_support:
-            self.BOX_TOP_LEFT = "╔"
-            self.BOX_TOP_RIGHT = "╗"
-            self.BOX_BOTTOM_LEFT = "╚"
-            self.BOX_BOTTOM_RIGHT = "╝"
-            self.BOX_HORIZONTAL = "═"
-            self.BOX_VERTICAL = "║"
+            self.BOX_TOP_LEFT = "╭"
+            self.BOX_TOP_RIGHT = "╮"
+            self.BOX_BOTTOM_LEFT = "╰"
+            self.BOX_BOTTOM_RIGHT = "╯"
+            self.BOX_HORIZONTAL = "─"
+            self.BOX_VERTICAL = "│"
             self.ARROW = "▶"
         else:
             self.BOX_TOP_LEFT = "+"
@@ -75,7 +75,7 @@ class ReaderLogger:
         # 其他系統檢查
         return hasattr(sys.stdout, 'isatty') and sys.stdout.isatty()
 
-    def _setup_unicode(self) -> bool:
+    def _check_unicode_support(self) -> bool:
         """設置 Unicode 支持"""
         if platform.system().lower() == 'windows':
             try:

AeroViz/rawDataReader/script/SMPS.py

@@ -38,6 +38,15 @@ class Reader(AbstractReader):
 
             _df = read_csv(f, sep=delimiter, skiprows=skip, low_memory=False)
 
+            if 'Date' not in _df.columns:  # 資料需要轉置
+                try:
+                    _df = _df.T  # 轉置
+                    _df.columns = _df.iloc[0]  # 使用第一列作為欄位名稱
+                    _df = _df.iloc[1:]  # 移除第一列（因為已經變成欄位名稱）
+                    _df = _df.reset_index(drop=True)  # 重設索引
+                except:
+                    raise NotImplementedError('Not supported date format')
+
             for date_format in date_formats:
                 _time_index = parse_date(_df, date_format)
                 if not _time_index.isna().all():

AeroViz/rawDataReader/script/TEOM.py

@@ -7,40 +7,77 @@ from AeroViz.rawDataReader.core import AbstractReader
 class Reader(AbstractReader):
     nam = 'TEOM'
 
+    # TEOM Output Data Formats
+    # There are three data formats from TEOM instrument output:
+    #
+    # 1. Remote download format
+    #    - Identified by 'Time Stamp' column
+    #    - Date format: 'DD - MM - YYYY HH:MM:SS'
+    #    - May contain Chinese month names requiring conversion
+    #    - Maps columns: Time Stamp → time, System status → status,
+    #      PM-2.5 base MC → PM_NV, PM-2.5 MC → PM_Total, PM-2.5 TEOM noise → noise
+    #
+    # 2. USB download or auto export format
+    #    - Identified by 'tmoStatusCondition_0' column
+    #    - Two possible time formats:
+    #      a) Standard: 'Date' and 'Time' columns (YYYY-MM-DD HH:MM:SS)
+    #      b) Alternative: 'time_stamp' column (similar to remote format)
+    #    - Maps columns: tmoStatusCondition_0 → status, tmoTEOMABaseMC_0 → PM_NV,
+    #      tmoTEOMAMC_0 → PM_Total, tmoTEOMANoise_0 → noise
+    #
+    # 3. Other formats
+    #    - Not implemented, raises NotImplementedError
+    #
+    # All formats are standardized to the same column names with timestamp as index
+
     def _raw_reader(self, file):
+        # TEOM Data Format Handler
+        # Standardizes different TEOM data formats (remote download and USB/auto export)
         _df = read_csv(file, skiprows=3, index_col=False)
 
-        if 'Time Stamp' in _df.columns:  # remote download
-            _df = _df.rename(columns={'Time Stamp': 'time',
-                                      'System status': 'status',
-                                      'PM-2.5 base MC': 'PM_NV',
-                                      'PM-2.5 MC': 'PM_Total',
-                                      'PM-2.5 TEOM noise': 'noise', })
-
-            _time_replace = {'十一月': '11', '十二月': '12', '一月': '01', '二月': '02', '三月': '03', '四月': '04',
-                             '五月': '05', '六月': '06', '七月': '07', '八月': '08', '九月': '09', '十月': '10'}
-
+        # Chinese month name conversion dictionary
+        _time_replace = {'十一月': '11', '十二月': '12', '一月': '01', '二月': '02', '三月': '03', '四月': '04',
+                         '五月': '05', '六月': '06', '七月': '07', '八月': '08', '九月': '09', '十月': '10'}
+
+        # Try both naming conventions (will ignore columns that don't exist)
+        _df = _df.rename(columns={
+            # Remote download format
+            'Time Stamp': 'time',
+            'System status': 'status',
+            'PM-2.5 base MC': 'PM_NV',
+            'PM-2.5 MC': 'PM_Total',
+            'PM-2.5 TEOM noise': 'noise',
+            # USB/auto export format
+            'time_stamp': 'time',
+            'tmoStatusCondition_0': 'status',
+            'tmoTEOMABaseMC_0': 'PM_NV',
+            'tmoTEOMAMC_0': 'PM_Total',
+            'tmoTEOMANoise_0': 'noise'
+        })
+
+        # Handle different time formats
+        if 'time' in _df.columns:  # Remote download or auto export with time column
             _tm_idx = _df.time
+            # Convert Chinese month names if present
             for _ori, _rpl in _time_replace.items():
                 _tm_idx = _tm_idx.str.replace(_ori, _rpl)
 
             _df = _df.set_index(to_datetime(_tm_idx, errors='coerce', format='%d - %m - %Y %X'))
 
-        elif 'tmoStatusCondition_0' in _df.columns:  # usb download
-            _df['time'] = pd.to_datetime(_df['Date'] + ' ' + _df['Time'], errors='coerce', format='%Y-%m-%d %H:%M:%S')
+        elif 'Date' in _df.columns and 'Time' in _df.columns:  # USB download format
+            _df['time'] = pd.to_datetime(_df['Date'] + ' ' + _df['Time'],
+                                         errors='coerce', format='%Y-%m-%d %H:%M:%S')
             _df.drop(columns=['Date', 'Time'], inplace=True)
             _df.set_index('time', inplace=True)
 
-            _df = _df.rename(columns={'tmoStatusCondition_0': 'status',
-                                      'tmoTEOMABaseMC_0': 'PM_NV',
-                                      'tmoTEOMAMC_0': 'PM_Total',
-                                      'tmoTEOMANoise_0': 'noise', })
         else:
-            raise NotImplementedError
+            raise NotImplementedError("Unsupported TEOM data format")
 
+        # Filter and clean data
         _df = _df.where(_df['status'] < 1)
         _df = _df[['PM_NV', 'PM_Total', 'noise']].apply(to_numeric, errors='coerce')
 
+        # Remove duplicates and NaN indices
         return _df.loc[~_df.index.duplicated() & _df.index.notna()]
 
     # QC data