fabricatio 0.5.0.dev0__tar.gz → 0.5.0.dev1__tar.gz

{fabricatio-0.5.0.dev0 → fabricatio-0.5.0.dev1}/.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.0.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.5.0.dev0
+Version: 0.5.0.dev1
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.12

fabricatio-0.5.0.dev1/examples/yue/compose.py

@@ -0,0 +1,32 @@
+"""Example of using the library."""
+
+from pathlib import Path
+
+from fabricatio import Action, Event, Role, Task, WorkFlow
+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)
+
+
+(
+    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.0.dev1}/packages/fabricatio-yue/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fabricatio-yue"
-version = "0.1.0-dev7"
+version = "0.1.0-dev10"
 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" }

{fabricatio-0.5.0.dev0 → fabricatio-0.5.0.dev1}/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.0.dev1}/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.0.dev1/packages/fabricatio-yue/python/fabricatio_yue/models/segment.py

@@ -0,0 +1,134 @@
+"""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.0.dev1}/pyproject.toml

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