processpi 0.0.0__tar.gz → 0.1.2.10__tar.gz

processpi-0.1.2.10/PKG-INFO

@@ -0,0 +1,225 @@
+Metadata-Version: 2.4
+Name: processpi
+Version: 0.1.2.10
+Summary: Python toolkit for chemical engineering simulations, equipment design, and unit conversions
+Home-page: https://github.com/varma666/ProcessPi
+Author: Raviteja Varma Nadimpalli
+Author-email: Raviteja Varma Nadimpalli <processpi.dev@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2025 Raviteja Varma Nadimpalli
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/varma666/ProcessPi
+Project-URL: BugTracker, https://github.com/varma666/ProcessPi/issues
+Project-URL: SourceCode, https://github.com/varma666/ProcessPi
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: tabulate>=0.9.0
+Requires-Dist: matplotlib>=3.7.0
+Requires-Dist: networkx>=3.1
+Requires-Dist: CoolProp>=6.5.0
+Requires-Dist: tqdm>=4.65.0
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+<p align="center">
+  <img src="https://img.shields.io/badge/Process_PI-🧪-blue?style=for-the-badge&logo=python" alt="Process PI Logo" height="40"/>
+</p>
+
+<h1 align="center">Process PI</h1>
+
+<p align="center">
+  <strong>Python toolkit for chemical engineering simulations, equipment design, and unit conversions</strong>
+</p>
+
+<p align="center">
+  <img src="https://img.shields.io/badge/🛠_Unit_Conversions-blue?style=for-the-badge" alt="Unit Conversions"/>
+  <img src="https://img.shields.io/badge/💧_Components-blue?style=for-the-badge" alt="Components"/>
+  <img src="https://img.shields.io/badge/🏭_Pipelines_&_Network_Engine-blue?style=for-the-badge" alt="Pipelines & Network Engine"/>
+  <img src="https://img.shields.io/badge/♨️_Heat_Transfer_(WIP)-blue?style=for-the-badge" alt="Heat Transfer"/>
+  <img src="https://img.shields.io/badge/⚗️_Reaction_&_Mass_Transfer_(WIP)-blue?style=for-the-badge" alt="Reaction & Mass Transfer"/>
+</p>
+
+<p align="center">
+  <a href="https://pypi.org/project/processpi/">
+    <img src="https://img.shields.io/pypi/v/processpi?style=for-the-badge&logo=pypi" alt="PyPI Version"/>
+  </a>
+  <a href="https://github.com/varma666/ProcessPi/stargazers">
+    <img src="https://img.shields.io/github/stars/varma666/ProcessPi?style=for-the-badge&logo=github" alt="GitHub Stars"/>
+  </a>
+  <a href="https://github.com/varma666/ProcessPi/network/members">
+    <img src="https://img.shields.io/github/forks/varma666/ProcessPi?style=for-the-badge&logo=github" alt="GitHub Forks"/>
+  </a>
+  <a href="https://github.com/varma666/ProcessPi/actions">
+    <img src="https://img.shields.io/github/actions/workflow/status/varma666/ProcessPi/python-package.yml?branch=main&style=for-the-badge" alt="Build Status"/>
+  </a>
+</p>
+
+<p align="center">
+  <em>Built with ❤️ for chemical engineers.</em>
+</p>
+
+---
+
+## 📖 Overview
+
+**Process PI** is a modular **Python toolkit** for chemical engineering that enables:
+
+- **Pipeline network simulations**
+- **Unit conversions across SI, CGS, and Imperial systems**
+- **Component-based property calculations**
+- And more, with advanced features under active development.
+
+---
+
+## 📑 Table of Contents
+
+- [Features](#-features)
+- [Installation](#-installation)
+- [Getting Started](#-getting-started)
+  - [Unit Conversions](#1-unit-conversions)
+  - [Components](#2-components)
+  - [Pipeline Network Engine](#3-pipeline-network-engine)
+- [Roadmap](#-roadmap)
+- [License](#-license)
+
+---
+
+## ⚡ Features
+
+- ⚙️ **Unit Conversion System** – Instant conversions between engineering unit systems.  
+- 🧪 **Components Library** – Access educational thermodynamic properties for 25+ fluids and growing.  
+- 🌐 **Pipeline Network Engine** – Build and simulate simple pipelines or complex interconnected networks, analyzing:
+  - Pressure drops
+  - Flow rates
+  - Reynolds number
+  - Pump requirements  
+- 🧮 **Calculation Modules (WIP)** – Heat transfer, mass transfer, and reaction engineering models in progress.  
+- 📊 **Simulation Tools (Planned)** – Transient dynamics, optimization, and interactive visualizations.  
+
+---
+
+## 📦 Installation
+
+Install from **PyPI**:
+
+```bash
+pip install processpi
+```
+
+For development:
+
+```bash
+git clone https://github.com/varma666/ProcessPi.git
+cd ProcessPi
+pip install -e .
+```
+
+---
+
+## 🚀 Getting Started
+
+### 1. Unit Conversions
+
+```python
+from processpi.units import Length, Pressure, Temperature
+
+# Length conversion
+length = Length(1.5, "m")
+print(length.to("ft"))  # Feet output
+
+# Pressure conversion
+p = Pressure(2, "bar")
+print(p.to("psi"))      # PSI output
+
+# Temperature conversion
+t = Temperature(100, "C")
+print(t.to("K"))        # Kelvin output
+```
+
+### 2. Components
+
+```python
+from processpi.components import Water, Ethanol
+
+water = Water()
+ethanol = Ethanol()
+
+print(f"Water density: {water.density()} kg/m3")
+print(f"Ethanol viscosity: {ethanol.viscosity()} Pa·s")
+```
+
+⚠ **Note**: Component data is for educational/demo purposes only. Extended property support is in progress.
+
+### 3. Pipeline Network Engine
+
+Perform single-pipe or multi-pipe network simulations.
+
+```python
+from processpi.pipelines.engine import PipelineEngine
+from processpi.pipelines.pipes import Pipe
+from processpi.components import Water
+from processpi.units import VolumetricFlowRate, Diameter, Length
+
+# Define pipe and fluid
+pipe = Pipe(
+    internal_diameter=Diameter(50, "mm"),
+    length=Length(10, "m")
+)
+water = Water()
+
+# Set up engine
+engine = PipelineEngine()
+engine.fit(
+    flowrate=VolumetricFlowRate(0.001, "m3/s"),
+    pipe=pipe,
+    fluid=water
+)
+
+# Run calculations
+results = engine.run()
+engine.summary()
+```
+
+Planned upgrades:
+- Dynamic simulations  
+- Branching/parallel pipeline analysis  
+- Integrated cost and energy optimization  
+
+---
+
+## 🛣 Roadmap
+
+- ✅ Pipeline Network Engine – Functional for single and multi-segment networks  
+- 🚧 Heat Transfer Modules – In progress for exchangers, conduction, and convection models  
+- 🚧 Mass Transfer & Reaction Modules – Basic structure in place, calculations coming soon  
+- 🔮 Advanced Features – Transient analysis, energy optimization, and GUI/web interfaces  
+
+---
+
+## 📜 License
+
+This project is licensed under the **MIT License** – see the LICENSE file for details.
+
+<p align="center"> <em>ProcessPI – Built with ❤️ for chemical engineers.</em> </p>

{processpi-0.0.0 → processpi-0.1.2.10}/README.md

@@ -1,4 +1,3 @@
-
 <p align="center">
   <img src="https://img.shields.io/badge/Process_PI-🧪-blue?style=for-the-badge&logo=python" alt="Process PI Logo" height="40"/>
 </p>
@@ -12,9 +11,9 @@
 <p align="center">
   <img src="https://img.shields.io/badge/🛠_Unit_Conversions-blue?style=for-the-badge" alt="Unit Conversions"/>
   <img src="https://img.shields.io/badge/💧_Components-blue?style=for-the-badge" alt="Components"/>
-  <img src="https://img.shields.io/badge/🏭_Pumps-Pipelines-blue?style=for-the-badge" alt="Pumps & Pipelines"/>
-  <img src="https://img.shields.io/badge/♨️_Heat_Exchangers-blue?style=for-the-badge" alt="Heat Exchangers"/>
-  <img src="https://img.shields.io/badge/⚗️_Chemical_Flasks-blue?style=for-the-badge" alt="Chemical Flasks"/>
+  <img src="https://img.shields.io/badge/🏭_Pipelines_&_Network_Engine-blue?style=for-the-badge" alt="Pipelines & Network Engine"/>
+  <img src="https://img.shields.io/badge/♨️_Heat_Transfer_(WIP)-blue?style=for-the-badge" alt="Heat Transfer"/>
+  <img src="https://img.shields.io/badge/⚗️_Reaction_&_Mass_Transfer_(WIP)-blue?style=for-the-badge" alt="Reaction & Mass Transfer"/>
 </p>
 
 <p align="center">
@@ -40,18 +39,23 @@
 
 ## 📖 Overview
 
-**Process PI** is a cross-platform **Python toolkit** for chemical engineering equipment design, simulations, and unit conversions.  
-It provides a **modular framework** for learning, experimenting, and simulating process systems.
+**Process PI** is a modular **Python toolkit** for chemical engineering that enables:
+
+- **Pipeline network simulations**
+- **Unit conversions across SI, CGS, and Imperial systems**
+- **Component-based property calculations**
+- And more, with advanced features under active development.
 
 ---
 
 ## 📑 Table of Contents
+
 - [Features](#-features)
 - [Installation](#-installation)
 - [Getting Started](#-getting-started)
   - [Unit Conversions](#1-unit-conversions)
   - [Components](#2-components)
-  - [Pipeline Network Analysis](#3-pipeline-network-analysis)
+  - [Pipeline Network Engine](#3-pipeline-network-engine)
 - [Roadmap](#-roadmap)
 - [License](#-license)
 
@@ -59,69 +63,73 @@ It provides a **modular framework** for learning, experimenting, and simulating
 
 ## ⚡ Features
 
-- ⚙️ **Unit Conversion System** – Seamless conversion across SI, CGS, and Imperial units.  
-- 🧪 **Components Database (Work in Progress)** – Educational thermodynamic properties of 25+ components (Water, Ethanol, CO₂, etc.), expanding regularly.  
-- 🏭 **Equipment Design Modules (WIP)** – Pumps, pipelines, heat exchangers, reactors, and more.  
-- 🌐 **Pipeline Networks** – Analyze single pipes and complex networked systems, calculate flow, pressure drops, velocity, and Reynolds numbers.  
-- 📊 **Simulation Tools (Upcoming)** – Steady-state/dynamic process analysis, flow optimization, and energy management.
+- ⚙️ **Unit Conversion System** – Instant conversions between engineering unit systems.  
+- 🧪 **Components Library** – Access educational thermodynamic properties for 25+ fluids and growing.  
+- 🌐 **Pipeline Network Engine** – Build and simulate simple pipelines or complex interconnected networks, analyzing:
+  - Pressure drops
+  - Flow rates
+  - Reynolds number
+  - Pump requirements  
+- 🧮 **Calculation Modules (WIP)** – Heat transfer, mass transfer, and reaction engineering models in progress.  
+- 📊 **Simulation Tools (Planned)** – Transient dynamics, optimization, and interactive visualizations.  
 
 ---
 
 ## 📦 Installation
 
-Install via **PyPI**:
+Install from **PyPI**:
 
 ```bash
 pip install processpi
 ```
 
+For development:
+
+```bash
+git clone https://github.com/varma666/ProcessPi.git
+cd ProcessPi
+pip install -e .
+```
+
 ---
 
 ## 🚀 Getting Started
 
 ### 1. Unit Conversions
 
-Easily convert between SI, CGS, and Imperial units.
-
 ```python
 from processpi.units import Length, Pressure, Temperature
 
-# Length
-l1 = Length(1.5, "m")
-print(l1.to("ft"))   # Output in feet
+# Length conversion
+length = Length(1.5, "m")
+print(length.to("ft"))  # Feet output
 
-# Pressure
+# Pressure conversion
 p = Pressure(2, "bar")
-print(p.to("Pa"))    # Output in Pascals
+print(p.to("psi"))      # PSI output
 
-# Temperature
+# Temperature conversion
 t = Temperature(100, "C")
-print(t.to("K"))     # Output in Kelvin
+print(t.to("K"))        # Kelvin output
 ```
 
----
-
 ### 2. Components
 
-Access educational thermodynamic properties of chemical components.
-
 ```python
 from processpi.components import Water, Ethanol
 
 water = Water()
 ethanol = Ethanol()
 
-print(f"Water density: {water.density()} kg/m³")
+print(f"Water density: {water.density()} kg/m3")
 print(f"Ethanol viscosity: {ethanol.viscosity()} Pa·s")
 ```
 
-⚠️ **Note**: Component data is provided for **educational and demonstration purposes**. The database is continuously expanding.
-
----
+⚠ **Note**: Component data is for educational/demo purposes only. Extended property support is in progress.
 
-### 3. Pipeline Network Analysis
+### 3. Pipeline Network Engine
 
-Perform hydraulic calculations for pipelines and network systems.
+Perform single-pipe or multi-pipe network simulations.
 
 ```python
 from processpi.pipelines.engine import PipelineEngine
@@ -129,37 +137,39 @@ from processpi.pipelines.pipes import Pipe
 from processpi.components import Water
 from processpi.units import VolumetricFlowRate, Diameter, Length
 
+# Define pipe and fluid
 pipe = Pipe(
     internal_diameter=Diameter(50, "mm"),
     length=Length(10, "m")
 )
+water = Water()
 
+# Set up engine
 engine = PipelineEngine()
 engine.fit(
-    flowrate=VolumetricFlowRate(0.001, "m^3/s"),
+    flowrate=VolumetricFlowRate(0.001, "m3/s"),
     pipe=pipe,
-    fluid=Water()
+    fluid=water
 )
 
+# Run calculations
 results = engine.run()
 engine.summary()
 ```
 
-#### Planned Enhancements
-
-- Support for branching and parallel pipeline networks  
-- Dynamic flow simulations and transient analysis  
-- Cost and energy optimization tools for network layouts  
+Planned upgrades:
+- Dynamic simulations  
+- Branching/parallel pipeline analysis  
+- Integrated cost and energy optimization  
 
 ---
 
 ## 🛣 Roadmap
 
-- Expand the Components Database to 50+ chemicals and fluids  
-- Add steady-state and dynamic simulation modules  
-- Implement energy optimization and cost analysis tools  
-- Build a GUI/web interface for interactive simulations  
-- Enable integration with real process data and sensor-driven workflows  
+- ✅ Pipeline Network Engine – Functional for single and multi-segment networks  
+- 🚧 Heat Transfer Modules – In progress for exchangers, conduction, and convection models  
+- 🚧 Mass Transfer & Reaction Modules – Basic structure in place, calculations coming soon  
+- 🔮 Advanced Features – Transient analysis, energy optimization, and GUI/web interfaces  
 
 ---
 
@@ -167,8 +177,4 @@ engine.summary()
 
 This project is licensed under the **MIT License** – see the LICENSE file for details.
 
----
-
-<p align="center">
-  <em>Process PI – Built with ❤️ for chemical engineers.</em>
-</p>
+<p align="center"> <em>ProcessPI – Built with ❤️ for chemical engineers.</em> </p>

processpi-0.1.2.10/processpi/__init__.py

@@ -0,0 +1,80 @@
+"""
+ProcessPI: Chemical & Process Engineering Tools
+==============================================
+
+ProcessPI is a Python library for process engineers to perform calculations,
+simulate fluid systems, and design equipment.
+
+Features:
+---------
+- Fluid mechanics and hydraulic calculations
+- Pipeline network simulation and visualization
+- Chemical and physical properties management
+- Unit handling and conversions
+"""
+
+import os
+import sys
+import time
+import importlib
+import pkgutil
+from pathlib import Path
+
+# -------------------------------------------------------------------
+# Dynamic Version Handling
+# -------------------------------------------------------------------
+try:
+    from importlib.metadata import version, PackageNotFoundError
+    __version__ = version("processpi")
+except PackageNotFoundError:
+    __version__ = "0.1.0"  # fallback version for dev environments
+
+__all__ = []
+
+# -------------------------------------------------------------------
+# Sleek Loading Animation
+# -------------------------------------------------------------------
+def _loading_animation(text="Initializing ProcessPI"):
+    frames = ["⠋","⠙","⠹","⠸","⠼","⠴","⠦","⠧","⠇","⠏"]
+    for i in range(20):
+        sys.stdout.write(f"\r{text} {frames[i % len(frames)]}")
+        sys.stdout.flush()
+        time.sleep(0.05)
+    sys.stdout.write("\r✅ ProcessPI Ready!             \n")
+
+# Only show animation in interactive sessions (terminal/Colab)
+if sys.stdout.isatty() or "COLAB_GPU" in os.environ:
+    _loading_animation()
+
+# -------------------------------------------------------------------
+# Import Core Submodules
+# -------------------------------------------------------------------
+from . import calculations, pipelines, units, components
+
+__all__.extend(["calculations", "pipelines", "units", "components"])
+
+# -------------------------------------------------------------------
+# Dynamic Discovery & Import of Component Classes
+# -------------------------------------------------------------------
+_components_dir = Path(__file__).parent / "components"
+
+for _, module_name, is_pkg in pkgutil.iter_modules([str(_components_dir)]):
+    if not is_pkg:  # Import each component module dynamically
+        module = importlib.import_module(f"{__name__}.components.{module_name}")
+        globals()[module_name] = module
+        __all__.append(module_name)
+
+# Automatically collect all classes from components
+for mod in list(__all__):
+    module_obj = globals().get(mod)
+    if module_obj and hasattr(module_obj, "__dict__"):
+        for name, obj in module_obj.__dict__.items():
+            if isinstance(obj, type):  # only classes
+                globals()[name] = obj
+                __all__.append(name)
+
+# -------------------------------------------------------------------
+# Friendly Banner for Interactive Users
+# -------------------------------------------------------------------
+if sys.stdout.isatty() or "COLAB_GPU" in os.environ:
+    print(f"📦 ProcessPI v{__version__} | Chemical & Process Engineering Tools Loaded!\n")

processpi-0.1.2.10/processpi/calculations/__init__.py

@@ -0,0 +1,65 @@
+"""
+Initializes the main calculations module of ProcessPI.
+
+This module dynamically discovers and loads all calculation submodules and
+makes their classes accessible under the processpi.calculations namespace.
+
+Example usage:
+
+    import processpi.calculations as calc
+    engine = calc.CalculationEngine()
+    water_calc = calc.fluids.PressureDropDarcy(...)
+"""
+
+import importlib
+import pkgutil
+import inspect
+from pathlib import Path
+import sys
+import time
+
+# ------------------------
+# Loading animation
+# ------------------------
+def _show_loading_animation():
+    frames = ["⠁","⠂","⠄","⠂"]
+    sys.stdout.write(f"⏳ Loading ProcessPI Calculations... ")
+    sys.stdout.flush()
+    for frame in frames * 2:
+        sys.stdout.write(f"\r⏳ Loading ProcessPI Calculations... {frame}")
+        sys.stdout.flush()
+        time.sleep(0.1)
+    sys.stdout.write("\r✅ Calculations module ready!          \n")
+    sys.stdout.flush()
+
+_show_loading_animation()
+
+# ------------------------
+# Import core classes if any
+# ------------------------
+from .engine import CalculationEngine  # optional; adjust as needed
+from .base import CalculationBase
+
+__all__ = ["CalculationEngine", "CalculationBase"]
+
+# ------------------------
+# Dynamically import submodules (e.g., fluids, heat_transfer, etc.)
+# ------------------------
+package_dir = Path(__file__).parent
+package_name = __name__
+
+for finder, name, ispkg in pkgutil.iter_modules([str(package_dir)]):
+    # skip private or undesired modules if any
+    if name.startswith("_"):
+        continue
+
+    full_mod = f"{package_name}.{name}"
+    module = importlib.import_module(full_mod)
+    globals()[name] = module
+    __all__.append(name)
+
+    # Optionally, auto-import module-level classes
+    for cls_name, cls_obj in inspect.getmembers(module, inspect.isclass):
+        if cls_obj.__module__ == module.__name__:
+            globals()[cls_name] = cls_obj
+            __all__.append(cls_name)

processpi-0.1.2.10/processpi/calculations/base.py

@@ -0,0 +1,101 @@
+from abc import ABC, abstractmethod
+
+class CalculationBase(ABC):
+    """
+    Abstract base class for all calculation modules in the processpi library.
+
+    This class defines a standard interface and common utility methods for all
+    calculation classes, ensuring they have a consistent structure for input
+    validation, calculation execution, and result handling. All specific
+    calculation classes (e.g., `PressureDropDarcy`, `ReynoldsNumber`) must
+    inherit from this class.
+    """
+
+    def __init__(self, **kwargs):
+        """
+        Initializes the calculation object and stores all input parameters.
+
+        The method automatically calls `validate_inputs()` to ensure that the
+        provided arguments are valid before the object is fully constructed.
+
+        Args:
+            **kwargs: Arbitrary keyword arguments representing the inputs for the
+                      specific calculation.
+        """
+        self.inputs = kwargs
+        self.validate_inputs()
+
+    @abstractmethod
+    def validate_inputs(self):
+        """
+        Abstract method to validate the inputs.
+
+        Subclasses must implement this method to check for the presence and
+        validity of required inputs. It should raise a `ValueError` if any
+        input is missing or invalid.
+        """
+        pass
+
+    @abstractmethod
+    def calculate(self):
+        """
+        Abstract method to perform the calculation.
+
+        Subclasses must implement this method to execute the core calculation
+        logic. The method should return the results, typically as a dictionary
+        or a specific unit object.
+        """
+        pass
+
+    def get_inputs(self):
+        """
+        Returns the original inputs provided during initialization.
+
+        Returns:
+            dict: A dictionary of the input parameters.
+        """
+        return self.inputs
+
+    def to_dict(self):
+        """
+        Performs the calculation and returns a dictionary with both inputs and results.
+
+        This method combines the inputs and the output of the `calculate()` method
+        into a single, comprehensive dictionary.
+
+        Returns:
+            dict: A dictionary containing two keys: "inputs" and "results".
+        """
+        result = self.calculate()
+        return {
+            "inputs": self.inputs,
+            "results": result
+        }
+
+    @staticmethod
+    def _get_value(x, name):
+        """
+        A static utility method to extract the numeric value from an input.
+
+        This method handles both simple numeric types (like `int`, `float`)
+        and custom objects that have a `.value` attribute, such as unit objects.
+        It raises a `TypeError` if the value cannot be interpreted as a number.
+
+        Args:
+            x: The input value, which can be a number or a unit object.
+            name (str): The name of the input, used for a more informative
+                        error message.
+
+        Returns:
+            float: The numeric value of the input.
+
+        Raises:
+            TypeError: If the input value cannot be converted to a float.
+        """
+        if hasattr(x, "value"):
+            return x.value
+        try:
+            # Accept numpy/scalar numbers.
+            return float(x)
+        except (TypeError, ValueError):
+            raise TypeError(f"Could not interpret {name} value: {x!r}")