Update pages/Types of Data.py

pages/Types of Data.py

@@ -1,6 +1,15 @@
 import streamlit as st
+from streamlit_lottie import st_lottie  # For Lottie animations
+import requests
 
-# Custom CSS for enhanced styling with gradients and interactive hover effects
+# Function to load Lottie animations
+def load_lottie_url(url):
+    response = requests.get(url)
+    if response.status_code == 200:
+        return response.json()
+    return None
+
+# Custom CSS for enhanced styling
 st.markdown(
     """
     <style>
@@ -15,429 +24,96 @@ st.markdown(
     .css-1d391kg p, .css-1v0mbdj p {
         color: #B0BEC5;
     }
-    .css-1aumxhk .stSlider .st-dh{
-        background-color: #76FF03;
-    }
     .stButton > button:hover {
         background-color: #4CAF50;
         color: white;
         transform: scale(1.05);
     }
-    .download-button button {
-        background-color: #FF4081;
-        color: white;
-    }
-    .download-button button:hover {
-        background-color: #F50057;
-        transform: scale(1.1);
-    }
     </style>
     """,
     unsafe_allow_html=True,
 )
 
-st.title("📊 Data Types Explorer", anchor=False)
+# App Title
+st.title("📊 Data Types Explorer")
 
+# Sidebar for navigation
 st.sidebar.subheader("🔍 Explore Data Types")
-
-# Dropdown to select data type to learn about
 data_type = st.sidebar.selectbox(
     "Select a Type of Data:",
     ["Structured Data", "Unstructured Data", "Semi-Structured Data"]
 )
 
-# Display information based on selected data type
+# Structured Data Section
 if data_type == "Structured Data":
     st.subheader("📋 Structured Data")
     st.write("""
-    **Definition**: Structured data refers to data that is organized and stored in a predefined format like rows and columns, making it easily searchable and manageable. 
-    It is highly organized, and each data point is placed into a defined structure.
+    **Definition**: Structured data is organized and stored in a predefined format like rows and columns, making it easily searchable and manageable.
     """)
-
-    st.write("**Features**:")
     st.markdown("""
-    - Fixed schema (e.g., tables with defined columns and data types).  
-    - Easy to process and analyze using query languages like SQL.  
-    - Relationships between data points are well-defined.  
+    **Features**:
+    - Fixed schema (e.g., tables with defined columns and data types).
+    - Easy to process using query languages like SQL.
+    - Relationships between data points are well-defined.
     """)
+    st.markdown("**Examples**: Excel Files 📊, MySQL Databases 💾")
 
-    st.write("**Examples of Structured Data**:")
-    st.markdown("""
-    1. **Excel Files** 📊
-    2. **MySQL Databases** 💾
-    """)
-
-
-    # Buttons for Structured Data Examples
-    if st.button("Show Excel Files 📂"):
+    if st.button("Learn About Excel Files 📂"):
         st.subheader("Excel Files")
         st.write("""
-        Excel files store structured data in rows and columns. They allow for easy calculations, analysis, and data manipulation using formulas or pivot tables.
-        Excel is a widely used tool in business, finance, and data analytics.
+        Excel files store structured data in rows and columns, making them ideal for analysis, visualization, and calculations.
         """)
-        # In the Structured Data page, add the following for the Excel button:
-        st.subheader("Excel Files")
-        st.write("""
-    **Excel** is a spreadsheet application developed by Microsoft. It stores structured data in rows and columns, 
-    making it ideal for data analysis, calculations, and visualization.
-    **Key Features of Excel:**
-    - Store, analyze, and visualize data in tabular format.
-    - Support for formulas, functions, and pivot tables for advanced data manipulation.
-    - Integration with other applications and databases.
-    - Support for multiple sheets in a single workbook.
-    **Common Extensions:**
-    - `.xlsx` (default format for modern Excel)
-    - `.xls` (older format for Excel)
-    - `.csv` (Comma-Separated Values, compatible with Excel)
-    **How to Handle Excel Files in Python:**
-    Python provides libraries like `pandas` and `openpyxl` for reading, writing, and processing Excel files.
-    """)
-
-        st.write("### Convert Excel to CSV 📄")
-        st.code("""
-import pandas as pd
-# Convert a single Excel sheet to CSV
-def excel_to_csv(excel_file, csv_file):
-    df = pd.read_excel(excel_file)  # Read the Excel file
-    df.to_csv(csv_file, index=False)  # Save as CSV
-    print(f"Excel file converted to {csv_file}")
-# Example usage
-excel_to_csv('input_file.xlsx', 'output_file.csv')
-    """, language="python")
-
-        st.write("### Convert Multiple Sheets to CSV 📄")
         st.code("""
 import pandas as pd
-# Convert all sheets in an Excel file to separate CSV files
-def excel_sheets_to_csv(excel_file, output_dir):
-    # Read all sheets
-    sheets = pd.read_excel(excel_file, sheet_name=None)  
-    for sheet_name, data in sheets.items():
-        csv_file = f"{output_dir}/{sheet_name}.csv"  # Name CSV files by sheet name
-        data.to_csv(csv_file, index=False)
-        print(f"Sheet '{sheet_name}' converted to {csv_file}")
-# Example usage
-excel_sheets_to_csv('input_file.xlsx', 'output_directory')
-    """, language="python")
-
-    # Placeholder button for GitHub link
-        if st.button("GitHub Link 🔗"):
-            st.write("**GitHub Repository:** [Provide your GitHub link here]")
+df = pd.read_excel('file.xlsx')
+df.to_csv('file.csv', index=False)
+        """, language="python")
 
-    # Optional: Add an animation for Excel
-        excel_animation_url = "https://assets9.lottiefiles.com/packages/lf20_ktn4ouly.json"  # Example Lottie URL for Excel
-        excel_animation = load_lottie_url(excel_animation_url)
-        if excel_animation:
-            st_lottie(excel_animation, height=300, key="excel_animation")
-
-    if st.button("Show MySQL Databases 💻"):
+    if st.button("Learn About MySQL Databases 💻"):
         st.subheader("MySQL Databases")
         st.write("""
-        MySQL is a relational database management system that stores structured data in tables. SQL (Structured Query Language) is used to query and manipulate data in these databases.
-        It is commonly used in web applications and enterprise systems.
+        MySQL is a relational database management system for storing structured data in tables. SQL is used to query and manipulate data.
         """)
-    
-        st.write("""
-    **MySQL** is an open-source relational database management system (RDBMS) that stores structured data in tables. 
-    It is widely used for managing and organizing data in web applications, enterprise systems, and data-driven projects.
-    **Key Features of MySQL:**
-    - High performance, scalability, and reliability.
-    - Support for SQL (Structured Query Language) for querying and managing data.
-    - Multi-user access and role-based permissions.
-    - Integration with multiple programming languages like Python, PHP, Java, etc.
-    **Common Use Cases:**
-    - Web application backends (e.g., WordPress, e-commerce platforms).
-    - Data analytics and reporting.
-    - Content management systems (CMS).
-    
-    **MySQL Extensions:**
-    - `.sql`: Standard file extension for SQL database dumps.
-    - `.db`: Extension used by certain database systems but can also represent MySQL databases.
-    """)
-
-        st.write("""
-    ### Advantages of MySQL:
-    - Open-source and free to use.
-    - Cross-platform support (Windows, Linux, macOS).
-    - Regular updates and strong community support.
-    - Supports ACID compliance for data reliability.
-    ### Limitations of MySQL:
-    - Not as feature-rich as some enterprise-level database systems (e.g., Oracle, MS SQL Server).
-    - Limited support for advanced analytics and distributed databases.
-    """)
-
-    # Placeholder button for GitHub link
-        if st.button("GitHub Link 🔗"):
-            st.write("**GitHub Repository:** [Provide your GitHub link here]")
-
-    # Optional: Add an animation for MySQL
-        mysql_animation_url = "https://assets10.lottiefiles.com/packages/lf20_kq5msyia.json"  # Example Lottie URL for MySQL
-        mysql_animation = load_lottie_url(mysql_animation_url)
-        if mysql_animation:
-            st_lottie(mysql_animation, height=300, key="mysql_animation")
-
-
 
+# Unstructured Data Section
 elif data_type == "Unstructured Data":
     st.subheader("🗂️ Unstructured Data")
-     st.write("""
-    **Definition**: Unstructured data lacks any predefined structure or schema, making it the most difficult to organize and analyze. 
-    It is typically raw and needs advanced processing to extract insights.
-    """)
-
-    st.write("**Features**:")
-    st.markdown("""
-    - Free-form; not stored in a tabular format.  
-    - Requires specialized tools like AI or machine learning to analyze.  
-    """)
-
-    st.write("**Examples of Unstructured Data**:")
-    st.markdown("""
-    1. **Images 🖼️**
-    2. **Videos 🎥**
-    3. **Audio 🔊**
-    4. **Text 🖹**
+    st.write("""
+    **Definition**: Unstructured data lacks any predefined structure or schema, making it the most difficult to organize and analyze.
     """)
+    st.markdown("**Examples**: Images 🖼️, Videos 🎥, Audio 🔊, Text 📝")
 
-    # Buttons for Unstructured Data Examples
-    if st.button("Show Image 📷"):
+    if st.button("Learn About Images 📷"):
         st.subheader("Working with Images")
         st.write("""
-    **Images** are one of the most common forms of unstructured data. They are represented as a grid of pixels, each having color information (RGB or grayscale). Images are used in various domains such as computer vision, medical imaging, and entertainment.
-    **Common File Formats:**
-    - `.jpg` or `.jpeg` (Joint Photographic Experts Group)
-    - `.png` (Portable Network Graphics)
-    - `.bmp` (Bitmap Image File)
-    - `.tiff` (Tagged Image File Format)
-    """)
-
-        st.write("### Steps to Convert an Image into an Array 📊")
-        st.write("""
-    Converting an image into a numerical array is a key step in image processing. Here's how it's typically done:
-    1. Load the image using an image processing library (e.g., OpenCV or PIL).
-    2. Convert the image into a NumPy array.
-    3. Access pixel data for analysis or manipulation.
-    """)
-
-        st.write("#### Example Code: Converting an Image into an Array")
-        st.code("""
-import cv2
-import numpy as np
-# Load the image
-image_path = 'image.jpg'  # Path to the image
-image = cv2.imread(image_path)  # Load image as BGR format
-# Convert to NumPy array
-image_array = np.array(image)
-# Display shape and pixel data
-print("Image Shape:", image_array.shape)  # (Height, Width, Channels)
-print("Pixel Data (Top-left):", image_array[0, 0])  # Pixel value at (0, 0)
-    """, language="python")
-
-    # Placeholder button for GitHub link
-        if st.button("Jupyter  Notebook 🔗 (Image)"):
-            st.markdown("https://colab.research.google.com/drive/1BxJuxD1mzeuDnPIjwc-06J_GIU2JgO1_?usp=sharing")
-
-    if st.button("Show Video 🎥"):
-        st.subheader("Working with Videos")
-        st.write("""
-    **Videos** are sequences of images (frames) that are displayed at a specific frame rate to create a moving picture. Videos are used in surveillance, entertainment, and machine learning applications like activity recognition and object detection.
-    **Common File Formats:**
-    - `.mp4` (MPEG-4 Part 14)
-    - `.avi` (Audio Video Interleave)
-    - `.mov` (QuickTime File Format)
-    - `.mkv` (Matroska Video File Format)
-    """)
-
-        st.write("### Steps to Convert a Video into Frames 📸")
-        st.write("""
-    Breaking a video into individual frames is an important step in video analysis. Here's how it's done:
-    1. Load the video using a video processing library like OpenCV.
-    2. Loop through each frame and save or process it.
-    3. Save the frames as images for further processing.
-    """)
-
-        st.write("#### Example Code: Converting a Video into Frames")
-        st.code("""
-import cv2
-import os
-# Load the video
-video_path = 'video.mp4'  # Path to the video
-video = cv2.VideoCapture(video_path)
-# Create a folder to store the frames
-output_folder = 'frames'
-os.makedirs(output_folder, exist_ok=True)
-frame_number = 0
-while True:
-    ret, frame = video.read()  # Read the next frame
-    if not ret:
-        break  # Exit if no frames are left
-    # Save the frame as an image
-    frame_path = os.path.join(output_folder, f'frame_{frame_number:04d}.jpg')
-    cv2.imwrite(frame_path, frame)
-    frame_number += 1
-print(f"Extracted {frame_number} frames and saved to {output_folder}")
-video.release()
-    """, language="python")
-
-    # Placeholder button for GitHub link
-        if st.button("GitHub Link 🔗 (Video)"):
-            st.write("**GitHub Repository:** [Provide your GitHub link here]")
-
-
-    if st.button("Show Audio 🔊"):
-        st.subheader("Audio")
-        st.write("""
-        Social media posts, such as tweets, Facebook updates, or Instagram images, represent unstructured data. They contain a mix of text, images, and metadata and require NLP (Natural Language Processing) for analysis.
+        Images are a form of unstructured data represented as grids of pixels. Common formats include JPG, PNG, and BMP.
         """)
 
-    if st.button("Show Text 📝"):
-        st.subheader("Text")
+    if st.button("Learn About Videos 🎥"):
+        st.subheader("Working with Videos")
         st.write("""
-        Social media posts, such as tweets, Facebook updates, or Instagram images, represent unstructured data. They contain a mix of text, images, and metadata and require NLP (Natural Language Processing) for analysis.
+        Videos are sequences of frames used in various applications like object detection and activity recognition. Common formats include MP4 and AVI.
         """)
 
-# Footer
-st.write("This app provides a clear understanding of data and its various types, especially based on structure. 🎉")
-
-
+# Semi-Structured Data Section
 elif data_type == "Semi-Structured Data":
     st.subheader("📄 Semi-Structured Data")
-    
     st.write("""
-    **Definition**: Semi-structured data does not have a strict table-based format but is partially organized using tags, markers, or key-value pairs. 
-    While it is more flexible than structured data, it still has some organizational components.
-    """)
-
-    st.write("**Features**:")
-    st.markdown("""
-    - Flexible schema; not bound to a rigid structure.  
-    - Easier to manage than unstructured data but more complex than structured data.  
+    **Definition**: Semi-structured data is partially organized using tags or key-value pairs. It is more flexible than structured data.
     """)
+    st.markdown("**Examples**: JSON Files 📑, XML Files 🌐")
 
-    st.write("**Examples of Semi-Structured Data**:")
-    st.markdown("""
-    1. **JSON Files** 📑
-    2. **XML Files** 🌐
-    """)
-
-    # Buttons for Semi-Structured Data Examples
-    if st.button("Show JSON Files 📄"):
+    if st.button("Learn About JSON Files 📄"):
         st.subheader("JSON Files")
         st.write("""
-    **JSON (JavaScript Object Notation)** is a lightweight data-interchange format. It is easy for humans to read and write, and it is easy for machines to parse and generate. JSON is widely used to transmit data between a server and a web application.
-    **Key Features of JSON:**
-    - Stores data as key-value pairs.
-    - Supports nested structures, such as arrays and objects.
-    - Language-independent but derived from JavaScript.
-    **Common Use Cases:**
-    - API responses and requests in web development.
-    - Configuration files for applications.
-    - Data serialization and exchange in distributed systems.
-    **File Extension:**
-    - `.json`
-    **Advantages of JSON:**
-    - Lightweight and compact.
-    - Human-readable and easy to understand.
-    - Supported by most modern programming languages.
-    **Limitations of JSON:**
-    - Does not support comments.
-    - Less efficient for very large datasets compared to binary formats.
-    """)
-
-        st.write("### Python Example: Working with JSON 📄")
-        st.write("#### Reading a JSON File and Accessing Its Data")
-        st.code("""
-import json
-# Reading a JSON file
-with open('data.json', 'r') as file:
-    data = json.load(file)
-# Accessing data
-print("Name:", data['name'])
-print("Age:", data['age'])
-    """, language="python")
-
-        st.write("#### Writing Data to a JSON File")
-        st.code("""
-# Writing data to a JSON file
-new_data = {
-    "name": "John Doe",
-    "age": 30,
-    "city": "New York"
-}
-with open('output.json', 'w') as file:
-    json.dump(new_data, file, indent=4)
-print("Data saved to output.json")
-    """, language="python")
-
-    # Placeholder button for GitHub link
-        if st.button("GitHub Link 🔗 (JSON)"):
-            st.write("**GitHub Repository:** [Provide your GitHub link here]")
-
-    # Optional: Add animation for JSON
-        json_animation_url = "https://assets9.lottiefiles.com/packages/lf20_9jdtwwzw.json"  # Example Lottie URL for JSON
-        json_animation = load_lottie_url(json_animation_url)
-        if json_animation:
-            st_lottie(json_animation, height=300, key="json_animation")
+        JSON stores data as key-value pairs and is commonly used in APIs and web development.
+        """)
 
-# XML Button
-    if st.button("Show XML Files 📄"):
+    if st.button("Learn About XML Files 📄"):
         st.subheader("XML Files")
         st.write("""
-    **XML (eXtensible Markup Language)** is a markup language designed to store and transport data. XML emphasizes simplicity, generality, and usability across the Internet.
-    **Key Features of XML:**
-    - Data is stored in a tree-like structure with nested elements.
-    - Customizable tags allow flexibility in representing data.
-    - Both human-readable and machine-readable.
-    **Common Use Cases:**
-    - Data interchange between systems.
-    - Configuration files for applications and servers.
-    - RSS feeds and web services (e.g., SOAP).
-    **File Extension:**
-    - `.xml`
-    **Advantages of XML:**
-    - Highly flexible and customizable.
-    - Self-descriptive and easy to understand.
-    - Widely supported in web and enterprise applications.
-    **Limitations of XML:**
-    - More verbose compared to JSON.
-    - Slower to parse and larger in size.
-    """)
-
-        st.write("### Python Example: Working with XML 📄")
-        st.write("#### Reading an XML File and Parsing Its Data")
-        st.code("""
-import xml.etree.ElementTree as ET
-# Parsing an XML file
-tree = ET.parse('data.xml')
-root = tree.getroot()
-# Accessing data
-for child in root:
-    print(child.tag, ":", child.text)
-    """, language="python")
-
-        st.write("#### Writing Data to an XML File")
-        st.code("""
-import xml.etree.ElementTree as ET
-# Creating an XML structure
-root = ET.Element("person")
-name = ET.SubElement(root, "name")
-name.text = "John Doe"
-age = ET.SubElement(root, "age")
-age.text = "30"
-# Writing to a file
-tree = ET.ElementTree(root)
-tree.write("output.xml")
-print("Data saved to output.xml")
-    """, language="python")
-
-    # Placeholder button for GitHub link
-        if st.button("GitHub Link 🔗 (XML)"):
-            st.write("**GitHub Repository:** [Provide your GitHub link here]")
-
-    # Optional: Add animation for XML
-        xml_animation_url = "https://assets7.lottiefiles.com/packages/lf20_7ozhpxio.json"  # Example Lottie URL for XML
-        xml_animation = load_lottie_url(xml_animation_url)
-        if xml_animation:
-            st_lottie(xml_animation, height=300, key="xml_animation")
+        XML stores data in a tree structure with nested elements. It is used in configuration files and data exchange.
+        """)
 
-st.sidebar.success("Select a data type to learn more!")
+# Footer
+st.write("This app provides a clear understanding of different data types. 🎉")