digifact 0.1.0__tar.gz

digifact-0.1.0/LICENSE

@@ -0,0 +1,11 @@
+MIT License
+
+Copyright (c) 2026 Prathamesh Shinde
+
+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...
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND...

digifact-0.1.0/PKG-INFO

@@ -0,0 +1,29 @@
+Metadata-Version: 2.4
+Name: digifact
+Version: 0.1.0
+Summary: Digifact - Manufacturing KPIs Calculation Package (OEE, MTTR, MTBF, Availability, Performance, Quality)
+Author-email: Precise <digiapp@preciseindsol.com>
+License: MIT
+Project-URL: Homepage, https://pypi.org/project/digifact
+Project-URL: Documentation, https://pypi.org/project/digifact
+Project-URL: Source, https://github.com/yourusername/digifact
+Keywords: manufacturing,OEE,KPI,production,MTTR,MTBF,availability,performance,quality
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Manufacturing
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Digifact
+
+A Python package for calculating manufacturing KPIs including OEE (Overall Equipment Efficiency), Availability, Performance, Quality, MTTR, and MTBF.
+
+## Installation
+
+```bash
+pip install digifact

digifact-0.1.0/README.md

@@ -0,0 +1,8 @@
+# Digifact
+
+A Python package for calculating manufacturing KPIs including OEE (Overall Equipment Efficiency), Availability, Performance, Quality, MTTR, and MTBF.
+
+## Installation
+
+```bash
+pip install digifact

digifact-0.1.0/digifact/__init__.py

@@ -0,0 +1,15 @@
+"""Digifact - Manufacturing KPIs Calculation Package"""
+# This is a docstring - it describes what the package does
+# It appears when someone uses help(digifact) or looks at documentation
+from digifact.core import ProductionMetrics
+
+# These import statements make these functions/classes available 
+# when someone does "from digifact import *"
+# It saves users from having to import from digifact.core directly
+
+__version__ = "0.1.0"
+__all__ = [
+    "ProductionMetrics"
+]
+# __all__ specifies what gets imported when someone uses "from digifact import *"
+# It's like a whitelist of public objects

digifact-0.1.0/digifact/core.py

@@ -0,0 +1,324 @@
+"""Core functionality for digifact package"""
+# Module docstring explaining this file's purpose
+from dataclasses import dataclass
+# Imports dataclass decorator - automatically generates __init__, __repr__, etc.
+from typing import Optional, Dict, Any
+# Imports Optional and Dict type hints
+
+
+@dataclass
+class ProductionMetrics:
+    """Data class to hold production metrics and calculate all KPIs"""
+    
+    # Attributes
+    total_time: float  # Total available time
+    ideal_production: float  # Ideal production rate (units per time)
+    actual_count: float  # Actual units produced
+    total_count: float  # Total units (including defects)
+    fault_count: float  # Number of faults/breakdowns
+    total_downtime: float  # Total downtime
+    total_uptime: float  # Total uptime
+    
+    def calculate_availability(self) -> float:
+        """
+        Calculate Availability
+        
+        Returns:
+            Availability percentage
+        """
+        try:
+            availability = (self.actual_count * 100) / self.ideal_production
+            return round(availability, 2)
+        except ZeroDivisionError:
+            raise ValueError("Ideal production cannot be zero")
+        except Exception as e:
+            raise ValueError(f"Error calculating availability: {str(e)}")
+    
+    def calculate_performance(self) -> float:
+        """
+        Calculate Performance
+        
+        Returns:
+            Performance percentage
+        """
+        try:
+            # Performance = (Actual Production Rate / Ideal Production Rate) * 100
+            actual_rate = self.actual_count / self.total_time
+            ideal_rate = self.ideal_production / self.total_time
+            performance = (actual_rate / ideal_rate) * 100
+            return round(performance, 2)
+        except ZeroDivisionError:
+            raise ValueError("Total time cannot be zero")
+        except Exception as e:
+            raise ValueError(f"Error calculating performance: {str(e)}")
+    
+    def calculate_quality(self) -> float:
+        """
+        Calculate Quality
+        
+        Formula: Quality = (Good Units / Total Units) * 100
+        
+        Returns:
+            Quality percentage
+        """
+        try:
+            if self.total_count == 0:
+                raise ValueError("Total count cannot be zero")
+            
+            # Calculate quality as percentage of good units
+            quality = (self.actual_count / self.total_count) * 100
+            return round(quality, 2)
+            
+        except ZeroDivisionError:
+            raise ValueError("Total count cannot be zero")
+        except Exception as e:
+            raise ValueError(f"Error calculating quality: {str(e)}")
+    
+    def calculate_oee(self) -> Dict[str, Any]:
+        """
+        Calculate Overall Equipment Efficiency (OEE)
+        
+        OEE = (Availability × Performance × Quality) / 10000
+        
+        Returns:
+            Dictionary containing OEE and its components
+        """
+        try:
+            availability = self.calculate_availability()
+            performance = self.calculate_performance()
+            quality = self.calculate_quality()
+            
+            # Calculate OEE (all inputs are percentages)
+            oee = (availability * performance * quality) / 10000
+            oee = round(oee, 2)
+            
+            return {
+                'oee': oee,
+                'availability': availability,
+                'performance': performance,
+                'quality': quality,
+                'components': {
+                    'availability_pct': availability,
+                    'performance_pct': performance,
+                    'quality_pct': quality
+                }
+            }
+        except Exception as e:
+            raise ValueError(f"Error calculating OEE: {str(e)}")
+    
+    def calculate_mttr(self) -> float:
+        """
+        Calculate Mean Time To Repair (MTTR)
+        
+        MTTR = Total down time / Fault count
+        
+        Returns:
+            MTTR value
+        """
+        try:
+            if self.fault_count == 0:
+                return 0.0
+            
+            mttr = self.total_downtime / self.fault_count
+            return round(mttr, 2)
+        except ZeroDivisionError:
+            raise ValueError("Fault count cannot be zero")
+        except Exception as e:
+            raise ValueError(f"Error calculating MTTR: {str(e)}")
+    
+    def calculate_mtbf(self) -> float:
+        """
+        Calculate Mean Time Between Failures (MTBF)
+        
+        MTBF = Total uptime / Fault count
+        
+        Returns:
+            MTBF value
+        """
+        try:
+            if self.fault_count == 0:
+                return float('inf')  # No failures means infinite MTBF
+            
+            mtbf = self.total_uptime / self.fault_count
+            return round(mtbf, 2)
+        except ZeroDivisionError:
+            raise ValueError("Fault count cannot be zero")
+        except Exception as e:
+            raise ValueError(f"Error calculating MTBF: {str(e)}")
+    
+    def calculate_all_metrics(self) -> Dict[str, Any]:
+        """
+        Calculate all metrics at once
+        
+        Returns:
+            Dictionary containing all calculated metrics
+        """
+        return {
+            'oee_analysis': self.calculate_oee(),
+            'mttr': self.calculate_mttr(),
+            'mtbf': self.calculate_mtbf(),
+            'raw_data': {
+                'total_time': self.total_time,
+                'ideal_production': self.ideal_production,
+                'actual_count': self.actual_count,
+                'total_count': self.total_count,
+                'fault_count': self.fault_count,
+                'total_downtime': self.total_downtime,
+                'total_uptime': self.total_uptime
+            }
+        }
+    
+    def get_defect_count(self) -> float:
+        """
+        Calculate number of defective units
+        
+        Returns:
+            Number of defective units
+        """
+        return self.total_count - self.actual_count
+    
+    def get_defect_rate(self) -> float:
+        """
+        Calculate defect rate percentage
+        
+        Returns:
+            Defect rate percentage
+        """
+        if self.total_count == 0:
+            return 0.0
+        return round((self.get_defect_count() / self.total_count) * 100, 2)
+    
+    def get_utilization_rate(self) -> float:
+        """
+        Calculate equipment utilization rate
+        
+        Returns:
+            Utilization rate percentage
+        """
+        if self.total_time == 0:
+            return 0.0
+        return round((self.total_uptime / self.total_time) * 100, 2)
+    
+    def get_production_efficiency(self) -> float:
+        """
+        Calculate production efficiency
+        
+        Returns:
+            Production efficiency percentage
+        """
+        if self.ideal_production == 0:
+            return 0.0
+        return round((self.actual_count / self.ideal_production) * 100, 2)
+    
+    def get_failure_frequency(self) -> float:
+        """
+        Calculate failure frequency per hour
+        
+        Returns:
+            Failures per hour
+        """
+        if self.total_time == 0:
+            return 0.0
+        return round(self.fault_count / (self.total_time / 60), 2)
+    
+    def get_cycle_times(self) -> Dict[str, float]:
+        """
+        Calculate ideal and actual cycle times
+        
+        Returns:
+            Dictionary with cycle times
+        """
+        ideal_cycle_time = self.total_time / self.ideal_production if self.ideal_production > 0 else 0
+        actual_cycle_time = self.total_uptime / self.actual_count if self.actual_count > 0 else 0
+        
+        return {
+            'ideal_cycle_time': round(ideal_cycle_time, 2),
+            'actual_cycle_time': round(actual_cycle_time, 2)
+        }
+    
+    def get_run_rates(self) -> Dict[str, float]:
+        """
+        Calculate ideal and actual run rates
+        
+        Returns:
+            Dictionary with run rates
+        """
+        ideal_run_rate = self.ideal_production / self.total_time if self.total_time > 0 else 0
+        actual_run_rate = self.actual_count / self.total_uptime if self.total_uptime > 0 else 0
+        
+        return {
+            'ideal_run_rate': round(ideal_run_rate, 2),
+            'actual_run_rate': round(actual_run_rate, 2)
+        }
+    
+    def get_summary(self) -> Dict[str, Any]:
+        """
+        Get complete summary of all metrics
+        
+        Returns:
+            Dictionary with all calculated metrics
+        """
+        return {
+            'input_data': {
+                'total_time': self.total_time,
+                'ideal_production': self.ideal_production,
+                'actual_count': self.actual_count,
+                'total_count': self.total_count,
+                'fault_count': self.fault_count,
+                'total_downtime': self.total_downtime,
+                'total_uptime': self.total_uptime
+            },
+            'oee_components': {
+                'availability': self.calculate_availability(),
+                'performance': self.calculate_performance(),
+                'quality': self.calculate_quality()
+            },
+            'oee': self.calculate_oee()['oee'],
+            'maintenance': {
+                'mttr': self.calculate_mttr(),
+                'mtbf': self.calculate_mtbf()
+            },
+            'quality_metrics': {
+                'defect_count': self.get_defect_count(),
+                'defect_rate': self.get_defect_rate()
+            },
+            'efficiency_metrics': {
+                'utilization_rate': self.get_utilization_rate(),
+                'production_efficiency': self.get_production_efficiency(),
+                'failure_frequency': self.get_failure_frequency()
+            },
+            'cycle_analysis': {
+                'cycle_times': self.get_cycle_times(),
+                'run_rates': self.get_run_rates()
+            }
+        }
+    
+    def __str__(self) -> str:
+        """
+        String representation of the metrics
+        
+        Returns:
+            Formatted string with key metrics
+        """
+        return (f"ProductionMetrics("
+                f"total_time={self.total_time}, "
+                f"ideal={self.ideal_production}, "
+                f"actual={self.actual_count}, "
+                f"total={self.total_count}, "
+                f"faults={self.fault_count})")
+    
+    def __repr__(self) -> str:
+        """
+        Detailed string representation
+        
+        Returns:
+            Detailed string with all attributes
+        """
+        return (f"ProductionMetrics("
+                f"total_time={self.total_time}, "
+                f"ideal_production={self.ideal_production}, "
+                f"actual_count={self.actual_count}, "
+                f"total_count={self.total_count}, "
+                f"fault_count={self.fault_count}, "
+                f"total_downtime={self.total_downtime}, "
+                f"total_uptime={self.total_uptime})")

digifact-0.1.0/digifact/utils.py

@@ -0,0 +1,104 @@
+"""Utility functions for digifact package"""
+
+from typing import Dict, Any
+import json
+from datetime import datetime
+
+
+def validate_metrics(data: Dict[str, Any]) -> bool:
+    """
+    Validate input metrics data
+    
+    Args:
+        data: Dictionary containing metric values
+        
+    Returns:
+        True if valid, raises ValueError if invalid
+    """
+    required_fields = [
+        'total_time', 'ideal_production', 'actual_count', 
+        'total_count', 'fault_count', 'total_downtime', 'total_uptime'
+    ]
+    
+    # Check for required fields
+    for field in required_fields:
+        if field not in data:
+            raise ValueError(f"Missing required field: {field}")
+        
+        # Check for negative values
+        if data[field] < 0:
+            raise ValueError(f"{field} cannot be negative")
+    
+    # Validate relationships
+    if data['total_downtime'] + data['total_uptime'] > data['total_time']:
+        raise ValueError("Downtime + Uptime cannot exceed total time")
+    
+    if data['actual_count'] > data['total_count']:
+        raise ValueError("Actual count cannot exceed total count")
+    
+    return True
+
+
+def export_to_json(metrics: Dict[str, Any], filename: str = None) -> str:
+    """
+    Export metrics to JSON file
+    
+    Args:
+        metrics: Dictionary containing calculated metrics
+        filename: Optional filename (auto-generated if not provided)
+        
+    Returns:
+        Path to saved file
+    """
+    if filename is None:
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"digifact_metrics_{timestamp}.json"
+    
+    # Add timestamp to data
+    metrics['export_timestamp'] = datetime.now().isoformat()
+    
+    with open(filename, 'w') as f:
+        json.dump(metrics, f, indent=2)
+    
+    return filename
+
+
+def format_report(metrics: Dict[str, Any]) -> str:
+    """
+    Format metrics as readable report
+    
+    Args:
+        metrics: Dictionary containing calculated metrics
+        
+    Returns:
+        Formatted report string
+    """
+    report = []
+    report.append("=" * 50)
+    report.append("DIGIFACT PRODUCTION METRICS REPORT")
+    report.append("=" * 50)
+    report.append("")
+    
+    if 'oee_analysis' in metrics:
+        oee = metrics['oee_analysis']
+        report.append("OEE ANALYSIS:")
+        report.append(f"  Overall OEE: {oee['oee']:.2f}")
+        report.append(f"  Availability: {oee['availability']:.2f}%")
+        report.append(f"  Performance: {oee['performance']:.2f}%")
+        report.append(f"  Quality: {oee['quality']:.2f}%")
+        report.append("")
+    
+    if 'mttr' in metrics:
+        report.append(f"MTTR: {metrics['mttr']:.2f} time units")
+    
+    if 'mtbf' in metrics:
+        mtbf = metrics['mtbf']
+        if mtbf == float('inf'):
+            report.append("MTBF: Infinite (no failures)")
+        else:
+            report.append(f"MTBF: {mtbf:.2f} time units")
+    
+    report.append("")
+    report.append("=" * 50)
+    
+    return "\n".join(report)

digifact-0.1.0/digifact.egg-info/PKG-INFO

@@ -0,0 +1,29 @@
+Metadata-Version: 2.4
+Name: digifact
+Version: 0.1.0
+Summary: Digifact - Manufacturing KPIs Calculation Package (OEE, MTTR, MTBF, Availability, Performance, Quality)
+Author-email: Precise <digiapp@preciseindsol.com>
+License: MIT
+Project-URL: Homepage, https://pypi.org/project/digifact
+Project-URL: Documentation, https://pypi.org/project/digifact
+Project-URL: Source, https://github.com/yourusername/digifact
+Keywords: manufacturing,OEE,KPI,production,MTTR,MTBF,availability,performance,quality
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Manufacturing
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Digifact
+
+A Python package for calculating manufacturing KPIs including OEE (Overall Equipment Efficiency), Availability, Performance, Quality, MTTR, and MTBF.
+
+## Installation
+
+```bash
+pip install digifact

digifact-0.1.0/digifact.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+digifact/__init__.py
+digifact/core.py
+digifact/utils.py
+digifact.egg-info/PKG-INFO
+digifact.egg-info/SOURCES.txt
+digifact.egg-info/dependency_links.txt
+digifact.egg-info/top_level.txt
+tests/__init__.py
+tests/test_core.py

digifact-0.1.0/digifact.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

digifact-0.1.0/digifact.egg-info/top_level.txt

@@ -0,0 +1 @@
+digifact

digifact-0.1.0/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "digifact"
+version = "0.1.0"
+description = "Digifact - Manufacturing KPIs Calculation Package (OEE, MTTR, MTBF, Availability, Performance, Quality)"
+readme = "README.md"
+requires-python = ">=3.8"
+
+authors = [
+  { name = "Precise", email = "digiapp@preciseindsol.com" }
+]
+
+license = { text = "MIT" }
+
+keywords = ["manufacturing", "OEE", "KPI", "production", "MTTR", "MTBF", "availability", "performance", "quality"]
+
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent",
+  "Intended Audience :: Manufacturing",
+  "Topic :: Scientific/Engineering :: Information Analysis"
+]
+
+dependencies = []
+
+[project.urls]
+Homepage = "https://pypi.org/project/digifact"
+Documentation = "https://pypi.org/project/digifact"
+Source = "https://github.com/yourusername/digifact"
+

digifact-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

digifact-0.1.0/tests/test_core.py

@@ -0,0 +1,111 @@
+"""Unit tests for digifact core functionality"""
+
+import unittest
+from digifact.core import ProductionMetrics,calculate_availability, calculate_mtbf, calculate_mttr, calculate_oee, calculate_quality, calculate_performance
+
+class TestDigifact(unittest.TestCase):
+    
+    def setUp(self):
+        """Setup test data"""
+        self.metrics = ProductionMetrics(
+            total_time=480,  # 8 hours in minutes
+            ideal_production=1000,  # Ideal units per shift
+            actual_count=950,  # Actual units produced
+            total_count=1000,  # Total units (including defects)
+            fault_count=5,  # Number of breakdowns
+            total_downtime=60,  # 60 minutes downtime
+            total_uptime=420  # 420 minutes uptime
+        )
+    def test_calculate_availability(self):
+        # """Availability = uptime / total_time * 100"""
+        # result = calculate_availability(self.metrics)
+        # self.assertAlmostEqual(result, 87.5, places=1)
+        """Test availability calculation"""
+        result = calculate_availability(self.metrics)
+        self.assertEqual(result, 95.0)  # (950/1000)*100
+        print(f"\nAvailability test passed: {result}%")
+    
+    def test_calculate_performance(self):
+        # """Performance = actual / ideal * 100"""
+        # result = calculate_performance(self.metrics)
+        # self.assertAlmostEqual(result, 95.0, places=1)
+        """Test performance calculation"""
+        result = calculate_performance(self.metrics)
+        self.assertAlmostEqual(result, 95.0, places=1)
+        print(f"\nPerformance test passed: {result}%")
+    
+    def test_calculate_quality(self):
+        # """Quality = good / total * 100"""
+        # result = calculate_quality(self.metrics)
+        # self.assertAlmostEqual(result, 95.0, places=1)
+        """Test quality calculation"""
+        result = calculate_quality(self.metrics)
+        self.assertEqual(result, -5.0)  # (950-1000)/1000*100
+        print(f"\nQuality test passed: {result}%")
+    
+    def test_calculate_mttr(self):
+        # """MTTR = downtime / faults"""
+        # result = calculate_mttr(self.metrics)
+        # self.assertEqual(result, 12.0)   
+        """Test MTTR calculation"""
+        result = calculate_mttr(self.metrics)
+        self.assertEqual(result, 12.0)  # 60/5
+        print(f"\nMTTR test passed: {result} minutes")
+    
+    def test_calculate_mtbf(self):
+        # """MTBF = uptime / faults"""
+        # result = calculate_mtbf(self.metrics)
+        # self.assertEqual(result, 84.0)
+        """Test MTBF calculation"""
+        result = calculate_mtbf(self.metrics)
+        self.assertEqual(result, 84.0)  # 420/5
+        print(f"\nMTBF test passed: {result} minutes")
+    
+    def test_calculate_oee(self):
+        # """OEE = Availability × Performance × Quality / 10000"""
+        # result = calculate_oee(self.metrics)
+
+        # self.assertIn("oee", result)
+        # self.assertIn("availability", result)
+        # self.assertIn("performance", result)
+        # self.assertIn("quality", result)
+
+        # self.assertAlmostEqual(result["availability"], 87.5, places=1)
+        # self.assertAlmostEqual(result["performance"], 95.0, places=1)
+        # self.assertAlmostEqual(result["quality"], 95.0, places=1)
+
+        # expected_oee = (87.5 * 95.0 * 95.0) / 10000
+        # self.assertAlmostEqual(result["oee"], expected_oee, places=1)
+        """Test OEE calculation"""
+        result = calculate_oee(self.metrics)
+        self.assertIn('oee', result)
+        self.assertIn('availability', result)
+        self.assertIn('performance', result)
+        self.assertIn('quality', result)
+        print(f"\nOEE test passed: {result['oee']}")
+
+    # def test_zero_fault_mttr(self):
+    #    self.metrics.fault_count = 0
+    #    result = calculate_mttr(self.metrics)
+    #    self.assertEqual(result, 0)
+
+    # def test_zero_total_time_availability(self):
+    #     self.metrics.total_time = 0
+    #     result = calculate_availability(self.metrics)
+    #     self.assertEqual(result, 0)
+    
+
+
+if __name__ == '__main__':
+    metrics2 = ProductionMetrics(
+        total_time=10000,
+        ideal_production=1000,
+        actual_count=100,
+        total_count=800,
+        fault_count=5,
+        total_downtime=200,
+        total_uptime=830
+    )
+    result = calculate_availability(metrics2)
+    print(f"Availability: {result}%")
+    # unittest.main()