fabricatio 0.2.9.dev4__cp312-cp312-win_amd64.whl → 0.2.10.dev0__cp312-cp312-win_amd64.whl

fabricatio/models/extra/advanced_judge.py

@@ -12,7 +12,7 @@ class JudgeMent(SketchedAble):
     """
 
     issue_to_judge: str
-    """The issue to be judged, true for affirmation, false for denial."""
+    """The issue to be judged, including the original question and context"""
 
     deny_evidence: List[str]
     """List of clues supporting the denial."""
@@ -21,7 +21,7 @@ class JudgeMent(SketchedAble):
     """List of clues supporting the affirmation."""
 
     final_judgement: bool
-    """The final judgment made according to all extracted clues."""
+    """The final judgment made according to all extracted clues. true for the `issue_to_judge` is correct and false for incorrect."""
 
     def __bool__(self) -> bool:
         """Return the final judgment value.

fabricatio/models/extra/article_base.py

@@ -2,8 +2,7 @@
 
 from abc import ABC, abstractmethod
 from enum import StrEnum
-from itertools import chain
-from typing import Generator, List, Optional, Self, Tuple, overload
+from typing import Generator, List, Optional, Self, Tuple
 
 from fabricatio.models.generic import (
     AsPrompt,
@@ -15,7 +14,6 @@ from fabricatio.models.generic import (
     PersistentAble,
     ProposedUpdateAble,
     ResolveUpdateConflict,
-    SequencePatch,
     SketchedAble,
     Titled,
     WordCount,
@@ -31,81 +29,9 @@ class ReferringType(StrEnum):
     SUBSECTION = "subsection"
 
 
-type RefKey = Tuple[str, Optional[str], Optional[str]]
-
-
-class ArticleRef(ProposedUpdateAble):
-    """Reference to a specific chapter, section or subsection within the article. You SHALL not refer to an article component that is external and not present within our own article.
-
-    Examples:
-        - Referring to a chapter titled `Introduction`:
-            Using Python
-            ```python
-            ArticleRef(chap="Introduction")
-            ```
-            Using JSON
-            ```json
-            {chap="Introduction"}
-            ```
-        - Referring to a section titled `Background` under the `Introduction` chapter:
-            Using Python
-            ```python
-            ArticleRef(chap="Introduction", sec="Background")
-            ```
-            Using JSON
-            ```json
-            {chap="Introduction", sec="Background"}
-            ```
-        - Referring to a subsection titled `Related Work` under the `Background` section of the `Introduction` chapter:
-            Using Python
-            ```python
-            ArticleRef(chap="Introduction", sec="Background", subsec="Related Work")
-            ```
-            Using JSON
-            ```json
-            {chap="Introduction", sec="Background", subsec="Related Work"}
-            ```
-    """
-
-    chap: str
-    """`title` Field of the referenced chapter"""
-    sec: Optional[str] = None
-    """`title` Field of the referenced section."""
-    subsec: Optional[str] = None
-    """`title` Field of the referenced subsection."""
-
-    def update_from_inner(self, other: Self) -> Self:
-        """Updates the current instance with the attributes of another instance."""
-        self.chap = other.chap
-        self.sec = other.sec
-        self.subsec = other.subsec
-        return self
-
-    def deref(self, article: "ArticleBase") -> Optional["ArticleOutlineBase"]:
-        """Dereference the reference to the actual section or subsection within the provided article.
-
-        Args:
-            article (ArticleOutline | Article): The article to dereference the reference from.
 
-        Returns:
-            ArticleMainBase | ArticleOutline | None: The dereferenced section or subsection, or None if not found.
-        """
-        chap = next((chap for chap in article.chapters if chap.title == self.chap), None)
-        if self.sec is None or chap is None:
-            return chap
-        sec = next((sec for sec in chap.sections if sec.title == self.sec), None)
-        if self.subsec is None or sec is None:
-            return sec
-        return next((subsec for subsec in sec.subsections if subsec.title == self.subsec), None)
+type RefKey = Tuple[str, Optional[str], Optional[str]]
 
-    @property
-    def referring_type(self) -> ReferringType:
-        """Determine the type of reference based on the presence of specific attributes."""
-        if self.subsec is not None:
-            return ReferringType.SUBSECTION
-        if self.sec is not None:
-            return ReferringType.SECTION
-        return ReferringType.CHAPTER
 
 
 class ArticleMetaData(SketchedAble, Described, WordCount, Titled, Language):
@@ -121,15 +47,8 @@ class ArticleMetaData(SketchedAble, Described, WordCount, Titled, Language):
     aims: List[str]
     """List of writing aims of the research component in academic style."""
 
-    support_to: List[ArticleRef]
-    """List of references to other future components in this article that this component supports to."""
-    depend_on: List[ArticleRef]
-    """List of references to other previous components in this article that this component depends on."""
 
 
-class ArticleRefSequencePatch(SequencePatch[ArticleRef]):
-    """Patch for article refs."""
-
 
 class ArticleOutlineBase(
     ArticleMetaData,
@@ -148,10 +67,6 @@ class ArticleOutlineBase(
 
     def update_metadata(self, other: ArticleMetaData) -> Self:
         """Updates the metadata of the current instance with the attributes of another instance."""
-        self.support_to.clear()
-        self.support_to.extend(other.support_to)
-        self.depend_on.clear()
-        self.depend_on.extend(other.depend_on)
         self.aims.clear()
         self.aims.extend(other.aims)
         self.description = other.description
@@ -319,34 +234,6 @@ class ArticleBase[T: ChapterBase](FinalizedDumpAble, AsPrompt, WordCount, Descri
                 yield sec
                 yield from sec.subsections
 
-    def iter_support_on(self, rev: bool = False) -> Generator[ArticleRef, None, None]:
-        """Iterates over all references that the article components support.
-
-        Args:
-            rev (bool): If True, iterate in reverse order.
-
-        Yields:
-            ArticleRef: Each reference that the article components support.
-        """
-        if rev:
-            yield from chain(*[a.support_to for a in self.iter_dfs_rev()])
-            return
-        yield from chain(*[a.support_to for a in self.iter_dfs()])
-
-    def iter_depend_on(self, rev: bool = False) -> Generator[ArticleRef, None, None]:
-        """Iterates over all references that the article components depend on.
-
-        Args:
-            rev (bool): If True, iterate in reverse order.
-
-        Yields:
-            ArticleRef: Each reference that the article components depend on.
-        """
-        if rev:
-            yield from chain(*[a.depend_on for a in self.iter_dfs_rev()])
-            return
-        yield from chain(*[a.depend_on for a in self.iter_dfs()])
-
     def iter_sections(self) -> Generator[Tuple[ChapterBase, SectionBase], None, None]:
         """Iterates through all sections in the article.
 
@@ -380,12 +267,6 @@ class ArticleBase[T: ChapterBase](FinalizedDumpAble, AsPrompt, WordCount, Descri
         """Gathers all introspected components in the article structure."""
         return "\n".join([i for component in self.chapters if (i := component.introspect())])
 
-    @overload
-    def find_illegal_ref(self, gather_identical: bool) -> Optional[Tuple[ArticleRef | List[ArticleRef], str]]: ...
-
-    @overload
-    def find_illegal_ref(self) -> Optional[Tuple[ArticleRef, str]]: ...
-
     def iter_chap_title(self) -> Generator[str, None, None]:
         """Iterates through all chapter titles in the article."""
         for chap in self.chapters:
@@ -401,71 +282,6 @@ class ArticleBase[T: ChapterBase](FinalizedDumpAble, AsPrompt, WordCount, Descri
         for _, _, subsec in self.iter_subsections():
             yield subsec.title
 
-    def find_illegal_ref(self, gather_identical: bool = False) -> Optional[Tuple[ArticleRef | List[ArticleRef], str]]:
-        """Finds the first illegal component in the outline.
-
-        Returns:
-            Tuple[ArticleOutlineBase, str]: A tuple containing the illegal component and an error message.
-        """
-        summary = ""
-        chap_titles_set = set(self.iter_chap_title())
-        sec_titles_set = set(self.iter_section_title())
-        subsec_titles_set = set(self.iter_subsection_title())
-
-        for component in self.iter_dfs_rev():
-            for ref in chain(component.depend_on, component.support_to):
-                if not ref.deref(self):
-                    summary += f"Invalid internal reference in `{component.__class__.__name__}` titled `{component.title}`, because the referred {ref.referring_type} is not exists within the article, see the original obj dump: {ref.model_dump()}\n"
-
-                    if ref.chap not in (chap_titles_set):
-                        summary += f"Chapter titled `{ref.chap}` is not any of {chap_titles_set}\n"
-                    if ref.sec and ref.sec not in (sec_titles_set):
-                        summary += f"Section Titled `{ref.sec}` is not any of {sec_titles_set}\n"
-                    if ref.subsec and ref.subsec not in (subsec_titles_set):
-                        summary += f"Subsection Titled `{ref.subsec}` is not any of {subsec_titles_set}"
-
-                if summary:
-                    return (
-                        (
-                            [
-                                identical_ref
-                                for identical_ref in chain(self.iter_depend_on(), self.iter_support_on())
-                                if identical_ref == ref
-                            ],
-                            summary,
-                        )
-                        if gather_identical
-                        else (ref, summary)
-                    )
-
-        return None
-
-    def gather_illegal_ref(self) -> Tuple[List[ArticleRef], str]:
-        """Gathers all illegal references in the article."""
-        summary = []
-        chap_titles_set = set(self.iter_chap_title())
-        sec_titles_set = set(self.iter_section_title())
-        subsec_titles_set = set(self.iter_subsection_title())
-        res_seq = []
-
-        for component in self.iter_dfs():
-            for ref in (
-                r for r in chain(component.depend_on, component.support_to) if not r.deref(self) and r not in res_seq
-            ):
-                res_seq.append(ref)
-                if ref.chap not in chap_titles_set:
-                    summary.append(
-                        f"Chapter titled `{ref.chap}` is not exist, since it is not any of {chap_titles_set}."
-                    )
-                if ref.sec and (ref.sec not in sec_titles_set):
-                    summary.append(f"Section Titled `{ref.sec}` is not exist, since it is not any of {sec_titles_set}")
-                if ref.subsec and (ref.subsec not in subsec_titles_set):
-                    summary.append(
-                        f"Subsection Titled `{ref.subsec}` is not exist, since it is not any of {subsec_titles_set}"
-                    )
-
-        return res_seq, "\n".join(summary)
-
     def finalized_dump(self) -> str:
         """Generates standardized hierarchical markup for academic publishing systems.
 

fabricatio/models/extra/article_main.py

@@ -1,13 +1,11 @@
 """ArticleBase and ArticleSubsection classes for managing hierarchical document components."""
 
-from itertools import chain
 from typing import Dict, Generator, List, Self, Tuple, override
 
 from fabricatio.fs.readers import extract_sections
 from fabricatio.journal import logger
 from fabricatio.models.extra.article_base import (
     ArticleBase,
-    ArticleOutlineBase,
     ChapterBase,
     SectionBase,
     SubSectionBase,
@@ -16,8 +14,7 @@ from fabricatio.models.extra.article_outline import (
     ArticleOutline,
 )
 from fabricatio.models.generic import Described, PersistentAble, SequencePatch, SketchedAble, WithRef, WordCount
-from fabricatio.rust import detect_language, word_count
-from fabricatio.utils import ok
+from fabricatio.rust import word_count
 from pydantic import Field
 
 PARAGRAPH_SEP = "// - - -"
@@ -66,10 +63,11 @@ class ArticleSubsection(SubSectionBase):
         summary = ""
         if len(self.paragraphs) == 0:
             summary += f"`{self.__class__.__name__}` titled `{self.title}` have no paragraphs, You should add some!\n"
-        if abs((wc := self.word_count) - self.expected_word_count) / self.expected_word_count > self._max_word_count_deviation:
-            summary += (
-                f"`{self.__class__.__name__}` titled `{self.title}` have {wc} words, expected {self.word_count} words!"
-            )
+        if (
+            abs((wc := self.word_count) - self.expected_word_count) / self.expected_word_count
+            > self._max_word_count_deviation
+        ):
+            summary += f"`{self.__class__.__name__}` titled `{self.title}` have {wc} words, expected {self.expected_word_count} words!"
 
         return summary
 
@@ -90,17 +88,14 @@ class ArticleSubsection(SubSectionBase):
         return f"=== {self.title}\n" + f"\n{PARAGRAPH_SEP}\n".join(p.content for p in self.paragraphs)
 
     @classmethod
-    def from_typst_code(cls, title: str, body: str, language: str) -> Self:
+    def from_typst_code(cls, title: str, body: str) -> Self:
         """Creates an Article object from the given Typst code."""
         return cls(
             heading=title,
             elaboration="",
             paragraphs=[Paragraph.from_content(p) for p in body.split(PARAGRAPH_SEP)],
             expected_word_count=word_count(body),
-            language=language,
             aims=[],
-            support_to=[],
-            depend_on=[],
         )
 
 
@@ -108,20 +103,16 @@ class ArticleSection(SectionBase[ArticleSubsection]):
     """Atomic argumentative unit with high-level specificity."""
 
     @classmethod
-    def from_typst_code(cls, title: str, body: str, language: str) -> Self:
+    def from_typst_code(cls, title: str, body: str) -> Self:
         """Creates an Article object from the given Typst code."""
         return cls(
             subsections=[
-                ArticleSubsection.from_typst_code(*pack, language=language)
-                for pack in extract_sections(body, level=3, section_char="=")
+                ArticleSubsection.from_typst_code(*pack) for pack in extract_sections(body, level=3, section_char="=")
             ],
             heading=title,
             elaboration="",
             expected_word_count=word_count(body),
-            language=language,
             aims=[],
-            support_to=[],
-            depend_on=[],
         )
 
 
@@ -129,20 +120,16 @@ class ArticleChapter(ChapterBase[ArticleSection]):
     """Thematic progression implementing research function."""
 
     @classmethod
-    def from_typst_code(cls, title: str, body: str, language: str) -> Self:
+    def from_typst_code(cls, title: str, body: str) -> Self:
         """Creates an Article object from the given Typst code."""
         return cls(
             sections=[
-                ArticleSection.from_typst_code(*pack, language=language)
-                for pack in extract_sections(body, level=2, section_char="=")
+                ArticleSection.from_typst_code(*pack) for pack in extract_sections(body, level=2, section_char="=")
             ],
             heading=title,
             elaboration="",
             expected_word_count=word_count(body),
-            language=language,
             aims=[],
-            support_to=[],
-            depend_on=[],
         )
 
 
@@ -210,92 +197,10 @@ class Article(
     def from_typst_code(cls, title: str, body: str) -> Self:
         """Generates an article from the given Typst code."""
         return cls(
-            language=(lang := detect_language(body)),
             chapters=[
-                ArticleChapter.from_typst_code(*pack, language=lang)
-                for pack in extract_sections(body, level=1, section_char="=")
+                ArticleChapter.from_typst_code(*pack) for pack in extract_sections(body, level=1, section_char="=")
             ],
             heading=title,
             expected_word_count=word_count(body),
             abstract="",
         )
-
-    def gather_dependencies(self, article: ArticleOutlineBase) -> List[ArticleOutlineBase]:
-        """Gathers dependencies for all sections and subsections in the article.
-
-        This method should be called after the article is fully constructed.
-        """
-        depends = [ok(a.deref(self)) for a in article.depend_on]
-
-        supports = []
-        for a in self.iter_dfs_rev():
-            if article in {ok(b.deref(self)) for b in a.support_to}:
-                supports.append(a)
-
-        return list(set(depends + supports))
-
-    def gather_dependencies_recursive(self, article: ArticleOutlineBase) -> List[ArticleOutlineBase]:
-        """Gathers all dependencies recursively for the given article.
-
-        Args:
-            article (ArticleOutlineBase): The article to gather dependencies for.
-
-        Returns:
-            List[ArticleBase]: A list of all dependencies for the given article.
-        """
-        q = self.gather_dependencies(article)
-
-        deps = []
-        while q:
-            a = q.pop()
-            deps.extend(self.gather_dependencies(a))
-
-        deps = list(
-            chain(
-                filter(lambda x: isinstance(x, ArticleChapter), deps),
-                filter(lambda x: isinstance(x, ArticleSection), deps),
-                filter(lambda x: isinstance(x, ArticleSubsection), deps),
-            )
-        )
-
-        # Initialize result containers
-        formatted_code = ""
-        processed_components = []
-
-        # Process all dependencies
-        while deps:
-            component = deps.pop()
-            # Skip duplicates
-            if (component_code := component.to_typst_code()) in formatted_code:
-                continue
-
-            # Add this component
-            formatted_code += component_code
-            processed_components.append(component)
-
-        return processed_components
-
-    def iter_dfs_with_deps(
-        self, chapter: bool = True, section: bool = True, subsection: bool = True
-    ) -> Generator[Tuple[ArticleOutlineBase, List[ArticleOutlineBase]], None, None]:
-        """Iterates through the article in a depth-first manner, yielding each component and its dependencies.
-
-        Args:
-            chapter (bool, optional): Whether to include chapter components. Defaults to True.
-            section (bool, optional): Whether to include section components. Defaults to True.
-            subsection (bool, optional): Whether to include subsection components. Defaults to True.
-
-        Yields:
-            Tuple[ArticleBase, List[ArticleBase]]: Each component and its dependencies.
-        """
-        if all((not chapter, not section, not subsection)):
-            raise ValueError("At least one of chapter, section, or subsection must be True.")
-
-        for component in self.iter_dfs_rev():
-            if not chapter and isinstance(component, ArticleChapter):
-                continue
-            if not section and isinstance(component, ArticleSection):
-                continue
-            if not subsection and isinstance(component, ArticleSubsection):
-                continue
-            yield component, (self.gather_dependencies_recursive(component))

fabricatio/models/extra/problem.py

@@ -1,11 +1,12 @@
 """A class representing a problem-solution pair identified during a review process."""
 
 from itertools import chain
-from typing import Any, List, Literal, Optional, Self, Tuple, Unpack
+from typing import Any, List, Optional, Self, Tuple, Unpack
 
 from fabricatio.journal import logger
 from fabricatio.models.generic import SketchedAble, WithBriefing
 from fabricatio.utils import ask_edit
+from pydantic import Field
 from questionary import Choice, checkbox, text
 from rich import print as r_print
 
@@ -13,36 +14,30 @@ from rich import print as r_print
 class Problem(SketchedAble, WithBriefing):
     """Represents a problem identified during review."""
 
-    description: str
-    """Description of the problem, The """
+    description: str = Field(alias="cause")
+    """The cause of the problem, including the root cause, the context, and the impact, make detailed enough for engineer to understand the problem and its impact."""
 
-    severity: Literal["low", "medium", "high"]
-    """Severity level of the problem."""
-
-    category: str
-    """Category of the problem."""
+    severity_level: int = Field(ge=0, le=10)
+    """Severity level of the problem, which is a number between 0 and 10, 0 means the problem is not severe, 10 means the problem is extremely severe."""
 
     location: str
     """Location where the problem was identified."""
 
-    recommendation: str
-    """Recommended solution or action."""
-
 
 class Solution(SketchedAble, WithBriefing):
     """Represents a proposed solution to a problem."""
 
-    description: str
+    description: str = Field(alias="mechanism")
     """Description of the solution, including a detailed description of the execution steps, and the mechanics, principle or fact."""
 
     execute_steps: List[str]
-    """A list of steps to execute to implement the solution, which is expected to be able to finally solve the corresponding problem."""
+    """A list of steps to execute to implement the solution, which is expected to be able to finally solve the corresponding problem, and which should be an Idiot-proof tutorial."""
 
-    feasibility: Literal["low", "medium", "high"]
-    """Feasibility level of the solution."""
+    feasibility_level: int = Field(ge=0, le=10)
+    """Feasibility level of the solution, which is a number between 0 and 10, 0 means the solution is not feasible, 10 means the solution is complete feasible."""
 
-    impact: Literal["low", "medium", "high"]
-    """Impact level of the solution."""
+    impact_level: int = Field(ge=0, le=10)
+    """Impact level of the solution, which is a number between 0 and 10, 0 means the solution is not impactful, 10 means the solution is extremely impactful."""
 
 
 class ProblemSolutions(SketchedAble):

fabricatio/models/extra/rag.py

@@ -0,0 +1,72 @@
+"""A module containing the RAG (Retrieval-Augmented Generation) models."""
+
+from abc import ABCMeta, abstractmethod
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Self, Sequence
+
+from fabricatio.decorators import precheck_package
+from pydantic import BaseModel, ConfigDict, JsonValue
+
+if TYPE_CHECKING:
+    from importlib.util import find_spec
+
+    from pydantic.fields import FieldInfo
+
+    if find_spec("pymilvus"):
+        from pymilvus import CollectionSchema
+
+
+class MilvusDataBase(BaseModel, metaclass=ABCMeta):
+    """A base class for Milvus data."""
+
+    model_config = ConfigDict(use_attribute_docstrings=True)
+
+    primary_field_name: ClassVar[str] = "id"
+
+    vector_field_name: ClassVar[str] = "vector"
+
+    def prepare_insertion(self, vector: List[float]) -> Dict[str, Any]:
+        """Prepares the data for insertion into Milvus.
+
+        Returns:
+            dict: A dictionary containing the data to be inserted into Milvus.
+        """
+        return {**self.model_dump(exclude_none=True, by_alias=True), self.vector_field_name: vector}
+
+    @property
+    @abstractmethod
+    def to_vectorize(self) -> str:
+        """The text representation of the data."""
+
+    @classmethod
+    @precheck_package(
+        "pymilvus", "pymilvus is not installed. Have you installed `fabricatio[rag]` instead of `fabricatio`?"
+    )
+    def as_milvus_schema(cls, dimension: int = 1024) -> "CollectionSchema":
+        """Generates the schema for Milvus collection."""
+        from pymilvus import CollectionSchema, DataType, FieldSchema
+
+        fields = [
+            FieldSchema(cls.primary_field_name, dtype=DataType.INT64, is_primary=True, auto_id=True),
+            FieldSchema(cls.vector_field_name, dtype=DataType.FLOAT_VECTOR, dim=dimension),
+        ]
+
+        type_mapping = {
+            str: DataType.STRING,
+            int: DataType.INT64,
+            float: DataType.DOUBLE,
+            JsonValue: DataType.JSON,
+            # TODO add more mapping
+        }
+
+        for k, v in cls.model_fields.items():
+            k: str
+            v: FieldInfo
+            fields.append(
+                FieldSchema(k, dtype=type_mapping.get(v.annotation, DataType.UNKNOWN), description=v.description or "")
+            )
+        return CollectionSchema(fields)
+
+    @classmethod
+    def from_sequence(cls, data: Sequence[Dict[str, Any]]) -> List[Self]:
+        """Constructs a list of instances from a sequence of dictionaries."""
+        return [cls(**d) for d in data]

fabricatio/models/extra/rule.py

@@ -40,12 +40,11 @@ class RuleSet(SketchedAble, PersistentAble, WithBriefing, Language):
     framework for the topic or domain covered by the rule set."""
 
     @classmethod
-    def gather(cls, *rulesets: Unpack[Tuple["RuleSet",...]]) -> Self:
+    def gather(cls, *rulesets: Unpack[Tuple["RuleSet", ...]]) -> Self:
         """Gathers multiple rule sets into a single rule set."""
         if not rulesets:
             raise ValueError("No rulesets provided")
         return cls(
-            language=rulesets[0].language,
             name=";".join(ruleset.name for ruleset in rulesets),
             description=";".join(ruleset.description for ruleset in rulesets),
             rules=list(flatten(r.rules for r in rulesets)),

fabricatio/models/generic.py

@@ -11,7 +11,7 @@ from fabricatio.config import configs
 from fabricatio.fs.readers import MAGIKA, safe_text_read
 from fabricatio.journal import logger
 from fabricatio.parser import JsonCapture
-from fabricatio.rust import blake3_hash
+from fabricatio.rust import blake3_hash, detect_language
 from fabricatio.rust_instances import TEMPLATE_MANAGER
 from fabricatio.utils import ok
 from litellm.utils import token_counter
@@ -53,7 +53,7 @@ class Display(Base):
         Returns:
             str: JSON string with 1-level indentation for readability
         """
-        return self.model_dump_json(indent=1)
+        return self.model_dump_json(indent=1,by_alias=True)
 
     def compact(self) -> str:
         """Generate compact JSON representation.
@@ -61,7 +61,7 @@ class Display(Base):
         Returns:
             str: Minified JSON string without whitespace
         """
-        return self.model_dump_json()
+        return self.model_dump_json(by_alias=True)
 
     @staticmethod
     def seq_display(seq: Iterable["Display"], compact: bool = False) -> str:
@@ -225,7 +225,7 @@ class PersistentAble(Base):
             - Hash generated from JSON content ensures uniqueness
         """
         p = Path(path)
-        out = self.model_dump_json(indent=1)
+        out = self.model_dump_json(indent=1,by_alias=True)
 
         # Generate a timestamp in the format YYYYMMDD_HHMMSS
         timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
@@ -298,10 +298,17 @@ class PersistentAble(Base):
 class Language(Base):
     """Class that provides a language attribute."""
 
-    language: str
-    """The fullname of the written language of this object."""
-
-
+    @property
+    def language(self)->str:
+        """Get the language of the object."""
+        if isinstance(self,Described):
+            return detect_language(self.description)
+        if isinstance(self,Titled):
+            return detect_language(self.title)
+        if isinstance(self,Named):
+            return detect_language(self.name)
+
+        return detect_language(self.model_dump_json(by_alias=True))
 class ModelHash(Base):
     """Class that provides a hash value for the object.
 
@@ -543,7 +550,7 @@ class FinalizedDumpAble(Base):
         Returns:
             str: The finalized dump of the object.
         """
-        return self.model_dump_json()
+        return self.model_dump_json(indent=1,by_alias=True)
 
     def finalized_dump_to(self, path: str | Path) -> Self:
         """Finalize the dump of the object to a file.