Create Types of Data.py

pages/Types of Data.py

@@ -0,0 +1,444 @@
+import streamlit as st
+from streamlit_lottie import st_lottie
+import requests
+
+# Function to load Lottie animation from a URL
+def load_lottie_url(url: str):
+    r = requests.get(url)
+    if r.status_code != 200:
+        return None
+    return r.json()
+
+# Load animations using URLs
+structured_animation_url = "https://assets10.lottiefiles.com/packages/lf20_4j6cnjjm.json"  # Example URL for structured data
+semi_structured_animation_url = "https://assets10.lottiefiles.com/packages/lf20_0fhcmhgf.json"  # Example URL for semi-structured data
+unstructured_animation_url = "https://assets10.lottiefiles.com/packages/lf20_rekwjvy0.json"  # Example URL for unstructured data
+
+# Sidebar navigation
+st.sidebar.title("Navigation")
+page = st.sidebar.radio("Choose a page", ["Home", "Structured Data", "Semi-Structured Data", "Unstructured Data"])
+
+# Home Page: Overview of What is Data and Types of Data
+if page == "Home":
+    st.title("Understanding Data and Its Types 🌐")
+    
+    st.header("What is Data?")
+    st.write("""
+    **Data** refers to raw facts, figures, or information that can be collected, measured, and analyzed for specific purposes. 
+    It serves as the foundation for generating insights, making decisions, and solving problems in various fields like business, 
+    science, and technology. 🧠
+    """)
+    
+    st.header("Types of Data 📊")
+    st.write("Data can exist in various forms depending on its source and nature. Common forms include:")
+    st.markdown("""
+    1. **Structured Data**: Data organized in a predefined format, making it easily searchable and manageable.  
+    2. **Semi-Structured Data**: Data that does not have a strict schema but is partially organized using tags or markers.  
+    3. **Unstructured Data**: Data without any predefined structure, requiring specialized tools to analyze.  
+    """)
+
+# Structured Data Page
+elif page == "Structured Data":
+    st.title("Structured Data 📋")
+    animation = load_lottie_url(structured_animation_url)
+    if animation:
+        st_lottie(animation, height=300, key="structured_animation")
+    
+    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.
+    """)
+
+    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.  
+    """)
+
+    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 📂"):
+        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.
+        """)
+        # 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]")
+
+    # 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 💻"):
+        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.
+        """)
+    
+        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")
+
+
+# Semi-Structured Data Page
+elif page == "Semi-Structured Data":
+    st.title("Semi-Structured Data 🧩")
+    animation = load_lottie_url(semi_structured_animation_url)
+    if animation:
+        st_lottie(animation, height=300, key="semi_structured_animation")
+    
+    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.  
+    """)
+
+    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 📄"):
+        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")
+
+# XML Button
+    if st.button("Show 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")
+
+
+# Unstructured Data Page
+elif page == "Unstructured Data":
+    st.title("Unstructured Data 🗂️")
+    animation = load_lottie_url(unstructured_animation_url)
+    if animation:
+        st_lottie(animation, height=300, key="unstructured_animation")
+    
+    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 🖹**
+    """)
+
+    # Buttons for Unstructured Data Examples
+    if st.button("Show Image 📷"):
+        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("GitHub Link 🔗 (Image)"):
+            st.write("**GitHub Repository:** [Provide your GitHub link here]")
+
+    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.
+        """)
+
+    if st.button("Show Text 📝"):
+        st.subheader("Text")
+        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.
+        """)
+
+# Footer
+st.write("This app provides a clear understanding of data and its various types, especially based on structure. 🎉")