steer-core 0.1.35__py3-none-any.whl → 0.1.37__py3-none-any.whl

steer_core/Constants/Units.py

@@ -19,6 +19,19 @@ mG_TO_G = 1e-3
 G_TO_mG = 1e3
 CM_TO_UM = 1e4
 UM_TO_CM = 1e-4
+KG_TO_T = 1e-3
+T_TO_KG = 1e3
+T_TO_MT = 1e-6
+MT_TO_T = 1e6
+LB_TO_KG = 0.453592
+KG_TO_LB = 1 / 0.453592
+T_TO_SHORT_TON = 1.10231
+SHORT_TON_TO_T = 1 / 1.10231
+LB_TO_SHORT_TON = 1 / 2000
+SHORT_TON_TO_LB = 2000
+LB_TO_T = 1 / 2000 * 1/1.10231
+
+
 
 # Current units
 A_TO_mA = 1e3
@@ -31,6 +44,9 @@ S_TO_MIN = 1 / 60
 MIN_TO_S = 60
 S_TO_Y = 1 / (3600 * 24 * 365)
 Y_TO_S = 3600 * 24 * 365
+H_TO_Y = 1 / 8760
+Y_TO_H = 8760
+
 
 # Energy units
 W_TO_KW = 1e-3
@@ -42,7 +58,14 @@ DEG_TO_RAD = 0.017453292519943295
 # Percentage units
 PERCENT_TO_FRACTION = 1e-2
 FRACTION_TO_PERCENT = 1e2
+FRACTION_TO_PPM = 1e6
+PPM_TO_FRACTION = 1e-6
 
 # Volume units
 L_TO_M3 = 1e-3
-M3_TO_L = 1e3
+M3_TO_L = 1e3
+GAL_TO_L = 3.78541
+L_TO_GAL = 1 / 3.78541
+MMGAL_TO_GAL = 1e-6
+GAL_TO_MMGAL = 1e6
+

steer_core/Constants/Universal.py

@@ -1,2 +1,7 @@
 ## Constants
 PI = 3.14159265358979323846
+
+# Molar Masses
+M_G_PER_MOL_NO2 = 46.0055
+M_G_PER_MOL_SO2 = 64.0638
+MW_G_PER_MOL_CO2 = 44.0095

steer_core/Mixins/Serializer.py

@@ -257,7 +257,7 @@ class SerializerMixin:
         ValueError
             If the object name is not found in any of the tables.
         """
-        from steer_core.Data.DataManager import DataManager
+        from steer_opencell_data.DataManager import DataManager
         
         database = DataManager()
         

steer_core/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.1.35"
+__version__ = "0.1.37"
 
 from .Mixins.Colors import ColorMixin
 from .Mixins.Coordinates import CoordinateMixin

{steer_core-0.1.35.dist-info → steer_core-0.1.37.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: steer-core
-Version: 0.1.35
+Version: 0.1.37
 Summary: Modelling energy storage from cell to site - STEER OpenCell Design
 Author-email: Nicholas Siemons <nsiemons@stanford.edu>
 Maintainer-email: Nicholas Siemons <nsiemons@stanford.edu>
@@ -21,14 +21,11 @@ Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Scientific/Engineering :: Physics
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
-Requires-Dist: pandas==2.1.4
-Requires-Dist: numpy==1.26.4
+Requires-Dist: pandas==2.3.3
+Requires-Dist: numpy==2.2.6
 Requires-Dist: datetime==5.5
 Requires-Dist: plotly==6.2.0
 Requires-Dist: scipy==1.15.3
-Requires-Dist: msgpack==1.1.2
-Requires-Dist: msgpack-numpy==0.4.8
-Requires-Dist: nbformat==5.10.4
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"

{steer_core-0.1.35.dist-info → steer_core-0.1.37.dist-info}/RECORD

@@ -1,11 +1,9 @@
-steer_core/__init__.py,sha256=IC03czBN7PlRAriVyRNwltNF1GKfFm4LVWJ43B1SCtA,321
-steer_core/Constants/Units.py,sha256=QIV_lDX7rANH-MKP90jOyiXbGueL15LILKMNr5dSWoI,714
-steer_core/Constants/Universal.py,sha256=5FWdrex5NiI2DResDmwO7GIvGN2B0DNtdlG1l-ysDh8,41
+steer_core/__init__.py,sha256=iv1Zv2edpDkh91ynlce2_TditJjHT03A-Lt6ECkaBIA,321
+steer_core/Constants/Units.py,sha256=wfbR52HHhFyeYBYyiJTTbFISuSQNzxnnfj-ifeDHDts,1114
+steer_core/Constants/Universal.py,sha256=_9FlNWGdGyjDx5zI8J-4M7B4_ThqXD4xauCNytv2KdY,135
 steer_core/Constants/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 steer_core/ContextManagers/ContextManagers.py,sha256=4rSeBdBi6xtKLMAbERklrYmZlbFr0zceAiwu-gjTR38,1869
 steer_core/ContextManagers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-steer_core/Data/DataManager.py,sha256=AUbuK1lmibTeY5oZ_RSmfof9FyFd9HQ5J2vMoLWsuAo,14707
-steer_core/Data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 steer_core/Decorators/Coordinates.py,sha256=MxUWXQNrR9Q0_p4gGAywS4qnPAztajJzSay1Cu6lCRQ,1441
 steer_core/Decorators/General.py,sha256=lc7YdvxU-JDo8b4kunVzSjxcB3_8C185458HrXQq-lk,970
 steer_core/Decorators/Objects.py,sha256=aYaRQBFgdSE0IB4QgBVfb6GhEPagoU6TRNrW_pOaqQI,506
@@ -15,10 +13,10 @@ steer_core/Mixins/Coordinates.py,sha256=DEPKvySoiDT8JhQSEQDiQgAxGjEJK7MezuZysSvf
 steer_core/Mixins/Data.py,sha256=c313F85muxlBHQ6yl6AKrifNyV2toHvVwEy35fNNUNE,4434
 steer_core/Mixins/Dunder.py,sha256=cIwh1VhcwzlwelUo2eM1KllVtxZddrkr6g0a5CkXea8,7146
 steer_core/Mixins/Plotter.py,sha256=wRRF0C5fz_6polCKKRVnZ07UFL4HBohZ5K2BSm_ULsg,13505
-steer_core/Mixins/Serializer.py,sha256=a3-J1ESM0UkO7b8Ctzjj605-p9bfzoFjJydM8k2grEQ,10458
+steer_core/Mixins/Serializer.py,sha256=1kqoY1U-SpGb-x3f46V4flhD6-PE19RjgLft2uJG19A,10462
 steer_core/Mixins/TypeChecker.py,sha256=eXgu1G4d2_btNg5AJ3UkTXpoFJ79bc6tSasInCnXqc0,10539
 steer_core/Mixins/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-steer_core-0.1.35.dist-info/METADATA,sha256=4LOmW1xfFIctfghEvREPZzvUZyvhbUWXg219_dctDic,1699
-steer_core-0.1.35.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-steer_core-0.1.35.dist-info/top_level.txt,sha256=6LFpGCSDE_SqRoT7raeM3Ax7KTBKQnyXLXxM9kXtw5M,11
-steer_core-0.1.35.dist-info/RECORD,,
+steer_core-0.1.37.dist-info/METADATA,sha256=OgqOn6S5ae7gjAJMbb9iqkqLj72lWd8hPX8LsJFs-cI,1600
+steer_core-0.1.37.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+steer_core-0.1.37.dist-info/top_level.txt,sha256=6LFpGCSDE_SqRoT7raeM3Ax7KTBKQnyXLXxM9kXtw5M,11
+steer_core-0.1.37.dist-info/RECORD,,

{steer_core-0.1.35.dist-info → steer_core-0.1.37.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

steer_core/Data/DataManager.py

@@ -1,432 +0,0 @@
-import sqlite3 as sql
-from pathlib import Path
-from typing import TypeVar
-import pandas as pd
-import importlib.resources
-
-from steer_core.Constants.Units import *
-from steer_core.Mixins.Serializer import SerializerMixin
-
-
-T = TypeVar('T', bound='SerializerMixin')
-
-
-class DataManager:
-    
-    def __init__(self):
-        with importlib.resources.path("steer_opencell_data", "database.db") as db_path:
-            self._db_path = db_path
-            self._connection = sql.connect(self._db_path)
-            self._cursor = self._connection.cursor()
-
-    def create_table(self, table_name: str, columns: dict):
-        """
-        Function to create a table in the database.
-
-        :param table_name: Name of the table.
-        :param columns: Dictionary of columns and their types.
-        """
-        columns_str = ", ".join([f"{k} {v}" for k, v in columns.items()])
-        self._cursor.execute(f"CREATE TABLE IF NOT EXISTS {table_name} ({columns_str})")
-        self._connection.commit()
-
-    def drop_table(self, table_name: str):
-        """
-        Function to drop a table from the database.
-
-        :param table_name: Name of the table.
-        """
-        self._cursor.execute(f"DROP TABLE IF EXISTS {table_name}")
-        self._connection.commit()
-
-    def get_table_names(self):
-        """
-        Function to get the names of all tables in the database.
-
-        :return: List of table names.
-        """
-        self._cursor.execute("SELECT name FROM sqlite_master WHERE type='table';")
-        return [row[0] for row in self._cursor.fetchall()]
-
-    def insert_data(self, table_name: str, data: pd.DataFrame):
-        """
-        Inserts data into the database only if it doesn’t already exist.
-
-        :param table_name: Name of the table.
-        :param data: DataFrame containing the data to insert.
-        """
-        for _, row in data.iterrows():
-            conditions = " AND ".join([f"{col} = ?" for col in data.columns])
-            check_query = f"SELECT COUNT(*) FROM {table_name} WHERE {conditions}"
-
-            self._cursor.execute(check_query, tuple(row))
-            if self._cursor.fetchone()[0] == 0:  # If the row does not exist, insert it
-                insert_query = f"INSERT INTO {table_name} ({', '.join(data.columns)}) VALUES ({', '.join(['?'] * len(row))})"
-                self._cursor.execute(insert_query, tuple(row))
-
-        self._connection.commit()
-
-    def get_data(
-        self,
-        table_name: str,
-        columns: list = None,
-        condition: str | list[str] = None,
-        latest_column: str = None,
-    ):
-        """
-        Retrieve data from the database.
-
-        :param table_name: Name of the table.
-        :param columns: List of columns to retrieve. If None, retrieves all columns.
-        :param condition: Optional condition (single string or list of conditions).
-        :param latest_column: Column name to find the most recent row.
-        """
-        # If columns is not provided, get all columns from the table
-        if columns is None:
-            self._cursor.execute(f"PRAGMA table_info({table_name})")
-            columns_info = self._cursor.fetchall()
-            columns = [col[1] for col in columns_info]  # Extract column names
-            if not columns:
-                raise ValueError(
-                    f"Table '{table_name}' does not exist or has no columns."
-                )
-
-        columns_str = ", ".join(columns)
-        query = f"SELECT {columns_str} FROM {table_name}"
-
-        # Add condition if specified
-        if condition:
-            if isinstance(condition, list):
-                condition_str = " AND ".join(condition)
-            else:
-                condition_str = condition
-            query += f" WHERE {condition_str}"
-
-        # If latest_column is provided, get the most recent entry
-        if latest_column:
-            query += f" ORDER BY {latest_column} DESC LIMIT 1"
-
-        # Execute and return the result
-        self._cursor.execute(query)
-        data = self._cursor.fetchall()
-
-        return pd.DataFrame(data, columns=columns)
-
-    def get_unique_values(self, table_name: str, column_name: str):
-        """
-        Retrieves all unique values from a specified column.
-
-        :param table_name: The name of the table.
-        :param column_name: The column to retrieve unique values from.
-        :return: A list of unique values.
-        """
-        query = f"SELECT DISTINCT {column_name} FROM {table_name}"
-        self._cursor.execute(query)
-        return [row[0] for row in self._cursor.fetchall()]
-
-    def get_current_collector_materials(self, most_recent: bool = True) -> pd.DataFrame:
-        """
-        Retrieves current collector materials from the database.
-
-        :param most_recent: If True, returns only the most recent entry.
-        :return: DataFrame with current collector materials.
-        """
-        data = (
-            self.get_data(table_name="current_collector_materials")
-            .groupby("name", group_keys=False)
-            .apply(
-                lambda x: x.sort_values("date", ascending=False).head(1)
-                if most_recent
-                else x
-            )
-            .reset_index(drop=True)
-        )
-
-        return data
-
-    def get_insulation_materials(self, most_recent: bool = True) -> pd.DataFrame:
-        """
-        Retrieves insulation materials from the database.
-
-        :param most_recent: If True, returns only the most recent entry.
-        :return: DataFrame with insulation materials.
-        """
-        data = (
-            self.get_data(table_name="insulation_materials")
-            .groupby("name", group_keys=False)
-            .apply(
-                lambda x: x.sort_values("date", ascending=False).head(1)
-                if most_recent
-                else x
-            )
-            .reset_index(drop=True)
-        )
-
-        return data
-
-    def get_cathode_materials(self, most_recent: bool = True) -> pd.DataFrame:
-        """
-        Retrieves cathode materials from the database.
-
-        :param most_recent: If True, returns only the most recent entry.
-        :return: DataFrame with cathode materials.
-        """
-        data = (
-            self.get_data(table_name="cathode_materials")
-            .groupby("name", group_keys=False)
-            .apply(
-                lambda x: x.sort_values("date", ascending=False).head(1)
-                if most_recent
-                else x
-            )
-            .reset_index(drop=True)
-        )
-
-        return data
-
-    def get_anode_materials(self, most_recent: bool = True) -> pd.DataFrame:
-        """
-        Retrieves anode materials from the database.
-
-        :param most_recent: If True, returns only the most recent entry.
-        :return: DataFrame with anode materials.
-        """
-        data = (
-            self.get_data(table_name="anode_materials")
-            .groupby("name", group_keys=False)
-            .apply(
-                lambda x: x.sort_values("date", ascending=False).head(1)
-                if most_recent
-                else x
-            )
-            .reset_index(drop=True)
-        )
-
-        return data
-
-    def get_binder_materials(self, most_recent: bool = True) -> pd.DataFrame:
-        """
-        Retrieves binder materials from the database.
-
-        :param most_recent: If True, returns only the most recent entry.
-        :return: DataFrame with binder materials.
-        """
-        data = (
-            self.get_data(table_name="binder_materials")
-            .groupby("name", group_keys=False)
-            .apply(
-                lambda x: x.sort_values("date", ascending=False).head(1)
-                if most_recent
-                else x
-            )
-            .reset_index(drop=True)
-        )
-
-        return data
-
-    def get_conductive_additive_materials(
-        self, most_recent: bool = True
-    ) -> pd.DataFrame:
-        """
-        Retrieves conductive additives from the database.
-
-        :param most_recent: If True, returns only the most recent entry.
-        :return: DataFrame with conductive additives.
-        """
-        data = (
-            self.get_data(table_name="conductive_additive_materials")
-            .groupby("name", group_keys=False)
-            .apply(
-                lambda x: x.sort_values("date", ascending=False).head(1)
-                if most_recent
-                else x
-            )
-            .reset_index(drop=True)
-        )
-
-        return data
-
-    def get_separator_materials(self, most_recent: bool = True) -> pd.DataFrame:
-        """
-        Retrieves separator materials from the database.
-
-        :param most_recent: If True, returns only the most recent entry.
-        :return: DataFrame with separator materials.
-        """
-        data = (
-            self.get_data(table_name="separator_materials")
-            .groupby("name", group_keys=False)
-            .apply(
-                lambda x: x.sort_values("date", ascending=False).head(1)
-                if most_recent
-                else x
-            )
-            .reset_index(drop=True)
-        )
-
-        return data
-    
-    def get_tape_materials(self, most_recent: bool = True) -> pd.DataFrame:
-        """
-        Retrieves tape materials from the database.
-
-        :param most_recent: If True, returns only the most recent entry.
-        :return: DataFrame with tape materials.
-        """
-        data = (
-            self.get_data(table_name="tape_materials")
-            .groupby("name", group_keys=False)
-            .apply(
-                lambda x: x.sort_values("date", ascending=False).head(1)
-                if most_recent
-                else x
-            )
-            .reset_index(drop=True)
-        )
-
-        return data
-
-    def get_prismatic_container_materials(self, most_recent: bool = True) -> pd.DataFrame:
-        """
-        Retrieves prismatic container materials from the database.
-
-        :param most_recent: If True, returns only the most recent entry.
-        :return: DataFrame with prismatic container materials.
-        """
-        data = (
-            self.get_data(table_name="prismatic_container_materials")
-            .groupby("name", group_keys=False)
-            .apply(
-                lambda x: x.sort_values("date", ascending=False).head(1)
-                if most_recent
-                else x
-            )
-            .reset_index(drop=True)
-        )
-
-        return data
-
-    @staticmethod
-    def read_half_cell_curve(half_cell_path) -> pd.DataFrame:
-        """
-        Function to read in a half cell curve for this active material
-
-        :param half_cell_path: Path to the half cell data file.
-        :return: DataFrame with the specific capacity and voltage.
-        """
-        try:
-            data = pd.read_csv(half_cell_path)
-        except:
-            raise FileNotFoundError(f"Could not find the file at {half_cell_path}")
-
-        if "Specific Capacity (mAh/g)" not in data.columns:
-            raise ValueError(
-                "The file must have a column named 'Specific Capacity (mAh/g)'"
-            )
-
-        if "Voltage (V)" not in data.columns:
-            raise ValueError("The file must have a column named 'Voltage (V)'")
-
-        if "Step_ID" not in data.columns:
-            raise ValueError("The file must have a column named 'Step_ID'")
-
-        data = (
-            data.rename(
-                columns={
-                    "Specific Capacity (mAh/g)": "specific_capacity",
-                    "Voltage (V)": "voltage",
-                    "Step_ID": "step_id",
-                }
-            )
-            .assign(
-                specific_capacity=lambda x: x["specific_capacity"]
-                * (H_TO_S * mA_TO_A / G_TO_KG)
-            )
-            .filter(["specific_capacity", "voltage", "step_id"])
-            .groupby(["specific_capacity", "step_id"], group_keys=False)["voltage"]
-            .max()
-            .reset_index()
-            .sort_values(["step_id", "specific_capacity"])
-        )
-
-        return data
-
-    def remove_data(self, table_name: str, condition: str):
-        """
-        Function to remove data from the database.
-
-        :param table_name: Name of the table.
-        :param condition: Condition to remove rows.
-        """
-        self._cursor.execute(f"DELETE FROM {table_name} WHERE {condition}")
-        self._connection.commit()
-
-    @classmethod
-    def from_database(cls: type[T], name: str, table_name: str = None) -> T:
-        """
-        Pull object from the database by name.
-        
-        Subclasses must define a '_table_name' class variable (str or list of str)
-        unless table_name is explicitly provided.
-
-        Parameters
-        ----------
-        name : str
-            Name of the object to retrieve.
-        table_name : str, optional
-            Specific table to search. If provided, '_table_name' is not required.
-            If None, uses class's _table_name.
-
-        Returns
-        -------
-        T
-            Instance of the class.
-            
-        Raises
-        ------
-        NotImplementedError
-            If the subclass doesn't define '_table_name' and table_name is not provided.
-        ValueError
-            If the object name is not found in any of the tables.
-        """
-        database = cls()
-        
-        # Get list of tables to search
-        if table_name:
-            tables_to_search = [table_name]
-        else:
-            # Only check for _table_name if table_name wasn't provided
-            if not hasattr(cls, '_table_name'):
-                raise NotImplementedError(
-                    f"{cls.__name__} must define a '_table_name' class variable "
-                    "or provide 'table_name' argument"
-                )
-            
-            if isinstance(cls._table_name, (list, tuple)):
-                tables_to_search = cls._table_name
-            else:
-                tables_to_search = [cls._table_name]
-        
-        # Try each table until found
-        for table in tables_to_search:
-            available_materials = database.get_unique_values(table, "name")
-            
-            if name in available_materials:
-                data = database.get_data(table, condition=f"name = '{name}'")
-                serialized_bytes = data["object"].iloc[0]
-                return cls.deserialize(serialized_bytes)
-        
-        # Not found in any table
-        all_available = []
-        for table in tables_to_search:
-            all_available.extend(database.get_unique_values(table, "name"))
-        
-        raise ValueError(
-            f"'{name}' not found in tables {tables_to_search}. "
-            f"Available: {all_available}"
-        )
-        
-    def __del__(self):
-        self._connection.close()
-
-