fabricatio 0.5.0.dev0__tar.gz → 0.5.1.dev0__tar.gz

{fabricatio-0.5.0.dev0 → fabricatio-0.5.1.dev0}/.github/workflows/build-package.yaml

@@ -70,7 +70,7 @@ jobs:
 
 
   create-release:
-    if: needs.determine_changes.outputs.version_changed == 'true'
+    if: needs.determine_changes.outputs.version_changed == 'true' && github.event_name != 'pull_request'
     name: Create Release
     needs: determine_changes
     runs-on: ubuntu-latest
@@ -124,7 +124,7 @@ jobs:
           uv sync --no-install-project --only-dev --index https://pypi.org/simple -p ${{ matrix.python-version }} 
 
       - name: Upload to PyPI
-        if: needs.determine_changes.outputs.version_changed == 'true'
+        if: needs.determine_changes.outputs.version_changed == 'true' && github.event_name != 'pull_request'
         run: |
           make publish PY=${{ matrix.python-version }}
         env:
@@ -134,6 +134,7 @@ jobs:
           UV_PUBLISH_TOKEN: ${{ secrets.PYPI_TOKEN }}
 
       - name: Upload assets
+        if: github.event_name != 'pull_request'
         uses: softprops/action-gh-release@v2
         with:
           tag_name: ${{ needs.determine_changes.outputs.current_version }}

{fabricatio-0.5.0.dev0 → fabricatio-0.5.1.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.5.0.dev0
+Version: 0.5.1.dev0
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.12
@@ -119,35 +119,32 @@ make bdist
 ### Basic Example
 
 ```python
-import asyncio
-from fabricatio import Action, Role, Task, logger, WorkFlow, Event
+"""Example of a simple hello world program using fabricatio."""
+
 from typing import Any
 
+from fabricatio import Action, Event, Role, Task, WorkFlow, logger
+
 
 class Hello(Action):
-    name: str = "hello"
+    """Action that says hello."""
+
     output_key: str = "task_output"
 
-    async def _execute(self, task_input: Task[str], **_) -> Any:
+    async def _execute(self, **_) -> Any:
         ret = "Hello fabricatio!"
         logger.info("executing talk action")
         return ret
 
+    """Main function."""
 
-async def main() -> None:
-    Role(
-        name="talker",
-        description="talker role",
-        registry={Event.quick_instantiate("talk"): WorkFlow(name="talk", steps=(Hello,))}
-    )
 
-    task = Task(name="say hello", goals=["say hello"], description="say hello to the world")
-    result = await task.delegate("talk")
-    logger.success(f"Result: {result}")
+(Role()
+ .register_workflow(Event.quick_instantiate("talk"), WorkFlow(name="talk", steps=(Hello,)))
+ .dispatch())
 
+assert Task(name="say hello").delegate_blocking("talk") == "Hello fabricatio!"
 
-if __name__ == "__main__":
-    asyncio.run(main())
 ```
 
 ### Examples

{fabricatio-0.5.0.dev0 → fabricatio-0.5.1.dev0}/README.md

@@ -67,35 +67,32 @@ make bdist
 ### Basic Example
 
 ```python
-import asyncio
-from fabricatio import Action, Role, Task, logger, WorkFlow, Event
+"""Example of a simple hello world program using fabricatio."""
+
 from typing import Any
 
+from fabricatio import Action, Event, Role, Task, WorkFlow, logger
+
 
 class Hello(Action):
-    name: str = "hello"
+    """Action that says hello."""
+
     output_key: str = "task_output"
 
-    async def _execute(self, task_input: Task[str], **_) -> Any:
+    async def _execute(self, **_) -> Any:
         ret = "Hello fabricatio!"
         logger.info("executing talk action")
         return ret
 
+    """Main function."""
 
-async def main() -> None:
-    Role(
-        name="talker",
-        description="talker role",
-        registry={Event.quick_instantiate("talk"): WorkFlow(name="talk", steps=(Hello,))}
-    )
 
-    task = Task(name="say hello", goals=["say hello"], description="say hello to the world")
-    result = await task.delegate("talk")
-    logger.success(f"Result: {result}")
+(Role()
+ .register_workflow(Event.quick_instantiate("talk"), WorkFlow(name="talk", steps=(Hello,)))
+ .dispatch())
 
+assert Task(name="say hello").delegate_blocking("talk") == "Hello fabricatio!"
 
-if __name__ == "__main__":
-    asyncio.run(main())
 ```
 
 ### Examples

{fabricatio-0.5.0.dev0 → fabricatio-0.5.1.dev0}/examples/minor/hello_fabricatio.py

@@ -20,12 +20,6 @@ class Hello(Action):
     """Main function."""
 
 
-Role(
-    name="talker",
-    description="talker role",
-    registry={Event.quick_instantiate("talk"): WorkFlow(name="talk", steps=(Hello,))},
-)
+(Role().register_workflow(Event.quick_instantiate("talk"), WorkFlow(name="talk", steps=(Hello,))).dispatch())
 
-
-if __name__ == "__main__":
-    task.delegate_blocking("talk")
+logger.success(task.delegate_blocking("talk"))

fabricatio-0.5.1.dev0/examples/yue/compose.py

@@ -0,0 +1,22 @@
+"""Example of using the library."""
+
+from fabricatio import Event, Role, Task, WorkFlow
+from fabricatio.actions import Compose
+from fabricatio.models import Song
+from fabricatio_core.utils import ok
+
+(
+    Role()
+    .register_workflow(Event.quick_instantiate(ns := "generate_deck"), WorkFlow(steps=(Compose().to_task_output(),)))
+    .dispatch()
+)
+
+generated_song: Song = ok(
+    Task(name="gen deck")
+    .update_init_context(
+        req="Write a folk-rock song about finding hope in difficult times, with verses about struggle and a uplifting "
+        "chorus about perseverance. Include bridge section with introspective lyrics.",
+        output="here",
+    )
+    .delegate_blocking(ns)
+)

{fabricatio-0.5.0.dev0 → fabricatio-0.5.1.dev0}/packages/fabricatio-yue/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fabricatio-yue"
-version = "0.1.0-dev7"
+version = "0.2.0-dev1"
 description = "An extension of fabricatio, provide capability to compose lyrics that can be used in music generation with YuE."
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -29,6 +29,12 @@ dev = [
     "pytest",
 ]
 
+[project.optional-dependencies]
+cli = [
+    "questionary>=2.1.0",
+    "typer-slim[standard]>=0.15.2",
+]
+
 
 [build-system]
 requires = ["hatchling"]
@@ -41,16 +47,23 @@ sources = ["python"]
 url = "https://mirrors.bfsu.edu.cn/pypi/web/simple"
 default = true
 
-[[tool.uv.index]]
-url = "https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple"
-
-[[tool.uv.index]]
-url = "https://mirrors.huaweicloud.com/repository/pypi/simple"
+[tool.uv.sources]
+fabricatio = { workspace = true }
 
 [project.urls]
 Homepage = "https://github.com/Whth/fabricatio"
 Repository = "https://github.com/Whth/fabricatio"
 Issues = "https://github.com/Whth/fabricatio/issues"
 
+[[tool.uv.index]]
+url = "https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple"
+
+[[tool.uv.index]]
+url = "https://mirrors.huaweicloud.com/repository/pypi/simple"
+
 [[tool.uv.index]]
 url = "https://mirrors.aliyun.com/pypi/simple/"
+
+
+[project.scripts]
+yuek = "fabricatio_yue.cli:main"

fabricatio-0.5.1.dev0/packages/fabricatio-yue/python/fabricatio_yue/actions/compose.py

@@ -0,0 +1,16 @@
+"""Compose action for creating songs."""
+
+from pathlib import Path
+
+from fabricatio import Action
+from fabricatio.capabilities import Lyricize
+from fabricatio_core.utils import ok
+
+from fabricatio_yue.models.segment import Song
+
+
+class Compose(Action, Lyricize):
+    """Compose a song."""
+
+    async def _execute(self, req: str, output: Path, **cxt) -> Song:
+        return ok(await self.lyricize(req)).save_to(output)

{fabricatio-0.5.0.dev0 → fabricatio-0.5.1.dev0}/packages/fabricatio-yue/python/fabricatio_yue/capabilities/genre.py

@@ -3,6 +3,7 @@
 from typing import List, Unpack, overload
 
 from fabricatio_core import TEMPLATE_MANAGER
+from fabricatio_core.journal import logger
 from fabricatio_core.models.kwargs_types import ValidateKwargs
 from fabricatio_core.models.usages import LLMUsage
 from more_itertools import flatten
@@ -79,16 +80,20 @@ class SelectGenre(LLMUsage):
             For multiple requirements: List where each element is either a list of genres or None.
         """
         if isinstance(requirement, str):
-            return await self.alist_str(
+            logger.debug("Processing single requirement")
+            result = await self.alist_str(
                 TEMPLATE_MANAGER.render_template(
                     yue_config.select_genre_template,
                     {"requirement": requirement, "genre_classifier": genre_classifier, "genres": genres},
                 ),
                 **kwargs,
             )
+            logger.debug(f"Selected genres for single requirement: {result}")
+            return result
         if isinstance(requirement, list):
+            logger.debug(f"Processing {len(requirement)} requirements")
             # Handle list of requirements
-            return await self.alist_str(
+            result = await self.alist_str(
                 TEMPLATE_MANAGER.render_template(
                     yue_config.select_genre_template,
                     [
@@ -98,7 +103,12 @@ class SelectGenre(LLMUsage):
                 ),
                 **kwargs,
             )
-        raise TypeError(f"requirement must be str or List[str], got {type(requirement)}")
+            logger.debug(f"Selected genres for multiple requirements: {result}")
+            return result
+
+        error_msg = f"requirement must be str or List[str], got {type(requirement)}"
+        logger.error(error_msg)
+        raise TypeError(error_msg)
 
     @overload
     async def gather_genres(
@@ -154,6 +164,9 @@ class SelectGenre(LLMUsage):
         """
         import asyncio
 
+        logger.debug(f"Gathering genres for requirements: {requirements}")
+        logger.debug(f"Available genre categories: {list(yue_config.genre.keys())}")
+
         async def gather_for_single_requirement(req: str) -> List[str] | None:
             """Gather genres for a single requirement from all categories.
 
@@ -163,19 +176,37 @@ class SelectGenre(LLMUsage):
             Returns:
                 List[str] | None: A list of selected genres from all categories, or None if no genres are found.
             """
+            logger.debug(f"Gathering genres for single requirement: {req}")
+
             results = await asyncio.gather(
                 *[
                     self.select_genre(req, genre_classifier, genres, **kwargs)
                     for genre_classifier, genres in yue_config.genre.items()
                 ]
             )
+
+            logger.debug(f"Raw results from genre selection: {results}")
+
             # Flatten the results from all genre categories, filtering out any None responses
             selected_genres = list(flatten(result for result in results if result))
-            return selected_genres if selected_genres else None
+
+            logger.debug(f"Flattened selected genres: {selected_genres}")
+
+            final_result = selected_genres if selected_genres else None
+            logger.debug(f"Final result for requirement '{req}': {final_result}")
+
+            return final_result
 
         if isinstance(requirements, str):
+            logger.debug("Processing single requirement string")
             return await gather_for_single_requirement(requirements)
         if isinstance(requirements, list):
+            logger.debug(f"Processing {len(requirements)} requirement strings")
             tasks = [gather_for_single_requirement(req) for req in requirements]
-            return await asyncio.gather(*tasks)
-        raise TypeError(f"requirements must be str or List[str], got {type(requirements)}")
+            result = await asyncio.gather(*tasks)
+            logger.debug(f"Results for all requirements: {result}")
+            return result
+
+        error_msg = f"requirements must be str or List[str], got {type(requirements)}"
+        logger.error(error_msg)
+        raise TypeError(error_msg)

{fabricatio-0.5.0.dev0 → fabricatio-0.5.1.dev0}/packages/fabricatio-yue/python/fabricatio_yue/capabilities/lyricize.py

@@ -4,6 +4,7 @@ from typing import List, Unpack, overload
 
 from fabricatio_core import TEMPLATE_MANAGER
 from fabricatio_core.capabilities.propose import Propose
+from fabricatio_core.journal import logger
 from fabricatio_core.models.kwargs_types import ValidateKwargs
 from fabricatio_core.utils import ok, override_kwargs
 
@@ -58,6 +59,7 @@ class Lyricize(Propose, SelectGenre):
         Returns:
             Song | None | List[Song | None]: Generated lyrics as Song object, list of Song objects, or None based on input type
         """
+        logger.debug(f"Lyricizing requirements: {requirement}")
         okwargs = override_kwargs(kwargs, default=None)
 
         async def lyricize_single(req: str) -> Song | None:
@@ -69,20 +71,29 @@ class Lyricize(Propose, SelectGenre):
             Returns:
                 Song | None: A Song object containing generated lyrics and metadata, or None if generation fails.
             """
+            logger.debug(f"Processing single lyricize requirement: {req}")
             genres = ok(await self.gather_genres(req, **okwargs))
+            logger.debug(f"Gathered genres for requirement: {genres}")
+
             prompt = TEMPLATE_MANAGER.render_template(
                 yue_config.lyricize_template,
                 {"requirement": req, "genres": genres, "section_types": yue_config.segment_types},
             )
+            logger.debug(f"Generated prompt for lyricize: {prompt}")
+
             return await self.propose(Song, prompt, **kwargs)
 
         if isinstance(requirement, str):
+            logger.debug("Processing single requirement string")
             return await lyricize_single(requirement)
 
         if isinstance(requirement, list):
+            logger.debug(f"Processing {len(requirement)} requirement strings")
             import asyncio
 
             tasks = [lyricize_single(req) for req in requirement]
             return await asyncio.gather(*tasks)
 
-        raise TypeError(f"Invalid requirement type: {type(requirement)}. Expected str or List[str].")
+        error_msg = f"Invalid requirement type: {type(requirement)}. Expected str or List[str]."
+        logger.error(error_msg)
+        raise TypeError(error_msg)

fabricatio-0.5.1.dev0/packages/fabricatio-yue/python/fabricatio_yue/cli.py

@@ -0,0 +1,60 @@
+"""Command-line interface for Fabricatio Yue song composition."""
+
+from importlib.util import find_spec
+
+from fabricatio_core.decorators import precheck_package
+
+if not find_spec("typer"):
+    raise ModuleNotFoundError(
+        "Please install fabricatio-yue with 'pip install fabricatio-yue[cli]' or 'uv tool install fabricatio-yue[cli]'"
+    )
+
+from pathlib import Path
+
+from typer import Option, Typer
+
+app = Typer(
+    name="yuek",
+    help="Compose lyrics with Fabricatio!",
+    epilog="For more information, visit: https://github.com/Whth/fabricatio",
+    short_help="Fabricatio Yue CLI for song composition",
+)
+
+
+@app.command()
+@precheck_package(
+    "questionary",
+    "Please install fabricatio-yue with 'pip install fabricatio-yue[cli]' or 'uv tool install fabricatio-yue[cli]'",
+)
+def compose(
+    requirement: str = Option(None, "-r", "--requirement", help="Song requirement/prompt"),
+    output: Path = Option(Path("song"), "-o", "--output", help="Output file folder"),
+) -> None:
+    """Compose a song based on your requirements."""
+    from fabricatio import Event, Role, Task, WorkFlow
+    from fabricatio_core.utils import ok
+    from questionary import text
+
+    from fabricatio_yue.actions.compose import Compose
+
+    Role().register_workflow(
+        Event.quick_instantiate(ns := "compose"), WorkFlow(steps=(Compose().to_task_output(),))
+    ).dispatch()
+
+    ok(
+        Task(name="compose song")
+        .update_init_context(
+            req=(
+                requirement
+                or ok(text("What kind of song would you like to compose?").ask(), "No requirement provided!")
+            ),
+            output=output,
+        )
+        .delegate_blocking(ns),
+        "Failed to compose song!",
+    )
+
+
+def main() -> None:
+    """Entry point for the CLI application."""
+    app()

fabricatio-0.5.1.dev0/packages/fabricatio-yue/python/fabricatio_yue/models/segment.py

@@ -0,0 +1,137 @@
+"""Models for representing song segments and complete songs.
+
+This module provides the data structures for working with songs and their
+component segments in the Fabricatio YUE system. Songs are composed of
+multiple segments, each with their own properties like duration, genre tags,
+and lyrics.
+"""
+
+from pathlib import Path
+from typing import List, Self
+
+from fabricatio_core import logger
+from fabricatio_core.models.generic import SketchedAble, WithBriefing
+from pydantic import NonNegativeInt, PrivateAttr
+
+
+class Segment(SketchedAble):
+    """Represents a segment of a song with its attributes."""
+
+    section_type: str
+    """Type of section."""
+
+    duration: NonNegativeInt
+    """Duration of the segment in seconds"""
+    lyrics: List[str]
+    """Lyrics for this segment as a list of lines"""
+    _extra_genres: List[str] = PrivateAttr(default_factory=list)
+    """Additional genre tags for this segment"""
+
+    def override_extra_genres(self, genres: List[str]) -> Self:
+        """Override the genre tags for this segment.
+
+        Args:
+            genres (List[str]): New list of genre tags
+        """
+        self._extra_genres = genres
+        return self
+
+    @property
+    def extra_genres(self) -> List[str]:
+        """Get the additional genre tags for this segment.
+
+        Returns:
+            List[str]: List of genre tags
+        """
+        return self._extra_genres
+
+    @property
+    def assemble(self) -> str:
+        """Assemble the segment into a formatted string representation.
+
+        Returns:
+            str: A formatted string with section type header and lyrics
+        """
+        return f"[{self.section_type}]\n" + "\n".join(self.lyrics) + "\n"
+
+
+class Song(SketchedAble, WithBriefing):
+    """Represents a complete song with its attributes and segments."""
+
+    genres: List[str]
+    """Primary genre classifications for the entire song"""
+    segments: List[Segment]
+    """Ordered list of segments that compose the song"""
+
+    @property
+    def duration(self) -> NonNegativeInt:
+        """Total duration of the song in seconds.
+
+        Calculated by summing the durations of all segments in the song.
+
+        Returns:
+            NonNegativeInt: The total duration in seconds
+        """
+        return sum(segment.duration for segment in self.segments)
+
+    def override_genres(self, genres: List[str]) -> Self:
+        """Override the primary genre tags for the entire song.
+
+        Args:
+            genres (List[str]): New list of genre tags
+        """
+        self.genres.clear()
+        self.genres.extend(genres)
+        return self
+
+    @property
+    def briefing(self) -> str:
+        """Generate a briefing of the song including its genre tags and duration."""
+        return f"# {self.name}\n>{self.description}\n\nDuration: {self.duration} s.\n\n{self.block(' '.join(self.genres), 'genres')} \n\n---\n"
+
+    def save_to(self, parent_dir: str | Path) -> Self:
+        """Save the song to a directory.
+
+        Args:
+            parent_dir (str): The directory to save the song to
+        """
+        parent_path = Path(parent_dir)
+        parent_path.mkdir(parents=True, exist_ok=True)
+
+        # Create filename from song name or use default
+        file_path = parent_path / f"{self.name}.md"
+
+        logger.info(f"Saving song to {file_path.as_posix()}")
+
+        out = f"{self.briefing}\n" + "\n".join(
+            f"## Section {i}. {seg.section_type.capitalize()}\n\n{self._wrapp(seg)}"
+            for i, seg in enumerate(self.segments)
+        )
+
+        file_path.write_text(out, encoding="utf-8")
+
+        return self
+
+    def _wrapp(self, segment: Segment) -> str:
+        return (
+            f"Duration: {segment.duration} s.\n\n"
+            + (
+                f"Extra Genres: {self.block(' '.join(segment.extra_genres), 'genres')}\n"
+                f"Assembled Genres: {self.block(' '.join(self.genres + segment.extra_genres), 'genres')}"
+            )
+            if segment.extra_genres
+            else "" + f"Lyrics:{self.block(segment.assemble, 'lyrics')}"
+        )
+
+    @staticmethod
+    def block(content: str, lang: str = "text") -> str:
+        """Create a markdown code block with the specified language.
+
+        Args:
+            content (str): The content to wrap in the code block
+            lang (str, optional): The language identifier for syntax highlighting. Defaults to 'text'
+
+        Returns:
+            str: A formatted markdown code block
+        """
+        return f"\n```{lang}\n{content}\n```\n"

{fabricatio-0.5.0.dev0 → fabricatio-0.5.1.dev0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fabricatio"
-version = "0.5.0-dev0"
+version = "0.5.1-dev0"
 description = "A LLM multi-agent framework."
 readme = "README.md"
 license = { file = "LICENSE" }

{fabricatio-0.5.0.dev0 → fabricatio-0.5.1.dev0}/python/fabricatio/actions/__init__.py

@@ -67,3 +67,8 @@ if find_spec("fabricatio_actions"):
         "RetrieveFromLatest",
         "RetrieveFromPersistent",
     ]
+
+if find_spec("fabricatio_yue"):
+    from fabricatio_yue.actions.compose import Compose
+
+    __all__ += ["Compose"]