pyadps 0.1.3__py3-none-any.whl → 0.1.4__py3-none-any.whl

pyadps/pages/09_Add-Ons.py

@@ -0,0 +1,168 @@
+import os
+import tempfile
+from pathlib import Path
+
+import re
+import io
+import contextlib
+
+import configparser
+import streamlit as st
+from utils.autoprocess import autoprocess
+from utils.multifile import ADCPBinFileCombiner
+
+# To make the page wider if the user presses the reload button.
+st.set_page_config(layout="wide")
+
+
+def ansi_to_html(text):
+    """
+    Function to convert ANSI (console color) to HTML.
+    To display the text, map the output to st.markdown
+    """
+    text = re.sub(r"\x1b\[31m", "<span style='color:red'><br>", text)  # red
+    text = re.sub(r"\x1b\[32m", "<span style='color:green'><br>", text)  # red
+    text = re.sub(r"\x1b\[33m", "<span style='color:orange'><br>", text)  # green
+    text = re.sub(r"\x1b\[0m", "</span>", text)  # reset
+    return text
+
+
+@st.cache_data
+def file_access(uploaded_file):
+    """
+    Function creates temporary directory to store the uploaded file.
+    The path of the file is returned
+
+    Args:
+        uploaded_file (string): Name of the uploaded file
+
+    Returns:
+        path (string): Path of the uploaded file
+    """
+    temp_dir = tempfile.mkdtemp()
+    path = os.path.join(temp_dir, uploaded_file.name)
+    with open(path, "wb") as f:
+        f.write(uploaded_file.getvalue())
+    return path
+
+
+def display_config_as_json(config_file):
+    config = configparser.ConfigParser()
+    config.read_string(config_file.getvalue().decode("utf-8"))
+    st.json({section: dict(config[section]) for section in config.sections()})
+
+
+def main():
+    st.title("🧰 Add-Ons")
+    st.header("🔧 Auto Processing Tool", divider=True)
+    st.write(
+        "You can use a configuration file from `pyadps` to re-process ADCP data by simply adjusting threshold values within the file. "
+        "This allows you to fine-tune the output without repeating the full processing workflow in the software."
+    )
+    st.write(
+        "To begin, upload both a binary ADCP file and a `config.ini` file for processing."
+    )
+
+    # File Upload Section
+    uploaded_binary_file = st.file_uploader(
+        "Upload ADCP Binary File", type=["000", "bin"]
+    )
+    uploaded_config_file = st.file_uploader(
+        "Upload Config File (config.ini)", type=["ini"]
+    )
+
+    if uploaded_binary_file and uploaded_config_file:
+        st.success("Files uploaded successfully!")
+
+        # Display config.ini file content as JSON
+        display_config_as_json(uploaded_config_file)
+
+        fpath = file_access(uploaded_binary_file)
+        # Process files
+        with st.spinner("Processing files. Please wait..."):
+            autoprocess(uploaded_config_file, binary_file_path=fpath)
+            st.success("Processing completed successfully!")
+            st.write("Processed file written.")
+
+    st.header("🔗 Binary File Combiner", divider=True)
+    st.write(
+        "ADCPs  may produce multiple binary segments instead of a single continuous file. "
+        "This tool scans each uploaded binary file for the `7f7f` header, removes any broken ensembles at the beginning or the end, and combines all valid segments into a single file. "
+        "To ensure correct order during concatenation, please rename the files using sequential numbering. "
+        "For example: `KKS_000.000`, `KKS_001.000`, `KKS_002.000`."
+    )
+    output_cat_filename = "merged_000.000"
+    st.info(f"Current file name: **{output_cat_filename}**")
+    output_cat_filename_radio = st.radio(
+        "Would you like to edit the output filename?",
+        ["No", "Yes"],
+        horizontal=True,
+    )
+    if output_cat_filename_radio == "Yes":
+        output_cat_filename = st.text_input(
+            "Enter file name (e.g., GD10A000)",
+            value=output_cat_filename,
+        )
+
+    display_log = st.radio(
+        "Display log from console:",
+        ["No", "Yes"],
+        horizontal=True,
+    )
+
+    uploaded_files = st.file_uploader(
+        "Upload multiple binary files", type=["bin", "000"], accept_multiple_files=True
+    )
+
+    if uploaded_files:
+        st.info("Saving uploaded files to temporary disk files...")
+
+        # Save files to temporary path
+        temp_file_paths = []
+        for uploaded_file in uploaded_files:
+            suffix = Path(uploaded_file.name).suffix
+            with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as tmp:
+                tmp.write(uploaded_file.read())
+                temp_path = Path(tmp.name)
+                temp_file_paths.append(temp_path)
+
+        st.divider()
+        st.subheader("🛠 Processing and Combining...")
+
+        if display_log == "Yes":
+            # The `buffer` is used to display console output to streamlit
+            buffer = io.StringIO()
+            with contextlib.redirect_stdout(buffer):
+                adcpcat = ADCPBinFileCombiner()
+                combined_data = adcpcat.combine_files(temp_file_paths)
+            st.markdown(ansi_to_html(buffer.getvalue()), unsafe_allow_html=True)
+        else:
+            adcpcat = ADCPBinFileCombiner()
+            combined_data = adcpcat.combine_files(temp_file_paths)
+
+        if combined_data:
+            st.success("✅ Valid binary data has been combined successfully.")
+            st.warning(
+                "⚠️ Note: The time axis in the final file may be irregular due to missing ensembles during concatenation."
+            )
+            st.download_button(
+                label="📥 Download Combined Binary File",
+                data=bytes(combined_data),
+                file_name=output_cat_filename,
+                mime="application/octet-stream",
+            )
+        else:
+            st.warning("⚠️ No valid data found to combine.")
+
+        # Optional: Clean up temporary files
+        for path in temp_file_paths:
+            try:
+                os.remove(path)
+            except Exception as e:
+                st.warning(f"Failed to delete temp file {path}: {e}")
+    else:
+        st.info("Please upload binary files to begin.")
+
+
+if __name__ == "__main__":
+    main()

pyadps/utils/__init__.py

@@ -9,4 +9,6 @@ from pyadps.utils.signal_quality import *
 from pyadps.utils.velocity_test import *
 from pyadps.utils.writenc import *
 from pyadps.utils.autoprocess import *
+from pyadps.utils.logging_utils import *
+from pyadps.utils.multifile import *
 from pyadps.utils.script import *

pyadps/utils/logging_utils.py

@@ -0,0 +1,269 @@
+"""
+Reusable Logging Utilities
+A clean, configurable logging module that can be used across multiple projects.
+"""
+
+import logging
+import sys
+from enum import Enum
+from typing import Optional, Union
+from pathlib import Path
+
+
+class LogLevel(Enum):
+    """Log level enumeration"""
+
+    DEBUG = logging.DEBUG
+    INFO = logging.INFO
+    WARNING = logging.WARNING
+    ERROR = logging.ERROR
+    CRITICAL = logging.CRITICAL
+
+
+class CustomFormatter(logging.Formatter):
+    """Custom colored formatter for console logging"""
+
+    COLORS = {
+        logging.DEBUG: "\x1b[36m",  # Cyan
+        logging.INFO: "\x1b[32m",  # Green
+        logging.WARNING: "\x1b[33m",  # Yellow
+        logging.ERROR: "\x1b[31m",  # Red
+        logging.CRITICAL: "\x1b[31;1m",  # Bold Red
+    }
+    RESET = "\x1b[0m"
+
+    def __init__(self, include_timestamp: bool = True, include_module: bool = False):
+        """
+        Initialize formatter with optional components
+
+        Args:
+            include_timestamp: Whether to include timestamp in log format
+            include_module: Whether to include module name in log format
+        """
+        self.include_timestamp = include_timestamp
+        self.include_module = include_module
+        super().__init__()
+
+    def format(self, record):
+        """Format log record with colors and optional components"""
+        # Build format string based on options
+        format_parts = []
+
+        if self.include_timestamp:
+            format_parts.append("%(asctime)s")
+
+        format_parts.append("%(levelname)s")
+
+        if self.include_module:
+            format_parts.append("%(name)s")
+
+        format_parts.append("%(message)s")
+
+        log_format = " - ".join(format_parts)
+
+        # Apply color
+        color = self.COLORS.get(record.levelno, "")
+        colored_format = color + log_format + self.RESET
+
+        formatter = logging.Formatter(
+            colored_format,
+            datefmt="%Y-%m-%d %H:%M:%S" if self.include_timestamp else None,
+        )
+        return formatter.format(record)
+
+
+class LoggerConfig:
+    """Configuration class for logger setup"""
+
+    def __init__(
+        self,
+        level: LogLevel = LogLevel.INFO,
+        include_timestamp: bool = True,
+        include_module: bool = False,
+        log_to_file: bool = False,
+        log_file_path: Optional[Union[str, Path]] = None,
+        file_log_level: Optional[LogLevel] = None,
+        max_file_size: int = 10 * 1024 * 1024,  # 10MB
+        backup_count: int = 5,
+    ):
+        """
+        Initialize logger configuration
+
+        Args:
+            level: Console logging level
+            include_timestamp: Include timestamp in console output
+            include_module: Include module name in output
+            log_to_file: Whether to also log to file
+            log_file_path: Path for log file (if log_to_file is True)
+            file_log_level: File logging level (defaults to console level)
+            max_file_size: Maximum size of log file before rotation
+            backup_count: Number of backup files to keep
+        """
+        self.level = level
+        self.include_timestamp = include_timestamp
+        self.include_module = include_module
+        self.log_to_file = log_to_file
+        self.log_file_path = Path(log_file_path) if log_file_path else None
+        self.file_log_level = file_log_level or level
+        self.max_file_size = max_file_size
+        self.backup_count = backup_count
+
+
+class LoggerManager:
+    """Manages logger configuration and setup"""
+
+    _loggers = {}  # Cache for created loggers
+
+    @classmethod
+    def setup_logger(
+        self, name: str = "app", config: Optional[LoggerConfig] = None
+    ) -> logging.Logger:
+        """
+        Set up and configure logger with given configuration
+
+        Args:
+            name: Logger name
+            config: Logger configuration (uses defaults if None)
+
+        Returns:
+            Configured logger instance
+        """
+        # Use default config if none provided
+        if config is None:
+            config = LoggerConfig()
+
+        # Return cached logger if it exists
+        cache_key = f"{name}_{id(config)}"
+        if cache_key in self._loggers:
+            return self._loggers[cache_key]
+
+        logger = logging.getLogger(name)
+        logger.setLevel(config.level.value)
+
+        # Remove existing handlers to avoid duplicates
+        logger.handlers.clear()
+
+        # Create console handler
+        console_handler = logging.StreamHandler(sys.stdout)
+        console_handler.setLevel(config.level.value)
+        console_formatter = CustomFormatter(
+            include_timestamp=config.include_timestamp,
+            include_module=config.include_module,
+        )
+        console_handler.setFormatter(console_formatter)
+        logger.addHandler(console_handler)
+
+        # Add file handler if requested
+        if config.log_to_file and config.log_file_path:
+            self._add_file_handler(logger, config)
+
+        # Prevent propagation to root logger
+        logger.propagate = False
+
+        # Cache the logger
+        self._loggers[cache_key] = logger
+
+        return logger
+
+    @classmethod
+    def _add_file_handler(self, logger: logging.Logger, config: LoggerConfig):
+        """Add rotating file handler to logger"""
+        from logging.handlers import RotatingFileHandler
+
+        # Ensure log directory exists
+        config.log_file_path.parent.mkdir(parents=True, exist_ok=True)
+
+        file_handler = RotatingFileHandler(
+            config.log_file_path,
+            maxBytes=config.max_file_size,
+            backupCount=config.backup_count,
+        )
+        file_handler.setLevel(config.file_log_level.value)
+
+        # File logs typically include more detail
+        file_formatter = logging.Formatter(
+            "%(asctime)s - %(name)s - %(levelname)s - %(funcName)s:%(lineno)d - %(message)s",
+            datefmt="%Y-%m-%d %H:%M:%S",
+        )
+        file_handler.setFormatter(file_formatter)
+        logger.addHandler(file_handler)
+
+    @classmethod
+    def get_logger(self, name: str = "app") -> logging.Logger:
+        """Get existing logger or create with default config"""
+        return logging.getLogger(name) or self.setup_logger(name)
+
+    @classmethod
+    def clear_cache(self):
+        """Clear logger cache (useful for testing)"""
+        self._loggers.clear()
+
+
+# Convenience functions for quick setup
+def get_console_logger(
+    name: str = "app", level: LogLevel = LogLevel.INFO, include_timestamp: bool = True
+) -> logging.Logger:
+    """Quick setup for console-only logger"""
+    config = LoggerConfig(
+        level=level, include_timestamp=include_timestamp, include_module=False
+    )
+    return LoggerManager.setup_logger(name, config)
+
+
+def get_file_logger(
+    name: str = "app",
+    log_file: Union[str, Path] = "app.log",
+    level: LogLevel = LogLevel.INFO,
+    file_level: Optional[LogLevel] = None,
+) -> logging.Logger:
+    """Quick setup for file + console logger"""
+    config = LoggerConfig(
+        level=level,
+        log_to_file=True,
+        log_file_path=log_file,
+        file_log_level=file_level or LogLevel.DEBUG,
+    )
+    return LoggerManager.setup_logger(name, config)
+
+
+def get_detailed_logger(
+    name: str = "app",
+    log_file: Union[str, Path] = "app.log",
+    console_level: LogLevel = LogLevel.INFO,
+    file_level: LogLevel = LogLevel.DEBUG,
+) -> logging.Logger:
+    """Setup logger with detailed configuration"""
+    config = LoggerConfig(
+        level=console_level,
+        include_timestamp=True,
+        include_module=True,
+        log_to_file=True,
+        log_file_path=log_file,
+        file_log_level=file_level,
+    )
+    return LoggerManager.setup_logger(name, config)
+
+
+# Example usage
+if __name__ == "__main__":
+    # Test different logger configurations
+
+    # Simple console logger
+    simple_logger = get_console_logger("simple", LogLevel.DEBUG)
+    simple_logger.debug("Debug message")
+    simple_logger.info("Info message")
+    simple_logger.warning("Warning message")
+    simple_logger.error("Error message")
+
+    print("\n" + "=" * 50 + "\n")
+
+    # File + console logger
+    file_logger = get_file_logger("file_test", "test.log", LogLevel.INFO)
+    file_logger.info("This goes to both console and file")
+    file_logger.debug("This only goes to file")
+
+    print("\n" + "=" * 50 + "\n")
+
+    # Detailed logger
+    detailed_logger = get_detailed_logger("detailed", "detailed.log")
+    detailed_logger.info("Detailed logging with module names")

pyadps/utils/multifile.py

@@ -0,0 +1,244 @@
+"""
+ADCP (Acoustic Doppler Current Profiler) File Processor
+A clean, maintainable implementation for processing and combining ADCP binary files.
+"""
+
+from pathlib import Path
+from dataclasses import dataclass
+from typing import List, Union
+
+# Import from our separate logging module
+from .logging_utils import LogLevel, get_console_logger
+
+
+@dataclass
+class ADCPConfig:
+    """Configuration for ADCP file processing"""
+
+    file_extension: str = "*.000"
+    header_signature: bytes = b"\x7f\x7f"
+    header_signature_ext: bytes = b"\x7f\x7f\xf0\x02"
+    ensemble_size_offset: int = 2
+    ensemble_size_length: int = 2
+    header_size_adjustment: int = 2
+    chunk_size: int = 8192  # For large file processing
+
+
+class ADCPError(Exception):
+    """Base exception for ADCP processing errors"""
+
+    pass
+
+
+class InvalidHeaderError(ADCPError):
+    """Raised when ADCP file has invalid header"""
+
+    pass
+
+
+class CorruptedFileError(ADCPError):
+    """Raised when ADCP file is corrupted"""
+
+    pass
+
+
+class ADCPFileValidator:
+    """Validates ADCP files and headers"""
+
+    def __init__(self, config: ADCPConfig, logger_name: str = "adcp_validator"):
+        self.config = config
+        self.logger = get_console_logger(logger_name, LogLevel.INFO)
+
+    def find_header_start(self, data: bytes) -> int:
+        """Find the first occurrence of the extended header signature"""
+        return data.find(self.config.header_signature_ext)
+
+    def validate_file_path(self, filepath: Path) -> None:
+        """Validate file path exists and is accessible"""
+        if not filepath.exists():
+            raise FileNotFoundError(f"File {filepath} does not exist")
+        if not filepath.is_file():
+            raise ValueError(f"Path {filepath} is not a file")
+        if filepath.stat().st_size == 0:
+            raise ValueError(f"File {filepath} is empty")
+
+    def has_valid_header(self, data: bytes) -> bool:
+        """Check if data starts with valid ADCP header"""
+        return data.startswith(self.config.header_signature)
+
+
+class ADCPFileProcessor:
+    """Processes individual ADCP files"""
+
+    def __init__(self, config: ADCPConfig = None, logger_name: str = "adcp_processor"):
+        self.config = config or ADCPConfig()
+        self.validator = ADCPFileValidator(self.config, f"{logger_name}_validator")
+        self.logger = get_console_logger(logger_name, LogLevel.INFO)
+
+    def _calculate_ensemble_size(self, data: bytes) -> int:
+        """Calculate size of single ensemble from header"""
+        offset = self.config.ensemble_size_offset
+        length = self.config.ensemble_size_length
+        return (
+            int.from_bytes(data[offset : offset + length], byteorder="little")
+            + self.config.header_size_adjustment
+        )
+
+    def _validate_file_integrity(
+        self, filepath: Path, data: bytes, ensemble_size: int
+    ) -> int:
+        """Validate file integrity and return number of valid ensembles"""
+        file_size = filepath.stat().st_size
+        if file_size % ensemble_size != 0:
+            valid_ensembles = file_size // ensemble_size
+            self.logger.warning(
+                f"File {filepath.name} is corrupted. "
+                f"Valid ensembles: {valid_ensembles}/{valid_ensembles + 1}"
+            )
+            return valid_ensembles
+        return file_size // ensemble_size
+
+    def process_file(self, filepath: Union[str, Path]) -> bytes:
+        """Process a single ADCP file and return valid data"""
+        filepath = Path(filepath)
+        try:
+            self.validator.validate_file_path(filepath)
+
+            with open(filepath, "rb") as f:
+                data = f.read()
+
+            header_index = 0
+            # Check if file starts with valid header
+            if not self.validator.has_valid_header(data):
+                header_index = self.validator.find_header_start(data)
+                if header_index == -1:
+                    raise InvalidHeaderError(
+                        f"File {filepath.name} contains no valid ADCP header"
+                    )
+                self.logger.warning(
+                    f"File {filepath.name} header found at byte {header_index}. "
+                    "Truncating invalid data before header."
+                )
+            else:
+                self.logger.info(f"Valid ADCP file: {filepath.name}")
+
+            # Calculate ensemble size and validate file integrity
+            ensemble_size = self._calculate_ensemble_size(data[header_index:])
+            valid_ensembles = self._validate_file_integrity(
+                filepath, data, ensemble_size
+            )
+
+            # Return only valid data
+            end_index = header_index + (valid_ensembles * ensemble_size)
+            return data[header_index:end_index]
+
+        except (InvalidHeaderError, FileNotFoundError, ValueError) as e:
+            self.logger.error(f"Error processing {filepath.name}: {e}")
+            return b""
+        except Exception as e:
+            self.logger.error(f"Unexpected error processing {filepath.name}: {e}")
+            return b""
+
+
+class ADCPBinFileCombiner:
+    """Combines or joins multiple ADCP files"""
+
+    def __init__(self, config: ADCPConfig = None, logger_name: str = "adcp_combiner"):
+        self.config = config or ADCPConfig()
+        self.processor = ADCPFileProcessor(self.config, f"{logger_name}_processor")
+        self.logger = get_console_logger(logger_name, LogLevel.INFO)
+
+    def get_adcp_files(self, folder_path: Union[str, Path]) -> List[Path]:
+        """Get all ADCP files from folder"""
+        folder_path = Path(folder_path)
+        if not folder_path.exists():
+            raise FileNotFoundError(f"Folder {folder_path} does not exist")
+        if not folder_path.is_dir():
+            raise NotADirectoryError(f"Path {folder_path} is not a directory")
+
+        files = sorted(folder_path.glob(self.config.file_extension))
+        if not files:
+            self.logger.error(
+                f"No {self.config.file_extension} files found in {folder_path}"
+            )
+        return files
+
+    def combine_files(self, files: List[Union[str, Path]]) -> bytearray:
+        """Combine multiple ADCP files into single bytearray"""
+        if not files:
+            self.logger.warning("No files provided for combination")
+            return bytearray()
+
+        combined_data = bytearray()
+        processed_count = 0
+
+        for file_path in files:
+            valid_data = self.processor.process_file(file_path)
+            if valid_data:
+                combined_data.extend(valid_data)
+                processed_count += 1
+
+        self.logger.info(f"Successfully combined {processed_count}/{len(files)} files")
+        return combined_data
+
+    def combine_folder(
+        self, folder_path: Union[str, Path], output_file: Union[str, Path]
+    ) -> bool:
+        """Combine all ADCP files from folder and write to output file"""
+        try:
+            files = self.get_adcp_files(folder_path)
+            if not files:
+                self.logger.error("No valid files found to combine")
+                return False
+
+            combined_data = self.combine_files(files)
+            if not combined_data:
+                self.logger.error("No valid data to write")
+                return False
+
+            output_path = Path(output_file)
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+
+            with open(output_path, "wb") as f:
+                f.write(combined_data)
+
+            self.logger.info(
+                # f"Successfully combined {len(files)} files. "
+                f"Output written to: {output_path} ({len(combined_data)} bytes)"
+            )
+            return True
+
+        except Exception as e:
+            self.logger.error(f"Error combining folder {folder_path}: {e}")
+            return False
+
+
+def main():
+    """Main entry point for CLI usage"""
+    try:
+        folder = input("Enter folder containing ADCP files (*.000): ").strip()
+        if not folder:
+            print("No folder specified. Exiting.")
+            return
+
+        output = input("Enter output filename (default: merged_000.000): ").strip()
+        if not output:
+            output = "merged_000.000"
+
+        # Create combiner with custom logger configuration
+        combiner = ADCPBinFileCombiner(logger_name="adcp_main")
+        success = combiner.combine_folder(folder, output)
+
+        if success:
+            print(f"✅ Files successfully combined to {output}")
+        else:
+            print("❌ Failed to combine files. Check logs for details.")
+
+    except KeyboardInterrupt:
+        print("\n⚠️  Operation cancelled by user.")
+    except Exception as e:
+        print(f"❌ Unexpected error: {e}")
+
+
+if __name__ == "__main__":
+    main()

{pyadps-0.1.3.dist-info → pyadps-0.1.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pyadps
-Version: 0.1.3
+Version: 0.1.4
 Summary: A Python package for ADCP data processing
 Home-page: https://pyadps.readthedocs.io/en/latest/index.html
 License: MIT

{pyadps-0.1.3.dist-info → pyadps-0.1.4.dist-info}/RECORD

@@ -9,14 +9,16 @@ pyadps/pages/05_QC_Test.py,sha256=6YjQTg_t0_Qll9xQ3SYieCBS2cDEMz9znovW3olPFwc,16
 pyadps/pages/06_Profile_Test.py,sha256=Vir91oRIWApbO2elBm4I59rdf83NtspUmtzAyWdsIiY,34891
 pyadps/pages/07_Velocity_Test.py,sha256=K4vEiLPMXrU4JMLj-mIA1G4H5ORozMbHMiMov3ZZXP0,23008
 pyadps/pages/08_Write_File.py,sha256=dehT7x68b0bzDDiTSE7W0cav4JdvoB1Awicip711hGY,23079
-pyadps/pages/09_Auto_process.py,sha256=SRtQVD9_kodlSvYdF9-02ur6EaWG2zMvN6-BcWdzYV8,1874
+pyadps/pages/09_Add-Ons.py,sha256=lweofAxcvKLxzfCJl6vybmUmxWgcm4jEn5DjFaTHbpI,5986
 pyadps/pages/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pyadps/utils/__init__.py,sha256=nCqRp-OT_1BC7RnL3ARUIldlw9sWyr1XqQvQid-B4ts,407
+pyadps/utils/__init__.py,sha256=JDIy5Yx6meDGxfLGyB5135TFWQc0lyNxu_cWrfSEDhU,485
 pyadps/utils/autoprocess.py,sha256=r6SZwx-FPV9Fp1DzuLfH06X5zStWVIi94182juebxfA,20374
+pyadps/utils/logging_utils.py,sha256=-b6rwnpF-g6ZSIj3PVyxiz4-blBKvKqh1HW1KRKpmyY,8492
 pyadps/utils/metadata/config.ini,sha256=TC7htzGwUukIXt_u3JR5ycyvOoDj_JxWgGY6khjNeck,2154
 pyadps/utils/metadata/demo.000,sha256=qxB3sgjABrpv4DNXkwjpbSxk5sc4UwAI8kgQX0--PM8,234468
 pyadps/utils/metadata/flmeta.json,sha256=eGw1lM5IKhZ6IuSkj7PiKQ-MpNtH446HaRmcby8rBIY,12673
 pyadps/utils/metadata/vlmeta.json,sha256=_dkQlGkkUvpAIM7S6kEUenSaiCpOrwXg8n1aU3dDF3s,22535
+pyadps/utils/multifile.py,sha256=NKSbikp6k98pHgT-5tciAyykYCTyWfPH1JFA9F8eiUs,8747
 pyadps/utils/plotgen.py,sha256=c7TUA9unErUxppYc14LZ2o_stzNMmmZ5X542iI5v1tA,26346
 pyadps/utils/profile_test.py,sha256=gnbS6ZsqKvv2tcHTj-Fi_VNOszbxDcPxl77_n4dLzSo,29237
 pyadps/utils/pyreadrdi.py,sha256=VwypCpKGfjTO0h0j_Vl1-JMhXooiaXnmQHmEFVPifGo,36886
@@ -26,8 +28,8 @@ pyadps/utils/sensor_health.py,sha256=aHRaU4kMJZ9dGmYypKpCCgq-owWoNjvcl1I_9I7dG68
 pyadps/utils/signal_quality.py,sha256=BYPAbXrAPGQBEfEyG4PFktYpqxuvhoafsWM172TVn08,16737
 pyadps/utils/velocity_test.py,sha256=O8dgjv_5pxhJq6QuWHxysMjNzxSnob_2KPLInmO1kHI,6112
 pyadps/utils/writenc.py,sha256=KDolQ11Whh2bi4L2wfrgjXym5BWL8ikp0xvo4Pa0r4E,14455
-pyadps-0.1.3.dist-info/LICENSE,sha256=sfY_7DzQF5FxnO2T6ek74dfm5uBmwEp1oEg_WlzNsb8,1092
-pyadps-0.1.3.dist-info/METADATA,sha256=F49hGNEXebr0Q8M0ul29c6HoB4ColJFetU03OGinEgg,4518
-pyadps-0.1.3.dist-info/WHEEL,sha256=RaoafKOydTQ7I_I3JTrPCg6kUmTgtm4BornzOqyEfJ8,88
-pyadps-0.1.3.dist-info/entry_points.txt,sha256=-oZhbbJq8Q29uNVh5SmzOLp9OeFM9VUzHVxovfI4LXA,126
-pyadps-0.1.3.dist-info/RECORD,,
+pyadps-0.1.4.dist-info/LICENSE,sha256=sfY_7DzQF5FxnO2T6ek74dfm5uBmwEp1oEg_WlzNsb8,1092
+pyadps-0.1.4.dist-info/METADATA,sha256=M9Qsr-K3w1VHOMajGLAw8CVlhJzD2gz7oqW_er-Jwak,4518
+pyadps-0.1.4.dist-info/WHEEL,sha256=RaoafKOydTQ7I_I3JTrPCg6kUmTgtm4BornzOqyEfJ8,88
+pyadps-0.1.4.dist-info/entry_points.txt,sha256=-oZhbbJq8Q29uNVh5SmzOLp9OeFM9VUzHVxovfI4LXA,126
+pyadps-0.1.4.dist-info/RECORD,,

pyadps/pages/09_Auto_process.py

@@ -1,64 +0,0 @@
-import os
-import tempfile
-
-import configparser
-import json
-import streamlit as st
-from utils.autoprocess import autoprocess
-
-# To make the page wider if the user presses the reload button.
-st.set_page_config(layout="wide")
-
-@st.cache_data
-def file_access(uploaded_file):
-    """
-    Function creates temporary directory to store the uploaded file.
-    The path of the file is returned
-
-    Args:
-        uploaded_file (string): Name of the uploaded file
-
-    Returns:
-        path (string): Path of the uploaded file
-    """
-    temp_dir = tempfile.mkdtemp()
-    path = os.path.join(temp_dir, uploaded_file.name)
-    with open(path, "wb") as f:
-        f.write(uploaded_file.getvalue())
-    return path
-
-
-def display_config_as_json(config_file):
-    config = configparser.ConfigParser()
-    config.read_string(config_file.getvalue().decode("utf-8"))
-    st.json({section: dict(config[section]) for section in config.sections()})
-
-
-def main():
-    st.title("ADCP Data Auto Processing Tool")
-    st.write("Upload a binary input file and config.ini file for processing.")
-
-    # File Upload Section
-    uploaded_binary_file = st.file_uploader(
-        "Upload ADCP Binary File", type=["000", "bin"]
-    )
-    uploaded_config_file = st.file_uploader(
-        "Upload Config File (config.ini)", type=["ini"]
-    )
-
-    if uploaded_binary_file and uploaded_config_file:
-        st.success("Files uploaded successfully!")
-
-        # Display config.ini file content as JSON
-        display_config_as_json(uploaded_config_file)
-
-        fpath = file_access(uploaded_binary_file)
-        # Process files
-        with st.spinner("Processing files. Please wait..."):
-            autoprocess(uploaded_config_file, binary_file_path=fpath)
-            st.success("Processing completed successfully!")
-            st.write("Processed file written.")
-
-
-if __name__ == "__main__":
-    main()