Update app.py

app.py

@@ -1,203 +1,190 @@
 import streamlit as st
-import networkx as nx
 import pandas as pd
 import numpy as np
-from datetime import timedelta
-from typing import List, Dict, Tuple
+from datetime import datetime, timedelta
+import networkx as nx
+import plotly.express as px
+from transformers import pipeline
 
-class TaskOptimizer:
+class AIProjectOptimizer:
     def __init__(self):
-        self.task_graph = nx.DiGraph()
+        # Model AI untuk generasi dan klasifikasi
+        try:
+            self.text_generator = pipeline('text-generation', model='distilgpt2')
+            self.task_classifier = pipeline('zero-shot-classification', 
+                                            model='facebook/bart-large-mnli')
+        except Exception as e:
+            st.warning(f"Gagal memuat model AI: {e}")
+            self.text_generator = None
+            self.task_classifier = None
+    
+    def generate_sample_tasks(self) -> pd.DataFrame:
+        """
+        Generate contoh tugas default jika tidak ada data
+        """
+        default_tasks = [
+            {
+                'Task Name': f'Tugas {i}', 
+                'Start Date': datetime.now() + timedelta(days=i*5),
+                'End Date': datetime.now() + timedelta(days=(i+1)*5),
+                'Duration': 5,
+                'Complexity': np.random.choice(['Low', 'Medium', 'High']),
+                'Progress': np.random.randint(0, 100),
+                'Cost': np.random.randint(1000, 10000)
+            } for i in range(5)
+        ]
+        return pd.DataFrame(default_tasks)
     
-    def build_dependency_graph(self, tasks: pd.DataFrame) -> nx.DiGraph:
+    def optimize_project(self, tasks: pd.DataFrame):
         """
-        Bangun graph ketergantungan antar tugas
+        Optimasi proyek dengan handling kasus kosong
         """
+        # Gunakan sample tasks jika input kosong
+        if tasks is None or tasks.empty:
+            tasks = self.generate_sample_tasks()
+        
+        # Graph untuk dependency
         G = nx.DiGraph()
         
-        # Tambahkan nodes (tugas)
+        # Tambahkan nodes
         for idx, task in tasks.iterrows():
             G.add_node(task['Task Name'], 
                        duration=task['Duration'],
                        complexity=self._complexity_to_weight(task['Complexity']))
         
-        # Tambahkan edges (ketergantungan)
-        for i in range(len(tasks)):
-            for j in range(i+1, len(tasks)):
-                # Logika sederhana untuk dependency
-                if tasks.iloc[i]['End Date'] < tasks.iloc[j]['Start Date']:
-                    G.add_edge(tasks.iloc[i]['Task Name'], tasks.iloc[j]['Task Name'])
+        # Tambahkan edges sederhana
+        for i in range(len(tasks)-1):
+            G.add_edge(tasks.iloc[i]['Task Name'], tasks.iloc[i+1]['Task Name'])
         
-        return G
-    
-    def _complexity_to_weight(self, complexity: str) -> float:
-        """Konversi kompleksitas ke bobot waktu"""
-        complexity_map = {
-            'Low': 1.0,
-            'Medium': 1.5,
-            'High': 2.0
-        }
-        return complexity_map.get(complexity, 1.0)
-    
-    def calculate_critical_path(self, tasks: pd.DataFrame) -> Dict:
-        """
-        Hitung jalur kritis dengan mempertimbangkan kompleksitas
-        """
-        G = self.build_dependency_graph(tasks)
-        
-        # Hitung earliest start dan latest finish
-        earliest_start = {}
-        latest_finish = {}
-        
-        # Forward pass
-        topological_order = list(nx.topological_sort(G))
-        for node in topological_order:
-            predecessors = list(G.predecessors(node))
-            
-            if not predecessors:
-                earliest_start[node] = 0
-            else:
-                earliest_start[node] = max(
-                    earliest_start[pred] + G.nodes[pred]['duration'] 
-                    for pred in predecessors
-                )
-        
-        # Backward pass
-        total_project_duration = max(earliest_start.values())
-        for node in reversed(topological_order):
-            successors = list(G.successors(node))
-            
-            if not successors:
-                latest_finish[node] = total_project_duration
-            else:
-                latest_finish[node] = min(
-                    latest_finish[succ] - G.nodes[node]['duration'] 
-                    for succ in successors
-                )
-        
-        # Identifikasi tugas kritis
-        critical_tasks = [
-            node for node in G.nodes 
-            if abs(latest_finish[node] - earliest_start[node]) < 0.1
-        ]
-        
-        return {
-            'critical_tasks': critical_tasks,
-            'total_project_duration': total_project_duration,
-            'earliest_start': earliest_start,
-            'latest_finish': latest_finish
-        }
-    
-    def optimize_task_schedule(self, tasks: pd.DataFrame) -> pd.DataFrame:
-        """
-        Optimasi penjadwalan tugas dengan algoritma cerdas
-        """
-        # Analisis jalur kritis
-        critical_path_analysis = self.calculate_critical_path(tasks)
-        
-        # Buat salinan dataframe untuk dioptimasi
-        optimized_tasks = tasks.copy()
+        # Hitung jalur kritis
+        try:
+            critical_path = list(nx.dag_longest_path(G))
+        except nx.NetworkXError:
+            critical_path = list(G.nodes)
         
-        # Prioritaskan tugas kritis
-        critical_tasks = critical_path_analysis['critical_tasks']
-        optimized_tasks['Priority'] = optimized_tasks['Task Name'].apply(
-            lambda x: 'Critical' if x in critical_tasks else 'Normal'
+        # Optimasi tasks
+        tasks['Priority'] = tasks['Task Name'].apply(
+            lambda x: 'Critical' if x in critical_path else 'Normal'
         )
         
-        # Optimasi alokasi sumber daya
-        optimized_tasks['Efficiency'] = optimized_tasks.apply(
-            lambda row: self._calculate_task_efficiency(row, critical_path_analysis), 
-            axis=1
-        )
+        # Hitung efisiensi
+        tasks['Efficiency'] = tasks.apply(self._calculate_task_efficiency, axis=1)
         
-        # Urutkan ulang berdasarkan efisiensi dan prioritas
-        optimized_tasks = optimized_tasks.sort_values(
+        # Urutkan berdasar prioritas dan efisiensi
+        optimized_tasks = tasks.sort_values(
             ['Priority', 'Efficiency'], 
             ascending=[False, False]
         )
         
-        return optimized_tasks
+        return optimized_tasks, critical_path
     
-    def _calculate_task_efficiency(self, task, critical_path_analysis):
-        """
-        Hitung efisiensi tugas berdasarkan kompleksitas dan jalur kritis
-        """
+    def _complexity_to_weight(self, complexity: str) -> float:
+        """Konversi kompleksitas ke bobot"""
+        return {
+            'Low': 1.0,
+            'Medium': 1.5,
+            'High': 2.0
+        }.get(complexity, 1.0)
+    
+    def _calculate_task_efficiency(self, task):
+        """Hitung efisiensi tugas"""
         complexity_factor = {
             'Low': 1.0,
             'Medium': 1.5,
             'High': 2.0
         }
         
-        # Pertimbangkan posisi tugas di jalur kritis
-        is_critical = task['Task Name'] in critical_path_analysis['critical_tasks']
-        
-        # Hitung skor efisiensi
-        efficiency_score = (
-            complexity_factor.get(task['Complexity'], 1.0) * 
-            (2 if is_critical else 1)
+        # Skor efisiensi dengan faktor kompleksitas
+        return complexity_factor.get(task['Complexity'], 1.0)
+    
+    def visualize_project(self, tasks: pd.DataFrame):
+        """Visualisasi proyek"""
+        # Gantt Chart
+        fig = px.timeline(
+            tasks, 
+            x_start='Start Date', 
+            x_end='End Date', 
+            y='Task Name',
+            color='Complexity',
+            title='Project Timeline'
         )
-        
-        return efficiency_score
+        return fig
 
-class AIProjectOptimizer:
+class StreamlitProjectApp:
     def __init__(self):
-        self.task_optimizer = TaskOptimizer()
-    
-    def optimize_project(self, tasks: pd.DataFrame) -> Tuple[pd.DataFrame, dict]:
-        """
-        Jalankan optimasi keseluruhan proyek
-        """
-        # Optimasi penjadwalan
-        optimized_tasks = self.task_optimizer.optimize_task_schedule(tasks)
-        
-        # Analisis jalur kritis
-        critical_path_analysis = self.task_optimizer.calculate_critical_path(tasks)
-        
-        return optimized_tasks, critical_path_analysis
-
-# Contoh integrasi di Streamlit
-def render_optimization_section(tasks: pd.DataFrame):
-    st.header("🚀 Optimizer Proyek AI")
+        self.optimizer = AIProjectOptimizer()
     
-    if st.button("Optimasi Proyek"):
-        optimizer = AIProjectOptimizer()
-        
-        try:
-            optimized_tasks, critical_path_info = optimizer.optimize_project(tasks)
-            
-            # Tampilkan hasil optimasi
-            st.subheader("Tugas Teroptimasi")
-            st.dataframe(optimized_tasks)
+    def run(self):
+        st.title("🚀 AI Project Optimizer")
+        
+        # Sidebar untuk input tugas
+        st.sidebar.header("Input Proyek")
+        
+        # Input tugas manual
+        with st.sidebar.form("task_input"):
+            task_name = st.text_input("Nama Tugas")
+            start_date = st.date_input("Tanggal Mulai")
+            duration = st.number_input("Durasi (Hari)", min_value=1, value=5)
+            complexity = st.selectbox("Kompleksitas", ['Low', 'Medium', 'High'])
             
-            # Informasi jalur kritis
-            st.subheader("Analisis Jalur Kritis")
-            col1, col2 = st.columns(2)
+            submit = st.form_submit_button("Tambah Tugas")
             
-            with col1:
-                st.metric("Durasi Total Proyek", 
-                          f"{critical_path_info['total_project_duration']} hari")
+            if submit:
+                # Tambahkan ke session state
+                if 'tasks' not in st.session_state:
+                    st.session_state.tasks = pd.DataFrame(columns=[
+                        'Task Name', 'Start Date', 'End Date', 
+                        'Duration', 'Complexity', 'Progress', 'Cost'
+                    ])
+                
+                new_task = pd.DataFrame([{
+                    'Task Name': task_name,
+                    'Start Date': start_date,
+                    'End Date': start_date + timedelta(days=duration),
+                    'Duration': duration,
+                    'Complexity': complexity,
+                    'Progress': 0,
+                    'Cost': duration * 500
+                }])
+                
+                st.session_state.tasks = pd.concat([
+                    st.session_state.tasks, 
+                    new_task
+                ], ignore_index=True)
+        
+        # Tampilkan daftar tugas
+        if hasattr(st.session_state, 'tasks') and not st.session_state.tasks.empty:
+            st.subheader("Daftar Tugas")
+            st.dataframe(st.session_state.tasks)
             
-            with col2:
-                st.write("Tugas Kritis:")
-                st.code(", ".join(critical_path_info['critical_tasks']))
-            
-            # Visualisasi efisiensi
-            st.subheader("Distribusi Efisiensi Tugas")
-            efficiency_dist = optimized_tasks['Efficiency'].value_counts()
-            st.bar_chart(efficiency_dist)
-        
-        except Exception as e:
-            st.error(f"Gagal mengoptimasi: {e}")
+            # Tombol Optimasi
+            if st.button("Optimasi Proyek"):
+                try:
+                    optimized_tasks, critical_path = self.optimizer.optimize_project(
+                        st.session_state.tasks
+                    )
+                    
+                    # Tampilkan hasil optimasi
+                    st.subheader("Tugas Teroptimasi")
+                    st.dataframe(optimized_tasks)
+                    
+                    # Visualisasi
+                    st.subheader("Visualisasi Proyek")
+                    fig = self.optimizer.visualize_project(optimized_tasks)
+                    st.plotly_chart(fig)
+                    
+                    # Informasi jalur kritis
+                    st.subheader("Jalur Kritis")
+                    st.write("Tugas Kritis:", critical_path)
+                
+                except Exception as e:
+                    st.error(f"Gagal mengoptimasi: {e}")
+        else:
+            st.info("Tambahkan tugas untuk memulai optimasi")
 
-# Contoh penggunaan di main app
 def main():
-    # Implementasi utama Streamlit
-    st.title("AI Project Optimizer")
-    
-    # Asumsi sudah ada dataframe tasks
-    tasks = pd.DataFrame()  # Load dari session state atau input
-    
-    render_optimization_section(tasks)
+    app = StreamlitProjectApp()
+    app.run()
 
 if __name__ == "__main__":
     main()