Update app.py

app.py

@@ -1,159 +1,112 @@
 import streamlit as st
-from azure.cosmos import CosmosClient, PartitionKey
+import requests
 import os
-import pandas as pd
+import shutil
+import zipfile
+from github import Github
+from git import Repo
+from datetime import datetime
 
-# Streamlit page configuration for wide mode
-st.set_page_config(layout="wide")
+def download_github_repo(url, local_path):
+    if os.path.exists(local_path):
+        shutil.rmtree(local_path)
+    Repo.clone_from(url, local_path)
 
-# Cosmos DB configuration
-ENDPOINT = "https://acae-afd.documents.azure.com:443/"
-SUBSCRIPTION_ID = "003fba60-5b3f-48f4-ab36-3ed11bc40816"
-DATABASE_NAME = os.environ.get("COSMOS_DATABASE_NAME")
-CONTAINER_NAME = os.environ.get("COSMOS_CONTAINER_NAME")
-Key = os.environ.get("Key")
+def create_zip_file(source_dir, output_filename):
+    shutil.make_archive(output_filename, 'zip', source_dir)
 
-def insert_record(record):
+def check_repo_exists(g, repo_name):
     try:
-        response = container.create_item(body=record)
-        return True, response
-    except Exception as e:
-        return False, str(e)
-
-def call_stored_procedure(record):
-    try:
-        response = container.scripts.execute_stored_procedure(
-            sproc="processPrompt",
-            params=[record],
-            partition_key=record['id']
-        )
-        return True, response
-    except Exception as e:
-        error_message = f"Error type: {type(e).__name__}\nError message: {str(e)}"
-        if hasattr(e, 'sub_status'):
-            error_message += f"\nSub-status: {e.sub_status}"
-        if hasattr(e, 'response'):
-            error_message += f"\nResponse: {e.response}"
-        return False, error_message
-
-def fetch_all_records():
-    query = "SELECT * FROM c"
-    items = list(container.query_items(query=query, enable_cross_partition_query=True))
-    return pd.DataFrame(items)
-
-def delete_records(ids):
-    try:
-        for id in ids:
-            container.delete_item(item=id, partition_key=id)
-        return True, f"Successfully deleted {len(ids)} records"
-    except Exception as e:
-        return False, f"Error deleting records: {str(e)}"
-
-# Streamlit app
-st.title("🌟 Cosmos DB Record Management")
-
-# Login section
-if 'logged_in' not in st.session_state:
-    st.session_state.logged_in = False
-
-if not st.session_state.logged_in:
-    st.subheader("🔐 Login")
-    input_key = Key
-    if st.button("🚀 Login"):
-        if input_key:
-            st.session_state.primary_key = input_key
-            st.session_state.logged_in = True
-            st.rerun()
-        else:
-            st.error("Invalid key. Please check your environment variables.")
-else:
-    # Initialize Cosmos DB client
-    client = CosmosClient(ENDPOINT, credential=st.session_state.primary_key)
-    database = client.get_database_client(DATABASE_NAME)
-    container = database.get_container_client(CONTAINER_NAME)
-
-    # Fetch all records
-    records_df = fetch_all_records()
-
-    # Sidebar for data editing
-    st.sidebar.title("Edit Records")
-    edited_df = st.sidebar.data_editor(records_df, num_rows="dynamic", key="sidebar_editor")
-
-    # Main Content Area
-    col1, col2 = st.columns(2)
-
-    with col1:
-        st.subheader("📝 Enter Record Details")
-        id = st.text_input("ID")
-        name = st.text_input("Name")
-        document = st.text_area("Document")
-        evaluation_text = st.text_area("Evaluation Text")
-        evaluation_score = st.number_input("Evaluation Score", min_value=0, max_value=100, step=1)
-
-        if st.button("💾 Insert Record"):
-            record = {
-                "id": id,
-                "name": name,
-                "document": document,
-                "evaluationText": evaluation_text,
-                "evaluationScore": evaluation_score
-            }
-            
-            success, response = insert_record(record)
-            if success:
-                st.success("✅ Record inserted successfully!")
-                st.json(response)
-            else:
-                st.error(f"❌ Failed to insert record: {response}")
-
-    with col2:
-        st.subheader("🔧 Call Stored Procedure")
-        if st.button("Call Procedure"):
-            record = {
-                "id": id,
-                "name": name,
-                "document": document,
-                "evaluationText": evaluation_text,
-                "evaluationScore": evaluation_score
-            }
-            
-            success, response = call_stored_procedure(record)
-            if success:
-                st.success("✅ Stored procedure executed successfully!")
-                st.json(response)
-            else:
-                st.error(f"❌ Failed to execute stored procedure: {response}")
-
-    st.subheader("📊 All Records")
-    st.dataframe(edited_df)
-
-    col3, col4 = st.columns(2)
-    with col3:
-        if st.button("🗑️ Delete Selected"):
-            selected_ids = edited_df[edited_df['select']]['id'].tolist() if 'select' in edited_df.columns else []
-            if selected_ids:
-                success, message = delete_records(selected_ids)
-                if success:
-                    st.success(message)
-                else:
-                    st.error(message)
-                st.rerun()
-            else:
-                st.warning("No records selected for deletion.")
-
-    with col4:
-        if st.download_button("📥 Download Data", edited_df.to_csv(index=False), "cosmos_db_data.csv", "text/csv"):
-            st.success("Data downloaded successfully!")
-
-    # Logout button
-    if st.button("🚪 Logout"):
-        st.session_state.logged_in = False
-        st.rerun()
-
-    # Display connection info
-    st.sidebar.markdown("---")
-    st.sidebar.subheader("🔗 Connection Information")
-    st.sidebar.text(f"Endpoint: {ENDPOINT}")
-    st.sidebar.text(f"Subscription ID: {SUBSCRIPTION_ID}")
-    st.sidebar.text(f"Database: {DATABASE_NAME}")
-    st.sidebar.text(f"Container: {CONTAINER_NAME}")
+        g.get_repo(repo_name)
+        return True
+    except:
+        return False
+
+def create_repo(g, repo_name):
+    user = g.get_user()
+    return user.create_repo(repo_name)
+
+def push_to_github(local_path, repo, github_token):
+    repo_url = f"https://{github_token}@github.com/{repo.full_name}.git"
+    repo = Repo(local_path)
+    if 'origin' in [remote.name for remote in repo.remotes]:
+        origin = repo.remote('origin')
+        origin.set_url(repo_url)
+    else:
+        origin = repo.create_remote('origin', repo_url)
+    origin.push(refspec='{}:{}'.format('master', 'master'))
+
+def main():
+    st.title("GitHub Repository Cloner and Uploader")
+    
+    # Sidebar instructions (unchanged)
+    st.sidebar.title("How to Get Your GitHub Token")
+    st.sidebar.markdown("""
+    1. Go to your GitHub account settings
+    2. Click on 'Developer settings' in the left sidebar
+    3. Click on 'Personal access tokens' and then 'Tokens (classic)'
+    4. Click 'Generate new token' and select 'Generate new token (classic)'
+    5. Give your token a descriptive name
+    6. Select the following scopes:
+       - repo (all)
+       - delete_repo
+    7. Click 'Generate token' at the bottom of the page
+    8. Copy your new token immediately (you won't be able to see it again!)
+    
+    **Important:** Keep your token secret and secure. Treat it like a password!
+    """)
+
+    # Input for source repository
+    source_repo = st.text_input("Source GitHub Repository URL", 
+                                value="https://github.com/AaronCWacker/AIExamples-8-24-Streamlit/")
+
+    # GitHub token input
+    github_token = os.environ.get("GITHUB")
+    if not github_token:
+        github_token = st.text_input("GitHub Personal Access Token", type="password",
+                                     help="Paste your GitHub token here. See sidebar for instructions on how to get it.")
+
+    if st.button("Clone and Upload"):
+        if not github_token:
+            st.error("Please enter a GitHub token. See the sidebar for instructions.")
+            return
+
+        with st.spinner("Processing..."):
+            try:
+                # Generate a date-stamped name
+                timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+                new_repo_name = f"AIExample-Clone-{timestamp}"
+                local_path = f"./temp_repo_{timestamp}"
+
+                # Download the source repository
+                download_github_repo(source_repo, local_path)
+
+                # Create a zip file
+                zip_filename = f"repo_contents_{timestamp}"
+                create_zip_file(local_path, zip_filename)
+
+                # Create the new repository
+                g = Github(github_token)
+                user = g.get_user()
+                new_repo = create_repo(g, new_repo_name)
+
+                # Push the contents to the new repository
+                push_to_github(local_path, new_repo, github_token)
+
+                # Clean up
+                shutil.rmtree(local_path)
+                os.remove(zip_filename + ".zip")
+
+                st.success(f"Repository cloned and uploaded successfully to {new_repo.html_url}!")
+
+            except Exception as e:
+                st.error(f"An error occurred: {str(e)}")
+            finally:
+                # Ensure cleanup even if an error occurs
+                if os.path.exists(local_path):
+                    shutil.rmtree(local_path)
+                if os.path.exists(zip_filename + ".zip"):
+                    os.remove(zip_filename + ".zip")
+
+if __name__ == "__main__":
+    main()