Upload 31 files

.gitattributes

@@ -1,35 +1,36 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+generated-icon.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,15 @@
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+.env
+.venv
+env/
+venv/
+
+# Streamlit
+.streamlit/secrets.toml
+
+# Miscellaneous
+.DS_Store

.replit

@@ -0,0 +1,39 @@
+modules = ["python-3.11"]
+
+[nix]
+channel = "stable-24_05"
+
+[deployment]
+deploymentTarget = "autoscale"
+run = ["sh", "-c", "streamlit run app.py"]
+
+[workflows]
+runButton = "Project"
+
+[[workflows.workflow]]
+name = "Project"
+mode = "parallel"
+author = "agent"
+
+[[workflows.workflow.tasks]]
+task = "workflow.run"
+args = "Streamlit App"
+
+[[workflows.workflow]]
+name = "Streamlit App"
+author = "agent"
+
+[workflows.workflow.metadata]
+agentRequireRestartOnSave = false
+
+[[workflows.workflow.tasks]]
+task = "packager.installForAll"
+
+[[workflows.workflow.tasks]]
+task = "shell.exec"
+args = "streamlit run app.py"
+waitForPort = 8501
+
+[[ports]]
+localPort = 8501
+externalPort = 80

.streamlit/config.toml

@@ -0,0 +1,12 @@
+
+[server]
+headless = true
+address = "0.0.0.0"
+port = 8501
+
+[theme]
+primaryColor = "#FFD21E"  # HF Yellow
+secondaryBackgroundColor = "#F0F2F6"
+backgroundColor = "#FFFFFF"  # White
+textColor = "#1A1A1A"  # Near black
+font = "sans serif"

.streamlit/styles.css

@@ -0,0 +1,363 @@
+/* Custom styles to match Hugging Face branding */
+
+@import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&family=Source+Sans+Pro:wght@400;600;700&display=swap');
+
+html, body, [class*="css"] {
+    font-family: 'Source Sans Pro', 'Inter', sans-serif;
+    font-size: 14px;
+}
+
+/* Primary buttons - HF Yellow */
+.stButton > button {
+    background-color: #FFD21E;
+    color: #1A1A1A;
+    border: none;
+    font-weight: 600;
+    padding: 0.5rem 1rem;
+    border-radius: 0.375rem;
+    transition: all 0.2s;
+    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.05);
+}
+
+.stButton > button:hover {
+    background-color: #E6BD1B;
+    color: #1A1A1A;
+    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+    transform: translateY(-1px);
+}
+
+.stButton > button:active {
+    transform: translateY(1px);
+    box-shadow: 0 1px 2px rgba(0, 0, 0, 0.1);
+}
+
+/* Secondary buttons - HF Blue */
+.secondary-button > button {
+    background-color: #84ADFF;
+    color: #1A1A1A;
+}
+
+.secondary-button > button:hover {
+    background-color: #6B8FE3;
+}
+
+/* Danger buttons - HF Coral */
+.danger-button > button {
+    background-color: #FF9D96;
+    color: #1A1A1A;
+}
+
+.danger-button > button:hover {
+    background-color: #E58A84;
+}
+
+/* Card styling */
+.hf-card {
+    background-color: #FFFFFF;
+    border-radius: 0.5rem;
+    padding: 1rem;
+    box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+    margin-bottom: 1rem;
+    border: 1px solid #E5E7EB;
+    transition: all 0.3s ease;
+}
+
+.hf-card:hover {
+    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
+    border-color: #84ADFF;
+    transform: translateY(-2px);
+}
+
+/* Links - HF Blue */
+a {
+    color: #84ADFF;
+    text-decoration: none;
+    transition: color 0.2s;
+}
+
+a:hover {
+    color: #6B8FE3;
+    text-decoration: underline;
+}
+
+/* Headers */
+h1, h2, h3, h4, h5, h6 {
+    font-family: 'Inter', sans-serif;
+    font-weight: 600;
+    color: #1A1A1A;
+    margin-top: 0.5em;
+    margin-bottom: 0.5em;
+}
+
+h1 {
+    font-size: 2rem;
+    border-bottom: 2px solid #FFD21E;
+    padding-bottom: 0.3em;
+    margin-bottom: 0.8em;
+    display: inline-block;
+}
+
+h2 {
+    font-size: 1.5rem;
+    border-bottom: 1px solid #E5E7EB;
+    padding-bottom: 0.2em;
+}
+
+/* Spacing */
+.spacing-16 {
+    margin: 16px 0;
+}
+
+/* Status indicators */
+.status-success {
+    color: #10B981;
+}
+
+.status-warning {
+    color: #FFD21E;
+}
+
+.status-error {
+    color: #FF9D96;
+}
+
+/* Sidebar styling */
+.css-1lcbmhc .css-1adrfps {
+    background-color: #F9FAFB;
+}
+
+section[data-testid="stSidebar"] {
+    background-color: #F9FAFB;
+    border-right: 1px solid #E5E7EB;
+}
+
+/* Custom progress bar */
+.stProgress > div > div > div > div {
+    background-color: #84ADFF;
+}
+
+/* Alert boxes */
+.st-emotion-cache-16idsys p {
+    font-size: 14px;
+}
+
+div[data-baseweb="tooltip"] {
+    background-color: #1A1A1A;
+    color: white;
+    padding: 8px 12px;
+    border-radius: 4px;
+    font-size: 12px;
+    max-width: 300px;
+    z-index: 1000;
+}
+
+/* Adjust sidebar width */
+section[data-testid="stSidebar"] {
+    width: 18rem !important;
+}
+
+/* Model cards layout */
+.model-card {
+    display: flex;
+    flex-direction: column;
+    gap: 8px;
+    padding: 16px;
+    border-radius: 8px;
+    border: 1px solid #E5E7EB;
+    background-color: white;
+    transition: all 0.3s ease;
+    position: relative;
+    overflow: hidden;
+}
+
+.model-card:hover {
+    border-color: #84ADFF;
+    box-shadow: 0 8px 16px rgba(0, 0, 0, 0.1);
+    transform: translateY(-3px);
+}
+
+.model-card::after {
+    content: '';
+    position: absolute;
+    top: 0;
+    left: 0;
+    width: 4px;
+    height: 100%;
+    background-color: #FFD21E;
+    opacity: 0;
+    transition: opacity 0.3s ease;
+}
+
+.model-card:hover::after {
+    opacity: 1;
+}
+
+.model-card-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+}
+
+.model-card-title {
+    font-weight: 600;
+    font-size: 1.1rem;
+    color: #1A1A1A;
+}
+
+.model-card-description {
+    color: #4B5563;
+    font-size: 0.9rem;
+    line-height: 1.4;
+}
+
+.model-card-footer {
+    display: flex;
+    justify-content: space-between;
+    margin-top: 12px;
+    align-items: center;
+}
+
+.model-card-tags {
+    display: flex;
+    gap: 8px;
+    flex-wrap: wrap;
+}
+
+.model-tag {
+    background-color: #F3F4F6;
+    padding: 4px 8px;
+    border-radius: 16px;
+    font-size: 0.8rem;
+    display: inline-flex;
+    align-items: center;
+    transition: background-color 0.2s;
+}
+
+.model-tag:hover {
+    background-color: #E5E7EB;
+}
+
+/* Badge styles */
+.badge {
+    display: inline-flex;
+    align-items: center;
+    padding: 4px 8px;
+    border-radius: 4px;
+    font-size: 0.8rem;
+    font-weight: 500;
+    margin-right: 8px;
+    transition: all 0.2s;
+}
+
+.github-badge {
+    background-color: #24292e;
+    color: white;
+}
+
+.hf-badge {
+    background-color: #FFD21E;
+    color: #1A1A1A;
+}
+
+.badge img {
+    height: 14px;
+    margin-right: 4px;
+}
+
+.badge:hover {
+    opacity: 0.9;
+    transform: translateY(-1px);
+}
+
+/* Tooltip container */
+.tooltip {
+    position: relative;
+    display: inline-block;
+    cursor: help;
+}
+
+.tooltip .tooltip-text {
+    visibility: hidden;
+    width: 200px;
+    background-color: #1A1A1A;
+    color: #fff;
+    text-align: center;
+    border-radius: 6px;
+    padding: 5px;
+    position: absolute;
+    z-index: 1;
+    bottom: 125%;
+    left: 50%;
+    margin-left: -100px;
+    opacity: 0;
+    transition: opacity 0.3s;
+    font-size: 12px;
+}
+
+.tooltip:hover .tooltip-text {
+    visibility: visible;
+    opacity: 1;
+}
+
+/* Instructions box */
+.instructions-box {
+    background-color: #F9FAFB;
+    border: 1px solid #E5E7EB;
+    border-left: 4px solid #84ADFF;
+    border-radius: 4px;
+    padding: 12px 16px;
+    margin-bottom: 16px;
+    font-size: 0.9rem;
+}
+
+.instructions-box h4 {
+    margin-top: 0;
+    margin-bottom: 8px;
+    color: #1A1A1A;
+}
+
+.instructions-box p {
+    margin: 0 0 8px 0;
+    color: #4B5563;
+}
+
+.instructions-box ul {
+    margin: 0;
+    padding-left: 20px;
+}
+
+/* Form inputs styling */
+.stTextInput > div > div > input {
+    border-radius: 4px;
+    border: 1px solid #E5E7EB;
+    padding: 8px 12px;
+    transition: all 0.2s;
+}
+
+.stTextInput > div > div > input:focus {
+    border-color: #84ADFF;
+    box-shadow: 0 0 0 3px rgba(132, 173, 255, 0.2);
+}
+
+.stTextArea > div > div > textarea {
+    border-radius: 4px;
+    border: 1px solid #E5E7EB;
+    padding: 8px 12px;
+    transition: all 0.2s;
+}
+
+.stTextArea > div > div > textarea:focus {
+    border-color: #84ADFF;
+    box-shadow: 0 0 0 3px rgba(132, 173, 255, 0.2);
+}
+
+/* Animation for loading states */
+@keyframes pulse {
+    0% { opacity: 1; }
+    50% { opacity: 0.6; }
+    100% { opacity: 1; }
+}
+
+.loading {
+    animation: pulse 1.5s infinite ease-in-out;
+}

README.md

@@ -1,13 +1,13 @@
----
-title: ModelHubManager
-emoji: 🐨
-colorFrom: purple
-colorTo: gray
-sdk: streamlit
-sdk_version: 1.43.1
-app_file: app.py
-pinned: false
-license: apache-2.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: ModelHubManager
+emoji: 🐨
+colorFrom: purple
+colorTo: gray
+sdk: streamlit
+sdk_version: 1.43.1
+app_file: app.py
+pinned: false
+license: apache-2.0
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,63 @@
+import streamlit as st
+import os
+from utils.auth import check_authentication, logout
+from components.sidebar import render_sidebar
+from pages.home import render_home
+from pages.model_details import render_model_details
+from pages.repository_management import render_repository_management
+from pages.analytics import render_analytics_page # Added import for analytics page
+from pages.batch_operations import render_batch_operations # Added import for batch operations page
+
+# Set page configuration
+st.set_page_config(
+    page_title="HF Model Manager",
+    page_icon="🤗",
+    layout="wide",
+    initial_sidebar_state="expanded",
+)
+
+# Apply custom CSS
+with open(".streamlit/styles.css") as f:
+    st.markdown(f"<style>{f.read()}</style>", unsafe_allow_html=True)
+
+# Initialize session state
+if "authenticated" not in st.session_state:
+    st.session_state.authenticated = False
+if "page" not in st.session_state:
+    st.session_state.page = "home"
+if "selected_model" not in st.session_state:
+    st.session_state.selected_model = None
+if "models" not in st.session_state:
+    st.session_state.models = []
+if "api_token" not in st.session_state:
+    st.session_state.api_token = None
+
+
+def main():
+    # Check authentication
+    if not st.session_state.authenticated:
+        check_authentication()
+    else:
+        # Render sidebar
+        render_sidebar()
+
+        # Render selected page
+        if st.session_state.page == "home":
+            render_home()
+        elif st.session_state.page == "model_details":
+            render_model_details()
+        elif st.session_state.page == "repository_management":
+            render_repository_management()
+        elif st.session_state.page == "analytics":
+            render_analytics_page()
+        elif st.session_state.page == "batch_operations": # Added routing for batch operations page
+            render_batch_operations()
+
+
+if __name__ == "__main__":
+    # Check if we have the Hugging Face token in secrets
+    if not st.session_state.get("api_token") and os.environ.get("HF_TOKEN"):
+        st.session_state.api_token = os.environ.get("HF_TOKEN")
+        st.rerun()
+
+    main()

attached_assets/Pasted-Project-Overview-Web-Based-Model-Management-Interface-with-Streamlit-A-web-based-model-management-i-1741430507133.txt

@@ -0,0 +1,46 @@
+Project Overview: Web-Based Model Management Interface with Streamlit
+A web-based model management interface built with Streamlit to interact with Hugging Face's ecosystem, enabling developers to efficiently manage their machine learning models through an intuitive, streamlined interface.
+
+Core Features:
+Create and manage model repositories: Easily create and maintain repositories for machine learning models with an intuitive interface.
+Interface with Hugging Face APIs: Seamlessly integrate with Hugging Face APIs to upload, update, and query model metadata.
+Push models to Hugging Face Model Hub: Directly push models to the Hugging Face Model Hub, making them accessible to the global ML community.
+Interactive model management interface: An interactive UI that allows users to add, update, and delete models, with the ability to view model details and manage associated metadata.
+Tech Stack:
+Frontend:
+Streamlit: Used for building the interactive UI, enabling rapid development of web applications.
+Tailwind CSS: For streamlined styling, ensuring that the app remains visually appealing and consistent with the Hugging Face aesthetic.
+Backend:
+Hugging Face API: To interact with the Hugging Face ecosystem, enabling model pushes and metadata management.
+Python: The backend logic for managing requests to Hugging Face APIs is implemented in Python.
+Database:
+Optionally, integrate a database like PostgreSQL or SQLite for persistent storage of model metadata.
+Visual References:
+Inspired by Hugging Face's Model Hub interface and Streamlit's clean app layouts, known for their developer-friendly and intuitive design.
+Hugging Face’s interface for managing models is simple yet feature-packed.
+Streamlit’s clean, minimalistic design will allow for quick interactions without distractions.
+Style Guide:
+Colors:
+Primary: #FFD21E (HF Yellow) – for key action buttons and highlights.
+Secondary: #84ADFF (HF Blue) – used for navigation, links, and headers.
+Background: #FFFFFF (white) – ensuring the app is light and easy on the eyes.
+Text: #1A1A1A (near black) – for readability and contrast.
+Accent: #FF9D96 (HF Coral) – for alerts, error messages, and secondary buttons.
+Design:
+Fonts: Source Sans Pro/Inter fonts – for clear and modern typography.
+Layout: Clean, single-column layout with consistent 16px spacing between elements.
+Components: Card-based components to display model information, making it easy to view and manage data.
+Responsive Design: Optimized for desktop workflows with mobile compatibility.
+Tech Specifications:
+Framework: Streamlit (Streamlit version 1.13.0 or above)
+API Integration: Hugging Face Model Hub API for repository management
+Hosting: Hugging Face Spaces (for deployment) or Heroku/Render for backend deployment
+Database: (Optional) Use SQLite for local storage or PostgreSQL for more robust database management
+Version Control: Git for version control and collaboration
+Frontend: Tailwind CSS for styling and layout management
+Backend Logic: Python for backend logic and integration with Hugging Face APIs
+Streamlit Features:
+Dynamic UI: Allows users to interact with form elements like text inputs, dropdowns, buttons, and file uploads for managing models.
+Data Display: Use of tables, cards, and lists to display model information dynamically.
+API Calls: Directly interact with Hugging Face APIs to push models, fetch metadata, and manage repositories without leaving the interface.
+Interactivity: Real-time updates based on user input, creating a seamless experience for users to create and manage models.

components/__init__.py

@@ -0,0 +1 @@
+# This file is intentionally left empty to make the directory a Python package

components/create_repository.py

@@ -0,0 +1,143 @@
+import streamlit as st
+import time
+
+
+def create_repository_form():
+    """Form for creating a new model repository"""
+    st.subheader("Create a New Model Repository")
+
+    with st.form("create_repo_form"):
+        # Repository name input
+        st.markdown("#### Repository Name")
+        repo_name = st.text_input(
+            "Enter a name for your repository",
+            help="This will be part of the URL: huggingface.co/username/repository-name",
+            placeholder="my-awesome-model",
+            key="repo_name_input",
+        )
+
+        # Repository visibility
+        st.markdown("#### Repository Visibility")
+        is_private = st.checkbox(
+            "Make repository private",
+            value=False,
+            help="Private repositories are only visible to you and collaborators",
+        )
+
+        # Repository type
+        st.markdown("#### Repository Type")
+        repo_type = st.selectbox(
+            "Select repository type",
+            options=["model", "dataset", "space"],
+            index=0,
+            help="The type of content you'll be storing in this repository",
+        )
+
+        # Model tags
+        st.markdown("#### Model Tags")
+        if "client" in st.session_state:
+            available_tags = st.session_state.client.get_model_tags()
+            selected_tags = st.multiselect(
+                "Select tags for your model",
+                options=available_tags,
+                help="Tags help others discover your model",
+            )
+
+        # Model description
+        st.markdown("#### Description")
+        description = st.text_area(
+            "Provide a brief description of your model",
+            placeholder="This model is designed for...",
+            help="This will appear on your model card and help others understand your model's purpose",
+        )
+
+        # Submit button
+        submitted = st.form_submit_button("Create Repository", use_container_width=True)
+
+        if submitted:
+            if not repo_name:
+                st.error("Repository name is required")
+                return False, None
+
+            # Validate repository name (alphanumeric with hyphens only)
+            if not all(c.isalnum() or c == "-" for c in repo_name):
+                st.error(
+                    "Repository name can only contain letters, numbers, and hyphens"
+                )
+                return False, None
+
+            # Create the repository
+            with st.spinner("Creating repository..."):
+                try:
+                    # Format the repo_id with username
+                    username = st.session_state.username
+                    repo_id = f"{username}/{repo_name}"
+
+                    # Create the repository
+                    success, response = st.session_state.client.create_model_repository(
+                        repo_name=repo_id,
+                        is_private=is_private,
+                        exist_ok=False,
+                        repo_type=repo_type,
+                    )
+
+                    if success:
+                        # Create a basic model card with description and tags
+                        model_card_content = f"""---
+tags:
+{chr(10).join(['- ' + tag for tag in selected_tags])}
+---
+
+# {repo_name}
+
+{description}
+
+## Model description
+
+Add more details about your model here.
+
+## Intended uses & limitations
+
+Describe the intended uses of your model and any limitations.
+
+## Training and evaluation data
+
+Describe the data you used to train and evaluate your model.
+
+## Training procedure
+
+Describe the training procedure.
+
+## Evaluation results
+
+Provide evaluation results.
+"""
+                        # Update the model card
+                        card_success, _ = st.session_state.client.update_model_card(
+                            repo_id, model_card_content
+                        )
+
+                        if card_success:
+                            st.success(f"Repository '{repo_id}' created successfully!")
+
+                            # Update the models list
+                            time.sleep(1)  # Wait briefly for the API to update
+                            st.session_state.models = (
+                                st.session_state.client.get_user_models()
+                            )
+
+                            return True, repo_id
+                        else:
+                            st.warning(
+                                "Repository created but failed to update model card."
+                            )
+                            return True, repo_id
+                    else:
+                        st.error(f"Failed to create repository: {response}")
+                        return False, None
+
+                except Exception as e:
+                    st.error(f"Error creating repository: {str(e)}")
+                    return False, None
+
+    return False, None

components/documentation_generator.py

@@ -0,0 +1,348 @@
+
+import streamlit as st
+import re
+import json
+import time
+
+def model_documentation_generator(model_info):
+    """Generate comprehensive model documentation based on metadata"""
+    if not model_info:
+        st.error("Model information not found")
+        return
+    
+    st.subheader("🔄 Automated Model Documentation Generator")
+    st.markdown("This tool generates a comprehensive model card based on model metadata and your input.")
+    
+    # Extract existing model card content if available
+    model_card_content = ""
+    yaml_content = ""
+    markdown_content = ""
+    try:
+        repo_id = model_info.modelId
+        model_card_url = f"https://huggingface.co/{repo_id}/raw/main/README.md"
+        response = st.session_state.client.api._get_paginated(model_card_url)
+        if response.status_code == 200:
+            model_card_content = response.text
+            
+            # Extract YAML frontmatter
+            yaml_match = re.search(r"---\s+(.*?)\s+---", model_card_content, re.DOTALL)
+            if yaml_match:
+                yaml_content = yaml_match.group(1)
+                
+                # Extract markdown content (everything after frontmatter)
+                markdown_match = re.search(r"---\s+.*?\s+---\s*(.*)", model_card_content, re.DOTALL)
+                if markdown_match:
+                    markdown_content = markdown_match.group(1).strip()
+    except Exception as e:
+        st.warning(f"Couldn't load model card: {str(e)}")
+    
+    # Form for model metadata input
+    with st.form("model_doc_form"):
+        st.markdown("### Model Metadata")
+        
+        # Basic Information
+        st.markdown("#### Basic Information")
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            # Extract model name from repo ID
+            model_name = model_info.modelId.split("/")[-1]
+            model_title = st.text_input("Model Title", value=model_name.replace("-", " ").title())
+        
+        with col2:
+            # Model type selection
+            model_type_options = [
+                "Text Classification", 
+                "Token Classification", 
+                "Question Answering", 
+                "Summarization", 
+                "Translation", 
+                "Text Generation", 
+                "Image Classification", 
+                "Object Detection", 
+                "Other"
+            ]
+            
+            # Try to determine model type from tags
+            default_type_index = 0
+            tags = getattr(model_info, "tags", [])
+            for i, option in enumerate(model_type_options):
+                option_key = option.lower().replace(" ", "-")
+                if option_key in tags or option_key.replace("-", "_") in tags:
+                    default_type_index = i
+                    break
+            
+            model_type = st.selectbox(
+                "Model Type", 
+                model_type_options,
+                index=default_type_index
+            )
+        
+        # Model description
+        description = st.text_area(
+            "Model Description", 
+            value=getattr(model_info, "description", "") or "",
+            height=100,
+            help="A brief overview of what the model does"
+        )
+        
+        # Technical Information
+        st.markdown("#### Technical Information")
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            # Model Architecture
+            architecture_options = [
+                "BERT", "GPT-2", "T5", "RoBERTa", "DeBERTa", "DistilBERT", 
+                "BART", "ResNet", "YOLO", "Other"
+            ]
+            architecture = st.selectbox("Model Architecture", architecture_options)
+            
+            # Framework
+            framework_options = ["PyTorch", "TensorFlow", "JAX", "Other"]
+            framework = st.selectbox("Framework", framework_options)
+        
+        with col2:
+            # Model size
+            model_size = st.text_input("Model Size (e.g., 110M parameters)")
+            
+            # Language
+            language_options = ["English", "French", "German", "Spanish", "Chinese", "Japanese", "Multilingual", "Other"]
+            language = st.selectbox("Language", language_options)
+        
+        # Training Information
+        st.markdown("#### Training Information")
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            # Training Dataset
+            training_data = st.text_input("Training Dataset(s)")
+            
+            # Training compute
+            training_compute = st.text_input("Training Infrastructure (e.g., TPU v3-8, 4x A100)")
+        
+        with col2:
+            # Evaluation Dataset
+            eval_data = st.text_input("Evaluation Dataset(s)")
+            
+            # Training time
+            training_time = st.text_input("Training Time (e.g., 3 days, 12 hours)")
+        
+        # Performance Metrics
+        st.markdown("#### Performance Metrics")
+        
+        metrics_data = st.text_area(
+            "Performance Metrics (one per line, e.g., 'Accuracy: 0.92')",
+            height=100,
+            help="Key metrics and their values"
+        )
+        
+        # Limitations
+        st.markdown("#### Limitations and Biases")
+        
+        limitations = st.text_area(
+            "Known Limitations and Biases",
+            height=100,
+            help="Document any known limitations, biases, or ethical considerations"
+        )
+        
+        # Usage Information
+        st.markdown("#### Usage Information")
+        
+        use_cases = st.text_area(
+            "Intended Use Cases",
+            height=100,
+            help="Describe how the model should be used"
+        )
+        
+        code_example = st.text_area(
+            "Code Example",
+            height=150,
+            value=f"""
+```python
+from transformers import AutoTokenizer, AutoModel
+
+tokenizer = AutoTokenizer.from_pretrained("{model_info.modelId}")
+model = AutoModel.from_pretrained("{model_info.modelId}")
+
+inputs = tokenizer("Hello, world!", return_tensors="pt")
+outputs = model(**inputs)
+```
+            """,
+            help="Provide a simple code example showing how to use the model"
+        )
+        
+        # License and Citation
+        st.markdown("#### License and Citation")
+        
+        license_options = ["MIT", "Apache-2.0", "GPL-3.0", "CC-BY-SA-4.0", "CC-BY-4.0", "Proprietary", "Other"]
+        license_type = st.selectbox("License", license_options)
+        
+        citation = st.text_area(
+            "Citation Information",
+            height=100,
+            help="Provide citation information if applicable"
+        )
+        
+        # Tags
+        st.markdown("#### Tags")
+        
+        # Get available tags
+        available_tags = st.session_state.client.get_model_tags()
+        
+        # Extract existing tags
+        existing_tags = []
+        if yaml_content:
+            tags_match = re.search(r"tags:\s*((?:- .*?\n)+)", yaml_content, re.DOTALL)
+            if tags_match:
+                existing_tags = [
+                    line.strip("- \n")
+                    for line in tags_match.group(1).split("\n")
+                    if line.strip().startswith("-")
+                ]
+        
+        selected_tags = st.multiselect(
+            "Select tags for your model",
+            options=available_tags,
+            default=existing_tags,
+            help="Tags help others discover your model"
+        )
+        
+        # Advanced options
+        with st.expander("Advanced Options"):
+            keep_existing_content = st.checkbox(
+                "Keep existing custom content",
+                value=True,
+                help="If checked, we'll try to preserve custom sections from your existing model card"
+            )
+            
+            additional_sections = st.text_area(
+                "Additional Custom Sections (in Markdown)",
+                height=200,
+                help="Add any additional custom sections in Markdown format"
+            )
+        
+        # Submit button
+        submitted = st.form_submit_button("Generate Model Card", use_container_width=True)
+        
+        if submitted:
+            with st.spinner("Generating comprehensive model card..."):
+                try:
+                    # Parse performance metrics
+                    metrics_list = []
+                    for line in metrics_data.split("\n"):
+                        line = line.strip()
+                        if line:
+                            metrics_list.append(line)
+                    
+                    # Generate YAML frontmatter
+                    yaml_frontmatter = f"""tags:
+{chr(10).join(['- ' + tag for tag in selected_tags])}
+license: {license_type}"""
+                    
+                    if language and language != "Other":
+                        yaml_frontmatter += f"\nlanguage: {language.lower()}"
+                    
+                    if model_type and model_type != "Other":
+                        yaml_frontmatter += f"\npipeline_tag: {model_type.lower().replace(' ', '-')}"
+                    
+                    # Generate markdown content
+                    md_content = f"""# {model_title}
+
+{description}
+
+## Model Description
+
+This model is a {architecture}-based model for {model_type} tasks. It was developed using {framework} and consists of {model_size if model_size else "multiple"} parameters.
+
+"""
+                    
+                    # Training section
+                    if training_data or eval_data or training_compute or training_time:
+                        md_content += "## Training and Evaluation Data\n\n"
+                        
+                        if training_data:
+                            md_content += f"The model was trained on {training_data}. "
+                        
+                        if training_compute:
+                            md_content += f"Training was performed using {training_compute}. "
+                        
+                        if training_time:
+                            md_content += f"The total training time was approximately {training_time}."
+                        
+                        md_content += "\n\n"
+                        
+                        if eval_data:
+                            md_content += f"Evaluation was performed on {eval_data}.\n\n"
+                    
+                    # Performance metrics
+                    if metrics_list:
+                        md_content += "## Model Performance\n\n"
+                        md_content += "The model achieves the following performance metrics:\n\n"
+                        for metric in metrics_list:
+                            md_content += f"- {metric}\n"
+                        md_content += "\n"
+                    
+                    # Limitations
+                    if limitations:
+                        md_content += "## Limitations and Biases\n\n"
+                        md_content += f"{limitations}\n\n"
+                    
+                    # Usage
+                    if use_cases:
+                        md_content += "## Intended Uses & Limitations\n\n"
+                        md_content += f"{use_cases}\n\n"
+                    
+                    # Code example
+                    if code_example:
+                        md_content += "## How to Use\n\n"
+                        md_content += "Here's an example of how to use this model:\n\n"
+                        md_content += f"{code_example}\n\n"
+                    
+                    # Citation
+                    if citation:
+                        md_content += "## Citation\n\n"
+                        md_content += f"{citation}\n\n"
+                    
+                    # Keep existing custom content if requested
+                    if keep_existing_content and markdown_content:
+                        # Try to extract sections we haven't covered
+                        existing_sections = re.findall(r"^## (.+?)\n\n(.*?)(?=^## |\Z)", markdown_content, re.MULTILINE | re.DOTALL)
+                        standard_sections = ["Model Description", "Training and Evaluation Data", "Model Performance", 
+                                            "Limitations and Biases", "Intended Uses & Limitations", "How to Use", "Citation"]
+                        
+                        for section_title, section_content in existing_sections:
+                            if section_title.strip() not in standard_sections:
+                                md_content += f"## {section_title}\n\n{section_content}\n\n"
+                    
+                    # Add additional custom sections
+                    if additional_sections:
+                        md_content += f"\n{additional_sections}\n"
+                    
+                    # Combine everything into the final model card
+                    final_model_card = f"---\n{yaml_frontmatter}\n---\n\n{md_content.strip()}"
+                    
+                    # Display the generated model card
+                    st.markdown("### Generated Model Card")
+                    st.code(final_model_card, language="markdown")
+                    
+                    # Option to update the model card
+                    if st.button("Update Model Card", use_container_width=True, type="primary"):
+                        with st.spinner("Updating model card..."):
+                            try:
+                                # Update the model card
+                                success, _ = st.session_state.client.update_model_card(
+                                    model_info.modelId, final_model_card
+                                )
+                                
+                                if success:
+                                    st.success("Model card updated successfully!")
+                                    time.sleep(1)  # Give API time to update
+                                    st.rerun()
+                                else:
+                                    st.error("Failed to update model card")
+                            except Exception as e:
+                                st.error(f"Error updating model card: {str(e)}")
+                    
+                except Exception as e:
+                    st.error(f"Error generating model card: {str(e)}")

components/edit_model.py

@@ -0,0 +1,155 @@
+import streamlit as st
+import re
+
+
+def edit_model_form(model_info):
+    """Form for editing model metadata"""
+    st.subheader("Edit Model Information")
+
+    if not model_info:
+        st.error("Model information not found")
+        return False, None
+
+    # Extract model card content (README.md) if available
+    model_card_content = ""
+    try:
+        repo_id = model_info.modelId
+        model_card_url = f"https://huggingface.co/{repo_id}/raw/main/README.md"
+        response = st.session_state.client.api._get_paginated(model_card_url)
+        if response.status_code == 200:
+            model_card_content = response.text
+    except Exception as e:
+        st.warning(f"Couldn't load model card: {str(e)}")
+
+    # Extract tags from model card
+    tags = []
+    if model_card_content:
+        # Look for tags section in YAML frontmatter
+        yaml_match = re.search(r"---\s+(.*?)\s+---", model_card_content, re.DOTALL)
+        if yaml_match:
+            yaml_content = yaml_match.group(1)
+            tags_match = re.search(r"tags:\s*((?:- .*?\n)+)", yaml_content, re.DOTALL)
+            if tags_match:
+                tags_content = tags_match.group(1)
+                tags = [
+                    line.strip("- \n")
+                    for line in tags_content.split("\n")
+                    if line.strip().startswith("-")
+                ]
+
+    # Extract description (first paragraph after the title)
+    description = ""
+    if model_card_content:
+        # Find content after title and before next heading
+        title_match = re.search(
+            r"# .*?\n\n(.*?)(?=\n## |\Z)", model_card_content, re.DOTALL
+        )
+        if title_match:
+            description = title_match.group(1).strip()
+
+    with st.form("edit_model_form"):
+        # Model tags
+        st.markdown("#### Model Tags")
+        available_tags = st.session_state.client.get_model_tags()
+        selected_tags = st.multiselect(
+            "Select tags for your model",
+            options=available_tags,
+            default=tags,
+            help="Tags help others discover your model",
+        )
+
+        # Model description
+        st.markdown("#### Description")
+        updated_description = st.text_area(
+            "Provide a brief description of your model",
+            value=description,
+            help="This will appear on your model card and help others understand your model's purpose",
+        )
+
+        # Full model card content (for advanced users)
+        st.markdown("#### Full Model Card (Markdown)")
+        st.markdown(
+            "Edit the full model card content if needed. This is in Markdown format."
+        )
+        updated_model_card = st.text_area(
+            "Model Card Content", value=model_card_content, height=300
+        )
+
+        # Submit button
+        submitted = st.form_submit_button(
+            "Update Model Information", use_container_width=True
+        )
+
+        if submitted:
+            # Update the model card
+            with st.spinner("Updating model information..."):
+                try:
+                    repo_id = model_info.modelId
+
+                    # If the user has edited the full model card, use that
+                    if updated_model_card != model_card_content:
+                        new_content = updated_model_card
+                    else:
+                        # Otherwise, update only tags and description in the existing card
+                        # Update tags in YAML frontmatter
+                        if yaml_match:
+                            yaml_content = yaml_match.group(1)
+                            if tags_match:
+                                # Replace tags section
+                                new_yaml = yaml_content.replace(
+                                    tags_match.group(0),
+                                    f"tags:\n"
+                                    + "\n".join([f"- {tag}" for tag in selected_tags])
+                                    + "\n",
+                                )
+                            else:
+                                # Add tags section
+                                new_yaml = (
+                                    yaml_content
+                                    + f"\ntags:\n"
+                                    + "\n".join([f"- {tag}" for tag in selected_tags])
+                                    + "\n"
+                                )
+
+                            new_content = model_card_content.replace(
+                                yaml_match.group(0), f"---\n{new_yaml}---"
+                            )
+                        else:
+                            # Add YAML frontmatter with tags
+                            tags_yaml = (
+                                "---\ntags:\n"
+                                + "\n".join([f"- {tag}" for tag in selected_tags])
+                                + "\n---\n\n"
+                            )
+                            new_content = tags_yaml + model_card_content
+
+                        # Update description
+                        if title_match and updated_description != description:
+                            new_content = new_content.replace(
+                                title_match.group(0),
+                                title_match.group(0).replace(
+                                    description, updated_description
+                                ),
+                            )
+
+                    # Update the model card
+                    success, _ = st.session_state.client.update_model_card(
+                        repo_id, new_content
+                    )
+
+                    if success:
+                        st.success("Model information updated successfully!")
+                        # Refresh the models list
+                        st.session_state.models = (
+                            st.session_state.client.get_user_models()
+                        )
+                        return True, repo_id
+                    else:
+                        st.error("Failed to update model information")
+                        return False, None
+
+                except Exception as e:
+                    st.error(f"Error updating model information: {str(e)}")
+                    return False, None
+
+    return False, None

components/model_card.py

@@ -0,0 +1,147 @@
+import streamlit as st
+import datetime
+
+
+def model_list(models, on_select_callback):
+    """Render a list of model cards with enhanced UI and metadata badges"""
+    if not models:
+        st.info("No models found. Create your first repository to get started!")
+        return
+
+    # Display the models in a grid
+    cols = st.columns(2)
+
+    for i, model in enumerate(models):
+        with cols[i % 2]:
+            with st.container():
+                st.markdown(
+                    f"""
+                    <div class="model-card">
+                        <div class="model-card-header">
+                            <div class="model-card-title">{model.modelId}</div>
+                            <div>
+                                <span class="badge hf-badge">
+                                    <img src="https://huggingface.co/front/assets/huggingface_logo-noborder.svg" alt="HF">
+                                    HF
+                                </span>
+                                <span class="tooltip">
+                                    ℹ️
+                                    <span class="tooltip-text">Last updated: {datetime.datetime.now().strftime("%Y-%m-%d")}</span>
+                                </span>
+                            </div>
+                        </div>
+                        <div class="model-card-description">
+                            {getattr(model, 'description', 'No description available.') or 'No description available.'}
+                        </div>
+                        <div class="model-card-footer">
+                            <div class="model-card-tags">
+                                {generate_tags(model)}
+                            </div>
+                            <div>
+                                <span style="color: #6B7280; font-size: 0.8rem; margin-right: 8px;">
+                                    <span title="Downloads">📥 {getattr(model, 'downloads', 0)}</span>
+                                </span>
+                                <span style="color: #6B7280; font-size: 0.8rem;">
+                                    <span title="Likes">❤️ {getattr(model, 'likes', 0)}</span>
+                                </span>
+                            </div>
+                        </div>
+                    </div>
+                    """,
+                    unsafe_allow_html=True,
+                )
+                # Button to select model below the card
+                if st.button(
+                    f"View Details",
+                    key=f"view_{model.modelId}",
+                    use_container_width=True,
+                ):
+                    on_select_callback(model.modelId)
+
+
+def generate_tags(model):
+    """Generate HTML for model tags"""
+    tags = getattr(model, "tags", []) or []
+    if not tags:
+        tags = ["untagged"]
+
+    tags_html = ""
+    for tag in tags[:3]:  # Limit to 3 tags to avoid clutter
+        tags_html += f'<span class="model-tag">{tag}</span>'
+
+    if len(tags) > 3:
+        tags_html += f'<span class="model-tag">+{len(tags) - 3} more</span>'
+
+    return tags_html
+
+
+def model_detail_card(model):
+    """Render a detailed model card with badges, stats, and actions"""
+    st.markdown(
+        f"""
+        <div class="hf-card" style="padding: 20px; margin-bottom: 24px;">
+            <div style="display: flex; justify-content: space-between; align-items: flex-start; margin-bottom: 16px;">
+                <div>
+                    <h2 style="margin-top: 0; margin-bottom: 8px;">{model.modelId}</h2>
+                    <div style="display: flex; gap: 8px; margin-bottom: 16px;">
+                        <a href="https://huggingface.co/{st.session_state.username}/{model.modelId}" target="_blank" class="badge hf-badge">
+                            <img src="https://huggingface.co/front/assets/huggingface_logo-noborder.svg" alt="HF">
+                            View on Hugging Face
+                        </a>
+                        <a href="#" class="badge github-badge">
+                            <img src="https://github.githubassets.com/images/modules/logos_page/GitHub-Mark.png" alt="GitHub">
+                            View on GitHub
+                        </a>
+                    </div>
+                </div>
+                <div style="display: flex; gap: 8px; align-items: center;">
+                    <span title="Downloads" class="tooltip">
+                        📥 {getattr(model, 'downloads', 0)}
+                        <span class="tooltip-text">Total downloads</span>
+                    </span>
+                    <span title="Likes" class="tooltip">
+                        ❤️ {getattr(model, 'likes', 0)}
+                        <span class="tooltip-text">Total likes</span>
+                    </span>
+                </div>
+            </div>
+            
+            <div style="margin-bottom: 16px;">
+                <h4 style="margin-bottom: 4px;">Description</h4>
+                <p>{getattr(model, 'description', 'No description available.') or 'No description available.'}</p>
+            </div>
+            
+            <div style="margin-bottom: 16px;">
+                <h4 style="margin-bottom: 4px;">Tags</h4>
+                <div style="display: flex; flex-wrap: wrap; gap: 8px;">
+                    {generate_detailed_tags(model)}
+                </div>
+            </div>
+            
+            <div style="display: grid; grid-template-columns: 1fr 1fr; gap: 16px; margin-bottom: 16px;">
+                <div>
+                    <h4 style="margin-bottom: 4px;">Last Updated</h4>
+                    <p>{datetime.datetime.now().strftime("%B %d, %Y")}</p>
+                </div>
+                <div>
+                    <h4 style="margin-bottom: 4px;">Model Size</h4>
+                    <p>{getattr(model, 'size', 'Unknown')} MB</p>
+                </div>
+            </div>
+        </div>
+        """,
+        unsafe_allow_html=True,
+    )
+
+
+def generate_detailed_tags(model):
+    """Generate HTML for detailed model tags view"""
+    tags = getattr(model, "tags", []) or []
+    if not tags:
+        return '<span class="model-tag">untagged</span>'
+
+    tags_html = ""
+    for tag in tags:
+        tags_html += f'<span class="model-tag">{tag}</span>'
+
+    return tags_html

components/model_inference.py

@@ -0,0 +1,378 @@
+
+import streamlit as st
+import json
+import pandas as pd
+import numpy as np
+import plotly.express as px
+from io import StringIO
+import time
+
+def model_inference_dashboard(model_info):
+    """Create a dashboard for testing model inference directly in the app"""
+    if not model_info:
+        st.error("Model information not found")
+        return
+    
+    st.subheader("🧠 Model Inference Dashboard")
+    
+    # Get the pipeline type based on model tags or information
+    pipeline_tag = getattr(model_info, "pipeline_tag", None)
+    if not pipeline_tag:
+        # Try to determine from tags
+        tags = getattr(model_info, "tags", [])
+        for tag in tags:
+            if tag in [
+                "text-classification", "token-classification", "question-answering",
+                "summarization", "translation", "text-generation", "fill-mask",
+                "sentence-similarity", "image-classification", "object-detection",
+                "image-segmentation", "text-to-image", "image-to-text"
+            ]:
+                pipeline_tag = tag
+                break
+        
+        if not pipeline_tag:
+            pipeline_tag = "text-classification"  # Default fallback
+    
+    # Display information about the model
+    st.info(f"This dashboard allows you to test your model's inference capabilities. Model pipeline: **{pipeline_tag}**")
+    
+    # Different input options based on pipeline type
+    input_data = None
+    
+    if pipeline_tag in ["text-classification", "token-classification", "fill-mask", "text-generation", "summarization"]:
+        # Text-based input
+        st.markdown("### Text Input")
+        input_text = st.text_area(
+            "Enter text for inference",
+            value="This model is amazing!",
+            height=150
+        )
+        
+        # Additional parameters for specific pipelines
+        if pipeline_tag == "text-generation":
+            col1, col2 = st.columns(2)
+            with col1:
+                max_length = st.slider("Max Length", min_value=10, max_value=500, value=100)
+            with col2:
+                temperature = st.slider("Temperature", min_value=0.1, max_value=2.0, value=1.0, step=0.1)
+            
+            input_data = {
+                "text": input_text,
+                "max_length": max_length,
+                "temperature": temperature
+            }
+        elif pipeline_tag == "summarization":
+            max_length = st.slider("Max Summary Length", min_value=10, max_value=200, value=50)
+            input_data = {
+                "text": input_text,
+                "max_length": max_length
+            }
+        else:
+            input_data = {"text": input_text}
+    
+    elif pipeline_tag in ["question-answering"]:
+        st.markdown("### Question & Context")
+        question = st.text_input("Question", value="What is this model about?")
+        context = st.text_area(
+            "Context", 
+            value="This model is a transformer-based language model designed for natural language understanding tasks.",
+            height=150
+        )
+        input_data = {
+            "question": question,
+            "context": context
+        }
+    
+    elif pipeline_tag in ["translation"]:
+        st.markdown("### Translation")
+        source_lang = st.selectbox("Source Language", ["English", "French", "German", "Spanish", "Chinese"])
+        target_lang = st.selectbox("Target Language", ["French", "English", "German", "Spanish", "Chinese"])
+        translation_text = st.text_area("Text to translate", value="Hello, how are you?", height=150)
+        input_data = {
+            "text": translation_text,
+            "source_language": source_lang,
+            "target_language": target_lang
+        }
+    
+    elif pipeline_tag in ["image-classification", "object-detection", "image-segmentation"]:
+        st.markdown("### Image Input")
+        upload_method = st.radio("Select input method", ["Upload Image", "Image URL"])
+        
+        if upload_method == "Upload Image":
+            uploaded_file = st.file_uploader("Upload an image", type=["jpg", "jpeg", "png"])
+            if uploaded_file is not None:
+                st.image(uploaded_file, caption="Uploaded Image", use_column_width=True)
+                input_data = {"image": uploaded_file}
+        else:
+            image_url = st.text_input("Image URL", value="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/distilbert-base-uncased-finetuned-sst-2-english-architecture.png")
+            if image_url:
+                st.image(image_url, caption="Image from URL", use_column_width=True)
+                input_data = {"image_url": image_url}
+    
+    elif pipeline_tag in ["audio-classification", "automatic-speech-recognition"]:
+        st.markdown("### Audio Input")
+        upload_method = st.radio("Select input method", ["Upload Audio", "Audio URL"])
+        
+        if upload_method == "Upload Audio":
+            uploaded_file = st.file_uploader("Upload an audio file", type=["mp3", "wav", "ogg"])
+            if uploaded_file is not None:
+                st.audio(uploaded_file)
+                input_data = {"audio": uploaded_file}
+        else:
+            audio_url = st.text_input("Audio URL")
+            if audio_url:
+                st.audio(audio_url)
+                input_data = {"audio_url": audio_url}
+    
+    # Execute inference
+    if st.button("Run Inference", use_container_width=True):
+        if input_data:
+            with st.spinner("Running inference..."):
+                # In a real implementation, this would call the HF Inference API
+                # For demo purposes, simulate a response
+                time.sleep(2)
+                
+                # Generate a sample response based on the pipeline type
+                if pipeline_tag == "text-classification":
+                    result = [
+                        {"label": "POSITIVE", "score": 0.9231},
+                        {"label": "NEGATIVE", "score": 0.0769}
+                    ]
+                elif pipeline_tag == "token-classification":
+                    result = [
+                        {"entity": "B-PER", "word": "This", "score": 0.2, "index": 0, "start": 0, "end": 4},
+                        {"entity": "O", "word": "model", "score": 0.95, "index": 1, "start": 5, "end": 10},
+                        {"entity": "O", "word": "is", "score": 0.99, "index": 2, "start": 11, "end": 13},
+                        {"entity": "B-MISC", "word": "amazing", "score": 0.85, "index": 3, "start": 14, "end": 21}
+                    ]
+                elif pipeline_tag == "text-generation":
+                    result = {
+                        "generated_text": input_data["text"] + " It provides state-of-the-art performance on a wide range of natural language processing tasks, including sentiment analysis, named entity recognition, and question answering. The model was trained on a diverse corpus of text data, allowing it to generate coherent and contextually relevant responses."
+                    }
+                elif pipeline_tag == "summarization":
+                    result = {
+                        "summary_text": "This model provides excellent performance."
+                    }
+                elif pipeline_tag == "question-answering":
+                    result = {
+                        "answer": "a transformer-based language model",
+                        "start": 9,
+                        "end": 45,
+                        "score": 0.953
+                    }
+                elif pipeline_tag == "translation":
+                    if input_data["target_language"] == "French":
+                        result = {"translation_text": "Bonjour, comment allez-vous?"}
+                    elif input_data["target_language"] == "German":
+                        result = {"translation_text": "Hallo, wie geht es dir?"}
+                    elif input_data["target_language"] == "Spanish":
+                        result = {"translation_text": "Hola, ¿cómo estás?"}
+                    elif input_data["target_language"] == "Chinese":
+                        result = {"translation_text": "你好，你好吗？"}
+                    else:
+                        result = {"translation_text": "Hello, how are you?"}
+                elif pipeline_tag in ["image-classification"]:
+                    result = [
+                        {"label": "diagram", "score": 0.9712},
+                        {"label": "architecture", "score": 0.0231},
+                        {"label": "document", "score": 0.0057}
+                    ]
+                elif pipeline_tag in ["object-detection"]:
+                    result = [
+                        {"label": "box", "score": 0.9712, "box": {"xmin": 10, "ymin": 20, "xmax": 100, "ymax": 80}},
+                        {"label": "text", "score": 0.8923, "box": {"xmin": 120, "ymin": 30, "xmax": 250, "ymax": 60}}
+                    ]
+                else:
+                    result = {"result": "Sample response for " + pipeline_tag}
+                
+                # Display the results
+                st.markdown("### Inference Results")
+                
+                # Different visualizations based on the response type
+                if pipeline_tag == "text-classification":
+                    # Create a bar chart for classification results
+                    result_df = pd.DataFrame(result)
+                    fig = px.bar(
+                        result_df, 
+                        x="label", 
+                        y="score", 
+                        color="score",
+                        color_continuous_scale=px.colors.sequential.Viridis,
+                        title="Classification Results"
+                    )
+                    st.plotly_chart(fig, use_container_width=True)
+                    
+                    # Show the raw results
+                    st.json(result)
+                
+                elif pipeline_tag == "token-classification":
+                    # Display entity highlighting
+                    st.markdown("#### Named Entities")
+                    
+                    # Create HTML with colored spans for entities
+                    html = ""
+                    input_text = input_data["text"]
+                    entities = {}
+                    
+                    for item in result:
+                        if item["entity"].startswith("B-") or item["entity"].startswith("I-"):
+                            entity_type = item["entity"][2:]  # Remove B- or I- prefix
+                            entities[entity_type] = entities.get(entity_type, 0) + 1
+                    
+                    # Create a color map for entity types
+                    colors = px.colors.qualitative.Plotly[:len(entities)]
+                    entity_colors = dict(zip(entities.keys(), colors))
+                    
+                    # Create the HTML
+                    for item in result:
+                        word = item["word"]
+                        entity = item["entity"]
+                        
+                        if entity == "O":
+                            html += f"{word} "
+                        else:
+                            entity_type = entity[2:] if entity.startswith("B-") or entity.startswith("I-") else entity
+                            color = entity_colors.get(entity_type, "#CCCCCC")
+                            html += f'<span style="background-color: {color}; padding: 2px; border-radius: 3px;" title="{entity} ({item["score"]:.2f})">{word}</span> '
+                    
+                    st.markdown(f'<div style="line-height: 2.5;">{html}</div>', unsafe_allow_html=True)
+                    
+                    # Display legend
+                    st.markdown("#### Entity Legend")
+                    legend_html = "".join([
+                        f'<span style="background-color: {color}; padding: 2px 8px; margin-right: 10px; border-radius: 3px;">{entity}</span>'
+                        for entity, color in entity_colors.items()
+                    ])
+                    st.markdown(f'<div>{legend_html}</div>', unsafe_allow_html=True)
+                    
+                    # Show the raw results
+                    st.json(result)
+                
+                elif pipeline_tag in ["text-generation", "summarization", "translation"]:
+                    # Display the generated text
+                    response_key = "generated_text" if "generated_text" in result else "summary_text" if "summary_text" in result else "translation_text"
+                    st.markdown(f"#### Output Text")
+                    st.markdown(f'<div style="background-color: #f0f2f6; padding: 20px; border-radius: 10px;">{result[response_key]}</div>', unsafe_allow_html=True)
+                    
+                    # Text stats
+                    st.markdown("#### Text Statistics")
+                    input_length = len(input_data["text"]) if "text" in input_data else 0
+                    output_length = len(result[response_key])
+                    
+                    col1, col2, col3 = st.columns(3)
+                    with col1:
+                        st.metric("Input Length", input_length, "characters")
+                    with col2:
+                        st.metric("Output Length", output_length, "characters")
+                    with col3:
+                        compression = ((output_length - input_length) / input_length * 100) if input_length > 0 else 0
+                        st.metric("Length Change", f"{compression:.1f}%", f"{output_length - input_length} chars")
+                
+                elif pipeline_tag == "question-answering":
+                    # Highlight the answer in the context
+                    st.markdown("#### Answer")
+                    st.markdown(f'<div style="background-color: #e6f3ff; padding: 10px; border-radius: 5px; font-weight: bold;">{result["answer"]}</div>', unsafe_allow_html=True)
+                    
+                    # Show the answer in context
+                    if "context" in input_data:
+                        st.markdown("#### Answer in Context")
+                        context = input_data["context"]
+                        start = result["start"] 
+                        end = result["end"]
+                        
+                        highlighted_context = (
+                            context[:start] + 
+                            f'<span style="background-color: #ffeb3b; font-weight: bold;">{context[start:end]}</span>' + 
+                            context[end:]
+                        )
+                        
+                        st.markdown(f'<div style="background-color: #f0f2f6; padding: 15px; border-radius: 10px; line-height: 1.5;">{highlighted_context}</div>', unsafe_allow_html=True)
+                    
+                    # Confidence score
+                    st.markdown("#### Confidence")
+                    st.progress(result["score"])
+                    st.text(f"Confidence Score: {result['score']:.4f}")
+                
+                elif pipeline_tag == "image-classification":
+                    # Create a bar chart for classification results
+                    result_df = pd.DataFrame(result)
+                    fig = px.bar(
+                        result_df, 
+                        x="score", 
+                        y="label", 
+                        orientation='h',
+                        color="score",
+                        color_continuous_scale=px.colors.sequential.Viridis,
+                        title="Image Classification Results"
+                    )
+                    fig.update_layout(yaxis={'categoryorder':'total ascending'})
+                    st.plotly_chart(fig, use_container_width=True)
+                    
+                    # Show the raw results
+                    st.json(result)
+                
+                else:
+                    # Generic display for other types
+                    st.json(result)
+                
+                # Option to save the results
+                st.download_button(
+                    label="Download Results",
+                    data=json.dumps(result, indent=2),
+                    file_name="inference_results.json",
+                    mime="application/json"
+                )
+        
+        else:
+            st.warning("Please provide input data for inference")
+
+    # API integration options
+    with st.expander("API Integration"):
+        st.markdown("### Use this model in your application")
+        
+        # Python code example
+        st.markdown("#### Python")
+        python_code = f"""
+```python
+import requests
+
+API_URL = "https://api-inference.huggingface.co/models/{model_info.modelId}"
+headers = {{"Authorization": "Bearer YOUR_API_KEY"}}
+
+def query(payload):
+    response = requests.post(API_URL, headers=headers, json=payload)
+    return response.json()
+
+# Example usage
+output = query({{
+    "inputs": "This model is amazing!"
+}})
+print(output)
+```
+        """
+        st.markdown(python_code)
+        
+        # JavaScript code example
+        st.markdown("#### JavaScript")
+        js_code = f"""
+```javascript
+async function query(data) {{
+    const response = await fetch(
+        "https://api-inference.huggingface.co/models/{model_info.modelId}",
+        {{
+            headers: {{ Authorization: "Bearer YOUR_API_KEY" }},
+            method: "POST",
+            body: JSON.stringify(data),
+        }}
+    );
+    const result = await response.json();
+    return result;
+}}
+
+// Example usage
+query({{"inputs": "This model is amazing!"}}).then((response) => {{
+    console.log(JSON.stringify(response));
+}});
+```
+        """
+        st.markdown(js_code)

components/sidebar.py

@@ -0,0 +1,148 @@
+import streamlit as st
+import datetime
+from utils.auth import logout
+
+def render_sidebar():
+    """Render the sidebar with navigation links and user info"""
+    with st.sidebar:
+        # App logo/title
+        st.markdown(
+            """
+            <div style="text-align: center; margin-bottom: 16px;">
+                <h2 style="margin-bottom: 0;">🤗 HF Model Manager</h2>
+            </div>
+            """,
+            unsafe_allow_html=True,
+        )
+
+        # User information with badge
+        st.markdown(
+            f"""
+            <div style="margin-bottom: 24px; padding: 16px; background-color: #F3F4F6; 
+                 border-radius: 8px; border: 1px solid #E5E7EB; box-shadow: 0 2px 4px rgba(0,0,0,0.05);">
+                <div style="font-size: 13px; color: #6B7280; margin-bottom: 4px;">Logged in as</div>
+                <div style="display: flex; align-items: center; justify-content: space-between;">
+                    <div style="font-weight: bold; font-size: 16px;">{st.session_state.username}</div>
+                    <div class="badge hf-badge" style="padding: 2px 6px; font-size: 10px;">
+                        <img src="https://huggingface.co/front/assets/huggingface_logo-noborder.svg" 
+                             alt="HF" style="height: 10px; margin-right: 2px;">
+                        Pro
+                    </div>
+                </div>
+                <div style="font-size: 12px; color: #6B7280; margin-top: 8px;">
+                    Last login: {datetime.datetime.now().strftime("%B %d, %Y")}
+                </div>
+            </div>
+            """,
+            unsafe_allow_html=True,
+        )
+
+        # Navigation with tooltips
+        st.markdown(
+            """
+            <h3 style="font-size: 16px; margin-bottom: 12px; color: #1A1A1A;">
+                Navigation
+            </h3>
+            """,
+            unsafe_allow_html=True,
+        )
+
+        # Home button
+        if st.button("🏠 Home", use_container_width=True, key="home_btn"):
+            st.session_state.page = "home"
+            st.session_state.selected_model = None
+            st.rerun()
+
+        # Repositories button
+        if st.button(
+            "📚 Manage Repositories", use_container_width=True, key="repo_btn"
+        ):
+            st.session_state.page = "repository_management"
+            st.rerun()
+
+        # Create new repository button with prominent styling
+        st.markdown(
+            """
+            <div style="margin: 16px 0;">
+            """,
+            unsafe_allow_html=True,
+        )
+        if st.button(
+            "➕ Create New Repository", 
+            use_container_width=True, 
+            key="create_new_repo"
+        ):
+            st.session_state.page = "repository_management"
+            st.rerun()
+
+        # Analytics button
+        if st.button("📊 Analytics", use_container_width=True, key="analytics_btn"):
+            st.session_state.page = "analytics"
+            st.session_state.selected_model = None
+            st.rerun()
+
+        # Batch Operations button
+        if st.button("🔄 Batch Operations", use_container_width=True, key="batch_btn"):
+            st.session_state.page = "batch_operations"
+            st.session_state.selected_model = None
+            st.rerun()
+
+
+        # Refresh models button
+        if st.button(
+            "🔄 Refresh Models", use_container_width=True, key="refresh_models"
+        ):
+            with st.spinner("Refreshing models..."):
+                try:
+                    st.session_state.models = st.session_state.client.get_user_models()
+                    st.success("Models refreshed!")
+                except Exception as e:
+                    st.error(f"Error refreshing models: {str(e)}")
+
+        # Spacer
+        st.markdown(
+            """
+            <div style="flex-grow: 1; min-height: 20px;"></div>
+            """,
+            unsafe_allow_html=True,
+        )
+
+        # Bottom links with improved styling
+        st.markdown(
+            """
+            <hr style="margin: 16px 0; border: none; height: 1px; background-color: #E5E7EB;">
+            """,
+            unsafe_allow_html=True,
+        )
+
+        # Helpful links section
+        st.markdown(
+            """
+            <div style="margin-bottom: 16px;">
+                <a href="https://huggingface.co/docs" target="_blank" style="display: flex; align-items: center; text-decoration: none; color: #6B7280; font-size: 13px; padding: 8px 0;">
+                    <span style="margin-right: 8px;">📚</span> Hugging Face Documentation
+                </a>
+                <a href="https://huggingface.co/models" target="_blank" style="display: flex; align-items: center; text-decoration: none; color: #6B7280; font-size: 13px; padding: 8px 0;">
+                    <span style="margin-right: 8px;">🔍</span> Browse Models
+                </a>
+                <a href="https://huggingface.co/spaces" target="_blank" style="display: flex; align-items: center; text-decoration: none; color: #6B7280; font-size: 13px; padding: 8px 0;">
+                    <span style="margin-right: 8px;">🚀</span> Explore Spaces
+                </a>
+            </div>
+            """,
+            unsafe_allow_html=True,
+        )
+
+        # Version info
+        st.markdown(
+            """
+            <div style="font-size: 12px; color: #9CA3AF; text-align: center; margin-bottom: 12px;">
+                HF Model Manager v1.0.0
+            </div>
+            """,
+            unsafe_allow_html=True,
+        )
+
+        # Logout button
+        if st.button("🚪 Logout", use_container_width=True, key="logout_btn"):
+            logout()

components/upload_model.py

@@ -0,0 +1,122 @@
+import streamlit as st
+import os
+import tempfile
+import io
+import zipfile
+import shutil
+
+
+def upload_model_form(model_info):
+    """Form for uploading model files"""
+    st.subheader("Upload Model Files")
+
+    if not model_info:
+        st.error("Model information not found")
+        return False
+
+    repo_id = model_info.modelId
+
+    st.info(
+        """
+    Upload model files to your repository. You can upload:
+    
+    - Individual model files (e.g., model weights, configuration files)
+    - A ZIP archive containing multiple files (will be extracted automatically)
+    
+    **Important**: Large files may take time to upload.
+    """
+    )
+
+    with st.form("upload_model_form"):
+        # File upload
+        uploaded_files = st.file_uploader(
+            "Upload model files",
+            accept_multiple_files=True,
+            help="Select one or more files to upload",
+        )
+
+        # ZIP handling option
+        extract_zip = st.checkbox(
+            "Extract ZIP files automatically",
+            value=True,
+            help="If enabled, ZIP files will be extracted in the repository",
+        )
+
+        # Commit message
+        commit_message = st.text_input(
+            "Commit message",
+            value="Upload model files",
+            help="Describe the changes you're making",
+        )
+
+        # Submit button
+        submitted = st.form_submit_button("Upload Files", use_container_width=True)
+
+        if submitted and uploaded_files:
+            with st.spinner("Uploading files..."):
+                try:
+                    # Create a temporary directory to work with files
+                    with tempfile.TemporaryDirectory() as temp_dir:
+                        files_to_upload = {}
+
+                        for uploaded_file in uploaded_files:
+                            file_content = uploaded_file.read()
+                            file_name = uploaded_file.name
+
+                            # Handle ZIP files if extraction is enabled
+                            if extract_zip and file_name.lower().endswith(".zip"):
+                                with zipfile.ZipFile(
+                                    io.BytesIO(file_content)
+                                ) as zip_ref:
+                                    zip_ref.extractall(
+                                        os.path.join(temp_dir, "extracted")
+                                    )
+
+                                    # Walk through the extracted files
+                                    for root, _, files in os.walk(
+                                        os.path.join(temp_dir, "extracted")
+                                    ):
+                                        for file in files:
+                                            file_path = os.path.join(root, file)
+                                            rel_path = os.path.relpath(
+                                                file_path,
+                                                os.path.join(temp_dir, "extracted"),
+                                            )
+
+                                            with open(file_path, "rb") as f:
+                                                files_to_upload[rel_path] = f.read()
+                            else:
+                                # Regular file
+                                files_to_upload[file_name] = file_content
+
+                        # Upload the files
+                        if files_to_upload:
+                            success, response = (
+                                st.session_state.client.upload_model_files(
+                                    repo_id=repo_id,
+                                    files=files_to_upload,
+                                    commit_message=commit_message,
+                                )
+                            )
+
+                            if success:
+                                st.success(
+                                    f"Successfully uploaded {len(files_to_upload)} files!"
+                                )
+                                return True
+                            else:
+                                st.error(f"Failed to upload files: {response}")
+                                return False
+                        else:
+                            st.warning("No files to upload")
+                            return False
+
+                except Exception as e:
+                    st.error(f"Error uploading files: {str(e)}")
+                    return False
+
+        elif submitted:
+            st.warning("Please select files to upload")
+            return False
+
+    return False

components/version_control.py

@@ -0,0 +1,194 @@
+
+import streamlit as st
+import pandas as pd
+from datetime import datetime
+import difflib
+import json
+
+def fetch_model_versions(repo_id):
+    """
+    Fetch model versions from the Hugging Face API.
+    In a real implementation, this would call the HF API to get version history.
+    For now, we'll use demo data.
+    """
+    # In a production app, you would fetch this from the Hugging Face API
+    # For demo purposes, create some sample version data
+    versions = [
+        {
+            "version": "v1.0",
+            "commit_id": "abc123",
+            "timestamp": "2023-01-15T10:30:00Z",
+            "author": st.session_state.username,
+            "message": "Initial model release",
+            "files_changed": 5,
+            "performance": {"accuracy": 0.85, "f1": 0.82}
+        },
+        {
+            "version": "v1.1",
+            "commit_id": "def456",
+            "timestamp": "2023-02-20T14:45:00Z",
+            "author": st.session_state.username,
+            "message": "Improved tokenization",
+            "files_changed": 2,
+            "performance": {"accuracy": 0.87, "f1": 0.84}
+        },
+        {
+            "version": "v2.0",
+            "commit_id": "ghi789",
+            "timestamp": "2023-03-10T09:15:00Z",
+            "author": st.session_state.username,
+            "message": "Major model architecture upgrade",
+            "files_changed": 12,
+            "performance": {"accuracy": 0.92, "f1": 0.90}
+        }
+    ]
+    return versions
+
+def render_version_history(model_info):
+    """Render the version history of a model"""
+    if not model_info:
+        st.error("Model information not found")
+        return
+    
+    repo_id = model_info.modelId
+    st.subheader("🔄 Version History")
+    
+    with st.spinner("Loading version history..."):
+        versions = fetch_model_versions(repo_id)
+    
+    if not versions:
+        st.info("No version history found for this model.")
+        return
+    
+    # Convert to DataFrame for easier display
+    df = pd.DataFrame(versions)
+    
+    # Format timestamp
+    df["timestamp"] = pd.to_datetime(df["timestamp"]).dt.strftime("%Y-%m-%d %H:%M")
+    
+    # Create a cleaner display version
+    display_df = df[["version", "timestamp", "author", "message", "files_changed"]]
+    display_df.columns = ["Version", "Date", "Author", "Commit Message", "Files Changed"]
+    
+    # Show the version history
+    st.dataframe(display_df, use_container_width=True)
+    
+    # Version comparison
+    st.subheader("Compare Versions")
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        base_version = st.selectbox(
+            "Base Version",
+            options=df["version"].tolist(),
+            index=0
+        )
+    
+    with col2:
+        compare_version = st.selectbox(
+            "Compare Version",
+            options=[v for v in df["version"].tolist() if v != base_version],
+            index=0
+        )
+    
+    if st.button("Compare", use_container_width=True):
+        with st.spinner("Generating comparison..."):
+            # In a real implementation, fetch the actual data from each version
+            # For demo, use the sample performance metrics
+            base_data = df[df["version"] == base_version].iloc[0]
+            compare_data = df[df["version"] == compare_version].iloc[0]
+            
+            # Display comparison
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                st.markdown(f"### {base_version}")
+                st.markdown(f"**Commit:** {base_data['commit_id']}")
+                st.markdown(f"**Date:** {base_data['timestamp']}")
+                st.markdown(f"**Author:** {base_data['author']}")
+                st.markdown(f"**Message:** {base_data['message']}")
+                
+                # Performance metrics
+                st.markdown("#### Performance Metrics")
+                for metric, value in base_data["performance"].items():
+                    st.markdown(f"**{metric.capitalize()}:** {value:.4f}")
+            
+            with col2:
+                st.markdown(f"### {compare_version}")
+                st.markdown(f"**Commit:** {compare_data['commit_id']}")
+                st.markdown(f"**Date:** {compare_data['timestamp']}")
+                st.markdown(f"**Author:** {compare_data['author']}")
+                st.markdown(f"**Message:** {compare_data['message']}")
+                
+                # Performance metrics
+                st.markdown("#### Performance Metrics")
+                for metric, value in compare_data["performance"].items():
+                    # Calculate change
+                    base_value = base_data["performance"].get(metric, 0)
+                    change = value - base_value
+                    change_pct = (change / base_value * 100) if base_value != 0 else float('inf')
+                    
+                    # Display with change indicator
+                    if change > 0:
+                        st.markdown(f"**{metric.capitalize()}:** {value:.4f} 📈 **(+{change:.4f}, {change_pct:.2f}%)**")
+                    elif change < 0:
+                        st.markdown(f"**{metric.capitalize()}:** {value:.4f} 📉 **({change:.4f}, {change_pct:.2f}%)**")
+                    else:
+                        st.markdown(f"**{metric.capitalize()}:** {value:.4f} (no change)")
+            
+            # Show visual diff of model config
+            st.subheader("Configuration Changes")
+            
+            # Sample configs (in a real app, you'd fetch these from the API)
+            base_config = {
+                "hidden_size": 768,
+                "num_attention_heads": 12,
+                "num_hidden_layers": 6,
+                "vocab_size": 30000
+            }
+            
+            compare_config = {
+                "hidden_size": 1024,
+                "num_attention_heads": 16,
+                "num_hidden_layers": 8,
+                "vocab_size": 30000
+            }
+            
+            # Generate a formatted diff
+            base_str = json.dumps(base_config, indent=2).splitlines()
+            compare_str = json.dumps(compare_config, indent=2).splitlines()
+            
+            diff = difflib.unified_diff(
+                base_str,
+                compare_str,
+                fromfile=f'config_{base_version}',
+                tofile=f'config_{compare_version}',
+                lineterm=''
+            )
+            
+            diff_html = []
+            for line in diff:
+                if line.startswith('+'):
+                    diff_html.append(f'<span style="color: green">{line}</span>')
+                elif line.startswith('-'):
+                    diff_html.append(f'<span style="color: red">{line}</span>')
+                elif line.startswith('@@'):
+                    diff_html.append(f'<span style="color: purple">{line}</span>')
+                else:
+                    diff_html.append(line)
+            
+            st.markdown('<div style="background-color: #f5f5f5; padding: 10px; border-radius: 5px; font-family: monospace; white-space: pre-wrap;">' + '<br>'.join(diff_html) + '</div>', unsafe_allow_html=True)
+    
+    # Rollback functionality
+    st.subheader("Rollback to Previous Version")
+    rollback_version = st.selectbox(
+        "Select version to rollback to",
+        options=df["version"].tolist(),
+        index=len(df)-2  # Default to second-to-last version
+    )
+    
+    if st.button("Rollback", use_container_width=True, type="primary"):
+        with st.spinner("Rolling back to version " + rollback_version):
+            # In a real implementation, this would call the HF API to perform the rollback
+            st.success(f"Successfully rolled back to {rollback_version}")
+            # Here you would update the model information and refresh the view

pages/__init__.py

@@ -0,0 +1 @@
+# This file is intentionally left empty to make the directory a Python package

pages/analytics.py

@@ -0,0 +1,277 @@
+
+import streamlit as st
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+from datetime import datetime, timedelta
+import random  # Only used for demo data, remove in production
+
+def generate_demo_data(model_ids, days=30):
+    """Generate demo data for visualization purposes"""
+    today = datetime.now()
+    data = []
+    
+    # For each model, generate 30 days of data
+    for model_id in model_ids:
+        base_downloads = random.randint(10, 1000)
+        base_likes = random.randint(5, 200)
+        
+        # Generate daily data with some randomness and trend
+        for i in range(days):
+            date = (today - timedelta(days=days-i-1)).strftime("%Y-%m-%d")
+            daily_downloads = max(1, int(base_downloads * (1 + 0.1 * i/days) * random.uniform(0.8, 1.2)))
+            daily_likes = max(0, int(base_likes * (1 + 0.05 * i/days) * random.uniform(0.7, 1.3)))
+            
+            data.append({
+                "model_id": model_id,
+                "date": date,
+                "downloads": base_downloads + daily_downloads,
+                "likes": base_likes + daily_likes,
+                "daily_downloads": daily_downloads,
+                "daily_likes": daily_likes
+            })
+            
+            # Update base values for next day (cumulative)
+            base_downloads += daily_downloads
+            base_likes += daily_likes
+    
+    return pd.DataFrame(data)
+
+def render_analytics_page():
+    st.title("📊 Model Performance Analytics")
+    
+    if "models" not in st.session_state or not st.session_state.models:
+        st.info("No models found. Please create or import models first.")
+        return
+    
+    # Get model IDs from the session state
+    model_ids = [model.modelId for model in st.session_state.models]
+    
+    # Time period selection
+    time_period = st.selectbox(
+        "Select Time Period",
+        ["Last 7 days", "Last 30 days", "Last 90 days", "All time"],
+        index=1
+    )
+    
+    # Convert time period to days
+    days_mapping = {
+        "Last 7 days": 7,
+        "Last 30 days": 30,
+        "Last 90 days": 90,
+        "All time": 180  # Default to 6 months for demo
+    }
+    days = days_mapping[time_period]
+    
+    # In a real implementation, we would fetch this data from the Hugging Face API
+    # For now, generate demo data
+    df = generate_demo_data(model_ids, days)
+    
+    # Model selection for detailed view
+    selected_models = st.multiselect(
+        "Select Models to Compare",
+        model_ids,
+        default=model_ids[:min(3, len(model_ids))]
+    )
+    
+    if not selected_models:
+        st.warning("Please select at least one model to display analytics.")
+        return
+    
+    # Filter data for selected models
+    filtered_df = df[df["model_id"].isin(selected_models)]
+    
+    # Create tabs for different analytics views
+    tab1, tab2, tab3, tab4 = st.tabs(["Downloads", "Likes", "Growth Rate", "Comparison"])
+    
+    with tab1:
+        st.subheader("Downloads Over Time")
+        
+        # Cumulative downloads
+        fig_cumulative = px.line(
+            filtered_df, 
+            x="date", 
+            y="downloads", 
+            color="model_id",
+            title="Cumulative Downloads",
+            labels={"downloads": "Total Downloads", "date": "Date", "model_id": "Model"}
+        )
+        st.plotly_chart(fig_cumulative, use_container_width=True)
+        
+        # Daily downloads
+        fig_daily = px.bar(
+            filtered_df, 
+            x="date", 
+            y="daily_downloads", 
+            color="model_id",
+            title="Daily Downloads",
+            labels={"daily_downloads": "Daily Downloads", "date": "Date", "model_id": "Model"},
+            barmode="group"
+        )
+        st.plotly_chart(fig_daily, use_container_width=True)
+    
+    with tab2:
+        st.subheader("Likes Over Time")
+        
+        # Cumulative likes
+        fig_cumulative = px.line(
+            filtered_df, 
+            x="date", 
+            y="likes", 
+            color="model_id",
+            title="Cumulative Likes",
+            labels={"likes": "Total Likes", "date": "Date", "model_id": "Model"}
+        )
+        st.plotly_chart(fig_cumulative, use_container_width=True)
+        
+        # Daily likes
+        fig_daily = px.bar(
+            filtered_df, 
+            x="date", 
+            y="daily_likes", 
+            color="model_id",
+            title="Daily Likes",
+            labels={"daily_likes": "Daily Likes", "date": "Date", "model_id": "Model"},
+            barmode="group"
+        )
+        st.plotly_chart(fig_daily, use_container_width=True)
+    
+    with tab3:
+        st.subheader("Growth Metrics")
+        
+        # Calculate growth rates
+        growth_data = []
+        for model in selected_models:
+            model_data = filtered_df[filtered_df["model_id"] == model]
+            if len(model_data) >= 2:
+                first_day = model_data.iloc[0]
+                last_day = model_data.iloc[-1]
+                
+                # Calculate download growth
+                if first_day["downloads"] > 0:
+                    download_growth = (last_day["downloads"] - first_day["downloads"]) / first_day["downloads"] * 100
+                else:
+                    download_growth = 100 if last_day["downloads"] > 0 else 0
+                
+                # Calculate like growth
+                if first_day["likes"] > 0:
+                    like_growth = (last_day["likes"] - first_day["likes"]) / first_day["likes"] * 100
+                else:
+                    like_growth = 100 if last_day["likes"] > 0 else 0
+                
+                growth_data.append({
+                    "model_id": model,
+                    "download_growth": download_growth,
+                    "like_growth": like_growth,
+                    "downloads": last_day["downloads"],
+                    "likes": last_day["likes"]
+                })
+        
+        growth_df = pd.DataFrame(growth_data)
+        
+        # Show growth rates
+        if not growth_df.empty:
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                fig = px.bar(
+                    growth_df,
+                    x="model_id",
+                    y="download_growth",
+                    title="Download Growth Rate (%)",
+                    labels={"download_growth": "Growth (%)", "model_id": "Model"},
+                    color="download_growth",
+                    color_continuous_scale=px.colors.sequential.Blues,
+                )
+                st.plotly_chart(fig, use_container_width=True)
+            
+            with col2:
+                fig = px.bar(
+                    growth_df,
+                    x="model_id",
+                    y="like_growth",
+                    title="Like Growth Rate (%)",
+                    labels={"like_growth": "Growth (%)", "model_id": "Model"},
+                    color="like_growth",
+                    color_continuous_scale=px.colors.sequential.Reds,
+                )
+                st.plotly_chart(fig, use_container_width=True)
+        else:
+            st.info("Not enough data to calculate growth rates.")
+    
+    with tab4:
+        st.subheader("Model Comparison")
+        
+        # Get the most recent data point for each model
+        latest_data = filtered_df.groupby("model_id").last().reset_index()
+        
+        # Create a radar chart for model comparison
+        categories = ["downloads", "likes", "daily_downloads", "daily_likes"]
+        fig = go.Figure()
+        
+        for model in latest_data["model_id"]:
+            model_row = latest_data[latest_data["model_id"] == model].iloc[0]
+            
+            # Normalize values for radar chart (0-1 scale)
+            max_vals = latest_data[categories].max()
+            normalized_vals = [model_row[cat]/max_vals[cat] if max_vals[cat] > 0 else 0 for cat in categories]
+            
+            fig.add_trace(go.Scatterpolar(
+                r=normalized_vals,
+                theta=["Total Downloads", "Total Likes", "Daily Downloads", "Daily Likes"],
+                fill='toself',
+                name=model
+            ))
+        
+        fig.update_layout(
+            polar=dict(
+                radialaxis=dict(
+                    visible=True,
+                    range=[0, 1]
+                )),
+            showlegend=True
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # Comparison table
+        st.subheader("Numeric Comparison")
+        comparison_df = latest_data[["model_id", "downloads", "likes", "daily_downloads", "daily_likes"]]
+        comparison_df.columns = ["Model", "Total Downloads", "Total Likes", "Daily Downloads", "Daily Likes"]
+        st.dataframe(comparison_df, use_container_width=True)
+
+    # Analytics insights
+    st.subheader("📈 Key Insights")
+    
+    # Calculate some basic insights
+    if not filtered_df.empty:
+        # Most downloaded model
+        most_downloaded = filtered_df.loc[filtered_df.groupby("model_id")["downloads"].idxmax()]
+        # Fastest growing model in terms of downloads
+        growth_rates = []
+        for model in selected_models:
+            model_data = filtered_df[filtered_df["model_id"] == model]
+            if len(model_data) >= 2:
+                first_downloads = model_data.iloc[0]["downloads"]
+                last_downloads = model_data.iloc[-1]["downloads"]
+                growth_rate = (last_downloads - first_downloads) / max(1, first_downloads)
+                growth_rates.append((model, growth_rate))
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            st.info(f"💡 Most downloaded model: **{most_downloaded['model_id']}** with **{most_downloaded['downloads']}** total downloads")
+            
+            if growth_rates:
+                fastest_growing = max(growth_rates, key=lambda x: x[1])
+                st.info(f"💡 Fastest growing model: **{fastest_growing[0]}** with a growth rate of **{fastest_growing[1]*100:.2f}%**")
+        
+        with col2:
+            # Most liked model
+            most_liked = filtered_df.loc[filtered_df.groupby("model_id")["likes"].idxmax()]
+            st.info(f"💡 Most liked model: **{most_liked['model_id']}** with **{most_liked['likes']}** total likes")
+            
+            # Average daily downloads
+            avg_daily = filtered_df.groupby("model_id")["daily_downloads"].mean().reset_index()
+            highest_avg = avg_daily.loc[avg_daily["daily_downloads"].idxmax()]
+            st.info(f"💡 Highest avg daily downloads: **{highest_avg['model_id']}** with **{highest_avg['daily_downloads']:.1f}** downloads/day")

pages/batch_operations.py

@@ -0,0 +1,319 @@
+
+import streamlit as st
+import pandas as pd
+import time
+
+def render_batch_operations():
+    """Render the batch operations page"""
+    st.title("🔄 Batch Operations")
+    
+    if "models" not in st.session_state or not st.session_state.models:
+        st.info("No models found. Please create repositories first.")
+        if st.button("Go to Dashboard", use_container_width=True):
+            st.session_state.page = "home"
+            st.experimental_rerun()
+        return
+    
+    # Create a dataframe for model selection
+    models_data = []
+    for model in st.session_state.models:
+        try:
+            models_data.append({
+                "Select": False,  # Checkbox column
+                "Model Name": model.modelId.split("/")[-1],
+                "Full ID": model.modelId,
+                "Downloads": getattr(model, "downloads", 0),
+                "Likes": getattr(model, "likes", 0),
+                "Private": getattr(model, "private", False),
+                "Tags": ", ".join(getattr(model, "tags", []) or []),
+            })
+        except Exception as e:
+            st.warning(f"Error processing model {getattr(model, 'modelId', 'unknown')}: {str(e)}")
+    
+    if not models_data:
+        st.error("Failed to process model data.")
+        return
+    
+    # Convert to DataFrame for display
+    df = pd.DataFrame(models_data)
+    
+    st.markdown("### Select Models for Batch Operations")
+    st.markdown("Use the checkboxes to select models you want to operate on.")
+    
+    # Editable dataframe
+    edited_df = st.data_editor(
+        df,
+        column_config={
+            "Select": st.column_config.CheckboxColumn(
+                "Select",
+                help="Select for batch operations",
+                default=False,
+            ),
+            "Full ID": st.column_config.TextColumn(
+                "Repository ID",
+                help="Full repository ID",
+                disabled=True,
+            ),
+            "Downloads": st.column_config.NumberColumn(
+                "Downloads",
+                help="Number of downloads",
+                disabled=True,
+            ),
+            "Likes": st.column_config.NumberColumn(
+                "Likes",
+                help="Number of likes",
+                disabled=True,
+            ),
+            "Private": st.column_config.CheckboxColumn(
+                "Private",
+                help="Repository visibility",
+                disabled=True,
+            ),
+            "Tags": st.column_config.TextColumn(
+                "Tags",
+                help="Current tags",
+                disabled=True,
+            ),
+        },
+        hide_index=True,
+        use_container_width=True,
+    )
+    
+    # Get selected models
+    selected_models = edited_df[edited_df["Select"] == True]
+    selected_count = len(selected_models)
+    
+    if selected_count > 0:
+        st.success(f"Selected {selected_count} models for batch operations.")
+    else:
+        st.info("Please select at least one model to perform batch operations.")
+    
+    # Batch operations tabs
+    if selected_count > 0:
+        tab1, tab2, tab3, tab4 = st.tabs(["Update Tags", "Update Visibility", "Add Collaborators", "Delete"])
+        
+        with tab1:
+            st.subheader("Update Tags")
+            
+            # Get available tags
+            available_tags = st.session_state.client.get_model_tags()
+            
+            # Tags selection
+            selected_tags = st.multiselect(
+                "Select tags to add to all selected models",
+                options=available_tags,
+                help="These tags will be added to all selected models"
+            )
+            
+            tags_action = st.radio(
+                "Tag Operation",
+                ["Add tags (keep existing)", "Replace tags (remove existing)"],
+                index=0
+            )
+            
+            if st.button("Apply Tags", use_container_width=True, type="primary"):
+                if not selected_tags:
+                    st.warning("Please select at least one tag to add.")
+                else:
+                    with st.spinner(f"Updating tags for {selected_count} models..."):
+                        # Track success and failures
+                        successes = 0
+                        failures = []
+                        
+                        # Process each selected model
+                        for idx, row in selected_models.iterrows():
+                            try:
+                                repo_id = row["Full ID"]
+                                model_info = st.session_state.client.get_model_info(repo_id)
+                                
+                                if model_info:
+                                    # Get current model card content
+                                    try:
+                                        model_card_url = f"https://huggingface.co/{repo_id}/raw/main/README.md"
+                                        response = st.session_state.client.api._get_paginated(model_card_url)
+                                        if response.status_code != 200:
+                                            failures.append((repo_id, "Failed to fetch model card"))
+                                            continue
+                                        
+                                        model_card_content = response.text
+                                        
+                                        # Update tags in the model card
+                                        import re
+                                        yaml_match = re.search(r"---\s+(.*?)\s+---", model_card_content, re.DOTALL)
+                                        
+                                        if yaml_match:
+                                            yaml_content = yaml_match.group(1)
+                                            tags_match = re.search(r"tags:\s*((?:- .*?\n)+)", yaml_content, re.DOTALL)
+                                            
+                                            if tags_match and tags_action == "Add tags (keep existing)":
+                                                # Extract existing tags
+                                                existing_tags = [
+                                                    line.strip("- \n")
+                                                    for line in tags_match.group(1).split("\n")
+                                                    if line.strip().startswith("-")
+                                                ]
+                                                
+                                                # Combine existing and new tags
+                                                all_tags = list(set(existing_tags + selected_tags))
+                                                
+                                                # Replace tags section
+                                                new_yaml = yaml_content.replace(
+                                                    tags_match.group(0),
+                                                    f"tags:\n" + "\n".join([f"- {tag}" for tag in all_tags]) + "\n",
+                                                )
+                                                
+                                                # Update the model card
+                                                new_content = model_card_content.replace(
+                                                    yaml_match.group(0), f"---\n{new_yaml}---"
+                                                )
+                                            elif tags_match and tags_action == "Replace tags (remove existing)":
+                                                # Replace tags section
+                                                new_yaml = yaml_content.replace(
+                                                    tags_match.group(0),
+                                                    f"tags:\n" + "\n".join([f"- {tag}" for tag in selected_tags]) + "\n",
+                                                )
+                                                
+                                                # Update the model card
+                                                new_content = model_card_content.replace(
+                                                    yaml_match.group(0), f"---\n{new_yaml}---"
+                                                )
+                                            elif tags_action == "Add tags (keep existing)" or tags_action == "Replace tags (remove existing)":
+                                                # Add tags section if it doesn't exist
+                                                new_yaml = yaml_content + f"\ntags:\n" + "\n".join([f"- {tag}" for tag in selected_tags]) + "\n"
+                                                
+                                                # Update the model card
+                                                new_content = model_card_content.replace(
+                                                    yaml_match.group(0), f"---\n{new_yaml}---"
+                                                )
+                                            else:
+                                                failures.append((repo_id, "Failed to update tags in model card"))
+                                                continue
+                                        else:
+                                            # Add YAML frontmatter with tags
+                                            tags_yaml = "---\ntags:\n" + "\n".join([f"- {tag}" for tag in selected_tags]) + "\n---\n\n"
+                                            new_content = tags_yaml + model_card_content
+                                        
+                                        # Update the model card
+                                        success, _ = st.session_state.client.update_model_card(repo_id, new_content)
+                                        
+                                        if success:
+                                            successes += 1
+                                        else:
+                                            failures.append((repo_id, "Failed to update model card"))
+                                    
+                                    except Exception as e:
+                                        failures.append((repo_id, str(e)))
+                                else:
+                                    failures.append((repo_id, "Failed to fetch model info"))
+                            
+                            except Exception as e:
+                                failures.append((row["Full ID"], str(e)))
+                        
+                        # Show results
+                        if successes > 0:
+                            st.success(f"Successfully updated tags for {successes} models")
+                        
+                        if failures:
+                            st.error(f"Failed to update {len(failures)} models")
+                            for repo_id, error in failures:
+                                st.warning(f"Failed to update {repo_id}: {error}")
+                        
+                        # Refresh models after batch operation
+                        st.session_state.models = st.session_state.client.get_user_models()
+                        st.info("Model list refreshed. You may need to wait a few minutes for all changes to propagate.")
+        
+        with tab2:
+            st.subheader("Update Visibility")
+            
+            visibility = st.radio(
+                "Set visibility for selected models",
+                ["Public", "Private"],
+                index=0,
+                help="Change the visibility of all selected models"
+            )
+            
+            if st.button("Update Visibility", use_container_width=True, type="primary"):
+                with st.spinner(f"Updating visibility for {selected_count} models..."):
+                    st.warning("This feature requires Hugging Face Pro or Enterprise subscription.")
+                    st.info("In the actual implementation, this would update the models' visibility settings.")
+                    
+                    # This is a placeholder for the actual implementation
+                    time.sleep(2)
+                    st.success(f"Successfully updated visibility for {selected_count} models")
+        
+        with tab3:
+            st.subheader("Add Collaborators")
+            
+            collaborators = st.text_area(
+                "Enter usernames of collaborators (one per line)",
+                help="These users will be added as collaborators to all selected models"
+            )
+            
+            role = st.selectbox(
+                "Collaborator role",
+                ["read", "write", "admin"],
+                index=0
+            )
+            
+            if st.button("Add Collaborators", use_container_width=True, type="primary"):
+                if not collaborators.strip():
+                    st.warning("Please enter at least one collaborator username.")
+                else:
+                    with st.spinner(f"Adding collaborators to {selected_count} models..."):
+                        # This is a placeholder for the actual implementation
+                        collaborator_list = [c.strip() for c in collaborators.split("\n") if c.strip()]
+                        st.info(f"Adding {len(collaborator_list)} collaborators with '{role}' role to {selected_count} models.")
+                        st.warning("This feature requires Hugging Face Pro or Enterprise subscription.")
+                        
+                        time.sleep(2)
+                        st.success(f"Successfully added collaborators to {selected_count} models")
+        
+        with tab4:
+            st.subheader("⚠️ Delete Models")
+            
+            st.warning(
+                "This operation is irreversible. All selected models will be permanently deleted."
+            )
+            
+            # Confirmation
+            confirmation = st.text_input(
+                "Type 'DELETE' to confirm deletion of all selected models",
+                key="batch_delete_confirm"
+            )
+            
+            if st.button("Delete Selected Models", use_container_width=True, type="primary"):
+                if confirmation != "DELETE":
+                    st.error("Please type 'DELETE' to confirm.")
+                else:
+                    with st.spinner(f"Deleting {selected_count} models..."):
+                        # Track success and failures
+                        successes = 0
+                        failures = []
+                        
+                        # Process each selected model
+                        for idx, row in selected_models.iterrows():
+                            try:
+                                repo_id = row["Full ID"]
+                                
+                                # Delete the repository
+                                success, message = st.session_state.client.delete_model_repository(repo_id)
+                                
+                                if success:
+                                    successes += 1
+                                else:
+                                    failures.append((repo_id, message))
+                            
+                            except Exception as e:
+                                failures.append((row["Full ID"], str(e)))
+                        
+                        # Show results
+                        if successes > 0:
+                            st.success(f"Successfully deleted {successes} models")
+                        
+                        if failures:
+                            st.error(f"Failed to delete {len(failures)} models")
+                            for repo_id, error in failures:
+                                st.warning(f"Failed to delete {repo_id}: {error}")
+                        
+                        # Refresh models after batch operation
+                        st.session_state.models = st.session_state.client.get_user_models()

pages/home.py

@@ -0,0 +1,209 @@
+
+import streamlit as st
+import pandas as pd
+from datetime import datetime
+
+def render_home():
+    """Render the home page with model overview and statistics"""
+    st.title("🤗 Hugging Face Model Manager")
+
+    st.markdown(
+        """
+        Welcome to your personal Hugging Face model management dashboard. 
+        From here, you can view, create, and manage your machine learning models.
+        """
+    )
+
+    # Check if we have models loaded
+    if not st.session_state.get("models"):
+        with st.spinner("Loading your models..."):
+            try:
+                st.session_state.models = st.session_state.client.get_user_models()
+            except Exception as e:
+                st.error(f"Error loading models: {str(e)}")
+
+    # Model Statistics Dashboard
+    st.markdown("### 📊 Model Statistics")
+
+    # Key statistics in cards
+    col1, col2, col3 = st.columns([1, 1, 1])
+
+    with col1:
+        # Total models count
+        total_models = len(st.session_state.models)
+        st.markdown(
+            f"""
+            <div class="tooltip" style="width: 100%;">
+                <div style="padding: 20px; background-color: #F9FAFB; border-radius: 10px; border: 1px solid #E5E7EB; text-align: center; box-shadow: 0 2px 4px rgba(0,0,0,0.05); transition: all 0.3s;">
+                    <div style="font-size: 36px; color: #6366F1; font-weight: bold;">
+                        {total_models}
+                    </div>
+                    <div style="color: #6B7280; font-weight: 500;">
+                        Total Models
+                    </div>
+                </div>
+                <span class="tooltip-text">Total number of models you've created</span>
+            </div>
+            """,
+            unsafe_allow_html=True,
+        )
+
+    with col2:
+        # Total downloads (sum from all models)
+        total_downloads = sum(
+            getattr(model, "downloads", 0) for model in st.session_state.models
+        )
+        st.markdown(
+            f"""
+            <div class="tooltip" style="width: 100%;">
+                <div style="padding: 20px; background-color: #F9FAFB; border-radius: 10px; border: 1px solid #E5E7EB; text-align: center; box-shadow: 0 2px 4px rgba(0,0,0,0.05); transition: all 0.3s;">
+                    <div style="font-size: 36px; color: #10B981; font-weight: bold;">
+                        {total_downloads:,}
+                    </div>
+                    <div style="color: #6B7280; font-weight: 500;">
+                        Total Downloads
+                    </div>
+                </div>
+                <span class="tooltip-text">Cumulative downloads across all your models</span>
+            </div>
+            """,
+            unsafe_allow_html=True,
+        )
+
+    with col3:
+        # Calculate total likes
+        total_likes = sum(
+            getattr(model, "likes", 0) for model in st.session_state.models
+        )
+        st.markdown(
+            f"""
+            <div class="tooltip" style="width: 100%;">
+                <div style="padding: 20px; background-color: #F9FAFB; border-radius: 10px; border: 1px solid #E5E7EB; text-align: center; box-shadow: 0 2px 4px rgba(0,0,0,0.05); transition: all 0.3s;">
+                    <div style="font-size: 36px; color: #FF9D96; font-weight: bold;">
+                        {total_likes}
+                    </div>
+                    <div style="color: #6B7280; font-weight: 500;">
+                        Total Likes
+                    </div>
+                </div>
+                <span class="tooltip-text">Cumulative likes across all your models</span>
+            </div>
+            """,
+            unsafe_allow_html=True,
+        )
+
+    # Quick Actions with improved styling
+    st.markdown("### 🚀 Quick Actions")
+
+    quick_actions_col1, quick_actions_col2 = st.columns([1, 1])
+
+    with quick_actions_col1:
+        if st.button(
+            "➕ Create New Repository", key="create_repo_home", use_container_width=True
+        ):
+            st.session_state.page = "repository_management"
+            st.experimental_rerun()
+
+    with quick_actions_col2:
+        if st.button(
+            "🔄 Refresh Models", key="refresh_models_home", use_container_width=True
+        ):
+            with st.spinner("Refreshing models..."):
+                try:
+                    st.session_state.models = st.session_state.client.get_user_models()
+                    st.success("Models refreshed!")
+                except Exception as e:
+                    st.error(f"Error refreshing models: {str(e)}")
+
+    # Your Models section
+    st.markdown("### 📚 Your Models")
+
+    if not st.session_state.models:
+        st.info(
+            "You don't have any models yet. Click 'Create New Repository' to get started!"
+        )
+    else:
+        # Create dataframe from models list for display
+        models_data = []
+        for model in st.session_state.models:
+            try:
+                # Extract key data
+                last_modified = (
+                    datetime.fromisoformat(model.lastModified.replace("Z", "+00:00"))
+                    if hasattr(model, "lastModified")
+                    else None
+                )
+                
+                model_data = {
+                    "Model Name": model.modelId.split("/")[-1],
+                    "Full ID": model.modelId,
+                    "Downloads": getattr(model, "downloads", 0),
+                    "Likes": getattr(model, "likes", 0),
+                    "Last Modified": last_modified,
+                    "Private": getattr(model, "private", False),
+                }
+                models_data.append(model_data)
+            except Exception as e:
+                st.warning(f"Error processing model {getattr(model, 'modelId', 'unknown')}: {str(e)}")
+
+        # Sorting
+        sort_options = ["Last Modified", "Downloads", "Likes", "Model Name"]
+        sort_by = st.selectbox("Sort by", sort_options, index=0)
+        
+        # Create DataFrame and sort
+        if models_data:
+            df = pd.DataFrame(models_data)
+            if sort_by == "Last Modified":
+                df = df.sort_values(by=sort_by, ascending=False)
+            elif sort_by in ["Downloads", "Likes"]:
+                df = df.sort_values(by=sort_by, ascending=False)
+            else:
+                df = df.sort_values(by=sort_by)
+            
+            # Format the Last Modified date
+            df["Last Modified"] = df["Last Modified"].apply(
+                lambda x: x.strftime("%b %d, %Y") if pd.notnull(x) else "N/A"
+            )
+            
+            # Display models as cards
+            for i, row in df.iterrows():
+                with st.container():
+                    col1, col2 = st.columns([3, 1])
+                    with col1:
+                        st.markdown(
+                            f"""
+                            <div style="padding: 16px; background-color: #F9FAFB; border-radius: 8px; border: 1px solid #E5E7EB; margin-bottom: 16px; cursor: pointer; transition: all 0.3s;" 
+                                 onclick="window.open('https://huggingface.co/{row['Full ID']}', '_blank')">
+                                <div style="display: flex; justify-content: space-between; align-items: center;">
+                                    <div>
+                                        <h3 style="margin: 0; color: #111827;">{row['Model Name']}</h3>
+                                        <p style="margin: 4px 0 0 0; color: #6B7280; font-size: 14px;">{row['Full ID']}</p>
+                                    </div>
+                                    <div style="display: flex; align-items: center;">
+                                        <div style="margin-right: 16px; text-align: center;">
+                                            <div style="font-weight: bold; color: #10B981;">{row['Downloads']:,}</div>
+                                            <div style="font-size: 12px; color: #6B7280;">downloads</div>
+                                        </div>
+                                        <div style="margin-right: 16px; text-align: center;">
+                                            <div style="font-weight: bold; color: #FF9D96;">{row['Likes']}</div>
+                                            <div style="font-size: 12px; color: #6B7280;">likes</div>
+                                        </div>
+                                        <div style="text-align: center;">
+                                            <div style="font-weight: bold; color: #6366F1;">{row['Last Modified']}</div>
+                                            <div style="font-size: 12px; color: #6B7280;">updated</div>
+                                        </div>
+                                    </div>
+                                </div>
+                            </div>
+                            """,
+                            unsafe_allow_html=True,
+                        )
+                    with col2:
+                        if st.button(
+                            "📝 Manage", 
+                            key=f"manage_{row['Full ID']}", 
+                            use_container_width=True
+                        ):
+                            st.session_state.selected_model = row["Full ID"]
+                            st.session_state.page = "model_details"
+                            st.experimental_rerun()

pages/model_details.py

@@ -0,0 +1,177 @@
+import streamlit as st
+import time
+from components.edit_model import edit_model_form
+from components.upload_model import upload_model_form
+
+
+def render_model_details():
+    """Render the model details page"""
+
+    if not st.session_state.selected_model:
+        st.error("No model selected. Please select a model from the sidebar.")
+        if st.button("Go back to Dashboard", use_container_width=True):
+            st.session_state.page = "home"
+            st.rerun()
+        return
+
+    # Get model info from Hugging Face API
+    with st.spinner("Loading model details..."):
+        try:
+            repo_id = st.session_state.selected_model
+            model_info = st.session_state.client.get_model_info(repo_id)
+
+            if not model_info:
+                st.error(
+                    "Model not found. It may have been deleted or you don't have access."
+                )
+                if st.button("Go back to Dashboard", use_container_width=True):
+                    st.session_state.page = "home"
+                    st.rerun()
+                return
+        except Exception as e:
+            st.error(f"Error loading model details: {str(e)}")
+            if st.button("Go back to Dashboard", use_container_width=True):
+                st.session_state.page = "home"
+                st.rerun()
+            return
+
+    # Display model header
+    st.title(f"Model: {repo_id}")
+
+    # Display model information
+    col1, col2 = st.columns([2, 1])
+
+    with col1:
+        st.markdown(
+            f"""
+        <div style="background-color: #F9FAFB; padding: 20px; border-radius: 10px; border: 1px solid #E5E7EB;">
+            <div style="display: flex; align-items: center; justify-content: space-between; margin-bottom: 10px;">
+                <h3 style="margin: 0;">{repo_id.split('/')[-1]}</h3>
+                <div>
+                    <span style="background-color: #FFD21E; padding: 5px 10px; border-radius: 20px; font-size: 12px; margin-right: 5px;">
+                        {model_info.modelId.split('/')[0]}
+                    </span>
+                    <span style="background-color: #84ADFF; padding: 5px 10px; border-radius: 20px; font-size: 12px;">
+                        {model_info.pipeline_tag if hasattr(model_info, 'pipeline_tag') else 'model'}
+                    </span>
+                </div>
+            </div>
+            <div style="margin-bottom: 10px;">
+                <a href="https://huggingface.co/{repo_id}" target="_blank" style="color: #84ADFF; text-decoration: none;">
+                    View on Hugging Face Hub 🔗
+                </a>
+            </div>
+            <div style="display: flex; gap: 20px; margin-top: 20px;">
+                <div>
+                    <div style="color: #6B7280; font-size: 12px;">DOWNLOADS</div>
+                    <div style="font-weight: bold;">{getattr(model_info, 'downloads', 0)}</div>
+                </div>
+                <div>
+                    <div style="color: #6B7280; font-size: 12px;">LIKES</div>
+                    <div style="font-weight: bold;">{getattr(model_info, 'likes', 0)}</div>
+                </div>
+                <div>
+                    <div style="color: #6B7280; font-size: 12px;">LAST MODIFIED</div>
+                    <div style="font-weight: bold;">
+                        {getattr(model_info, 'lastModified', 'Unknown').split('T')[0] if hasattr(model_info, 'lastModified') else 'Unknown'}
+                    </div>
+                </div>
+            </div>
+        </div>
+        """,
+            unsafe_allow_html=True,
+        )
+
+    with col2:
+        st.markdown(
+            f"""
+        <div style="background-color: #F9FAFB; padding: 20px; border-radius: 10px; border: 1px solid #E5E7EB; height: 100%;">
+            <div style="color: #6B7280; font-size: 12px; margin-bottom: 10px;">TAGS</div>
+            <div style="display: flex; flex-wrap: wrap; gap: 5px;">
+                {' '.join([f'<span style="background-color: #E5E7EB; padding: 5px 10px; border-radius: 20px; font-size: 12px;">{tag}</span>' for tag in (model_info.tags if hasattr(model_info, 'tags') else [])])}
+            </div>
+        </div>
+        """,
+            unsafe_allow_html=True,
+        )
+
+    # Tabs for different actions
+    tab1, tab2, tab3, tab4, tab5, tab6 = st.tabs(["Model Card", "Upload Files", "Edit Model", "Version Control", "Test Inference", "Auto Documentation"])
+
+    with tab1:
+        st.markdown("### Model Card")
+
+        # Display model card iframe
+        st.markdown(
+            f"""
+        <iframe src="https://huggingface.co/{repo_id}" width="100%" height="600" style="border: 1px solid #E5E7EB; border-radius: 10px;"></iframe>
+        """,
+            unsafe_allow_html=True,
+        )
+
+    with tab2:
+        success = upload_model_form(model_info)
+        if success:
+            # Refresh model info after successful upload
+            time.sleep(2)  # Wait for the API to update
+            st.session_state.selected_model = repo_id  # Keep the same model selected
+            st.rerun()
+
+    with tab3:
+        success, _ = edit_model_form(model_info)
+        if success:
+            # Refresh model info after successful edit
+            time.sleep(2)  # Wait for the API to update
+            st.session_state.selected_model = repo_id  # Keep the same model selected
+            st.rerun()
+
+    with tab4:
+        from components.version_control import render_version_history
+        render_version_history(model_info)
+
+    with tab5:
+        from components.model_inference import model_inference_dashboard
+        model_inference_dashboard(model_info)
+
+    with tab6:
+        from components.documentation_generator import model_documentation_generator
+        model_documentation_generator(model_info)
+
+    # Delete model option
+    st.markdown("---")
+    with st.expander("⚠️ Danger Zone"):
+        st.warning(
+            "Deleting a repository is irreversible. All files and data will be permanently lost."
+        )
+
+        # Confirmation input
+        confirm_text = st.text_input(
+            f"Type the repository name '{repo_id.split('/')[-1]}' to confirm deletion:",
+            key="confirm_delete_input",
+        )
+
+        if st.button(
+            "🗑️ Delete Repository", key="delete_repo_btn", use_container_width=True
+        ):
+            if confirm_text == repo_id.split("/")[-1]:
+                with st.spinner("Deleting repository..."):
+                    try:
+                        success, message = (
+                            st.session_state.client.delete_model_repository(repo_id)
+                        )
+
+                        if success:
+                            st.success("Repository deleted successfully!")
+                            # Refresh models and go back to home
+                            st.session_state.models = (
+                                st.session_state.client.get_user_models()
+                            )
+                            st.session_state.page = "home"
+                            st.session_state.selected_model = None
+                            st.rerun()
+                        else:
+                            st.error(f"Failed to delete repository: {message}")
+                    except Exception as e:
+                        st.error(f"Error deleting repository: {str(e)}")
+            else:
+                st.error("Repository name doesn't match. Deletion aborted.")

pages/repository_management.py

@@ -0,0 +1,55 @@
+
+import streamlit as st
+from components.create_repository import create_repository_form
+
+def render_repository_management():
+    """Render the repository management page"""
+    st.title("🗄️ Repository Management")
+
+    st.markdown(
+        """
+        Create and manage your Hugging Face model repositories. 
+        A repository is where you store model files, configuration, and documentation.
+        """
+    )
+
+    # Create new repository section
+    created, repo_id = create_repository_form()
+    
+    if created and repo_id:
+        # If repository was created, navigate to model details page
+        st.session_state.selected_model = repo_id
+        st.session_state.page = "model_details"
+        st.rerun()
+
+    # Tips for repository creation
+    with st.expander("Tips for creating a good repository"):
+        st.markdown(
+            """
+        ### Best Practices for Model Repositories
+        
+        1. **Choose a descriptive name**
+           - Use clear, lowercase names with hyphens (e.g., `bert-finetuned-sentiment`)
+           - Avoid generic names like "test" or "model"
+        
+        2. **Add appropriate tags**
+           - Tags help others discover your model
+           - Include task types (e.g., "text-classification", "object-detection")
+           - Add framework tags (e.g., "pytorch", "tensorflow")
+        
+        3. **Write a comprehensive model card**
+           - Describe what the model does and how it was trained
+           - Document model limitations and biases
+           - Include performance metrics
+           - Specify intended use cases
+        
+        4. **Organize your files**
+           - Include all necessary files for model loading
+           - Add configuration files
+           - Include example scripts if helpful
+        
+        5. **License your model appropriately**
+           - Choose an open-source license if possible
+           - Document any usage restrictions
+        """
+        )

pyproject.toml

@@ -0,0 +1,9 @@
+[project]
+name = "repl-nix-workspace"
+version = "0.1.0"
+description = "Add your description here"
+requires-python = ">=3.11"
+dependencies = [
+    "huggingface-hub>=0.29.2",
+    "streamlit>=1.43.1",
+]

replit.nix

@@ -0,0 +1,7 @@
+{pkgs}: {
+  deps = [
+    pkgs.glibcLocales
+    pkgs.python312Packages.autopep8
+    pkgs.pre-commit
+  ];
+}

requirements.txt

@@ -0,0 +1,15 @@
+
+# Core dependencies
+huggingface-hub>=0.29.2
+streamlit>=1.43.1
+
+# Development tools
+black
+isort
+mypy
+pylint
+pytest
+flake8
+numpy
+pandas
+plotly

utils/__init__.py

@@ -0,0 +1 @@
+# This file is intentionally left empty to make the directory a Python package

utils/api_client.py

@@ -0,0 +1,154 @@
+import os
+import requests
+import tempfile
+import streamlit as st
+from huggingface_hub import (
+    HfApi,
+    login,
+    create_repo,
+    delete_repo,
+    upload_file,
+    HfFolder,
+)
+from huggingface_hub.utils import RepositoryNotFoundError, RevisionNotFoundError
+
+
+class HuggingFaceClient:
+    def __init__(self, token=None):
+        self.token = token
+        self.api = HfApi(token=token)
+
+    def authenticate(self, token):
+        """Authenticate with Hugging Face API using token"""
+        self.token = token
+        self.api = HfApi(token=token)
+        try:
+            login(token=token)
+            whoami = self.api.whoami()
+            return True, whoami
+        except Exception as e:
+            return False, str(e)
+
+    def get_user_models(self):
+        """Get all models created by the logged-in user"""
+        try:
+            # First try to get username from whoami API call
+            whoami = self.api.whoami()
+            username = whoami.get("name")
+
+            # Fallback to the HF_USERNAME secret if available
+            if not username and os.environ.get("HF_USERNAME"):
+                username = os.environ.get("HF_USERNAME")
+
+            # Get all models for this user using the list_models API
+            user_models = list(self.api.list_models(author=username))
+            return user_models
+        except Exception as e:
+            st.error(f"Error fetching models: {str(e)}")
+            return []
+
+    def get_model_info(self, repo_id):
+        """Get detailed information about a specific model"""
+        try:
+            model_info = self.api.model_info(repo_id)
+            return model_info
+        except RepositoryNotFoundError:
+            st.error(f"Repository {repo_id} not found")
+            return None
+        except Exception as e:
+            st.error(f"Error fetching model info: {str(e)}")
+            return None
+
+    def create_model_repository(
+        self, repo_name, is_private=False, exist_ok=False, repo_type="model"
+    ):
+        """Create a new model repository on Hugging Face"""
+        try:
+            response = create_repo(
+                repo_id=repo_name,
+                token=self.token,
+                private=is_private,
+                exist_ok=exist_ok,
+                repo_type=repo_type,
+            )
+            return True, response
+        except Exception as e:
+            return False, str(e)
+
+    def delete_model_repository(self, repo_id):
+        """Delete a model repository from Hugging Face"""
+        try:
+            response = delete_repo(repo_id=repo_id, token=self.token)
+            return True, "Repository deleted successfully"
+        except Exception as e:
+            return False, str(e)
+
+    def upload_model_files(self, repo_id, files, commit_message="Upload model files"):
+        """Upload model files to a repository"""
+        try:
+            uploaded_files = []
+            for file_path, file_content in files.items():
+                with tempfile.NamedTemporaryFile(delete=False) as temp_file:
+                    temp_file.write(file_content)
+                    temp_file_path = temp_file.name
+
+                upload_response = upload_file(
+                    path_or_fileobj=temp_file_path,
+                    path_in_repo=file_path,
+                    repo_id=repo_id,
+                    token=self.token,
+                    commit_message=commit_message,
+                )
+                uploaded_files.append(upload_response)
+
+                # Clean up temporary file
+                os.unlink(temp_file_path)
+
+            return True, uploaded_files
+        except Exception as e:
+            return False, str(e)
+
+    def update_model_card(self, repo_id, model_card_content):
+        """Update the README.md (model card) of a repository"""
+        try:
+            with tempfile.NamedTemporaryFile(delete=False, mode="w") as temp_file:
+                temp_file.write(model_card_content)
+                temp_file_path = temp_file.name
+
+            upload_response = upload_file(
+                path_or_fileobj=temp_file_path,
+                path_in_repo="README.md",
+                repo_id=repo_id,
+                token=self.token,
+                commit_message="Update model card",
+            )
+
+            # Clean up temporary file
+            os.unlink(temp_file_path)
+
+            return True, upload_response
+        except Exception as e:
+            return False, str(e)
+
+    def get_model_tags(self):
+        """Get available model tags from Hugging Face Hub"""
+        try:
+            # This is a simplified version; in a real app, you'd fetch actual tags from the HF API
+            tags = [
+                "text-classification",
+                "token-classification",
+                "question-answering",
+                "translation",
+                "summarization",
+                "text-generation",
+                "fill-mask",
+                "conversational",
+                "image-classification",
+                "object-detection",
+                "audio-classification",
+                "automatic-speech-recognition",
+            ]
+            return tags
+        except Exception as e:
+            st.error(f"Error fetching tags: {str(e)}")
+            return []

utils/auth.py

@@ -0,0 +1,91 @@
+import streamlit as st
+import os
+from utils.api_client import HuggingFaceClient
+
+
+def check_authentication():
+    """Handle user authentication with Hugging Face API"""
+
+    st.markdown(
+        """
+    <div style="text-align: center; margin-bottom: 30px;">
+        <h1>🤗 Hugging Face Model Manager</h1>
+        <p>Manage your machine learning models and publish to the Hugging Face Model Hub</p>
+    </div>
+    """,
+        unsafe_allow_html=True,
+    )
+
+    st.markdown(
+        """
+    <div style="background-color: #F9FAFB; padding: 20px; border-radius: 10px; border: 1px solid #E5E7EB;">
+        <h3 style="margin-top: 0;">Welcome to Hugging Face Model Manager</h3>
+        <p>This application allows you to:</p>
+        <ul>
+            <li>Create and manage model repositories</li>
+            <li>Upload and publish models to Hugging Face Hub</li>
+            <li>Update model metadata and documentation</li>
+            <li>Organize your models with tags and descriptions</li>
+        </ul>
+    </div>
+    """,
+        unsafe_allow_html=True,
+    )
+
+    with st.form("auth_form"):
+        st.subheader("Login with Hugging Face API Token")
+
+        # Info alert about creating a token
+        st.info(
+            """
+        To use this application, you need a Hugging Face API token.
+
+        You can create one at: [https://huggingface.co/settings/tokens](https://huggingface.co/settings/tokens)
+
+        Make sure to grant **write** access if you want to upload models.
+        """
+        )
+
+        # Token input
+        token = st.text_input("Enter your Hugging Face API token", type="password")
+
+        # Get token from environment or Secrets if available and not provided
+        if not token:
+            if os.environ.get("HF_TOKEN"):
+                token = os.environ.get("HF_TOKEN")
+                st.success("Using API token from Secrets.")
+            elif os.environ.get("HF_API_TOKEN"):
+                token = os.environ.get("HF_API_TOKEN")
+                st.success("Using API token from environment variables.")
+
+        submitted = st.form_submit_button("Login", use_container_width=True)
+
+        if submitted and token:
+            # Authenticate with Hugging Face
+            with st.spinner("Authenticating..."):
+                client = HuggingFaceClient()
+                success, user_info = client.authenticate(token)
+
+                if success:
+                    st.session_state.authenticated = True
+                    st.session_state.api_token = token
+                    st.session_state.username = user_info.get("name", "User")
+                    st.session_state.client = client
+                    st.success(
+                        f"Successfully authenticated as {st.session_state.username}"
+                    )
+                    st.rerun()
+                else:
+                    st.error(f"Authentication failed: {user_info}")
+
+        elif submitted:
+            st.error("Please enter your Hugging Face API token")
+
+
+def logout():
+    """Log out the current user"""
+    for key in list(st.session_state.keys()):
+        del st.session_state[key]
+    st.session_state.authenticated = False
+    st.session_state.page = "home"
+    st.rerun()