Update app.py

app.py

@@ -4,187 +4,235 @@ import numpy as np
 from datetime import datetime, timedelta
 import networkx as nx
 import plotly.express as px
-from transformers import pipeline
+import plotly.graph_objs as go
 
-class AIProjectOptimizer:
+# Simulasi Model AI Sederhana
+class AIProjectAnalyzer:
     def __init__(self):
-        # 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
+        # Model sederhana untuk klasifikasi dan prediksi
+        self.complexity_weights = {
+            'Low': 1.0,
+            'Medium': 1.5,
+            'High': 2.0
+        }
     
-    def generate_sample_tasks(self) -> pd.DataFrame:
+    def predict_task_duration(self, task):
         """
-        Generate contoh tugas default jika tidak ada data
+        Prediksi durasi tugas berdasarkan kompleksitas
         """
-        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)
+        base_duration = task['Duration']
+        complexity_factor = self.complexity_weights.get(task['Complexity'], 1.0)
+        
+        # Prediksi durasi dengan faktor kompleksitas
+        predicted_duration = base_duration * complexity_factor
+        
+        return max(1, round(predicted_duration))
     
-    def optimize_project(self, tasks: pd.DataFrame):
+    def calculate_risk_score(self, task):
         """
-        Optimasi proyek dengan handling kasus kosong
+        Hitung skor risiko berdasarkan kompleksitas dan dependencies
         """
-        # Gunakan sample tasks jika input kosong
-        if tasks is None or tasks.empty:
-            tasks = self.generate_sample_tasks()
+        complexity_risk = {
+            'Low': 0.2,
+            'Medium': 0.5,
+            'High': 0.8
+        }
         
-        # Graph untuk dependency
-        G = nx.DiGraph()
+        base_risk = complexity_risk.get(task['Complexity'], 0.5)
         
-        # Tambahkan nodes
-        for idx, task in tasks.iterrows():
-            G.add_node(task['Task Name'], 
-                       duration=task['Duration'],
-                       complexity=self._complexity_to_weight(task['Complexity']))
+        # Pertimbangkan dependencies dalam skor risiko
+        dependency_multiplier = 1 + (len(task.get('Dependencies', [])) * 0.1)
         
-        # 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 round(base_risk * dependency_multiplier, 2)
+
+class AdvancedTaskDependencyManager:
+    def __init__(self):
+        # Inisialisasi graph ketergantungan dengan NetworkX
+        self.dependency_graph = nx.DiGraph()
+        self.ai_analyzer = AIProjectAnalyzer()
+    
+    def add_task_dependency(self, tasks_df, task_name, predecessors=None, successors=None):
+        """
+        Tambahkan dependencies antar tugas dengan validasi kompleks
+        """
+        # Validasi tugas
+        if task_name not in tasks_df['Task Name'].values:
+            raise ValueError(f"Tugas {task_name} tidak ditemukan")
         
-        # Hitung jalur kritis
-        try:
-            critical_path = list(nx.dag_longest_path(G))
-        except nx.NetworkXError:
-            critical_path = list(G.nodes)
+        # Tambahkan dependencies
+        if predecessors:
+            for pred in predecessors:
+                if pred not in tasks_df['Task Name'].values:
+                    raise ValueError(f"Predecessor {pred} tidak ditemukan")
+                self.dependency_graph.add_edge(pred, task_name)
         
-        # Optimasi tasks
-        tasks['Priority'] = tasks['Task Name'].apply(
-            lambda x: 'Critical' if x in critical_path else 'Normal'
-        )
+        if successors:
+            for succ in successors:
+                if succ not in tasks_df['Task Name'].values:
+                    raise ValueError(f"Successor {succ} tidak ditemukan")
+                self.dependency_graph.add_edge(task_name, succ)
+    
+    def optimize_project_timeline(self, tasks_df):
+        """
+        Optimasi timeline proyek dengan pertimbangan dependencies
+        """
+        # Clone dataframe untuk manipulasi
+        optimized_tasks = tasks_df.copy()
         
-        # Hitung efisiensi
-        tasks['Efficiency'] = tasks.apply(self._calculate_task_efficiency, axis=1)
+        # Hitung jalur kritis
+        try:
+            critical_path = list(nx.dag_longest_path(self.dependency_graph))
+        except:
+            critical_path = list(self.dependency_graph.nodes)
         
-        # Urutkan berdasar prioritas dan efisiensi
-        optimized_tasks = tasks.sort_values(
-            ['Priority', 'Efficiency'], 
-            ascending=[False, False]
-        )
+        # Analisis dan optimasi durasi
+        for index, task in optimized_tasks.iterrows():
+            # Prediksi durasi dengan AI
+            predicted_duration = self.ai_analyzer.predict_task_duration(task)
+            optimized_tasks.at[index, 'Predicted Duration'] = predicted_duration
+            
+            # Hitung skor risiko
+            risk_score = self.ai_analyzer.calculate_risk_score(task)
+            optimized_tasks.at[index, 'Risk Score'] = risk_score
         
         return optimized_tasks, critical_path
-    
-    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
-        }
-        
-        # 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 fig
 
-class StreamlitProjectApp:
+class AIProjectDashboard:
     def __init__(self):
-        self.optimizer = AIProjectOptimizer()
+        self.dependency_manager = AdvancedTaskDependencyManager()
     
     def run(self):
-        st.title("🚀 AI Project Optimizer")
+        st.set_page_config(
+            page_title="🚀 AI Project Dependency Optimizer",
+            page_icon="📊",
+            layout="wide"
+        )
         
-        # Sidebar untuk input tugas
-        st.sidebar.header("Input Proyek")
+        st.title("🚀 Intelligent Project Dependency Management")
         
-        # 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'])
-            
-            submit = st.form_submit_button("Tambah Tugas")
-            
-            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'
-                    ])
+        # Inisialisasi session state
+        if 'tasks' not in st.session_state:
+            st.session_state.tasks = pd.DataFrame(columns=[
+                'Task Name', 'Start Date', 'Duration', 'Complexity', 
+                'Predecessors', 'Successors', 'Predicted Duration', 'Risk Score'
+            ])
+        
+        # Sidebar untuk input tugas
+        with st.sidebar:
+            st.header("🔧 Input Tugas Proyek")
+            with st.form("task_form"):
+                task_name = st.text_input("Nama Tugas")
+                start_date = st.date_input("Tanggal Mulai")
+                duration = st.number_input("Durasi Awal (Hari)", min_value=1, value=5)
+                complexity = st.selectbox("Kompleksitas Tugas", ['Low', 'Medium', 'High'])
                 
-                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
-                }])
+                # Pilih predecessors dan successors
+                existing_tasks = list(st.session_state.tasks['Task Name'])
+                predecessors = st.multiselect("Predecessor Tugas", existing_tasks)
+                successors = st.multiselect("Successor Tugas", existing_tasks)
                 
-                st.session_state.tasks = pd.concat([
-                    st.session_state.tasks, 
-                    new_task
-                ], ignore_index=True)
+                submit = st.form_submit_button("Tambah Tugas")
+                
+                if submit and task_name:
+                    # Buat tugas baru
+                    new_task = pd.DataFrame([{
+                        'Task Name': task_name,
+                        'Start Date': start_date,
+                        'Duration': duration,
+                        'Complexity': complexity,
+                        'Predecessors': str(predecessors) if predecessors else None,
+                        'Successors': str(successors) if successors else None,
+                        'Predicted Duration': None,
+                        'Risk Score': None
+                    }])
+                    
+                    # Tambahkan ke dataframe
+                    st.session_state.tasks = pd.concat([
+                        st.session_state.tasks, 
+                        new_task
+                    ], ignore_index=True)
+                    
+                    # Tambahkan dependency
+                    try:
+                        self.dependency_manager.add_task_dependency(
+                            st.session_state.tasks, 
+                            task_name, 
+                            predecessors=predecessors, 
+                            successors=successors
+                        )
+                    except ValueError as e:
+                        st.error(str(e))
         
         # Tampilkan daftar tugas
-        if hasattr(st.session_state, 'tasks') and not st.session_state.tasks.empty:
-            st.subheader("Daftar Tugas")
+        if not st.session_state.tasks.empty:
+            st.header("📋 Daftar Tugas Proyek")
             st.dataframe(st.session_state.tasks)
             
-            # Tombol Optimasi
-            if st.button("Optimasi Proyek"):
+            # Tombol optimasi proyek
+            if st.button("🔍 Optimasi Proyek dengan AI"):
                 try:
-                    optimized_tasks, critical_path = self.optimizer.optimize_project(
+                    # Optimasi timeline
+                    optimized_tasks, critical_path = self.dependency_manager.optimize_project_timeline(
                         st.session_state.tasks
                     )
                     
                     # Tampilkan hasil optimasi
-                    st.subheader("Tugas Teroptimasi")
+                    st.subheader("🎯 Hasil Optimasi Proyek")
                     st.dataframe(optimized_tasks)
                     
-                    # Visualisasi
-                    st.subheader("Visualisasi Proyek")
-                    fig = self.optimizer.visualize_project(optimized_tasks)
+                    # Tampilkan jalur kritis
+                    st.subheader("🔗 Jalur Kritis Proyek")
+                    st.write("Urutan Tugas Kritis:", critical_path)
+                    
+                    # Visualisasi Graph Dependency
+                    st.subheader("🌐 Visualisasi Hubungan Tugas")
+                    dependency_graph = self.dependency_manager.dependency_graph
+                    
+                    # Konversi graph ke edge list
+                    edges_list = list(dependency_graph.edges())
+                    edges_df = pd.DataFrame(edges_list, columns=['Source', 'Target'])
+                    
+                    # Visualisasi graph dengan Plotly
+                    fig = go.Figure(data=[go.Sankey(
+                        node=dict(
+                            pad=15,
+                            thickness=20,
+                            line=dict(color='black', width=0.5),
+                            label=list(set(edges_df['Source']) | set(edges_df['Target'])),
+                            color='blue'
+                        ),
+                        link=dict(
+                            source=[list(edges_df['Source']).index(x) for x in edges_df['Source']],
+                            target=[list(edges_df['Target']).index(x) for x in edges_df['Target']],
+                            value=[1]*len(edges_df)
+                        )
+                    )])
+                    
+                    fig.update_layout(title_text="Diagram Dependency Proyek", font_size=10)
                     st.plotly_chart(fig)
                     
-                    # Informasi jalur kritis
-                    st.subheader("Jalur Kritis")
-                    st.write("Tugas Kritis:", critical_path)
+                    # Analisis Risiko
+                    st.subheader("⚠️ Analisis Risiko Proyek")
+                    risk_analysis = optimized_tasks[['Task Name', 'Risk Score']]
+                    st.dataframe(risk_analysis)
+                    
+                    # Bar chart risiko
+                    risk_fig = px.bar(
+                        risk_analysis, 
+                        x='Task Name', 
+                        y='Risk Score', 
+                        title='Skor Risiko per Tugas'
+                    )
+                    st.plotly_chart(risk_fig)
                 
                 except Exception as e:
                     st.error(f"Gagal mengoptimasi: {e}")
         else:
-            st.info("Tambahkan tugas untuk memulai optimasi")
+            st.info("Tambahkan tugas untuk memulai analisis")
 
 def main():
-    app = StreamlitProjectApp()
-    app.run()
+    dashboard = AIProjectDashboard()
+    dashboard.run()
 
 if __name__ == "__main__":
     main()