pub-analyzer 0.2.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

pub_analyzer/widgets/author/core.py

@@ -5,20 +5,21 @@ from typing import Any
 import httpx
 from textual import on
 from textual.app import ComposeResult
-from textual.containers import Container, Horizontal, Vertical, VerticalScroll
+from textual.containers import Container, Horizontal, Vertical
 from textual.widgets import Button, Collapsible, Label, Static
 
 from pub_analyzer.internal.identifier import get_author_id
 from pub_analyzer.models.author import Author, AuthorResult
 from pub_analyzer.widgets.common.filters import DateRangeFilter, Filter
+from pub_analyzer.widgets.common.summary import SummaryWidget
 from pub_analyzer.widgets.report.core import CreateAuthorReportWidget
 
 from .cards import CitationMetricsCard, IdentifiersCard, LastInstitutionCard
 from .tables import AuthorWorksByYearTable
 
 
-class _AuthorResumeWidget(Static):
-    """Author info resume."""
+class _AuthorSummaryWidget(Static):
+    """Author info summary."""
 
     def __init__(self, author: Author) -> None:
         self.author = author
@@ -62,12 +63,12 @@ class _AuthorResumeWidget(Static):
                 yield DateRangeFilter(checkbox_label="Cited date range:", id="cited-date-range-filter")
 
             # Button
-            with Vertical(classes="block-container button-container"):
+            with Vertical(classes="button-container"):
                 yield Button("Make Report", variant="primary", id="make-report-button")
 
 
-class AuthorResumeWidget(VerticalScroll):
-    """Author info resume container."""
+class AuthorSummaryWidget(SummaryWidget):
+    """Author info summary container."""
 
     def __init__(self, author_result: AuthorResult) -> None:
         self.author_result = author_result
@@ -91,17 +92,17 @@ class AuthorResumeWidget(VerticalScroll):
     async def load_data(self) -> None:
         """Query OpenAlex API and composing the widget."""
         await self._get_info()
-        await self.mount(_AuthorResumeWidget(author=self.author))
+        await self.mount(_AuthorSummaryWidget(author=self.author))
 
         self.loading = False
 
     @on(Filter.Changed)
     def filter_change(self) -> None:
         """Handle filter changes."""
-        filters = [filter for filter in self.query("_AuthorResumeWidget Filter").results(Filter) if not filter.filter_disabled]
+        filters = [filter for filter in self.query("_AuthorSummaryWidget Filter").results(Filter) if not filter.filter_disabled]
         all_filters_valid = all(filter.validation_state for filter in filters)
 
-        self.query_one("_AuthorResumeWidget #make-report-button", Button).disabled = not all_filters_valid
+        self.query_one("_AuthorSummaryWidget #make-report-button", Button).disabled = not all_filters_valid
 
     @on(Button.Pressed, "#make-report-button")
     async def make_report(self) -> None:
@@ -118,4 +119,4 @@ class AuthorResumeWidget(VerticalScroll):
 
         report_widget = CreateAuthorReportWidget(author=self.author, **filters)
         await self.app.query_one("MainContent").mount(report_widget)
-        await self.app.query_one("AuthorResumeWidget").remove()
+        await self.app.query_one("AuthorSummaryWidget").remove()

pub_analyzer/widgets/common/summary.py

@@ -0,0 +1,7 @@
+"""Common Summary format Widget."""
+
+from textual.containers import VerticalScroll
+
+
+class SummaryWidget(VerticalScroll):
+    """Common format summary container."""

pub_analyzer/widgets/institution/core.py

@@ -5,20 +5,21 @@ from typing import Any
 import httpx
 from textual import on
 from textual.app import ComposeResult
-from textual.containers import Container, Horizontal, Vertical, VerticalScroll
+from textual.containers import Container, Horizontal, Vertical
 from textual.widgets import Button, Collapsible, Label, Static
 
 from pub_analyzer.internal.identifier import get_institution_id
 from pub_analyzer.models.institution import Institution, InstitutionResult
 from pub_analyzer.widgets.common.filters import DateRangeFilter, Filter
+from pub_analyzer.widgets.common.summary import SummaryWidget
 from pub_analyzer.widgets.report.core import CreateInstitutionReportWidget
 
 from .cards import CitationMetricsCard, IdentifiersCard, RolesCard
 from .tables import InstitutionWorksByYearTable
 
 
-class _InstitutionResumeWidget(Static):
-    """Institution info resume."""
+class _InstitutionSummaryWidget(Static):
+    """Institution info summary."""
 
     def __init__(self, institution: Institution) -> None:
         self.institution = institution
@@ -66,8 +67,8 @@ class _InstitutionResumeWidget(Static):
                 yield Button("Make Report", variant="primary", id="make-report-button")
 
 
-class InstitutionResumeWidget(VerticalScroll):
-    """Institution info resume container."""
+class InstitutionSummaryWidget(SummaryWidget):
+    """Institution info summary container."""
 
     def __init__(self, institution_result: InstitutionResult) -> None:
         self.institution_result = institution_result
@@ -91,17 +92,17 @@ class InstitutionResumeWidget(VerticalScroll):
     async def load_data(self) -> None:
         """Query OpenAlex API and composing the widget."""
         await self._get_info()
-        await self.mount(_InstitutionResumeWidget(institution=self.institution))
+        await self.mount(_InstitutionSummaryWidget(institution=self.institution))
 
         self.loading = False
 
     @on(Filter.Changed)
     def filter_change(self) -> None:
         """Handle filter changes."""
-        filters = [filter for filter in self.query("_InstitutionResumeWidget Filter").results(Filter) if not filter.filter_disabled]
+        filters = [filter for filter in self.query("_InstitutionSummaryWidget Filter").results(Filter) if not filter.filter_disabled]
         all_filters_valid = all(filter.validation_state for filter in filters)
 
-        self.query_one("_InstitutionResumeWidget #make-report-button", Button).disabled = not all_filters_valid
+        self.query_one("_InstitutionSummaryWidget #make-report-button", Button).disabled = not all_filters_valid
 
     @on(Button.Pressed, "#make-report-button")
     async def make_report(self) -> None:
@@ -118,4 +119,4 @@ class InstitutionResumeWidget(VerticalScroll):
 
         report_widget = CreateInstitutionReportWidget(institution=self.institution, **filters)
         await self.app.query_one("MainContent").mount(report_widget)
-        await self.app.query_one("InstitutionResumeWidget").remove()
+        await self.app.query_one("InstitutionSummaryWidget").remove()

pub_analyzer/widgets/report/cards.py

@@ -11,9 +11,8 @@ from pub_analyzer.models.report import AuthorReport, InstitutionReport, WorkRepo
 from pub_analyzer.models.work import Work
 from pub_analyzer.widgets.common import Card
 
-# Works pane cards.
-
 
+# Works pane cards.
 class ReportCitationMetricsCard(Card):
     """Citation metrics for this report."""
 
@@ -26,8 +25,8 @@ class ReportCitationMetricsCard(Card):
         yield Label("[italic]Citation metrics:[/italic]", classes="card-title")
 
         with Vertical(classes="card-container"):
-            type_a_count = self.report.citation_resume.type_a_count
-            type_b_count = self.report.citation_resume.type_b_count
+            type_a_count = self.report.citation_summary.type_a_count
+            type_b_count = self.report.citation_summary.type_b_count
             cited_by_count = type_a_count + type_b_count
 
             yield Label(f"[bold]Count:[/bold] {cited_by_count}")
@@ -35,8 +34,8 @@ class ReportCitationMetricsCard(Card):
             yield Label(f"[bold]Type B:[/bold] {type_b_count}")
 
 
-class WorksTypeResumeCard(Card):
-    """Works Type Counters Resume Card."""
+class WorksTypeSummaryCard(Card):
+    """Works Type Counters Summary Card."""
 
     def __init__(self, report: AuthorReport | InstitutionReport) -> None:
         self.report = report
@@ -47,11 +46,11 @@ class WorksTypeResumeCard(Card):
         yield Label("[italic]Work Type[/italic]", classes="card-title")
 
         with VerticalScroll(classes="card-container"):
-            for work_type_counter in self.report.works_type_resume:
+            for work_type_counter in self.report.works_type_summary:
                 yield Label(f"[bold]{work_type_counter.type_name}:[/bold] {work_type_counter.count}")
 
 
-class OpenAccessResumeCard(Card):
+class OpenAccessSummaryCard(Card):
     """Open Access counts for this report."""
 
     def __init__(self, report: AuthorReport | InstitutionReport) -> None:
@@ -63,7 +62,7 @@ class OpenAccessResumeCard(Card):
         yield Label("[italic]Open Access[/italic]", classes="card-title")
 
         with VerticalScroll(classes="card-container"):
-            for status, count in self.report.open_access_resume.model_dump().items():
+            for status, count in self.report.open_access_summary.model_dump().items():
                 yield Label(f"[bold]{status}:[/bold] {count}")
 
 
@@ -120,8 +119,8 @@ class CitationMetricsCard(Card):
 
     def compose(self) -> ComposeResult:
         """Compose card."""
-        type_a_count = self.work_report.citation_resume.type_a_count
-        type_b_count = self.work_report.citation_resume.type_b_count
+        type_a_count = self.work_report.citation_summary.type_a_count
+        type_b_count = self.work_report.citation_summary.type_b_count
         cited_by_count = type_a_count + type_b_count
 
         yield Label("[italic]Citation[/italic]", classes="card-title")

pub_analyzer/widgets/report/concept.py

@@ -0,0 +1,47 @@
+"""Concepts Widgets."""
+
+from urllib.parse import quote
+
+from rich.table import Table
+from rich.text import Text
+from textual.app import ComposeResult
+from textual.widgets import Static
+
+from pub_analyzer.models.concept import DehydratedConcept
+
+
+class ConceptsTable(Static):
+    """All Concepts from a work in a table."""
+
+    DEFAULT_CSS = """
+    ConceptsTable .concepts-table {
+        height: auto;
+        padding: 1 2 0 2;
+    }
+    """
+
+    def __init__(self, concepts_list: list[DehydratedConcept]) -> None:
+        self.concepts_list = concepts_list
+        super().__init__()
+
+    def compose(self) -> ComposeResult:
+        """Compose Table."""
+        concepts_table = Table(title="Concepts", expand=True, show_lines=True)
+
+        # Define Columns
+        concepts_table.add_column("", justify="center", vertical="middle")
+        concepts_table.add_column("Name", ratio=5)
+        concepts_table.add_column("Score", ratio=1)
+        concepts_table.add_column("Level", ratio=1)
+
+        for idx, concept in enumerate(self.concepts_list):
+            name = f"""[@click=app.open_link('{quote(str(concept.wikidata))}')][u]{concept.display_name}[/u][/]"""
+
+            concepts_table.add_row(
+                str(idx),
+                Text.from_markup(name, overflow="ellipsis"),
+                Text.from_markup(f"{concept.score:.2f}"),
+                Text.from_markup(f"{concept.level:.1f}"),
+            )
+
+        yield Static(concepts_table, classes="concepts-table")

pub_analyzer/widgets/report/core.py

@@ -3,12 +3,15 @@
 import datetime
 import pathlib
 from enum import Enum
+from typing import ClassVar
 
 import httpx
 from pydantic import TypeAdapter, ValidationError
 from textual import on
 from textual.app import ComposeResult
+from textual.binding import Binding, BindingType
 from textual.containers import Container, Horizontal
+from textual.reactive import reactive
 from textual.widget import Widget
 from textual.widgets import Button, LoadingIndicator, Static, TabbedContent, TabPane
 
@@ -28,6 +31,17 @@ from .work import WorkReportPane
 class ReportWidget(Static):
     """Base report widget."""
 
+    BINDINGS: ClassVar[list[BindingType]] = [
+        Binding(key="ctrl+y", action="toggle_works", description="Toggle empty works"),
+    ]
+
+    show_empty_works: reactive[bool] = reactive(True)
+
+    async def action_toggle_works(self) -> None:
+        """Toggle show empty works attribute."""
+        self.show_empty_works = not self.show_empty_works
+        await self.query_one(WorkReportPane).toggle_empty_works()
+
 
 class AuthorReportWidget(ReportWidget):
     """Author report generator view."""

pub_analyzer/widgets/report/grants.py

@@ -0,0 +1,46 @@
+"""Grants Widgets."""
+
+from urllib.parse import quote
+
+from rich.table import Table
+from rich.text import Text
+from textual.app import ComposeResult
+from textual.widgets import Static
+
+from pub_analyzer.models.work import Grant
+
+
+class GrantsTable(Static):
+    """All Grants from a work in a table."""
+
+    DEFAULT_CSS = """
+    GrantsTable .grants-table {
+        height: auto;
+        padding: 1 2 0 2;
+    }
+    """
+
+    def __init__(self, grants_list: list[Grant]) -> None:
+        self.grants_list = grants_list
+        super().__init__()
+
+    def compose(self) -> ComposeResult:
+        """Compose Table."""
+        grants_table = Table(title="Grants", expand=True, show_lines=True)
+
+        # Define Columns
+        grants_table.add_column("", justify="center", vertical="middle")
+        grants_table.add_column("Name", ratio=3)
+        grants_table.add_column("Award ID", ratio=2)
+
+        for idx, grant in enumerate(self.grants_list):
+            name = f"""[@click=app.open_link('{quote(str(grant.funder))}')][u]{grant.funder_display_name}[/u][/]"""
+            award_id = grant.award_id or "-"
+
+            grants_table.add_row(
+                str(idx),
+                Text.from_markup(name, overflow="ellipsis"),
+                Text.from_markup(award_id),
+            )
+
+        yield Static(grants_table, classes="grants-table")

pub_analyzer/widgets/report/source.py

@@ -9,7 +9,7 @@ from textual.containers import VerticalScroll
 from textual.widgets import Static
 
 from pub_analyzer.models.report import AuthorReport, InstitutionReport
-from pub_analyzer.models.source import DehydratedSource
+from pub_analyzer.models.source import Source
 
 
 class SourcesTable(Static):
@@ -22,7 +22,7 @@ class SourcesTable(Static):
     }
     """
 
-    def __init__(self, sources_list: list[DehydratedSource]) -> None:
+    def __init__(self, sources_list: list[Source]) -> None:
         self.sources_list = sources_list
         super().__init__()
 
@@ -36,7 +36,9 @@ class SourcesTable(Static):
         sources_table.add_column("Publisher or institution", ratio=2)
         sources_table.add_column("Type")
         sources_table.add_column("ISSN-L")
-        sources_table.add_column("Is Open Access")
+        sources_table.add_column("Impact factor")
+        sources_table.add_column("h-index")
+        sources_table.add_column("Is OA")
 
         for idx, source in enumerate(self.sources_list):
             if source.host_organization_name:
@@ -49,6 +51,9 @@ class SourcesTable(Static):
             title = f"""[@click=app.open_link('{quote(str(source.id))}')][u]{source.display_name}[/u][/]"""
             type_source = source.type
             issn_l = source.issn_l if source.issn_l else "-"
+            impact_factor = f"{source.summary_stats.two_yr_mean_citedness:.3f}"
+            h_index = f"{source.summary_stats.h_index}"
+
             is_open_access = "[#909d63]True[/]" if source.is_oa else "[#bc5653]False[/]"
 
             sources_table.add_row(
@@ -57,6 +62,8 @@ class SourcesTable(Static):
                 Text.from_markup(host_organization),
                 Text.from_markup(type_source),
                 Text.from_markup(issn_l),
+                Text.from_markup(impact_factor),
+                Text.from_markup(h_index),
                 Text.from_markup(is_open_access),
             )
 
@@ -80,4 +87,4 @@ class SourcesReportPane(VerticalScroll):
 
     def compose(self) -> ComposeResult:
         """Compose content pane."""
-        yield SourcesTable(sources_list=self.report.sources_resume.sources)
+        yield SourcesTable(sources_list=self.report.sources_summary.sources)

pub_analyzer/widgets/report/topic.py

@@ -0,0 +1,55 @@
+"""Topics Widgets."""
+
+from urllib.parse import quote
+
+from rich.table import Table
+from rich.text import Text
+from textual.app import ComposeResult
+from textual.widgets import Static
+
+from pub_analyzer.models.topic import DehydratedTopic
+
+
+class TopicsTable(Static):
+    """All Topics from a work in a table."""
+
+    DEFAULT_CSS = """
+    TopicsTable .topics-table {
+        height: auto;
+        padding: 1 2 0 2;
+    }
+    """
+
+    def __init__(self, topics_list: list[DehydratedTopic]) -> None:
+        self.topics_list = topics_list
+        super().__init__()
+
+    def compose(self) -> ComposeResult:
+        """Compose Table."""
+        topics_table = Table(title="Topics", expand=True, show_lines=True)
+
+        # Define Columns
+        topics_table.add_column("", justify="center", vertical="middle")
+        topics_table.add_column("Name", ratio=3)
+        topics_table.add_column("Score", ratio=1)
+        topics_table.add_column("Domain", ratio=1)
+        topics_table.add_column("Field", ratio=1)
+        topics_table.add_column("SubField", ratio=1)
+
+        for idx, topic in enumerate(self.topics_list):
+            name = f"""[@click=app.open_link('{quote(str(topic.id))}')][u]{topic.display_name}[/u][/]"""
+
+            domain = f"""[@click=app.open_link('{quote(str(topic.domain.id))}')][u]{topic.domain.display_name}[/u][/]"""
+            field = f"""[@click=app.open_link('{quote(str(topic.field.id))}')][u]{topic.field.display_name}[/u][/]"""
+            subfield = f"""[@click=app.open_link('{quote(str(topic.subfield.id))}')][u]{topic.subfield.display_name}[/u][/]"""
+
+            topics_table.add_row(
+                str(idx),
+                Text.from_markup(name, overflow="ellipsis"),
+                Text.from_markup(f"{topic.score:.2f}"),
+                Text.from_markup(domain),
+                Text.from_markup(field),
+                Text.from_markup(subfield),
+            )
+
+        yield Static(topics_table, classes="topics-table")

pub_analyzer/widgets/report/work.py

@@ -17,12 +17,15 @@ from pub_analyzer.widgets.report.cards import (
     AuthorshipCard,
     CitationMetricsCard,
     OpenAccessCard,
-    OpenAccessResumeCard,
+    OpenAccessSummaryCard,
     ReportCitationMetricsCard,
-    WorksTypeResumeCard,
+    WorksTypeSummaryCard,
 )
 
+from .concept import ConceptsTable
+from .grants import GrantsTable
 from .locations import LocationsTable
+from .topic import TopicsTable
 
 
 class CitedByTable(Static):
@@ -108,22 +111,40 @@ class WorkModal(Modal[None]):
                 yield CitationMetricsCard(work_report=self.work_report)
 
             with TabbedContent(id="tables-container"):
+                # Abtract if exists
+                if self.work_report.work.abstract:
+                    with TabPane("Abstract"):
+                        yield Label(self.work_report.work.abstract, classes="abstract")
                 # Citations Table
                 with TabPane("Cited By Works"):
                     if len(self.work_report.cited_by):
                         yield CitedByTable(citations_list=self.work_report.cited_by)
                     else:
                         yield Label("No works found.")
+                # Concepts Table
+                with TabPane("Concepts"):
+                    if len(self.work_report.work.concepts):
+                        yield ConceptsTable(self.work_report.work.concepts)
+                    else:
+                        yield Label("No Concepts found.")
+                # Grants Table
+                with TabPane("Grants"):
+                    if len(self.work_report.work.grants):
+                        yield GrantsTable(self.work_report.work.grants)
+                    else:
+                        yield Label("No Grants found.")
                 # Locations Table
                 with TabPane("Locations"):
                     if len(self.work_report.work.locations):
                         yield LocationsTable(self.work_report.work.locations)
                     else:
                         yield Label("No sources found.")
-                # Abtract if exists
-                if self.work_report.work.abstract:
-                    with TabPane("Abstract"):
-                        yield Label(self.work_report.work.abstract, classes="abstract")
+                # Topics Table
+                with TabPane("Topics"):
+                    if len(self.work_report.work.topics):
+                        yield TopicsTable(self.work_report.work.topics)
+                    else:
+                        yield Label("No Topics found.")
 
 
 class WorksTable(Static):
@@ -136,8 +157,9 @@ class WorksTable(Static):
     }
     """
 
-    def __init__(self, report: AuthorReport | InstitutionReport) -> None:
+    def __init__(self, report: AuthorReport | InstitutionReport, show_empty_works: bool = True) -> None:
         self.report = report
+        self.show_empty_works = show_empty_works
         super().__init__()
 
     class _WorksTableRenderer(Static):
@@ -174,6 +196,9 @@ class WorksTable(Static):
 
         for idx, work_report in enumerate(self.report.works):
             work = work_report.work
+            if not self.show_empty_works and len(work_report.cited_by) < 1:
+                continue
+
             doi = work.ids.doi
             doi_url = f"""[@click=app.open_link("{quote(str(doi))}")]DOI[/]""" if doi else "-"
 
@@ -204,12 +229,23 @@ class WorkReportPane(VerticalScroll):
         self.report = report
         super().__init__()
 
+    async def toggle_empty_works(self) -> None:
+        """Hide/show works if cites are cero."""
+        report_works_status: bool = self.app.query_one("ReportWidget").show_empty_works  # type: ignore
+        table_works_status = self.query_one(WorksTable).show_empty_works
+
+        if self.report.works and (report_works_status != table_works_status):
+            self.loading = True
+            await self.query_one(WorksTable).remove()
+            await self.mount(WorksTable(report=self.report, show_empty_works=report_works_status))
+            self.loading = False
+
     def compose(self) -> ComposeResult:
         """Compose content pane."""
         with Horizontal(classes="cards-container"):
             yield ReportCitationMetricsCard(report=self.report)
-            yield WorksTypeResumeCard(report=self.report)
-            yield OpenAccessResumeCard(report=self.report)
+            yield WorksTypeSummaryCard(report=self.report)
+            yield OpenAccessSummaryCard(report=self.report)
 
         if self.report.works:
             yield WorksTable(report=self.report)

pub_analyzer/widgets/search/results.py

@@ -8,8 +8,8 @@ from textual.widgets import Button, Label, Static
 
 from pub_analyzer.models.author import AuthorResult
 from pub_analyzer.models.institution import InstitutionResult
-from pub_analyzer.widgets.author.core import AuthorResumeWidget
-from pub_analyzer.widgets.institution.core import InstitutionResumeWidget
+from pub_analyzer.widgets.author.core import AuthorSummaryWidget
+from pub_analyzer.widgets.institution.core import InstitutionSummaryWidget
 
 
 class ResultWidget(Static):
@@ -39,14 +39,14 @@ class AuthorResultWidget(ResultWidget):
             yield Label(self.author_result.hint or "", classes="text-hint")
 
     async def on_button_pressed(self, event: Button.Pressed) -> None:
-        """Go to the Author resume page."""
+        """Go to the Author summary page."""
         from pub_analyzer.widgets.body import MainContent
 
-        author_resume_widget = AuthorResumeWidget(author_result=self.author_result)
+        author_summary_widget = AuthorSummaryWidget(author_result=self.author_result)
 
         main_content = self.app.query_one(MainContent)
         main_content.update_title(title=self.author_result.display_name)
-        await main_content.mount(author_resume_widget)
+        await main_content.mount(author_summary_widget)
 
         await self.app.query_one("FinderWidget").remove()
 
@@ -74,13 +74,13 @@ class InstitutionResultWidget(ResultWidget):
             yield Label(self.institution_result.hint or "", classes="text-hint")
 
     async def on_button_pressed(self, event: Button.Pressed) -> None:
-        """Go to the Institution resume page."""
+        """Go to the Institution summary page."""
         from pub_analyzer.widgets.body import MainContent
 
-        institution_resume_widget = InstitutionResumeWidget(institution_result=self.institution_result)
+        institution_summary_widget = InstitutionSummaryWidget(institution_result=self.institution_result)
 
         main_content = self.app.query_one(MainContent)
         main_content.update_title(title=self.institution_result.display_name)
-        await main_content.mount(institution_resume_widget)
+        await main_content.mount(institution_summary_widget)
 
         await self.app.query_one("FinderWidget").remove()

pub_analyzer/widgets/sidebar.py

@@ -1,5 +1,7 @@
 """Sidebar components and options."""
+
 from enum import Enum
+from importlib.metadata import version
 
 from textual import on
 from textual.app import ComposeResult
@@ -25,19 +27,26 @@ class SideBar(Static):
 
     def compose(self) -> ComposeResult:
         """Compose dynamically the sidebar options."""
+        pub_analyzer_version = version("pub-analyzer")
+
         with Vertical(classes="sidebar-options-column"):
             yield Label("Menu", id="sidebar-title")
 
-            yield Button(SideBarOptionsName.SEARCH.value, variant="primary", id="search-sidebar-button", classes="sidebar-option")
-            yield Button(SideBarOptionsName.LOAD_REPORT.value, variant="primary", id="load-sidebar-button", classes="sidebar-option")
+            with Vertical(classes="sidebar-buttons-column"):
+                yield Button(SideBarOptionsName.SEARCH.value, variant="primary", id="search-sidebar-button", classes="sidebar-option")
+                yield Button(SideBarOptionsName.LOAD_REPORT.value, variant="primary", id="load-sidebar-button", classes="sidebar-option")
+
+            yield Label(f"v{pub_analyzer_version}", id="module-version-label")
 
     def toggle(self) -> None:
         """Show/Hide Sidebar."""
         if self.has_class("-hidden"):
             self.remove_class("-hidden")
+            self.styles.animate("width", value=20, duration=0.5)
         else:
             if self.query("*:focus"):
                 self.screen.set_focus(None)
+            self.styles.animate("width", value=0, duration=0.5)
             self.add_class("-hidden")
 
     async def _replace_main_content(self, new_title: str, new_widget: Widget) -> None: