corrosions 0.1.0__tar.gz

corrosions-0.1.0/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.3
+Name: corrosions
+Version: 0.1.0
+Summary: Corrosion calculation created by Capella Global Innovation
+Author: Martanto
+Author-email: Martanto <martanto@live.com>
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: black>=25.9.0
+Requires-Dist: isort>=7.0.0
+Requires-Dist: matplotlib>=3.10.7
+Requires-Dist: openpyxl>=3.1.5
+Requires-Dist: pandas>=2.3.3
+Requires-Dist: pip>=25.3
+Requires-Dist: python-slugify>=8.0.4
+Requires-Dist: xlsxwriter>=3.2.9
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+

corrosions-0.1.0/pyproject.toml

@@ -0,0 +1,57 @@
+[build-system]
+requires = ["uv_build>=0.9.8,<0.10.0"]
+build-backend = "uv_build"
+
+[project]
+name = "corrosions"
+version = "0.1.0"
+authors = [
+    {name = "Martanto", email = "martanto@live.com"},
+]
+description = "Corrosion calculation created by Capella Global Innovation"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "black>=25.9.0",
+    "isort>=7.0.0",
+    "matplotlib>=3.10.7",
+    "openpyxl>=3.1.5",
+    "pandas>=2.3.3",
+    "pip>=25.3",
+    "python-slugify>=8.0.4",
+    "xlsxwriter>=3.2.9",
+]
+classifiers = [
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+
+[tool.black]
+line-length = 79
+target-version = ['py311', 'py312']
+include = '\.pyi?$'
+exclude = '''
+/(
+    \.eggs
+  | \.git
+  | \.hg
+  | \.mypy_cache
+  | \.tox
+  | \.venv
+  | \.uv_cache
+  | _build
+  | buck-out
+  | build
+  | dist
+)/
+'''
+
+[tool.isort]
+profile = "black"
+line_length = 79
+skip = [
+    ".venv",
+    ".uv_cache",
+]

corrosions-0.1.0/src/corrosions/__init__.py

@@ -0,0 +1,28 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# Third party imports
+from importlib.metadata import version
+from .cips import CIPS
+from .pcm import PCM
+from .sync import Sync
+from .acvg_dcvg import AcvgDcvg
+
+__version__ = version("corrosions")
+__author__ = "Martanto"
+__author_email__ = "martanto@live.com"
+__license__ = "MIT"
+__copyright__ = "Copyright (c) 2025, Martanto"
+__url__ = "https://github.com/martanto/corrosions"
+
+__all__ = [
+    "__version__",
+    "__author__",
+    "__author_email__",
+    "__license__",
+    "__copyright__",
+    "AcvgDcvg",
+    "CIPS",
+    "PCM",
+    "Sync",
+]

corrosions-0.1.0/src/corrosions/acvg_dcvg.py

@@ -0,0 +1,211 @@
+import pandas as pd
+import numpy as np
+from typing import Optional
+
+from .pcm import PCM
+from .const import *
+from .utils import *
+
+
+class AcvgDcvg(PCM):
+    def __init__(
+        self,
+        file_or_dir: str,
+        overwrite: bool = False,
+        verbose: bool = False,
+    ):
+        super().__init__(file_or_dir, overwrite, verbose)
+
+        self.prefix = "acvg_dcvg"
+
+        self.COLUMNS_VALIDATED = [
+            "segment_code",
+            "diameter",
+            "anomaly_location",
+            "surface_condition",
+            "drop_pcm",
+            "on_potential",
+            "off_potential",
+            "survey_dcvg",
+            "survey_acvg",
+            "latitude",
+            "longitude",
+            "ir_drop",
+            "pipe_depth",
+            "result_acvg",
+            "protection",
+        ]
+
+        self.UNIQUE_COLUMNS = ["latitude", "longitude"]
+
+        self.check_sequential_file = False
+        self.excel_dir = ACVG_DCVG_EXCEL_DIR
+        self.json_dir = ACVG_DCVG_JSON_DIR
+
+    @staticmethod
+    def closest_distance_pcm(
+        df_acvg_dcvg: pd.DataFrame, df_pcm: pd.DataFrame
+    ) -> pd.DataFrame:
+        acvg_dvcg_distance = []
+        closest_pcm_distance = []
+        closest_pcm_index = []
+        closest_pcm_latitude = []
+        closest_pcm_longitude = []
+        closest_pcm_real_distance = []
+
+        pcm_coordinates = df_pcm[
+            ["Int GPS Latitude", "Int GPS Longitude", "Real Distance"]
+        ]
+
+        for index, row_acvg_dcvg in df_acvg_dcvg.iterrows():
+            distances = []
+            lat2 = row_acvg_dcvg["latitude"]
+            lon2 = row_acvg_dcvg["longitude"]
+
+            for _, pcm in pcm_coordinates.iterrows():
+                lat1 = pcm["Int GPS Latitude"]
+                lon1 = pcm["Int GPS Longitude"]
+                distance = calculate_distance(lat1, lon1, lat2, lon2)
+                distances.append(distance)
+
+            np_distances = np.array(distances)
+            distance_min = np.min(np_distances)
+
+            acvg_dvcg_distance.append(
+                pcm_coordinates.iloc[np_distances.argmin()]["Real Distance"]
+                + distance_min
+            )
+            closest_pcm_distance.append(0 - distance_min)
+            closest_pcm_index.append(np_distances.argmin())
+            closest_pcm_latitude.append(
+                pcm_coordinates.iloc[np_distances.argmin()]["Int GPS Latitude"]
+            )
+            closest_pcm_longitude.append(
+                pcm_coordinates.iloc[np_distances.argmin()][
+                    "Int GPS Longitude"
+                ]
+            )
+            closest_pcm_real_distance.append(
+                pcm_coordinates.iloc[np_distances.argmin()]["Real Distance"]
+            )
+
+        df_acvg_dcvg["real_distance"] = acvg_dvcg_distance
+        df_acvg_dcvg["closest_pcm_distance"] = closest_pcm_distance
+        df_acvg_dcvg["closest_pcm_real_distance"] = closest_pcm_real_distance
+        df_acvg_dcvg["closest_pcm_index"] = closest_pcm_index
+        df_acvg_dcvg["closest_pcm_latitude"] = closest_pcm_latitude
+        df_acvg_dcvg["closest_pcm_longitude"] = closest_pcm_longitude
+
+        df_acvg_dcvg.sort_values("real_distance", ascending=True, inplace=True)
+
+        return df_acvg_dcvg
+
+    @staticmethod
+    def closest_distance_cips(
+        df_acvg_dcvg: pd.DataFrame, df_cips: pd.DataFrame
+    ) -> pd.DataFrame:
+        closest_cips_distance = []
+        closest_cips_index = []
+        closest_cips_latitude = []
+        closest_cips_longitude = []
+        closest_cips_real_distance = []
+        closest_cips_condition = []
+        closest_cips_voltage_inverse = []
+
+        cips_coordinates = df_cips[["Latitude", "Longitude", "Real Distance"]]
+
+        for index, row_acvg_dcvg in df_acvg_dcvg.iterrows():
+            distances = []
+            lat2 = row_acvg_dcvg["latitude"]
+            lon2 = row_acvg_dcvg["longitude"]
+
+            for _, cips in cips_coordinates.iterrows():
+                lat1 = cips["Latitude"]
+                lon1 = cips["Longitude"]
+                distance = calculate_distance(lat1, lon1, lat2, lon2)
+                distances.append(distance)
+
+            np_distances = np.array(distances)
+            distance_min = np.min(np_distances)
+
+            closest_cips_distance.append(0 - distance_min)
+            closest_cips_index.append(np_distances.argmin())
+
+            closest_cips_voltage_inverse.append(
+                df_cips.iloc[np_distances.argmin()]["voltage_inverse"]
+            )
+            closest_cips_condition.append(
+                df_cips.iloc[np_distances.argmin()]["condition"]
+            )
+            closest_cips_latitude.append(
+                cips_coordinates.iloc[np_distances.argmin()]["Latitude"]
+            )
+            closest_cips_longitude.append(
+                cips_coordinates.iloc[np_distances.argmin()]["Longitude"]
+            )
+            closest_cips_real_distance.append(
+                cips_coordinates.iloc[np_distances.argmin()]["Real Distance"]
+            )
+
+        df_acvg_dcvg["closest_cips_distance"] = closest_cips_distance
+        df_acvg_dcvg["closest_cips_real_distance"] = closest_cips_real_distance
+        df_acvg_dcvg["closest_cips_index"] = closest_cips_index
+        df_acvg_dcvg["closest_cips_latitude"] = closest_cips_latitude
+        df_acvg_dcvg["closest_cips_longitude"] = closest_cips_longitude
+        df_acvg_dcvg["closest_cips_voltage_inverse"] = (
+            closest_cips_voltage_inverse
+        )
+        df_acvg_dcvg["closest_cips_condition"] = closest_cips_condition
+
+        df_acvg_dcvg.sort_values("real_distance", ascending=True, inplace=True)
+
+        return df_acvg_dcvg
+
+    def transform(
+        self,
+        df: pd.DataFrame,
+        excel_filepath: str,
+        sheet_name: str = "Sheet1",
+        json_filepath: Optional[str] = None,
+    ) -> str:
+        """Normalize a file.
+
+        Args:
+            df (pd.DataFrame): data frame.
+            excel_filepath (str): filename to normalize.
+            sheet_name (str): sheet name.
+            json_filepath (str): json file path.
+
+        Returns:
+            str: normalized file.
+        """
+        df_acvg_dcvg = df.drop_duplicates(
+            subset=self.UNIQUE_COLUMNS, keep="last"
+        )
+
+        df_acvg_dcvg.dropna(subset=["latitude", "longitude"], inplace=True)
+        df_acvg_dcvg.reset_index(drop=True, inplace=True)
+
+        try:
+            writer = pd.ExcelWriter(excel_filepath, engine="xlsxwriter")
+
+            df_acvg_dcvg["survey_dcvg"] = df_acvg_dcvg["survey_dcvg"].apply(
+                lambda x: x.strftime("%Y-%m-%d") if not pd.isnull(x) else None
+            )
+            df_acvg_dcvg["survey_acvg"] = df_acvg_dcvg["survey_acvg"].apply(
+                lambda x: x.strftime("%Y-%m-%d") if not pd.isnull(x) else None
+            )
+
+            df_acvg_dcvg.to_excel(writer, sheet_name="Sheet1", index=False)
+            df_acvg_dcvg.columns = rename_columns(
+                df_acvg_dcvg.columns.tolist()
+            )
+            df_acvg_dcvg.to_json(json_filepath, orient="records")
+
+            writer.close()
+
+            # print(excel_filepath)
+
+            return excel_filepath
+        except Exception as e:
+            raise e

corrosions-0.1.0/src/corrosions/cips.py

@@ -0,0 +1,339 @@
+import glob
+import pandas as pd
+from typing import Self, Any, Optional
+from .utils import *
+from .const import *
+
+
+class CIPS:
+    def __init__(
+        self,
+        file_or_dir: str,
+        overwrite: bool = False,
+        keep_original_filename: bool = False,
+        verbose: bool = False,
+    ):
+        self.file_or_dir = file_or_dir
+        self.overwrite = overwrite
+        self.keep_original_filename = keep_original_filename
+        self.prefix = "cips"
+        self.excel_dir = CIPS_EXCEL_DIR
+        self.json_dir = CIPS_JSON_DIR
+        self.results = []
+
+        self.COLUMNS_VALIDATED = [
+            "Data No",
+            "Latitude",
+            "Longitude",
+            "DCP/Feature/DCVG Anomaly",
+        ]
+
+        self.UNIQUE_COLUMNS = ["Latitude", "Longitude"]
+
+        self.check_sequential_file = False
+        self.verbose = verbose
+
+    @property
+    def files(self) -> List[str]:
+        files = []
+        if os.path.isfile(self.file_or_dir):
+            files.append(self.file_or_dir)
+
+        if os.path.isdir(self.file_or_dir):
+            files = glob.glob(os.path.join(self.file_or_dir, "*.xlsx"))
+
+        return files
+
+    def validate_column(self, columns: list[str]) -> tuple[bool, list[str]]:
+        """Validate columns.
+
+        Args:
+            columns (list[str]): list of column names.
+
+        Returns:
+            bool: column validated.
+            list[str]: list of column names.
+        """
+
+        missing_columns: list[str] = []
+
+        for column_validated in self.COLUMNS_VALIDATED:
+            if column_validated not in columns:
+                missing_columns.append(column_validated)
+
+        if ("Voltage" not in columns) and ("Off Voltage" not in columns):
+            missing_columns.append("Voltage/Off Voltage")
+
+        if len(missing_columns) > 0:
+            return False, missing_columns
+
+        return True, missing_columns
+
+    @staticmethod
+    def transform_df(df: pd.DataFrame) -> pd.DataFrame:
+        """Extract data from a file.
+
+        Args:
+            df (pd.DataFrame): data frame.
+
+        Returns:
+            pd.DataFrame: data extracted.
+        """
+        if "Off Voltage" in df.columns:
+            # iccp - impress current cathodic protection
+            df = df[
+                [
+                    "Data No",
+                    "Off Voltage",
+                    "On Voltage",
+                    "Latitude",
+                    "Longitude",
+                    "Comment",
+                    "DCP/Feature/DCVG Anomaly",
+                ]
+            ].copy(deep=True)
+            df["protection"] = "ICCP"
+            df.rename(columns={"Off Voltage": "Voltage"}, inplace=True)
+            return df
+
+        # sacp - sacrificial anode cathodic protection
+        df = df[
+            [
+                "Data No",
+                "Voltage",
+                "Latitude",
+                "Longitude",
+                "Comment",
+                "DCP/Feature/DCVG Anomaly",
+            ]
+        ].copy(deep=True)
+        df["On Voltage"] = None
+        df["protection"] = "SACP"
+        return df
+
+    @staticmethod
+    def condition(voltage: float) -> str:
+        """Get condition based on voltage.
+
+        Args:
+            voltage (float): voltage.
+
+        Returns:
+            str: condition.
+        """
+        if -1.2 < voltage <= -0.85:
+            return "PROTECTED"
+        if voltage <= -1.2:
+            return "OVER PROTECTED"
+        return "UNPROTECTED"
+
+    def transform(
+        self,
+        df: pd.DataFrame,
+        excel_filepath: str,
+        sheet_name: str = "Sheet1",
+        json_filepath: Optional[str] = None,
+    ) -> str:
+        """Normalize a file.
+
+        Args:
+            df (pd.DataFrame): data frame.
+            excel_filepath (str): filename to normalize.
+            sheet_name (str): sheet name.
+            json_filepath (str): json file path.
+
+        Returns:
+            str: normalized file.
+        """
+        df = self.transform_df(df)
+
+        df["condition"] = df["Voltage"].apply(lambda x: self.condition(x))
+        df["voltage_inverse"] = df["Voltage"] * -1
+        df["on_voltage_inverse"] = df["On Voltage"] * -1
+
+        df["type"] = "PCM" if "4Hz Current (A)" in df.columns else "CIPS"
+        df["interpolated"] = df["Latitude"].isna() & df["Longitude"].isna()
+        df["Latitude"] = df["Latitude"].interpolate(method="linear")
+        df["Longitude"] = df["Longitude"].interpolate(method="linear")
+
+        for index in df.index:
+            if index == 0:
+                df["Distance"] = 0.0
+                df["Real Distance"] = 0.0
+                continue
+
+            # if index == len(df) - 1:
+            #     continue
+
+            lat_1 = df.loc[index - 1, "Latitude"]
+            lon_1 = df.loc[index - 1, "Longitude"]
+            lat_2 = df.loc[index, "Latitude"]
+            lon_2 = df.loc[index, "Longitude"]
+
+            distance = calculate_distance(lat_1, lon_1, lat_2, lon_2)
+            df.loc[index, "Distance"] = distance
+            df.loc[index, "Real Distance"] = (
+                distance + df.loc[index - 1, "Real Distance"]
+            )
+
+        df.set_index("Data No", inplace=True)
+        df.to_excel(excel_filepath, sheet_name=sheet_name, index=True)
+
+        if json_filepath:
+            df.columns = rename_columns(df.columns.tolist())
+            df.to_json(json_filepath, orient="records")
+
+        return excel_filepath
+
+    def drop_columns(self, df: pd.DataFrame) -> pd.DataFrame:
+        """Drop empty row and duplicated columns.
+
+        Args:
+            df: pd.DataFrame
+
+        Returns:
+            pd.DataFrame
+        """
+        df.dropna(how="all", inplace=True)
+        df = df.drop_duplicates(
+            subset=self.UNIQUE_COLUMNS, keep="last"
+        ).reset_index(drop=True)
+
+        return df
+
+    def process_df(
+        self,
+        df: pd.DataFrame,
+        filename: str,
+        sheet_name: str = "Sheet1",
+        as_json: bool = False,
+        overwrite: bool = False,
+    ) -> dict[str, Any]:
+        """Process a file.
+
+        Args:
+            df (pd.DataFrame): path to file
+            filename (str): filename to normalize.
+            sheet_name (str): sheet name.
+            as_json (bool): whether to return as json.
+            overwrite (bool): overwrite existing file.
+
+        Returns:
+            dict[str, Any]: processed file.
+        """
+        _basename = get_basename(
+            filename,
+            sheet_name,
+            prefix=self.prefix,
+            keep_original=self.keep_original_filename,
+        )
+
+        excel_filepath = os.path.join(
+            self.excel_dir, f"{slugify(_basename)}.xlsx"
+        )
+        json_filepath = (
+            os.path.join(self.json_dir, f"{slugify(_basename)}.json")
+            if as_json
+            else None
+        )
+
+        if os.path.exists(excel_filepath) and not overwrite:
+            return {
+                "success": True,
+                "message": "File already normalized",
+                "excel": excel_filepath,
+                "json": json_filepath,
+                "sheet": sheet_name,
+            }
+
+        try:
+            df = self.drop_columns(df)
+
+            return {
+                "success": True,
+                "message": "File normalized",
+                "excel": self.transform(
+                    df,
+                    excel_filepath,
+                    sheet_name=sheet_name,
+                    json_filepath=json_filepath,
+                ),
+                "json": json_filepath,
+                "sheet": sheet_name,
+            }
+        except Exception as e:
+            if self.verbose:
+                raise Exception(e)
+            return {
+                "success": False,
+                "message": e,
+                "excel": filename,
+                "json": json_filepath,
+                "sheet": None,
+            }
+
+    def create_dir(self) -> Self:
+        os.makedirs(self.excel_dir, exist_ok=True)
+        os.makedirs(self.json_dir, exist_ok=True)
+        return self
+
+    def normalize(self) -> None:
+        if len(self.files) > 0:
+            self.create_dir()
+            for file in self.files:
+                if self.verbose:
+                    print(f"Processing file: {file}")
+                sheets = worksheets(file)
+
+                sheet_name = None
+                if self.check_sequential_file:
+                    sheet_name = sequential_file(sheets)
+
+                    # Change to Sequential file sheet
+                    sheets = [sheet_name]
+                    if sheet_name is None:
+                        self.results.append(
+                            {
+                                "success": False,
+                                "message": f"Missing Sequential File sheet",
+                                "excel": file,
+                                "json": None,
+                                "sheet": None,
+                            }
+                        )
+                        continue
+
+                dfs = pd.read_excel(file, sheet_name=sheet_name)
+                for sheet in sheets:
+                    if self.verbose:
+                        print(f"|| Processing sheet: {sheet}", end="")
+                    df = dfs[sheet] if (sheet_name is None) else dfs
+                    columns = df.columns.tolist()
+                    column_is_oke, missing_columns = self.validate_column(
+                        columns
+                    )
+                    if column_is_oke:
+                        if self.verbose:
+                            print(" OK!")
+                        result = self.process_df(
+                            df,
+                            filename=file,
+                            sheet_name=sheet,
+                            as_json=True,
+                            overwrite=self.overwrite,
+                        )
+                        self.results.append(result)
+                    else:
+                        if self.verbose:
+                            print(" ‼️NOT OK!")
+                        self.results.append(
+                            {
+                                "success": False,
+                                "message": f"Sheet: {sheet}. Missing columns: {missing_columns}",
+                                "excel": file,
+                                "json": None,
+                                "sheet": sheet,
+                            }
+                        )
+
+        return None

corrosions-0.1.0/src/corrosions/const.py

@@ -0,0 +1,16 @@
+import os
+
+
+NORMALIZE_DIR = os.path.join(os.getcwd(), "normalize")
+
+CIPS_DIR = os.path.join(NORMALIZE_DIR, "cips")
+CIPS_EXCEL_DIR = os.path.join(CIPS_DIR, "excel")
+CIPS_JSON_DIR = os.path.join(CIPS_DIR, "json")
+
+PCM_DIR = os.path.join(NORMALIZE_DIR, "pcm")
+PCM_EXCEL_DIR = os.path.join(PCM_DIR, "excel")
+PCM_JSON_DIR = os.path.join(PCM_DIR, "json")
+
+ACVG_DCVG_DIR = os.path.join(NORMALIZE_DIR, "acvg_dcvg")
+ACVG_DCVG_EXCEL_DIR = os.path.join(ACVG_DCVG_DIR, "excel")
+ACVG_DCVG_JSON_DIR = os.path.join(ACVG_DCVG_DIR, "json")