convoviz 0.1.6__py3-none-any.whl → 0.2.0__py3-none-any.whl

convoviz/models/_conversation_set.py

@@ -1,190 +0,0 @@
-"""ConversationSet class to model a set of conversations.
-
-Groups conversations by week, month, and year, etc.
-"""
-
-from __future__ import annotations
-
-from pathlib import Path
-from typing import TYPE_CHECKING, Any, Unpack
-
-from orjson import OPT_INDENT_2, dumps, loads
-from pydantic import BaseModel
-from tqdm import tqdm
-
-from convoviz.data_analysis import generate_week_barplot, generate_wordcloud
-from convoviz.utils import get_archive, sanitize
-
-from ._conversation import Conversation  # noqa: TCH001
-
-if TYPE_CHECKING:
-    from datetime import datetime
-
-    from matplotlib.figure import Figure
-    from PIL.Image import Image
-
-    from convoviz.utils import GraphKwargs, WordCloudKwargs
-
-    from ._message import AuthorRole
-
-
-class ConversationSet(BaseModel):
-    """Stores a set of conversations."""
-
-    array: list[Conversation]
-
-    @property
-    def index(self) -> dict[str, Conversation]:
-        """Get the index of conversations."""
-        return {convo.conversation_id: convo for convo in self.array}
-
-    @classmethod
-    def from_json(cls, filepath: Path | str) -> ConversationSet:
-        """Load from a JSON file, containing an array of conversations."""
-        filepath = Path(filepath)
-        with filepath.open(encoding="utf-8") as file:
-            return cls(array=loads(file.read()))
-
-    @classmethod
-    def from_zip(cls, filepath: Path | str) -> ConversationSet:
-        """Load from a ZIP file, containing a JSON file."""
-        filepath = Path(filepath)
-        convos_path = get_archive(filepath) / "conversations.json"
-
-        return cls.from_json(convos_path)
-
-    @property
-    def last_updated(self) -> datetime:
-        """Return the timestamp of the last updated conversation in the list."""
-        return max(conversation.update_time for conversation in self.array)
-
-    def update(self, conv_set: ConversationSet) -> None:
-        """Update the conversation set with the new one."""
-        if conv_set.last_updated <= self.last_updated:
-            return
-        self.index.update(conv_set.index)
-        self.array = list(self.index.values())
-
-    def save(self, dir_path: Path | str, *, progress_bar: bool = False) -> None:
-        """Save the conversation set to the directory."""
-        dir_path = Path(dir_path)
-        dir_path.mkdir(parents=True, exist_ok=True)
-
-        for conversation in tqdm(
-            self.array,
-            "Writing Markdown 📄 files",
-            disable=not progress_bar,
-        ):
-            filepath = dir_path / sanitize(f"{conversation.title}.md")
-            conversation.save(filepath)
-
-    @property
-    def custom_instructions(self) -> list[dict[str, Any]]:
-        """Get a list of all custom instructions, in all conversations in the set."""
-        custom_instructions: list[dict[str, Any]] = []
-
-        for conversation in self.array:
-            if not conversation.custom_instructions:
-                continue
-
-            instructions_info = {
-                "chat_title": conversation.title,
-                "chat_link": conversation.url,
-                "time": conversation.create_time,
-                "custom_instructions": conversation.custom_instructions,
-            }
-
-            custom_instructions.append(instructions_info)
-
-        return custom_instructions
-
-    def save_custom_instructions(self, filepath: Path | str) -> None:
-        """Save the custom instructions to the file."""
-        filepath = Path(filepath)
-        with filepath.open("w", encoding="utf-8") as file:
-            file.write(dumps(self.custom_instructions, option=OPT_INDENT_2).decode())
-
-    def timestamps(
-        self,
-        *authors: AuthorRole,
-    ) -> list[float]:
-        """Get a list of all message timestamps, in all conversations in the list."""
-        timestamps: list[float] = []
-
-        for conversation in self.array:
-            timestamps.extend(conversation.timestamps(*authors))
-
-        return timestamps
-
-    def week_barplot(
-        self,
-        title: str,
-        *authors: AuthorRole,
-        **kwargs: Unpack[GraphKwargs],
-    ) -> Figure:
-        """Create a bar graph from the given conversation set."""
-        if len(authors) == 0:
-            authors = ("user",)
-        timestamps = self.timestamps(*authors)
-        return generate_week_barplot(timestamps, title, **kwargs)
-
-    def plaintext(
-        self,
-        *authors: AuthorRole,
-    ) -> str:
-        """Get a string of all text, in all conversations in the list."""
-        return "\n".join(
-            conversation.plaintext(*authors) for conversation in self.array
-        )
-
-    def wordcloud(
-        self,
-        *authors: AuthorRole,
-        **kwargs: Unpack[WordCloudKwargs],
-    ) -> Image:
-        """Create a wordcloud from the given conversation set."""
-        if len(authors) == 0:
-            authors = ("user", "assistant")
-        text = self.plaintext(*authors)
-        return generate_wordcloud(text, **kwargs)
-
-    def add(self, conv: Conversation) -> None:
-        """Add a conversation to the dictionary and list."""
-        self.index[conv.conversation_id] = conv
-        self.array.append(conv)
-
-    def group_by_week(self) -> dict[datetime, ConversationSet]:
-        """Get a dictionary of conversations grouped by the start of the week."""
-        grouped: dict[datetime, ConversationSet] = {}
-
-        for conversation in self.array:
-            week_start = conversation.week_start
-            if week_start not in grouped:
-                grouped[week_start] = ConversationSet(array=[])
-            grouped[week_start].add(conversation)
-
-        return grouped
-
-    def group_by_month(self) -> dict[datetime, ConversationSet]:
-        """Get a dictionary of conversations grouped by the start of the month."""
-        grouped: dict[datetime, ConversationSet] = {}
-
-        for conversation in self.array:
-            month_start = conversation.month_start
-            if month_start not in grouped:
-                grouped[month_start] = ConversationSet(array=[])
-            grouped[month_start].add(conversation)
-
-        return grouped
-
-    def group_by_year(self) -> dict[datetime, ConversationSet]:
-        """Get a dictionary of conversations grouped by the start of the year."""
-        grouped: dict[datetime, ConversationSet] = {}
-
-        for conversation in self.array:
-            year_start = conversation.year_start
-            if year_start not in grouped:
-                grouped[year_start] = ConversationSet(array=[])
-            grouped[year_start].add(conversation)
-
-        return grouped

convoviz/models/_message.py

@@ -1,89 +0,0 @@
-"""Represents a single message in a conversation. It's contained in a Node object.
-
-object path : conversations.json -> conversation -> mapping -> mapping node -> message
-"""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any, ClassVar, Literal
-
-from pydantic import BaseModel, ConfigDict
-
-from convoviz.utils import DEFAULT_MESSAGE_CONFIGS, MessageConfigs, code_block
-
-if TYPE_CHECKING:
-    from datetime import datetime
-
-AuthorRole = Literal["user", "assistant", "system", "tool"]
-
-
-class MessageAuthor(BaseModel):
-    """Type of the `author` field in a `message`."""
-
-    role: AuthorRole
-    name: str | None = None
-    metadata: dict[str, Any]
-
-
-class MessageContent(BaseModel):
-    """Type of the `content` field in a `message`."""
-
-    content_type: str
-    parts: list[str] | None = None
-    text: str | None = None
-    result: str | None = None
-
-
-class MessageMetadata(BaseModel):
-    """Type of the `metadata` field in a `message`."""
-
-    model_slug: str | None = None
-    invoked_plugin: dict[str, Any] | None = None
-    is_user_system_message: bool | None = None
-    user_context_message_data: dict[str, Any] | None = None
-
-    model_config = ConfigDict(protected_namespaces=())
-
-
-class Message(BaseModel):
-    """Wrapper class for the `message` field in a `node`.
-
-    see `MessageJSON` and `models.Node` for more details
-    """
-
-    __configs: ClassVar[MessageConfigs] = DEFAULT_MESSAGE_CONFIGS
-
-    id: str  # noqa: A003
-    author: MessageAuthor
-    create_time: datetime | None = None
-    update_time: datetime | None = None
-    content: MessageContent
-    status: str
-    end_turn: bool | None = None
-    weight: float
-    metadata: MessageMetadata
-    recipient: str
-
-    @classmethod
-    def update_configs(cls, configs: MessageConfigs) -> None:
-        """Set the configuration for all messages."""
-        cls.__configs.update(configs)
-
-    @property
-    def header(self) -> str:
-        """Get the title header of the message based on the configs."""
-        return self.__configs["author_headers"][self.author.role]
-
-    @property
-    def text(self) -> str:
-        """Get the text content of the message."""
-        if self.content.parts is not None:
-            return str(self.content.parts[0])
-        if self.content.text is not None:
-            return code_block(self.content.text)
-        if self.content.result is not None:
-            return self.content.result
-
-        # this error caught some hidden bugs in the data. need more of these
-        err_msg = f"No valid content found in message: {self.id}"
-        raise ValueError(err_msg)

convoviz/models/_node.py

@@ -1,74 +0,0 @@
-"""Node class and methods for the node object in a conversation.
-
-object path : conversations.json -> conversation -> mapping -> mapping node
-
-will implement methods to handle conversation branches, like
-counting the number of branches,
-get the branch of a given node,
-and some other version control stuff
-"""
-
-from __future__ import annotations
-
-from pydantic import BaseModel
-
-from ._message import Message  # noqa: TCH001
-
-
-class Node(BaseModel):
-    """Wrapper class for a `node` in the `mapping` field of a `conversation`."""
-
-    id: str  # noqa: A003
-    message: Message | None = None
-    parent: str | None = None
-    children: list[str]
-    parent_node: Node | None = None
-    children_nodes: list[Node] = []
-
-    def add_child(self, node: Node) -> None:
-        """Add a child to the node."""
-        self.children_nodes.append(node)
-        node.parent_node = self
-
-    @classmethod
-    def mapping(cls, mapping: dict[str, Node]) -> dict[str, Node]:
-        """Return a dictionary of connected Node objects, based on the mapping."""
-        # Initialize connections
-        for node in mapping.values():
-            node.children_nodes = []  # Ensure list is empty to avoid duplicates
-            node.parent_node = None  # Ensure parent_node is None
-
-        # Connect nodes
-        for node in mapping.values():
-            for child_id in node.children:
-                child_node = mapping[child_id]
-                node.add_child(child_node)
-
-        return mapping
-
-    @property
-    def header(self) -> str:
-        """Get the header of the node message, containing a link to its parent."""
-        if self.message is None:
-            return ""
-
-        parent_link = (
-            f"[parent ⬆️](#{self.parent_node.id})\n"
-            if self.parent_node and self.parent_node.message
-            else ""
-        )
-        return f"###### {self.id}\n{parent_link}{self.message.header}\n"
-
-    @property
-    def footer(self) -> str:
-        """Get the footer of the node message, containing links to its children."""
-        if len(self.children_nodes) == 0:
-            return ""
-        if len(self.children_nodes) == 1:
-            return f"\n[child ⬇️](#{self.children_nodes[0].id})\n"
-
-        footer = "\n" + " | ".join(
-            f"[child {i+1} ⬇️](#{child.id})"
-            for i, child in enumerate(self.children_nodes)
-        )
-        return footer + "\n"

convoviz-0.1.6.dist-info/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2023 Mohamed Cheikh Sidiya
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

convoviz-0.1.6.dist-info/WHEEL

@@ -1,4 +0,0 @@
-Wheel-Version: 1.0
-Generator: poetry-core 1.8.1
-Root-Is-Purelib: true
-Tag: py3-none-any