ures 2.2.1__tar.gz → 2.3.0__tar.gz

{ures-2.2.1 → ures-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ures
-Version: 2.2.1
+Version: 2.3.0
 Summary: The project is designed to provide standard utilization functions for improving the reusability of frequently used functions.
 License: MIT
 Keywords: utilization,Research Tool,Python

{ures-2.2.1 → ures-2.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "ures"
-version = "2.2.1"
+version = "2.3.0"
 description = "The project is designed to provide standard utilization functions for improving the reusability of frequently used functions."
 authors = ["stone <github@stone-bo.com>"]
 license = "MIT"

{ures-2.2.1 → ures-2.3.0}/ures/literature/citation/__init__.py

@@ -148,7 +148,14 @@ class CitationManager:
     def save_bibliography(
         self,
         file_path: str,
-        middlewares: Optional[List[Type[CitationMiddleware]]] = None,
+        middlewares: Optional[
+            List[
+                Union[
+                    Type[bibtexparser.middlewares.BlockMiddleware],
+                    bibtexparser.middlewares.BlockMiddleware,
+                ]
+            ]
+        ] = None,
     ) -> None:
         """Save all bibliography entries to a BibTeX file.
 

{ures-2.2.1 → ures-2.3.0}/ures/literature/citation/manager.py

@@ -77,7 +77,14 @@ class BibManager:
     def load_from_file(
         self,
         file_path: str,
-        middlewares: Optional[List[Type[CitationMiddleware]]] = None,
+        middlewares: Optional[
+            List[
+                Union[
+                    Type[bibtexparser.middlewares.BlockMiddleware],
+                    bibtexparser.middlewares.BlockMiddleware,
+                ]
+            ]
+        ] = None,
     ) -> bibtexparser.Library:
         # Implementation for importing bibliography
         _middlewares: List[bibtexparser.middlewares.BlockMiddleware] = [
@@ -106,7 +113,14 @@ class BibManager:
         self,
         file_path: str,
         library: bibtexparser.Library,
-        middlewares: Optional[List[Type[CitationMiddleware]]] = None,
+        middlewares: Optional[
+            List[
+                Union[
+                    Type[bibtexparser.middlewares.BlockMiddleware],
+                    bibtexparser.middlewares.BlockMiddleware,
+                ]
+            ]
+        ] = None,
     ) -> None:
         _middlewares: List[bibtexparser.middlewares.BlockMiddleware] = [
             OutputOnlyDesiredFieldsMiddleware(rule_register=self.rules),

{ures-2.2.1 → ures-2.3.0}/ures/literature/citation/middlewares.py

@@ -230,7 +230,7 @@ class OutputCleanupNoneResultMiddleware(CitationMiddleware):
     def transform_entry(self, entry: Entry, *args, **kwargs) -> Optional[Entry]:
         need_to_removed = []
         for field in entry.fields:
-            if field.value in [None, "", []]:
+            if field.value in [None, "", [], "none"]:
                 need_to_removed.append(field)
         for field in need_to_removed:
             entry.pop(field.key, None)

ures-2.3.0/ures/markdown/__init__.py

@@ -0,0 +1,4 @@
+from .manipulator import MarkdownDocument, Content, ContentSection
+from .zettelkasten import Zettelkasten
+
+__all__ = ["MarkdownDocument", "Zettelkasten", "Content", "ContentSection"]

{ures-2.2.1 → ures-2.3.0}/ures/markdown/manipulator.py

@@ -1,10 +1,108 @@
 import os
+import re
 import frontmatter
+from collections import OrderedDict
 from pathlib import Path
 from typing import Any, Dict, Optional, List, AnyStr, Union
 from copy import deepcopy
 
 
+class ContentSection:
+    """Represents a specific section within a note, containing a title, hierarchy level, and text content.
+
+    Attributes:
+        title (str): The title of the section (e.g., "Introduction").
+        level (int): The heading level of the section (e.g., 1 for #, 2 for ##).
+        content (List[str]): A list of strings representing the lines of content in this section.
+    """
+
+    def __init__(self, title: str, level: int):
+        """Initializes a ContentSection with a title and a heading level.
+
+        Args:
+            title (str): The title of the section.
+            level (int): The Markdown heading level (e.g., 1, 2, 3).
+        """
+        self.title = title
+        self.level = level
+        self.content: List[str] = []
+
+    def add_content(self, content: Union[str, List[str]]):
+        """Appends text content to this section.
+
+        Args:
+            content (Union[str, List[str]]): A single string line or a list of string lines to add.
+        """
+        if isinstance(content, list):
+            self.content.extend(content)
+        else:
+            self.content.append(content)
+
+
+class Content:
+    """Represents the body of a note, organized into titled sections.
+
+    Attributes:
+        sections (Dict[str, ContentSection]): A dictionary mapping section titles to ContentSection objects.
+    """
+
+    def __init__(self):
+        """Initializes an empty Content container."""
+        self.sections: OrderedDict[str, ContentSection] = OrderedDict()
+
+    def new_section(self, title: str, level: int):
+        """Creates a new empty section if it does not already exist.
+
+        Args:
+            title (str): The unique title of the section.
+            level (int): The Markdown heading level for the section.
+        """
+        if title not in self.sections:
+            self.sections[title] = ContentSection(title, level)
+
+    def add_section(self, section: ContentSection):
+        """Adds an existing ContentSection object to the content.
+
+        If a section with the same title already exists, this operation is ignored.
+
+        Args:
+            section (ContentSection): The section object to add.
+        """
+        if section.title not in self.sections.keys():
+            self.sections[section.title] = section
+
+    def add_content(
+        self,
+        content: Union[str, list],
+        section_title: str = "default",
+        section_level: int = 1,
+    ):
+        """Adds content to a specific section, creating the section if it does not exist.
+
+        Args:
+            content (str, list): The text content to add.
+            section_title (str, optional): The title of the target section. Defaults to "default".
+            section_level (int, optional): The heading level if a new section needs to be created. Defaults to 1.
+        """
+        if section_title not in self.sections:
+            self.new_section(section_title, section_level)
+        self.sections[section_title].add_content(content)
+
+    def to_string(self) -> str:
+        """Serializes the entire content into a Markdown-formatted string.
+
+        Returns:
+            str: The complete Markdown content with section headers.
+        """
+        markdown_lines: List[str] = []
+        for section in self.sections.values():
+            if section.title != "default":
+                markdown_lines.append(f"{'#' * section.level} {section.title}")
+            markdown_lines.extend(section.content)
+            markdown_lines.append("")  # Add a blank line after each section
+        return "\n".join(markdown_lines).strip()
+
+
 class MarkdownDocument:
     """
     A low-level class for manipulating Markdown files with front matter.
@@ -435,6 +533,52 @@ class MarkdownDocument:
         self.post.content = post.content
         self.post.metadata = deepcopy(post.metadata)
 
+    def parse_content(self) -> Content:
+        """Parses the raw note content into a structured Content object.
+
+        Iterates through the raw text line by line, identifying Markdown headers
+        (e.g., '# Title') to delimit sections. Text found before the first header
+        is assigned to a 'default' section.
+
+        Returns:
+            Content: An object containing the parsed sections, their hierarchy levels,
+            and associated text content.
+        """
+        lines = self.content.split("\n")
+        current_section = "default"
+        current_head_level = 1
+        content_buffer: List[str] = []
+        new_content = Content()
+
+        for line in lines:
+            header_match = re.match(r"^(#+)\s+(.+)$", line)
+
+            if header_match:
+                if len(content_buffer) > 0:
+                    new_content.add_content(
+                        content="\n".join(content_buffer).strip(),
+                        section_title=current_section,
+                        section_level=current_head_level,
+                    )
+                    content_buffer = []
+
+                current_head_level = len(header_match.group(1))
+                current_section = header_match.group(2).strip()
+
+                new_content.new_section(title=current_section, level=current_head_level)
+            else:
+                if line.strip() or len(content_buffer) > 0:
+                    content_buffer.append(line)
+
+        if len(content_buffer) > 0:
+            new_content.add_content(
+                content="\n".join(content_buffer).strip(),
+                section_title=current_section,
+                section_level=current_head_level,
+            )
+
+        return new_content
+
     def clear_content(self) -> None:
         """
         Clears all Markdown content, leaving only the front matter.

{ures-2.2.1 → ures-2.3.0}/ures/markdown/zettelkasten.py

@@ -1,8 +1,8 @@
 import os
-from typing import Optional
+from typing import Optional, Union
 from ures.timedate import time_now
 from ures.string import zettelkasten_id
-from .manipulator import MarkdownDocument, frontmatter
+from .manipulator import MarkdownDocument, frontmatter, Content
 
 
 class Zettelkasten(MarkdownDocument):
@@ -62,7 +62,7 @@ class Zettelkasten(MarkdownDocument):
         super().__init__(metadata=_metadata)
 
     @classmethod
-    def from_file(cls, file_path: str) -> "MarkdownDocument":
+    def from_file(cls, file_path: str) -> Union["MarkdownDocument", "Zettelkasten"]:
         """
         Creates a MarkdownDocument instance by loading a Markdown file.
 
@@ -163,3 +163,75 @@ class Zettelkasten(MarkdownDocument):
 
     def remove_alias(self, alias: str):
         self.aliases.remove(alias)
+
+    def to_llm_friendly_content(
+        self, prop_ignores: Optional[list] = None, context: Optional[Content] = None
+    ) -> Content:
+        """Generates an LLM-friendly representation of the note, filtering metadata and merging context.
+
+        This method creates a structured content object designed for LLM consumption. It first
+        adds a 'Metadata' section (filtering out specified keys), then appends the note's
+        main body, and finally merges any external context provided.
+
+        Args:
+            prop_ignores (Optional[List[str]]): A list of metadata keys to exclude from the output.
+                Defaults to None. The keys "aliases", "url", "id", and "title" are always ignored
+                by default.
+            context (Optional[Content]): Additional contextual content to append to the note.
+                Defaults to None.
+
+        Returns:
+            Content: A new Content object organized into 'Metadata', 'Main Content', and
+            optionally 'Context' sections.
+        """
+        properties = self.metadata
+        content = Content()
+        # Create a new section for metadata
+        properties_ignore_list = ["aliases", "url", "id", "title"]
+        if prop_ignores:
+            properties_ignore_list.extend(prop_ignores)
+        for key, value in properties.items():
+            if key not in properties_ignore_list:
+                if isinstance(value, list):
+                    value = ", ".join(value)
+                else:
+                    value = str(value)
+
+                content.add_content(
+                    content=f"**{key}**: {value}",
+                    section_title="Metadata",
+                    section_level=1,
+                )
+
+        # Merge all existing sections into the main body
+        body_title = "Main Content"
+        body_level = 1
+        for key, value in self.parse_content().sections.items():
+            content.add_content(
+                content=f"**{key}**:",
+                section_title=body_title,
+                section_level=body_level,
+            )
+            content.add_content(
+                content=value.content,
+                section_title=body_title,
+                section_level=body_level,
+            )
+
+        # If context is provided, merge it
+        if context:
+            context_title = "Context"
+            context_level = 2
+            for key, value in context.sections.items():
+                content.add_content(
+                    content=f"**{key}**:",
+                    section_title=context_title,
+                    section_level=context_level,
+                )
+                content.add_content(
+                    content=value.content,
+                    section_title=context_title,
+                    section_level=context_level,
+                )
+
+        return content

ures-2.2.1/ures/markdown/__init__.py

@@ -1,4 +0,0 @@
-from .manipulator import MarkdownDocument
-from .zettelkasten import Zettelkasten
-
-__all__ = ["MarkdownDocument", "Zettelkasten"]