Create app.py

app.py

@@ -0,0 +1,180 @@
+import pandas as pd
+import numpy as np
+import plotly.graph_objects as go
+import gradio as gr
+from datasets import Dataset, DatasetDict
+from huggingface_hub import HfApi, HfFolder
+
+# Generate a synthetic dataset
+def synthesize_dataset(file_path):
+    np.random.seed(42)
+    data = {
+        'title': [f'Place {i}' for i in range(100)],
+        'latitude': np.random.uniform(low=32.0, high=36.0, size=100),
+        'longitude': np.random.uniform(low=-114.0, high=-110.0, size=100),
+        'info': [f'Info {i}' for i in range(100)]
+    }
+    df = pd.DataFrame(data)
+    df.to_csv(file_path, index=False)
+    return df
+
+class DataLoader:
+    """
+    Class to handle loading of datasets.
+    """
+
+    def __init__(self, file_path: str):
+        """
+        Initialize with the path to the dataset file.
+
+        Args:
+            file_path (str): Path to the CSV dataset file.
+        """
+        self.file_path = file_path
+
+    def load(self) -> pd.DataFrame:
+        """
+        Load the dataset from the CSV file.
+
+        Returns:
+            pd.DataFrame: Loaded dataset as a pandas DataFrame.
+        """
+        return pd.read_csv(self.file_path)
+
+class MapVisualizer:
+    """
+    Class to handle creation of map visualizations.
+    """
+
+    def __init__(self, df: pd.DataFrame):
+        """
+        Initialize with a DataFrame.
+
+        Args:
+            df (pd.DataFrame): DataFrame containing the data to visualize.
+        """
+        self.df = df
+
+    def create(self, filter_keyword: str) -> go.Figure:
+        """
+        Create a map visualization filtered by a keyword.
+
+        Args:
+            filter_keyword (str): Keyword to filter the dataset by 'title' column.
+
+        Returns:
+            go.Figure: Plotly figure object with the map visualization.
+        """
+        filtered_df = self.df[self.df['title'].str.contains(filter_keyword, case=False, na=False)]
+        
+        fig = go.Figure(go.Scattermapbox(
+            lat=filtered_df['latitude'].tolist(),
+            lon=filtered_df['longitude'].tolist(),
+            mode='markers',
+            marker=go.scattermapbox.Marker(size=6),
+            text=filtered_df['info'].tolist(),
+            hoverinfo="text",
+            hovertemplate='<b>Info</b>: %{text}<br><b>Latitude</b>: %{lat}<br><b>Longitude</b>: %{lon}'
+        ))
+
+        fig.update_layout(
+            mapbox_style="open-street-map",
+            hovermode='closest',
+            mapbox=dict(
+                bearing=0,
+                center=go.layout.mapbox.Center(
+                    lat=filtered_df['latitude'].mean(),
+                    lon=filtered_df['longitude'].mean()
+                ),
+                pitch=0,
+                zoom=8
+            ),
+        )
+
+        return fig
+
+class GradioApp:
+    """
+    Class to handle the Gradio application interface.
+    """
+
+    def __init__(self, dataset_path: str):
+        """
+        Initialize with the path to the dataset.
+
+        Args:
+            dataset_path (str): Path to the dataset CSV file.
+        """
+        self.data_loader = DataLoader(dataset_path)
+        self.df = self.data_loader.load()
+        self.map_visualizer = MapVisualizer(self.df)
+        
+    def filter_map(self, keyword: str) -> go.Figure:
+        """
+        Filter the map visualization by a keyword.
+
+        Args:
+            keyword (str): Keyword to filter the dataset by 'title' column.
+
+        Returns:
+            go.Figure: Plotly figure object with the map visualization.
+        """
+        return self.map_visualizer.create(keyword)
+
+    def launch(self):
+        """
+        Launch the Gradio application.
+        """
+        with gr.Blocks() as demo:
+            gr.Markdown("# 📈 Real-Time Map Plot")
+            keyword_input = gr.Textbox(label="Keyword to Filter", placeholder="Enter keyword")
+            map_output = gr.Plot()
+            filter_button = gr.Button("Update Map")
+
+            filter_button.click(self.filter_map, inputs=[keyword_input], outputs=map_output)
+
+        demo.launch(share=True)
+
+class HuggingFaceIntegration:
+    """
+    Class to handle interaction with Hugging Face Hub.
+    """
+
+    def __init__(self):
+        """
+        Initialize Hugging Face API.
+        """
+        self.api = HfApi()
+
+    def upload_dataset(self, df: pd.DataFrame, repo_id: str):
+        """
+        Upload dataset to Hugging Face Hub.
+
+        Args:
+            df (pd.DataFrame): DataFrame containing the dataset.
+            repo_id (str): Hugging Face repository ID.
+        """
+        dataset = Dataset.from_pandas(df)
+        dataset_dict = DatasetDict({"train": dataset})
+        dataset_dict.push_to_hub(repo_id)
+
+    def load_dataset(self, repo_id: str) -> pd.DataFrame:
+        """
+        Load dataset from Hugging Face Hub.
+
+        Args:
+            repo_id (str): Hugging Face repository ID.
+
+        Returns:
+            pd.DataFrame: Loaded dataset as a pandas DataFrame.
+        """
+        dataset = Dataset.from_hub(repo_id, split="train")
+        return dataset.to_pandas()
+
+# Synthesize a dataset
+synthesize_dataset('/content/synthetic_dataset.csv')
+
+# Create and launch the Gradio app
+if __name__ == "__main__":
+    app = GradioApp('/content/synthetic_dataset.csv')
+    app.launch()