tumblrbot 1.4.5__tar.gz → 1.4.6__tar.gz

{tumblrbot-1.4.5 → tumblrbot-1.4.6}/PKG-INFO

@@ -1,17 +1,15 @@
 Metadata-Version: 2.4
 Name: tumblrbot
-Version: 1.4.5
+Version: 1.4.6
 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

{tumblrbot-1.4.5 → tumblrbot-1.4.6}/pyproject.toml

@@ -1,18 +1,16 @@
 [project]
 name = "tumblrbot"
-version = "1.4.5"
+version = "1.4.6"
 description = "An updated bot that posts to Tumblr, based on your very own blog!"
 readme = "README.md"
 requires-python = ">= 3.13"
 dependencies = [
-  "httpx[http2]",
   "keyring",
-  "more-itertools",
-  "niquests[speedups,http3]",
   "openai",
   "pwinput",
   "pydantic",
   "pydantic-settings",
+  "requests",
   "requests-oauthlib",
   "rich",
   "tiktoken",
@@ -26,5 +24,5 @@ Source = "https://github.com/MaidThatPrograms/tumblrbot"
 tumblrbot = "tumblrbot.__main__:main"
 
 [build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
+requires = ["flit_core"]
+build-backend = "flit_core.buildapi"

{tumblrbot-1.4.5 → tumblrbot-1.4.6}/src/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
 
@@ -15,10 +15,7 @@ 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,
-    ):
+    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-1.4.5 → tumblrbot-1.4.6}/src/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
 
@@ -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)
@@ -84,15 +84,14 @@ class ExamplesWriter(FlowClass):
             with data_path.open(encoding="utf_8") 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-1.4.5 → tumblrbot-1.4.6}/src/tumblrbot/utils/config.py

@@ -5,7 +5,7 @@ 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 import Field, NonNegativeFloat, PositiveFloat, PositiveInt, model_validator
 from pydantic_settings import BaseSettings, PydanticBaseSettingsSource, SettingsConfigDict, TomlConfigSettingsSource
 from rich.prompt import Prompt
 from tomlkit import comment, document
@@ -31,6 +31,7 @@ class Config(BaseSettings):
     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
@@ -88,8 +89,7 @@ class Config(BaseSettings):
                 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]
+            toml_table[name] = dumped_model[name]
 
         Path(toml_file).write_text(
             tomlkit.dumps(toml_table),

{tumblrbot-1.4.5 → tumblrbot-1.4.6}/src/tumblrbot/utils/models.py

@@ -3,23 +3,14 @@ from typing import Annotated, Any, ClassVar, Literal, Self, override
 
 import rich
 from keyring import get_password, set_password
-from niquests import Session
 from openai import BaseModel
 from pwinput import pwinput
-from pydantic import ConfigDict, PlainSerializer, SecretStr
+from pydantic import ConfigDict, PlainSerializer
 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",
-    ),
-]
-
 
 class FullyValidatedModel(BaseModel):
     model_config = ConfigDict(
@@ -33,24 +24,28 @@ class FullyValidatedModel(BaseModel):
 
 class Tokens(FullyValidatedModel):
     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()
 
@@ -64,34 +59,30 @@ class Tokens(FullyValidatedModel):
     def model_post_init(self, context: object) -> None:
         super().model_post_init(context)
 
-        if not self.openai_api_key.get_secret_value() or Confirm.ask("Reset OpenAI API key?", default=False):
+        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())
 
@@ -120,8 +111,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-1.4.6/src/tumblrbot/utils/tumblr.py

@@ -0,0 +1,40 @@
+from typing import Self
+
+from requests import HTTPError, Response
+from requests_oauthlib import OAuth1Session
+
+from tumblrbot.utils.models import Post, Tokens
+
+
+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: Response, *_args: object, **_kwargs: object) -> None:
+        try:
+            response.raise_for_status()
+        except HTTPError as error:
+            if response.text:
+                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": after,
+                "sort": "asc",
+                "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(),
+        )

tumblrbot-1.4.5/src/tumblrbot/utils/tumblr.py

@@ -1,47 +0,0 @@
-from dataclasses import dataclass
-from typing import Self
-
-from niquests import HTTPError, PreparedRequest, Response, Session
-from requests_oauthlib import OAuth1
-
-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"))
-        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 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),
-                "sort": "asc",
-                "npf": str(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"),
-        )