tumblrbot 1.4.5__py3-none-any.whl → 1.4.7__py3-none-any.whl

tumblrbot/__main__.py

@@ -1,4 +1,4 @@
-from openai import DefaultHttpxClient, OpenAI
+from openai import OpenAI
 from rich.prompt import Confirm
 from rich.traceback import install
 
@@ -14,11 +14,8 @@ from tumblrbot.utils.tumblr import TumblrSession
 def main() -> None:
     install()
 
-    tokens = Tokens.read_from_keyring()
-    with (
-        OpenAI(api_key=tokens.openai_api_key.get_secret_value(), http_client=DefaultHttpxClient(http2=True)) as openai,
-        TumblrSession(tokens=tokens) as tumblr,
-    ):
+    tokens = Tokens.load()
+    with OpenAI(api_key=tokens.openai_api_key) as openai, TumblrSession(tokens) as tumblr:
         if Confirm.ask("Download latest posts?", default=False):
             PostDownloader(openai=openai, tumblr=tumblr).main()
 

tumblrbot/flow/download.py

@@ -18,7 +18,7 @@ class PostDownloader(FlowClass):
                 completed = 0
                 after = 0
                 if data_path.exists():
-                    lines = data_path.read_text("utf_8").splitlines() if data_path.exists() else []
+                    lines = data_path.read_bytes().splitlines() if data_path.exists() else []
                     completed = len(lines)
                     if lines:
                         after = Post.model_validate_json(lines[-1]).timestamp

tumblrbot/flow/examples.py

@@ -1,11 +1,11 @@
 from collections.abc import Generator
+from itertools import batched
 from json import loads
 from math import ceil
 from re import search
 from typing import IO, override
 
 import rich
-from more_itertools import chunked
 from openai import BadRequestError
 from rich.prompt import Confirm
 
@@ -49,7 +49,7 @@ class ExamplesWriter(FlowClass):
         self.config.custom_prompts_file.parent.mkdir(parents=True, exist_ok=True)
         self.config.custom_prompts_file.touch(exist_ok=True)
 
-        with self.config.custom_prompts_file.open("r", encoding="utf_8") as fp:
+        with self.config.custom_prompts_file.open("rb") as fp:
             for line in fp:
                 data: dict[str, str] = loads(line)
                 yield from data.items()
@@ -58,18 +58,18 @@ class ExamplesWriter(FlowClass):
         posts = self.get_valid_posts()
 
         if Confirm.ask("[gray62]Remove posts flagged by the OpenAI moderation? This can sometimes resolve errors with fine-tuning validation, but is slow.", default=False):
-            chunk_size = self.get_moderation_chunk_limit()
+            batch_size = self.get_moderation_batch_size()
             posts = list(posts)
             removed = 0
 
             with PreviewLive() as live:
-                for chunk in live.progress.track(
-                    chunked(posts, chunk_size),
-                    ceil(len(posts) / chunk_size),
+                for batch in live.progress.track(
+                    batched(posts, batch_size, strict=False),
+                    ceil(len(posts) / batch_size),
                     description="Removing flagged posts...",
                 ):
-                    response = self.openai.moderations.create(input=list(map(Post.get_content_text, chunk)))
-                    for post, moderation in zip(chunk, response.results, strict=True):
+                    response = self.openai.moderations.create(input=list(map(Post.get_content_text, batch)))
+                    for post, moderation in zip(batch, response.results, strict=True):
                         if moderation.flagged:
                             removed += 1
                             live.custom_update(post)
@@ -81,18 +81,17 @@ class ExamplesWriter(FlowClass):
 
     def get_valid_posts(self) -> Generator[Post]:
         for data_path in self.get_data_paths():
-            with data_path.open(encoding="utf_8") as fp:
+            with data_path.open("rb") as fp:
                 for line in fp:
                     post = Post.model_validate_json(line)
-                    if not (post.is_submission or post.trail) and post.only_text_blocks() and post.get_content_text():
+                    if post.valid_text_post():
                         yield post
 
-    def get_moderation_chunk_limit(self) -> int:
-        test_n = 1000
+    def get_moderation_batch_size(self) -> int:
         try:
-            self.openai.moderations.create(input=[""] * test_n)
+            self.openai.moderations.create(input=[""] * self.config.max_moderation_batch_size)
         except BadRequestError as error:
             message = error.response.json()["error"]["message"]
             if match := search(r"(\d+)\.", message):
                 return int(match.group(1))
-        return test_n
+        return self.config.max_moderation_batch_size

tumblrbot/flow/fine_tune.py

@@ -98,8 +98,8 @@ class FineTuner(FlowClass):
             if job.status == "failed" and job.error is not None:
                 raise RuntimeError(job.error.message)
 
-        if job.fine_tuned_model:
-            self.config.fine_tuned_model = job.fine_tuned_model or ""
+        if job.fine_tuned_model is not None:
+            self.config.fine_tuned_model = job.fine_tuned_model
 
     def print_estimates(self) -> None:
         estimated_tokens = sum(self.count_tokens())

tumblrbot/utils/common.py

@@ -1,4 +1,5 @@
 from abc import abstractmethod
+from pathlib import Path
 from random import choice
 from typing import ClassVar, Self, override
 
@@ -10,15 +11,14 @@ from rich.live import Live
 from rich.progress import MofNCompleteColumn, Progress, SpinnerColumn, TimeElapsedColumn
 from rich.table import Table
 
-from tumblrbot.utils.config import Config, Path
-from tumblrbot.utils.models import FullyValidatedModel
+from tumblrbot.utils.models import Config, FullyValidatedModel
 from tumblrbot.utils.tumblr import TumblrSession
 
 
 class FlowClass(FullyValidatedModel):
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
-    config: ClassVar = Config()  # pyright: ignore[reportCallIssue]
+    config: ClassVar = Config.load()
 
     openai: OpenAI
     tumblr: TumblrSession

tumblrbot/utils/models.py

@@ -1,24 +1,20 @@
+import tomllib
+from abc import abstractmethod
 from collections.abc import Generator
+from pathlib import Path
 from typing import Annotated, Any, ClassVar, Literal, Self, override
 
 import rich
+import tomlkit
 from keyring import get_password, set_password
-from niquests import Session
-from openai import BaseModel
+from openai.types import ChatModel
 from pwinput import pwinput
-from pydantic import ConfigDict, PlainSerializer, SecretStr
+from pydantic import BaseModel, ConfigDict, Field, NonNegativeFloat, PlainSerializer, PositiveFloat, PositiveInt, model_validator
 from pydantic.json_schema import SkipJsonSchema
 from requests_oauthlib import OAuth1Session
 from rich.panel import Panel
-from rich.prompt import Confirm
-
-type SerializableSecretStr = Annotated[
-    SecretStr,
-    PlainSerializer(
-        SecretStr.get_secret_value,
-        when_used="json-unless-none",
-    ),
-]
+from rich.prompt import Confirm, Prompt
+from tomlkit import comment, document
 
 
 class FullyValidatedModel(BaseModel):
@@ -31,84 +27,162 @@ class FullyValidatedModel(BaseModel):
     )
 
 
-class Tokens(FullyValidatedModel):
+class FileSyncSettings(FullyValidatedModel):
+    @classmethod
+    @abstractmethod
+    def read(cls) -> Self | dict[str, object] | str | None: ...
+
+    @classmethod
+    def load(cls) -> Self:
+        data = cls.read() or {}
+        return cls.model_validate_json(data) if isinstance(data, str) else cls.model_validate(data)
+
+    @model_validator(mode="after")
+    @abstractmethod
+    def write(self) -> Self: ...
+
+
+class Config(FileSyncSettings):
+    toml_file: ClassVar = Path("config.toml")
+
+    # Downloading Posts & Writing Examples
+    download_blog_identifiers: list[str] = Field([], description="The identifiers of the blogs which post data will be downloaded from. These must be blogs associated with the same account as the configured Tumblr secret tokens.")
+    data_directory: Path = Field(Path("data"), description="Where to store downloaded post data.")
+
+    # Writing Examples
+    max_moderation_batch_size: PositiveInt = Field(100, description="How many posts, at most, to submit to the OpenAI moderation API. This is also capped by the API.")
+    custom_prompts_file: Path = Field(Path("custom_prompts.jsonl"), description="Where to read in custom prompts from.")
+
+    # Writing Examples & Fine-Tuning
+    examples_file: Path = Field(Path("examples.jsonl"), description="Where to output the examples that will be used to fine-tune the model.")
+
+    # Writing Examples & Generating
+    developer_message: str = Field("You are a Tumblr post bot. Please generate a Tumblr post in accordance with the user's request.", description="The developer message used by the OpenAI API to generate drafts.")
+    user_message: str = Field("Please write a comical Tumblr post.", description="The user input used by the OpenAI API to generate drafts.")
+
+    # Fine-Tuning
+    expected_epochs: PositiveInt = Field(3, description="The expected number of epochs fine-tuning will be run for. This will be updated during fine-tuning.")
+    token_price: PositiveFloat = Field(3, description="The expected price in USD per million tokens during fine-tuning for the current model.")
+    job_id: str = Field("", description="The fine-tuning job ID that will be polled on next run.")
+
+    # Fine-Tuning & Generating
+    base_model: ChatModel = Field("gpt-4o-mini-2024-07-18", description="The name of the model that will be fine-tuned by the generated training data.")
+    fine_tuned_model: str = Field("", description="The name of the OpenAI model that was fine-tuned with your posts.")
+
+    # Generating
+    upload_blog_identifier: str = Field("", description="The identifier of the blog which generated drafts will be uploaded to. This must be a blog associated with the same account as the configured Tumblr secret tokens.")
+    draft_count: PositiveInt = Field(150, description="The number of drafts to process. This will affect the number of tokens used with OpenAI")
+    tags_chance: NonNegativeFloat = Field(0.1, description="The chance to generate tags for any given post. This will incur extra calls to OpenAI.")
+    tags_developer_message: str = Field("You will be provided with a block of text, and your task is to extract a very short list of the most important subjects from it.", description="The developer message used to generate tags.")
+
+    @classmethod
+    @override
+    def read(cls) -> dict[str, object] | None:
+        return tomllib.loads(cls.toml_file.read_text("utf_8")) if cls.toml_file.exists() else None
+
+    @model_validator(mode="after")
+    @override
+    def write(self) -> Self:
+        if not self.download_blog_identifiers:
+            rich.print("Enter the [cyan]identifiers of your blogs[/] that data should be [bold purple]downloaded[/] from, separated by commas.")
+            self.download_blog_identifiers = list(map(str.strip, Prompt.ask("[bold][Example] [dim]staff.tumblr.com,changes").split(",")))
+
+        if not self.upload_blog_identifier:
+            rich.print("Enter the [cyan]identifier of your blog[/] that drafts should be [bold purple]uploaded[/] to.")
+            self.upload_blog_identifier = Prompt.ask("[bold][Example] [dim]staff.tumblr.com or changes").strip()
+
+        toml_table = document()
+
+        for (name, field), value in zip(self.__class__.model_fields.items(), self.model_dump(mode="json").values(), strict=True):
+            if field.description is not None:
+                for line in field.description.split(". "):
+                    toml_table.add(comment(f"{line.removesuffix('.')}."))
+
+            toml_table[name] = value
+
+        Path(self.toml_file).write_text(tomlkit.dumps(toml_table), encoding="utf_8")
+
+        return self
+
+
+class Tokens(FileSyncSettings):
     class Tumblr(FullyValidatedModel):
-        client_key: SerializableSecretStr = SecretStr("")
-        client_secret: SerializableSecretStr = SecretStr("")
-        resource_owner_key: SerializableSecretStr = SecretStr("")
-        resource_owner_secret: SerializableSecretStr = SecretStr("")
+        client_key: str = ""
+        client_secret: str = ""
+        resource_owner_key: str = ""
+        resource_owner_secret: str = ""
 
     service_name: ClassVar = "tumblrbot"
     username: ClassVar = "tokens"
 
-    openai_api_key: SerializableSecretStr = SecretStr("")
+    openai_api_key: str = ""
     tumblr: Tumblr = Tumblr()
 
     @staticmethod
-    def online_token_prompt(url: str, *tokens: str) -> Generator[SecretStr]:
+    def get_oauth_tokens(token: dict[str, str]) -> tuple[str, str]:
+        return token["oauth_token"], token["oauth_token_secret"]
+
+    @staticmethod
+    def online_token_prompt(url: str, *tokens: str) -> Generator[str]:
         formatted_token_string = " and ".join(f"[cyan]{token}[/]" for token in tokens)
 
         rich.print(f"Retrieve your {formatted_token_string} from: {url}")
         for token in tokens:
-            yield SecretStr(pwinput(f"Enter your {token} (masked): ").strip())
+            yield pwinput(f"Enter your {token} (masked): ").strip()
 
         rich.print()
 
     @classmethod
-    def read_from_keyring(cls) -> Self:
-        if json_data := get_password(cls.service_name, cls.username):
-            return cls.model_validate_json(json_data)
-        return cls()
-
     @override
-    def model_post_init(self, context: object) -> None:
-        super().model_post_init(context)
+    def read(cls) -> str | None:
+        return get_password(cls.service_name, cls.username)
 
-        if not self.openai_api_key.get_secret_value() or Confirm.ask("Reset OpenAI API key?", default=False):
+    @model_validator(mode="after")
+    @override
+    def write(self) -> Self:
+        if not self.openai_api_key or Confirm.ask("Reset OpenAI API key?", default=False):
             (self.openai_api_key,) = self.online_token_prompt("https://platform.openai.com/api-keys", "API key")
 
-        if not all(self.tumblr.model_dump(mode="json").values()) or Confirm.ask("Reset Tumblr API tokens?", default=False):
+        if not all(self.tumblr.model_dump().values()) or Confirm.ask("Reset Tumblr API tokens?", default=False):
             self.tumblr.client_key, self.tumblr.client_secret = self.online_token_prompt("https://tumblr.com/oauth/apps", "consumer key", "consumer secret")
 
-            OAuth1Session.__bases__ = (Session,)
-
             with OAuth1Session(
-                self.tumblr.client_key.get_secret_value(),
-                self.tumblr.client_secret.get_secret_value(),
+                self.tumblr.client_key,
+                self.tumblr.client_secret,
             ) as oauth_session:
                 fetch_response = oauth_session.fetch_request_token("http://tumblr.com/oauth/request_token")
                 full_authorize_url = oauth_session.authorization_url("http://tumblr.com/oauth/authorize")
                 (redirect_response,) = self.online_token_prompt(full_authorize_url, "full redirect URL")
-                oauth_response = oauth_session.parse_authorization_response(redirect_response.get_secret_value())
+                oauth_response = oauth_session.parse_authorization_response(redirect_response)
 
             with OAuth1Session(
-                self.tumblr.client_key.get_secret_value(),
-                self.tumblr.client_secret.get_secret_value(),
-                fetch_response["oauth_token"],
-                fetch_response["oauth_token_secret"],
+                self.tumblr.client_key,
+                self.tumblr.client_secret,
+                *self.get_oauth_tokens(fetch_response),
                 verifier=oauth_response["oauth_verifier"],
             ) as oauth_session:
                 oauth_tokens = oauth_session.fetch_access_token("http://tumblr.com/oauth/access_token")
 
-            self.tumblr.resource_owner_key = oauth_tokens["oauth_token"]
-            self.tumblr.resource_owner_secret = oauth_tokens["oauth_token_secret"]
+            self.tumblr.resource_owner_key, self.tumblr.resource_owner_secret = self.get_oauth_tokens(oauth_tokens)
 
         set_password(self.service_name, self.username, self.model_dump_json())
 
+        return self
+
 
 class Post(FullyValidatedModel):
     class Block(FullyValidatedModel):
         type: str = "text"
         text: str = ""
-        blocks: list[int] = []  # noqa: RUF012
+        blocks: list[int] = []
 
     timestamp: SkipJsonSchema[int] = 0
-    tags: Annotated[list[str], PlainSerializer(",".join)] = []  # noqa: RUF012
+    tags: Annotated[list[str], PlainSerializer(",".join)] = []
     state: SkipJsonSchema[Literal["published", "queued", "draft", "private", "unapproved"]] = "draft"
 
-    content: SkipJsonSchema[list[Block]] = []  # noqa: RUF012
-    layout: SkipJsonSchema[list[Block]] = []  # noqa: RUF012
-    trail: SkipJsonSchema[list[Any]] = []  # noqa: RUF012
+    content: SkipJsonSchema[list[Block]] = []
+    layout: SkipJsonSchema[list[Block]] = []
+    trail: SkipJsonSchema[list[Any]] = []
 
     is_submission: SkipJsonSchema[bool] = False
 
@@ -120,8 +194,8 @@ class Post(FullyValidatedModel):
             subtitle_align="left",
         )
 
-    def only_text_blocks(self) -> bool:
-        return all(block.type == "text" for block in self.content) and not any(block.type == "ask" for block in self.layout)
+    def valid_text_post(self) -> bool:
+        return bool(self.content) and all(block.type == "text" for block in self.content) and not (self.is_submission or self.trail or any(block.type == "ask" for block in self.layout))
 
     def get_content_text(self) -> str:
         return "\n\n".join(block.text for block in self.content)

tumblrbot/utils/tumblr.py

@@ -1,47 +1,39 @@
-from dataclasses import dataclass
 from typing import Self
 
-from niquests import HTTPError, PreparedRequest, Response, Session
-from requests_oauthlib import OAuth1
+from requests import HTTPError, Response
+from requests_oauthlib import OAuth1Session
 
 from tumblrbot.utils.models import Post, Tokens
 
 
-@dataclass
-class TumblrSession(Session):
-    tokens: Tokens
-
-    def __post_init__(self) -> None:
-        super().__init__(multiplexed=True, happy_eyeballs=True)
-
-        self.auth = OAuth1(**self.tokens.tumblr.model_dump(mode="json"))
+class TumblrSession(OAuth1Session):
+    def __init__(self, tokens: Tokens) -> None:
+        super().__init__(**tokens.tumblr.model_dump())
         self.hooks["response"].append(self.response_hook)
 
     def __enter__(self) -> Self:
         super().__enter__()
         return self
 
-    def response_hook(self, response: PreparedRequest | Response) -> None:
-        if isinstance(response, Response):
-            try:
-                response.raise_for_status()
-            except HTTPError as error:
-                if response.text:
-                    error.add_note(response.text)
-                raise
+    def response_hook(self, response: Response, *_args: object, **_kwargs: object) -> None:
+        try:
+            response.raise_for_status()
+        except HTTPError as error:
+            error.add_note(response.text)
+            raise
 
     def retrieve_published_posts(self, blog_identifier: str, after: int) -> Response:
         return self.get(
             f"https://api.tumblr.com/v2/blog/{blog_identifier}/posts",
             params={
-                "after": str(after),
+                "after": after,
                 "sort": "asc",
-                "npf": str(True),
+                "npf": True,
             },
         )
 
     def create_post(self, blog_identifier: str, post: Post) -> Response:
         return self.post(
             f"https://api.tumblr.com/v2/blog/{blog_identifier}/posts",
-            json=post.model_dump(mode="json"),
+            json=post.model_dump(),
         )

{tumblrbot-1.4.5.dist-info → tumblrbot-1.4.7.dist-info}/METADATA

@@ -1,22 +1,19 @@
 Metadata-Version: 2.4
 Name: tumblrbot
-Version: 1.4.5
+Version: 1.4.7
 Summary: An updated bot that posts to Tumblr, based on your very own blog!
 Requires-Python: >= 3.13
 Description-Content-Type: text/markdown
-Requires-Dist: httpx[http2]
 Requires-Dist: keyring
-Requires-Dist: more-itertools
-Requires-Dist: niquests[speedups, http3]
 Requires-Dist: openai
 Requires-Dist: pwinput
 Requires-Dist: pydantic
-Requires-Dist: pydantic-settings
+Requires-Dist: requests
 Requires-Dist: requests-oauthlib
 Requires-Dist: rich
 Requires-Dist: tiktoken
 Requires-Dist: tomlkit
-Project-URL: Source, https://github.com/MaidThatPrograms/tumblrbot
+Project-URL: Source, https://github.com/MaidScientistIzutsumiMarin/tumblrbot
 
 # tumblrbot
 
@@ -59,7 +56,6 @@ Features:
 - An [interactive console][Main] for all steps of generating posts for the blog:
    1. Asks for [OpenAI] and [Tumblr] tokens.
       - Stores API tokens using [keyring].
-      - Prevents API tokens from printing to the console.
    1. Retrieves [Tumblr] [OAuth] tokens.
    1. [Downloads posts][Download] from the [configured][config] [Tumblr] blogs.
       - Skips redownloading already downloaded posts.
@@ -69,8 +65,8 @@ Features:
       - Filters out any posts flagged by the [OpenAI] [Moderation API] (optional).
          - Shows progress and previews the current post.
       - Adds custom user messages and assistant responses to the dataset from the [configured][config] file.
-   1. Provides cost estimates if the currently saved examples are used to fine-tune the [configured][config] model.
    1. [Uploads examples][Fine-Tune] to [OpenAI] and begins the fine-tuning process.
+      - Provides cost estimates if the currently saved examples are used to fine-tune the [configured][config] model.
       - Resumes monitoring the same fine-tuning process when restarted.
       - Deletes the uploaded examples file if fine-tuning does not succeed (optional).
       - Stores the output model automatically when fine-tuning is completed.

tumblrbot-1.4.7.dist-info/RECORD

@@ -0,0 +1,15 @@
+tumblrbot/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tumblrbot/__main__.py,sha256=BenjVNlVZDy-ZlSWukEIguGLa6qXvZjhYSSWMqa8-0Q,1447
+tumblrbot/flow/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tumblrbot/flow/download.py,sha256=wdXmtCnnArn8Zw7D2Hoa_KhH-k61j9w3cbYztgBkUlY,2036
+tumblrbot/flow/examples.py,sha256=Th6vgiu3D2VloOx7otZlk164h3ifkJEwDk21YHMEYP0,3976
+tumblrbot/flow/fine_tune.py,sha256=YDukEwZNw3GveEAH4ORv6oylka5MQNLK_4iSmuAVPtg,5387
+tumblrbot/flow/generate.py,sha256=Q6nUtmoj28-rGUCs4V0fuovJshvFMlmipyu9GGqnmzM,2147
+tumblrbot/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tumblrbot/utils/common.py,sha256=RvICPORtBSqsN7VWADgStogJ8w4owzBfR1E2XbCQrfA,1795
+tumblrbot/utils/models.py,sha256=Z0k16qJsZEO8tfmPp7X3edz-RgGCDLRSm7HrSDLGh1Y,9663
+tumblrbot/utils/tumblr.py,sha256=6V9AjT-dyR2vuUkfqgqs52Ua5irhQJzhgQhV54xKyGM,1258
+tumblrbot-1.4.7.dist-info/entry_points.txt,sha256=lTiN7PxAbyGY1fpCWApEw6NUIUgobfcOKhvn6cu3IQA,53
+tumblrbot-1.4.7.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+tumblrbot-1.4.7.dist-info/METADATA,sha256=q_PH1oU-d0PRdXDuL5Bjh-Y8gccZJVvLCCho2E_CLvc,10104
+tumblrbot-1.4.7.dist-info/RECORD,,

tumblrbot/utils/config.py

@@ -1,97 +0,0 @@
-from collections.abc import Sequence
-from pathlib import Path
-from typing import TYPE_CHECKING, Self, override
-
-import rich
-import tomlkit
-from openai.types import ChatModel
-from pydantic import Field, NonNegativeFloat, PositiveFloat, PositiveInt, Secret, model_validator
-from pydantic_settings import BaseSettings, PydanticBaseSettingsSource, SettingsConfigDict, TomlConfigSettingsSource
-from rich.prompt import Prompt
-from tomlkit import comment, document
-
-if TYPE_CHECKING:
-    from _typeshed import StrPath
-
-
-class Config(BaseSettings):
-    model_config = SettingsConfigDict(
-        extra="ignore",
-        validate_assignment=True,
-        validate_return=True,
-        validate_by_name=True,
-        cli_parse_args=True,
-        cli_avoid_json=True,
-        cli_kebab_case=True,
-        toml_file="config.toml",
-    )
-
-    # Downloading Posts & Writing Examples
-    download_blog_identifiers: list[str] = Field([], description="The identifiers of the blogs which post data will be downloaded from. These must be blogs associated with the same account as the configured Tumblr secret tokens.")
-    data_directory: Path = Field(Path("data"), description="Where to store downloaded post data.")
-
-    # Writing Examples
-    custom_prompts_file: Path = Field(Path("custom_prompts.jsonl"), description="Where to read in custom prompts from.")
-
-    # Writing Examples & Fine-Tuning
-    examples_file: Path = Field(Path("examples.jsonl"), description="Where to output the examples that will be used to fine-tune the model.")
-
-    # Writing Examples & Generating
-    developer_message: str = Field("You are a Tumblr post bot. Please generate a Tumblr post in accordance with the user's request.", description="The developer message used by the OpenAI API to generate drafts.")
-    user_message: str = Field("Please write a comical Tumblr post.", description="The user input used by the OpenAI API to generate drafts.")
-
-    # Fine-Tuning
-    expected_epochs: PositiveInt = Field(3, description="The expected number of epochs fine-tuning will be run for. This will be updated during fine-tuning.")
-    token_price: PositiveFloat = Field(3, description="The expected price in USD per million tokens during fine-tuning for the current model.")
-    job_id: str = Field("", description="The fine-tuning job ID that will be polled on next run.")
-
-    # Fine-Tuning & Generating
-    base_model: ChatModel = Field("gpt-4o-mini-2024-07-18", description="The name of the model that will be fine-tuned by the generated training data.")
-    fine_tuned_model: str = Field("", description="The name of the OpenAI model that was fine-tuned with your posts.")
-
-    # Generating
-    upload_blog_identifier: str = Field("", description="The identifier of the blog which generated drafts will be uploaded to. This must be a blog associated with the same account as the configured Tumblr secret tokens.")
-    draft_count: PositiveInt = Field(150, description="The number of drafts to process. This will affect the number of tokens used with OpenAI")
-    tags_chance: NonNegativeFloat = Field(0.1, description="The chance to generate tags for any given post. This will incur extra calls to OpenAI.")
-    tags_developer_message: str = Field("You will be provided with a block of text, and your task is to extract a very short list of the most important subjects from it.", description="The developer message used to generate tags.")
-
-    @override
-    @classmethod
-    def settings_customise_sources(cls, settings_cls: type[BaseSettings], *args: PydanticBaseSettingsSource, **kwargs: PydanticBaseSettingsSource) -> tuple[PydanticBaseSettingsSource, ...]:
-        return (TomlConfigSettingsSource(settings_cls),)
-
-    @model_validator(mode="after")
-    def write_to_file(self) -> Self:
-        if not self.download_blog_identifiers:
-            rich.print("Enter the [cyan]identifiers of your blogs[/] that data should be [bold purple]downloaded[/] from, separated by commas.")
-            self.download_blog_identifiers = list(map(str.strip, Prompt.ask("[bold][Example] [dim]staff.tumblr.com,changes").split(",")))
-
-        if not self.upload_blog_identifier:
-            rich.print("Enter the [cyan]identifier of your blog[/] that drafts should be [bold purple]uploaded[/] to.")
-            self.upload_blog_identifier = Prompt.ask("[bold][Example] [dim]staff.tumblr.com or changes").strip()
-
-        toml_files = self.model_config.get("toml_file")
-        if isinstance(toml_files, (Path, str)):
-            self.dump_toml(toml_files)
-        elif isinstance(toml_files, Sequence):
-            for toml_file in toml_files:
-                self.dump_toml(toml_file)
-
-        return self
-
-    def dump_toml(self, toml_file: "StrPath") -> None:
-        toml_table = document()
-
-        dumped_model = self.model_dump(mode="json")
-        for name, field in self.__class__.model_fields.items():
-            if field.description:
-                for line in field.description.split(". "):
-                    toml_table.add(comment(f"{line.removesuffix('.')}."))
-
-            value = getattr(self, name)
-            toml_table[name] = value.get_secret_value() if isinstance(value, Secret) else dumped_model[name]
-
-        Path(toml_file).write_text(
-            tomlkit.dumps(toml_table),
-            encoding="utf_8",
-        )

tumblrbot-1.4.5.dist-info/RECORD

@@ -1,16 +0,0 @@
-tumblrbot/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tumblrbot/__main__.py,sha256=SbMPe0vwfPXdYQWy9UKkn0FLngU_QtznJTWybVnGFoA,1578
-tumblrbot/flow/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tumblrbot/flow/download.py,sha256=xSfic66FR-LIG0KtJMcM5KVd2hiijCH3cyD7dzFKwLM,2042
-tumblrbot/flow/examples.py,sha256=5k14Eyqi9MRFF_k7Vp7WhjP9khq7YDDgxz54Shs1nU8,4031
-tumblrbot/flow/fine_tune.py,sha256=X9xR9uPgiK6DKQ-lZ6oqwTPypUx5D5S1MiKrFKSm5ng,5381
-tumblrbot/flow/generate.py,sha256=Q6nUtmoj28-rGUCs4V0fuovJshvFMlmipyu9GGqnmzM,2147
-tumblrbot/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tumblrbot/utils/common.py,sha256=tnKBBiEGQPOWByLi0vT31BzpntndbIP_JekGkgjy15U,1841
-tumblrbot/utils/config.py,sha256=WL7LW8mKJy27DxcKK8JepO09pc4zz6Lwii8haV9vXLE,5399
-tumblrbot/utils/models.py,sha256=R2TPA35b8Lp4FalQrdzS0mhUClgBGx3FtdiGAZMU3tg,5355
-tumblrbot/utils/tumblr.py,sha256=bWTE1AAcOY1vf0NLoJCQCra0o0y7mJao4KvojgARJzI,1521
-tumblrbot-1.4.5.dist-info/entry_points.txt,sha256=lTiN7PxAbyGY1fpCWApEw6NUIUgobfcOKhvn6cu3IQA,53
-tumblrbot-1.4.5.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
-tumblrbot-1.4.5.dist-info/METADATA,sha256=a2Et1vIW4HXA_fl_nPNP23g1XSVdTWTeq343ZPNXcoM,10258
-tumblrbot-1.4.5.dist-info/RECORD,,