ebk 0.1.0__py3-none-any.whl → 0.3.1__py3-none-any.whl

ebk/merge.py

@@ -1,308 +0,0 @@
-import os
-import json
-import shutil
-from slugify import slugify
-from typing import List, Dict, Tuple
-from .ident import add_unique_id
-import logging
-
-logger = logging.getLogger(__name__)
-
-def load_all_metadata(source_folders: List[str]) -> List[Tuple[Dict, str]]:
-    """
-    Given a list of source folders, load all 'metadata.json' files and 
-    return them as a list of (metadata_entry, source_folder).
-    """
-    all_entries = []
-    for folder in source_folders:
-        meta_path = os.path.join(folder, "metadata.json")
-        if os.path.exists(meta_path):
-            with open(meta_path, "r", encoding="utf-8") as f:
-                try:
-                    data = json.load(f)
-                    for entry in data:
-                        all_entries.append((entry, folder))
-                except json.JSONDecodeError as e:
-                    logger.error(f"Error decoding JSON from {meta_path}: {e}")
-        else:
-            logger.warning(f"No metadata.json found in {folder}")
-    return all_entries
-
-def perform_set_operation(
-    entries: List[Dict], 
-    operation: str, 
-    source_counts: Dict[str, int]
-) -> List[Dict]:
-    """
-    Perform the specified set operation on the list of entries.
-    
-    Args:
-        entries (List[Dict]): List of eBook entries with 'unique_id'.
-        operation (str): One of 'union', 'intersect', 'diff', 'symdiff'.
-        source_counts (Dict[str, int]): Counts of how many sources each unique_id appears in.
-    
-    Returns:
-        List[Dict]: Filtered list of entries based on the set operation.
-    """
-    if operation == "union":
-        # All unique entries
-        return entries
-    elif operation == "intersect":
-        # Entries present in all source libraries
-        return [entry for entry in entries if source_counts.get(entry['unique_id'], 0) == len(source_counts)]
-    elif operation == "diff":
-        # Set difference: entries present in the first library but not in others
-        # Assuming 'diff' is lib1 - lib2
-        # Modify the function signature to pass specific libraries if needed
-        return [entry for entry in entries if source_counts.get(entry['unique_id'], 0) == 1]
-    elif operation == "symdiff":
-        # Symmetric difference: entries present in one library but not in both
-        return [entry for entry in entries if source_counts.get(entry['unique_id'], 0) == 1]
-    else:
-        logger.error(f"Unsupported set operation: {operation}")
-        return []
-
-def merge_libraries(
-    source_folders: List[str], 
-    merged_folder: str, 
-    operation: str
-):
-    """
-    Merges multiple ebook libraries (each in a separate folder) into a single library
-    based on the specified set-theoretic operation.
-    
-    Args:
-        source_folders (List[str]): List of source library folders to merge.
-        merged_folder (str): Path to the folder where the merged library will be saved.
-        operation (str): Set operation to apply ('union', 'intersect', 'diff', 'symdiff').
-    """
-    if not os.path.exists(merged_folder):
-        os.makedirs(merged_folder)
-        logger.info(f"Created merged folder at {merged_folder}")
-    
-    # Load all entries
-    entries_with_sources = load_all_metadata(source_folders)
-    
-    # Index entries by unique_id
-    unique_entries = {}
-    source_counts = {}
-    
-    for entry, source in entries_with_sources:
-        uid = entry['unique_id']
-        if uid not in unique_entries:
-            unique_entries[uid] = entry
-            source_counts[uid] = 1
-        else:
-            source_counts[uid] += 1
-            # Optionally, handle metadata conflicts here
-            # For example, you could merge metadata fields or prioritize certain sources
-            # Here, we'll assume the first occurrence is kept
-            logger.debug(f"Duplicate entry found for unique_id {uid} in {source}. Ignoring.")
-    
-    all_unique_entries = list(unique_entries.values())
-    
-    # Perform the set operation
-    filtered_entries = perform_set_operation(all_unique_entries, operation, source_counts)
-    
-    logger.info(f"Performing '{operation}' operation. {len(filtered_entries)} entries selected.")
-    
-    # **New Step:** Preprocess filenames to identify conflicts
-    filename_counts = {}
-    cover_filename_counts = {}
-    
-    for entry in filtered_entries:
-        # Count ebook filenames
-        for file_rel_path in entry.get('file_paths', []):
-            filename = os.path.basename(file_rel_path)
-            filename_counts[filename] = filename_counts.get(filename, 0) + 1
-        # Count cover filenames
-        cover_path = entry.get('cover_path')
-        if cover_path:
-            cover_filename = os.path.basename(cover_path)
-            cover_filename_counts[cover_filename] = cover_filename_counts.get(cover_filename, 0) + 1
-    
-    logger.debug(f"Ebook filename counts: {filename_counts}")
-    logger.debug(f"Cover filename counts: {cover_filename_counts}")
-    
-    # Copy files and prepare merged metadata
-    merged_metadata = []
-    
-    for entry in filtered_entries:
-        # Copy eBook files with awareness of filename uniqueness
-        new_entry = copy_entry_files(entry, source_folders, merged_folder, filename_counts)
-        # Copy cover image with awareness of filename uniqueness
-        new_entry = copy_cover_image(new_entry, source_folders, merged_folder, cover_filename_counts)
-        merged_metadata.append(new_entry)
-    
-    # Write merged metadata.json
-    merged_meta_path = os.path.join(merged_folder, "metadata.json")
-    with open(merged_meta_path, "w", encoding="utf-8") as f:
-        json.dump(merged_metadata, f, indent=2, ensure_ascii=False)
-    
-    logger.info(f"Merged {len(merged_metadata)} entries into {merged_folder}")
-
-def copy_entry_files(
-    entry: Dict, 
-    source_folders: List[str], 
-    dst_folder: str,
-    filename_counts: Dict[str, int]
-) -> Dict:
-    """
-    Copies all relevant files for an entry from its source folder to the destination folder.
-    
-    Args:
-        entry (Dict): The eBook entry metadata.
-        source_folders (List[str]): List of source library folders.
-        dst_folder (str): Destination folder to copy files to.
-        filename_counts (Dict[str, int]): Counts of each ebook filename across all entries.
-    
-    Returns:
-        Dict: The updated entry with new file paths.
-    """
-    new_entry = entry.copy()
-    
-    # Find the source folder containing this entry
-    source_folder = find_source_folder(entry, source_folders)
-    if not source_folder:
-        logger.warning(f"Source folder not found for entry with unique_id {entry['unique_id']}")
-        return new_entry
-    
-    # Copy eBook files
-    new_file_paths = []
-    for file_rel_path in entry.get('file_paths', []):
-        src_path = os.path.join(source_folder, file_rel_path)
-        if not os.path.exists(src_path):
-            logger.warning(f"Ebook file '{src_path}' does not exist.")
-            continue
-        original_filename = os.path.basename(file_rel_path)
-        
-        if filename_counts.get(original_filename, 0) == 1:
-            # Filename is unique; keep it as is
-            dst_filename = original_filename
-        else:
-            # Filename is duplicated; append unique_id to disambiguate
-            name, ext = os.path.splitext(original_filename)
-            safe_name = slugify(name)
-            safe_unique_id = slugify(entry['unique_id'])
-            dst_filename = f"{safe_name}__{safe_unique_id}{ext}"
-        
-        dst_path = os.path.join(dst_folder, dst_filename)
-        dst_path = get_unique_filename(dst_path)
-        try:
-            shutil.copy(src_path, dst_path)
-        except OSError as e:
-            logger.error(f"Error copying file '{src_path}' to '{dst_path}': {e}")
-            continue
-        new_file_paths.append(os.path.basename(dst_path))
-        logger.debug(f"Copied ebook file '{src_path}' to '{dst_path}'")
-    
-    new_entry['file_paths'] = new_file_paths
-    
-    return new_entry
-
-def copy_cover_image(
-    entry: Dict, 
-    source_folders: List[str], 
-    dst_folder: str,
-    cover_filename_counts: Dict[str, int]
-) -> Dict:
-    """
-    Copies the cover image for an entry from its source folder to the destination folder.
-    
-    Args:
-        entry (Dict): The eBook entry metadata.
-        source_folders (List[str]): List of source library folders.
-        dst_folder (str): Destination folder to copy files to.
-        cover_filename_counts (Dict[str, int]): Counts of each cover filename across all entries.
-    
-    Returns:
-        Dict: The updated entry with new cover path.
-    """
-    cover_path = entry.get('cover_path')
-    if not cover_path:
-        return entry  # No cover to copy
-    
-    new_entry = entry.copy()
-    
-    # Find the source folder containing this entry
-    source_folder = find_source_folder(entry, source_folders)
-    if not source_folder:
-        logger.warning(f"Source folder not found for entry with unique_id {entry['unique_id']} (cover)")
-        new_entry['cover_path'] = None
-        return new_entry
-    
-    src_cover = os.path.join(source_folder, cover_path)
-    if not os.path.exists(src_cover):
-        logger.warning(f"Cover image '{src_cover}' does not exist.")
-        new_entry['cover_path'] = None
-        return new_entry
-    
-    original_cover_filename = os.path.basename(cover_path)
-    
-    if cover_filename_counts.get(original_cover_filename, 0) == 1:
-        # Cover filename is unique; keep it as is
-        dst_cover_filename = original_cover_filename
-    else:
-        # Cover filename is duplicated; append unique_id to disambiguate
-        name, ext = os.path.splitext(original_cover_filename)
-        safe_name = slugify(name)
-        safe_unique_id = slugify(entry['unique_id'])
-        dst_cover_filename = f"{safe_name}__{safe_unique_id}{ext}"
-    
-    dst_cover_path = os.path.join(dst_folder, dst_cover_filename)
-    dst_cover_path = get_unique_filename(dst_cover_path)
-    try:
-        shutil.copy(src_cover, dst_cover_path)
-    except OSError as e:
-        logger.error(f"Error copying cover image '{src_cover}' to '{dst_cover_path}': {e}")
-        new_entry['cover_path'] = None
-        return new_entry
-    new_entry['cover_path'] = os.path.basename(dst_cover_path)
-    logger.debug(f"Copied cover image '{src_cover}' to '{dst_cover_path}'")
-    
-    return new_entry
-
-def find_source_folder(entry: Dict, source_folders: List[str]) -> str:
-    """
-    Identifies the source folder where the entry's files are located.
-    
-    Args:
-        entry (Dict): The eBook entry metadata.
-        source_folders (List[str]): List of source library folders.
-    
-    Returns:
-        str: The path to the source folder, or None if not found.
-    """
-    for folder in source_folders:
-        meta_path = os.path.join(folder, "metadata.json")
-        if not os.path.exists(meta_path):
-            continue
-        with open(meta_path, "r", encoding="utf-8") as f:
-            try:
-                data = json.load(f)
-                for src_entry in data:
-                    if src_entry.get('unique_id') == entry.get('unique_id'):
-                        return folder
-            except json.JSONDecodeError as e:
-                logger.error(f"Error decoding JSON from {meta_path}: {e}")
-    return None
-
-def get_unique_filename(target_path: str) -> str:
-    """
-    If target_path already exists, generate a new path with (1), (2), etc.
-    Otherwise just return target_path.
-    
-    Example:
-       'myfile.pdf' -> if it exists -> 'myfile (1).pdf' -> if that exists -> 'myfile (2).pdf'
-    """
-    if not os.path.exists(target_path):
-        return target_path
-
-    base, ext = os.path.splitext(target_path)
-    counter = 1
-    new_path = f"{base} ({counter}){ext}"
-    while os.path.exists(new_path):
-        counter += 1
-        new_path = f"{base} ({counter}){ext}"
-
-    return new_path

ebk/streamlit/app.py

@@ -1,185 +0,0 @@
-import streamlit as st
-import pandas as pd
-import os
-import logging
-from utils import load_metadata, extract_zip
-from filters import sanitize_dataframe, create_filters
-from display import display_books_tab, display_statistics_tab
-
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-)
-logger = logging.getLogger(__name__)
-
-#def display_footer():
-#    st.markdown("---")
-#    st.write("Developed with ❤️ using Streamlit.")
-
-def display_dashboard(metadata_list: list, cover_images: dict, ebook_files: dict):
-    """
-    Displays the main dashboard with advanced filtering and a compact UI layout using tabs.
-    """
-    # Convert metadata list to DataFrame
-    df = pd.DataFrame(metadata_list)
-    logger.debug("Converted metadata list to DataFrame.")
-
-    # Sanitize DataFrame
-    df = sanitize_dataframe(df)
-    logger.debug("Sanitized DataFrame.")
-
-    # Apply Filters
-    filtered_df = create_filters(df)
-    logger.debug("Applied filters to DataFrame.")
-
-    # Create Tabs
-    tabs = st.tabs(["📚 Books", "📊 Statistics", "Advanced Search", "📖 Table", "📝 Instructions"])
-    
-
-    with tabs[0]:
-        # Display Books
-        display_books_tab(filtered_df, cover_images, ebook_files)
-
-    with tabs[1]:
-        # Display Statistics
-        display_statistics_tab(filtered_df)
-
-    with tabs[2]:
-        # Display Advanced Search
-        display_advanced_search_tab(metadata_list)
-
-    with tabs[3]:
-        # Display Table
-        display_table_view_tab(filtered_df)
-
-    with tabs[4]:
-        # Display Instructions
-        st.header("📝 Instructions")
-        st.markdown("""
-        1. **Prepare a ZIP Archive** of an ebk library using the following process:
-        - Go to the directory containing the desired ebk library (should have 'metadata.json` and associated files).
-        - Compress the directory into a ZIP archive.
-                - The `ebk` CLI tool can also autoatically output a ZIP archive,
-                e.g., `ebk import calibre <calibre-library> --output.zip`.
-        2. **Upload the ZIP Archive** using the uploader below.
-        3. **Use the Sidebar** to apply filters and search your library.
-        4. **Interact** with the dashboard to view details and download ebooks.
-        """)
-
-    # Display Footer
-    # display_footer()
-
-def main():
-    st.set_page_config(page_title="ebk Dashboard", layout="wide")
-    st.title("📚 ebk Dashoard")
-    st.write("""
-    Upload a **ZIP archive** containing your `metadata.json`, all associated cover images, and ebook files.
-    The app will automatically process and display your library with advanced search and filtering options.
-    """)
-
-    # File uploader for ZIP archive
-    st.subheader("📁 Upload ZIP Archive")
-    zip_file = st.file_uploader(
-        label="Upload a ZIP file containing `metadata.json`, cover images, and ebook files",
-        type=["zip"],
-        key="zip_upload"
-    )
-
-    MAX_ZIP_SIZE = 8 * 1024 * 1024 * 1024  # 1 GB
-
-    if zip_file:
-        print("Uploaded ZIP file:", zip_file.name)
-        print("🔄 File size:", zip_file.size)
-        if zip_file.size > MAX_ZIP_SIZE:
-            st.error(f"❌ Uploaded ZIP file is {zip_file.size / 1024 / 1024 / 1024:.2f} GB, which exceeds the size limit of 1 GB.")
-            logger.error("Uploaded ZIP file exceeds the size limit.")
-            st.stop()
-
-        with st.spinner("🔄 Extracting and processing ZIP archive..."):
-            extracted_files = extract_zip(zip_file)
-        if not extracted_files:
-            logger.error("No files extracted from the ZIP archive.")
-            st.stop()  # Stop if extraction failed
-
-        # Locate metadata.json (case-insensitive search)
-        metadata_key = next((k for k in extracted_files if os.path.basename(k).lower() == "metadata.json"), None)
-        if not metadata_key:
-            st.error("❌ `metadata.json` not found in the uploaded ZIP archive.")
-            logger.error("`metadata.json` not found in the uploaded ZIP archive.")
-            st.stop()
-
-        metadata_content = extracted_files[metadata_key]
-        metadata_list = load_metadata(metadata_content)
-        if not metadata_list:
-            logger.error("Failed to load metadata from `metadata.json`.")
-            st.stop()
-
-        # Collect cover images and ebook files
-        cover_images = {}
-        ebook_files = {}
-        for filename, file_bytes in extracted_files.items():
-            lower_filename = filename.lower()
-            basename = os.path.basename(filename)
-            if lower_filename.endswith(('.jpg', '.jpeg', '.png')):
-                cover_images[basename] = file_bytes
-                logger.debug(f"Added cover image: {basename}")
-            elif lower_filename.endswith(('.pdf', '.epub', '.mobi', '.azw3', '.txt')):
-                ebook_files[basename] = file_bytes
-                logger.debug(f"Added ebook file: {basename}")
-            else:
-                # Ignore other file types or handle as needed
-                logger.debug(f"Ignored unsupported file type: {basename}")
-                pass
-
-        # Inform user about unmatched cover images
-        expected_covers = {os.path.basename(md.get("cover_path", "")) for md in metadata_list if md.get("cover_path")}
-        uploaded_covers = set(cover_images.keys())
-        missing_covers = expected_covers - uploaded_covers
-        if missing_covers:
-            st.warning(f"⚠️ The following cover images are referenced in `metadata.json` but were not uploaded: {', '.join(missing_covers)}")
-            logger.warning(f"Missing cover images: {missing_covers}")
-
-        # Inform user about unmatched ebook files
-        expected_ebooks = {os.path.basename(path) for md in metadata_list for path in md.get("file_paths", [])}
-        uploaded_ebooks = set(ebook_files.keys())
-        missing_ebooks = expected_ebooks - uploaded_ebooks
-        if missing_ebooks:
-            st.warning(f"⚠️ The following ebook files are referenced in `metadata.json` but were not uploaded: {', '.join(missing_ebooks)}")
-            logger.warning(f"Missing ebook files: {missing_ebooks}")
-
-        # Display the dashboard with metadata and cover images
-        display_dashboard(metadata_list, cover_images, ebook_files)
-    else:
-        st.info("📥 Please upload a ZIP archive to get started.")
-        logger.debug("No ZIP archive uploaded yet.")
-
-def display_table_view_tab(filtered_df: pd.DataFrame):
-    """
-    Displays the Table tab with a searchable table of metadata.
-    """
-    st.header("📖 Table")
-    st.write("Explore the metadata of your library using the interactive table below.")
-    st.dataframe(filtered_df)
-
-def display_advanced_search_tab(metadata_list: list):
-    """
-    Using JMESPath to search the metadata list.
-    """
-    import jmespath
-
-    st.header("Advanced Search")
-    st.write("Use JMESPath queries to search the metadata list.")
-    query = st.text_input("Enter a JMESPath query", "[].[?date > `2020-01-01`]")
-    try:
-        result = jmespath.search(query, metadata_list)
-        st.write("Search Results:")
-        st.write(result)
-    except Exception as e:
-        st.error(f"An error occurred: {e}")
-        logger.error(f"JMESPath search error: {e}")
-
-
-
-if __name__ == "__main__":
-    main()

ebk/streamlit/display.py

@@ -1,168 +0,0 @@
-import streamlit as st
-from PIL import Image
-import pandas as pd
-import altair as alt
-import logging
-import os
-
-logger = logging.getLogger(__name__)
-
-def display_books_tab(filtered_df: pd.DataFrame, cover_images: dict, ebook_files: dict):
-    """
-    Displays the Books tab with book entries and download/view links.
-    """
-    total_size = len(filtered_df)
-    st.subheader(f"📚 Book Entries (Total: {total_size})")
-    if not filtered_df.empty:
-        for idx, row in filtered_df.iterrows():
-            with st.expander(f"**{row.get('title', 'No Title')}**"):
-                # Layout: Cover Image & Downloads | Metadata
-                cols = st.columns([1.5, 3])
-
-                # Left Column: Cover Image
-                with cols[0]:
-                    # Cover Image
-                    cover_path = row.get("cover_path", "")
-                    cover_filename = os.path.basename(cover_path)
-                    cover_data = cover_images.get(cover_filename)
-                    if cover_data:
-                        try:
-                            image = Image.open(cover_data)
-                            st.image(image, use_container_width=True, caption="🖼️ Cover")
-                            logger.debug(f"Displayed cover image: {cover_filename}")
-                        except Exception as e:
-                            st.error(f"🖼️ Error loading image: {e}")
-                            logger.error(f"Error loading image {cover_filename}: {e}")
-                    else:
-                        st.info("🖼️ No cover image available.")
-                        logger.debug(f"No cover image available for {cover_filename}.")
-
-                # Right Column: Metadata Details and Ebook Links
-                with cols[1]:
-
-
-                    # show title in a header style
-                    title = row.get("title", "No Title")
-                    st.markdown(f"# 📖 {title}")
-
-                    metadata_details = {
-                        "👤 **Author(s)**": ", ".join(row.get("creators", ["N/A"])),
-                        "📚 **Subjects**": ", ".join(row.get("subjects", ["N/A"])),
-                        "📝 **Description**": row.get("description", "N/A"),
-                        "🌐 **Language**": row.get("language", "N/A"),
-                        "📅 **Publication Date**": row.get("date", "N/A") if pd.notna(row.get("date", None)) else "N/A",
-                        "📖 **Publisher**": row.get("publisher", "N/A"),
-                        "📏 **File Size**": row.get("file_size", "N/A"),
-                        "📚 **Virtual Libraries**": ", ".join(row.get("virtual_libs", ["N/A"])),
-                        "🔑 **Identifiers**": ", ".join([f"{k}: {v}" for k, v in row.get("identifiers", {}).items()]),
-                        "🔑 **Unique ID**": row.get("unique_id", "NA"),
-                    }
-
-                    for key, value in metadata_details.items():
-                        st.markdown(f"{key}: {value}")
-
-                    # Ebook Download and View Links
-                    ebook_paths = row.get("file_paths", [])
-                    if ebook_paths:
-                        st.markdown("### 📥 Ebook Links")
-                        for ebook_path in ebook_paths:
-                            ebook_filename = os.path.basename(ebook_path)
-                            ebook_data = ebook_files.get(ebook_filename)
-                            if ebook_data:
-                                # Determine MIME type based on file extension
-                                _, ext = os.path.splitext(ebook_filename.lower())
-                                mime_types = {
-                                    '.pdf': 'application/pdf',
-                                    '.epub': 'application/epub+zip',
-                                    '.mobi': 'application/x-mobipocket-ebook',
-                                    '.azw3': 'application/vnd.amazon.ebook',
-                                    '.txt': 'text/plain'
-                                }
-                                mime_type = mime_types.get(ext, 'application/octet-stream')
-
-                                st.download_button(
-                                    label=f"💾 Download {ebook_filename}",
-                                    data=ebook_data.getvalue(),
-                                    file_name=ebook_filename,
-                                    mime=mime_type
-                                )
-                                logger.debug(f"Provided link for {ebook_filename}.")
-                            else:
-                                st.warning(f"Ebook file '{ebook_filename}' not found in the uploaded ZIP.")
-                                logger.warning(f"Ebook file '{ebook_filename}' not found in the uploaded ZIP.")
-                    else:
-                        st.info("📄 No ebook files available for download.")
-                        logger.debug("No ebook files available for download.")
-    else:
-        st.info("📚 No books match the current filter criteria.")
-        logger.debug("No books match the current filter criteria.")
-
-def display_statistics_tab(filtered_df: pd.DataFrame):
-    """
-    Displays the Statistics tab with various visualizations.
-    """
-    st.subheader("📊 Statistics")
-
-    if not filtered_df.empty:
-        # Visualization: Books per Author (Top 10)
-        st.markdown("### 📈 Top 10 Authors by Number of Books")
-        author_counts = pd.Series([creator for creators in filtered_df['creators'] for creator in creators]).value_counts().nlargest(10).reset_index()
-        author_counts.columns = ['Author', 'Number of Books']
-        
-        chart = alt.Chart(author_counts).mark_bar().encode(
-            x=alt.X('Number of Books:Q', title='Number of Books'),
-            y=alt.Y('Author:N', sort='-x', title='Author'),
-            tooltip=['Author', 'Number of Books']
-        ).properties(
-            width=600,
-            height=400
-        )
-        
-        st.altair_chart(chart, use_container_width=True)
-        logger.debug("Displayed Top 10 Authors chart.")
-
-        # Visualization: Books per Subject (Top 10)
-        st.markdown("### 📊 Top 10 Subjects by Number of Books")
-        subject_counts = pd.Series([subject for subjects in filtered_df['subjects'] for subject in subjects]).value_counts().nlargest(10).reset_index()
-        subject_counts.columns = ['Subject', 'Number of Books']
-        
-        subject_chart = alt.Chart(subject_counts).mark_bar().encode(
-            x=alt.X('Number of Books:Q', title='Number of Books'),
-            y=alt.Y('Subject:N', sort='-x', title='Subject'),
-            tooltip=['Subject', 'Number of Books']
-        ).properties(
-            width=600,
-            height=400
-        )
-        
-        st.altair_chart(subject_chart, use_container_width=True)
-        logger.debug("Displayed Top 10 Subjects chart.")
-
-        # Visualization: Books Published Over Time
-        st.markdown("### 📈 Books Published Over Time")
-        if 'date' in filtered_df.columns and pd.api.types.is_numeric_dtype(filtered_df['date']):
-            publication_years = filtered_df['date'].dropna().astype(int)
-            if not publication_years.empty:
-                year_counts = publication_years.value_counts().sort_index().reset_index()
-                year_counts.columns = ['Year', 'Number of Books']
-                
-                time_chart = alt.Chart(year_counts).mark_line(point=True).encode(
-                    x=alt.X('Year:O', title='Year'),
-                    y=alt.Y('Number of Books:Q', title='Number of Books'),
-                    tooltip=['Year', 'Number of Books']
-                ).properties(
-                    width=800,
-                    height=400
-                )
-                
-                st.altair_chart(time_chart, use_container_width=True)
-                logger.debug("Displayed Books Published Over Time chart.")
-            else:
-                st.info("📅 No publication date data available.")
-                logger.warning("Publication year data is empty after filtering.")
-        else:
-            st.info("📅 Publication date data is not available or not in a numeric format.")
-            logger.warning("Publication date data is not available or not numeric.")
-    else:
-        st.info("📊 No statistics to display as no books match the current filter criteria.")
-        logger.debug("No statistics to display due to empty filtered DataFrame.")