wp_python 0.1.0__py3-none-any.whl

src/wordpress_api/endpoints/posts.py

@@ -0,0 +1,131 @@
+"""Posts endpoint."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ..models.post import Post, PostCreate, PostUpdate, PostStatus
+from .base import CRUDEndpoint
+
+
+class PostsEndpoint(CRUDEndpoint[Post]):
+    """Endpoint for managing WordPress posts."""
+
+    _path = "/wp/v2/posts"
+    _model_class = Post
+
+    def list(
+        self,
+        page: int = 1,
+        per_page: int = 10,
+        search: str | None = None,
+        order: str = "desc",
+        orderby: str = "date",
+        status: str | PostStatus | list[str] | None = None,
+        categories: list[int] | None = None,
+        categories_exclude: list[int] | None = None,
+        tags: list[int] | None = None,
+        tags_exclude: list[int] | None = None,
+        author: int | list[int] | None = None,
+        author_exclude: list[int] | None = None,
+        before: str | None = None,
+        after: str | None = None,
+        modified_before: str | None = None,
+        modified_after: str | None = None,
+        slug: str | list[str] | None = None,
+        sticky: bool | None = None,
+        **kwargs: Any,
+    ) -> list[Post]:
+        """List posts with filtering options.
+        
+        Args:
+            page: Current page of the collection.
+            per_page: Maximum number of items to return.
+            search: Limit results to those matching a string.
+            order: Order sort attribute ascending or descending.
+            orderby: Sort collection by attribute.
+            status: Limit result set to posts with specific status(es).
+            categories: Limit result set to posts with specific categories.
+            categories_exclude: Exclude posts with specific categories.
+            tags: Limit result set to posts with specific tags.
+            tags_exclude: Exclude posts with specific tags.
+            author: Limit result set to posts by specific author(s).
+            author_exclude: Exclude posts by specific authors.
+            before: Limit to posts published before a given date.
+            after: Limit to posts published after a given date.
+            modified_before: Limit to posts modified before a given date.
+            modified_after: Limit to posts modified after a given date.
+            slug: Limit result set to posts with specific slug(s).
+            sticky: Limit result set to sticky or non-sticky posts.
+        """
+        params: dict[str, Any] = {
+            "page": page,
+            "per_page": per_page,
+            "order": order,
+            "orderby": orderby,
+        }
+        
+        if search:
+            params["search"] = search
+        if status:
+            if isinstance(status, PostStatus):
+                params["status"] = status.value
+            elif isinstance(status, list):
+                params["status"] = ",".join(status)
+            else:
+                params["status"] = status
+        if categories:
+            params["categories"] = ",".join(map(str, categories))
+        if categories_exclude:
+            params["categories_exclude"] = ",".join(map(str, categories_exclude))
+        if tags:
+            params["tags"] = ",".join(map(str, tags))
+        if tags_exclude:
+            params["tags_exclude"] = ",".join(map(str, tags_exclude))
+        if author is not None:
+            if isinstance(author, list):
+                params["author"] = ",".join(map(str, author))
+            else:
+                params["author"] = author
+        if author_exclude:
+            params["author_exclude"] = ",".join(map(str, author_exclude))
+        if before:
+            params["before"] = before
+        if after:
+            params["after"] = after
+        if modified_before:
+            params["modified_before"] = modified_before
+        if modified_after:
+            params["modified_after"] = modified_after
+        if slug:
+            if isinstance(slug, list):
+                params["slug"] = ",".join(slug)
+            else:
+                params["slug"] = slug
+        if sticky is not None:
+            params["sticky"] = sticky
+
+        params.update(kwargs)
+        response = self._get(self._path, params=params)
+        return [Post.model_validate(item) for item in response]
+
+    def create(self, data: PostCreate | dict[str, Any]) -> Post:
+        """Create a new post."""
+        return super().create(data)
+
+    def update(self, id: int, data: PostUpdate | dict[str, Any]) -> Post:
+        """Update an existing post."""
+        return super().update(id, data)
+
+    def trash(self, id: int) -> Post:
+        """Move a post to trash."""
+        return self.update(id, PostUpdate(status=PostStatus.TRASH))
+
+    def restore(self, id: int) -> Post:
+        """Restore a post from trash."""
+        return self.update(id, PostUpdate(status=PostStatus.DRAFT))
+
+    def get_by_slug(self, slug: str) -> Post | None:
+        """Get a post by its slug."""
+        posts = self.list(slug=slug)
+        return posts[0] if posts else None

src/wordpress_api/endpoints/revisions.py

@@ -0,0 +1,121 @@
+"""Revisions endpoint."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any
+
+from pydantic import BaseModel, Field, field_validator
+
+from ..models.base import RenderedContent, parse_datetime
+from .base import BaseEndpoint
+
+
+class Revision(BaseModel):
+    """WordPress Revision object."""
+
+    id: int
+    author: int = 0
+    date: datetime | None = None
+    date_gmt: datetime | None = None
+    guid: RenderedContent | None = None
+    modified: datetime | None = None
+    modified_gmt: datetime | None = None
+    parent: int = 0
+    slug: str = ""
+    title: RenderedContent | None = None
+    content: RenderedContent | None = None
+    excerpt: RenderedContent | None = None
+
+    @field_validator("date", "date_gmt", "modified", "modified_gmt", mode="before")
+    @classmethod
+    def parse_dates(cls, v: Any) -> datetime | None:
+        return parse_datetime(v)
+
+
+class RevisionsEndpoint(BaseEndpoint):
+    """Endpoint for managing post and page revisions."""
+
+    def list_post_revisions(
+        self,
+        post_id: int,
+        page: int = 1,
+        per_page: int = 10,
+        **kwargs: Any,
+    ) -> list[Revision]:
+        """List revisions for a post."""
+        params: dict[str, Any] = {
+            "page": page,
+            "per_page": per_page,
+        }
+        params.update(kwargs)
+        
+        response = self._get(f"/wp/v2/posts/{post_id}/revisions", params=params)
+        return [Revision.model_validate(item) for item in response]
+
+    def get_post_revision(self, post_id: int, revision_id: int) -> Revision:
+        """Get a specific post revision."""
+        response = self._get(f"/wp/v2/posts/{post_id}/revisions/{revision_id}")
+        return Revision.model_validate(response)
+
+    def delete_post_revision(
+        self,
+        post_id: int,
+        revision_id: int,
+        force: bool = True,
+    ) -> dict[str, Any]:
+        """Delete a post revision."""
+        return self._delete(
+            f"/wp/v2/posts/{post_id}/revisions/{revision_id}",
+            params={"force": force},
+        )
+
+    def list_page_revisions(
+        self,
+        page_id: int,
+        page: int = 1,
+        per_page: int = 10,
+        **kwargs: Any,
+    ) -> list[Revision]:
+        """List revisions for a page."""
+        params: dict[str, Any] = {
+            "page": page,
+            "per_page": per_page,
+        }
+        params.update(kwargs)
+        
+        response = self._get(f"/wp/v2/pages/{page_id}/revisions", params=params)
+        return [Revision.model_validate(item) for item in response]
+
+    def get_page_revision(self, page_id: int, revision_id: int) -> Revision:
+        """Get a specific page revision."""
+        response = self._get(f"/wp/v2/pages/{page_id}/revisions/{revision_id}")
+        return Revision.model_validate(response)
+
+    def delete_page_revision(
+        self,
+        page_id: int,
+        revision_id: int,
+        force: bool = True,
+    ) -> dict[str, Any]:
+        """Delete a page revision."""
+        return self._delete(
+            f"/wp/v2/pages/{page_id}/revisions/{revision_id}",
+            params={"force": force},
+        )
+
+    def get_latest_revision(self, post_id: int, post_type: str = "posts") -> Revision | None:
+        """Get the most recent revision."""
+        if post_type == "pages":
+            revisions = self.list_page_revisions(post_id, per_page=1)
+        else:
+            revisions = self.list_post_revisions(post_id, per_page=1)
+        return revisions[0] if revisions else None
+
+    def count_revisions(self, post_id: int, post_type: str = "posts") -> int:
+        """Count the number of revisions for a post or page."""
+        if post_type == "pages":
+            all_revisions = self.list_page_revisions(post_id, per_page=100)
+        else:
+            all_revisions = self.list_post_revisions(post_id, per_page=100)
+        return len(all_revisions)

src/wordpress_api/endpoints/search.py

@@ -0,0 +1,81 @@
+"""Search endpoint."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel
+
+from .base import BaseEndpoint
+
+
+class SearchResult(BaseModel):
+    """WordPress search result."""
+
+    id: int
+    title: str = ""
+    url: str = ""
+    type: str = ""
+    subtype: str = ""
+
+
+class SearchEndpoint(BaseEndpoint):
+    """Endpoint for WordPress site-wide search."""
+
+    _path = "/wp/v2/search"
+
+    def search(
+        self,
+        search: str,
+        page: int = 1,
+        per_page: int = 10,
+        type: str | None = None,
+        subtype: str | list[str] | None = None,
+        **kwargs: Any,
+    ) -> list[SearchResult]:
+        """Search the site.
+        
+        Args:
+            search: Search query string.
+            page: Current page of the collection.
+            per_page: Maximum number of items to return.
+            type: Limit results to a specific type (post, term, post-format).
+            subtype: Limit results to specific subtypes (post, page, category, etc.).
+        """
+        params: dict[str, Any] = {
+            "search": search,
+            "page": page,
+            "per_page": per_page,
+        }
+        
+        if type:
+            params["type"] = type
+        if subtype:
+            if isinstance(subtype, list):
+                params["subtype"] = ",".join(subtype)
+            else:
+                params["subtype"] = subtype
+        params.update(kwargs)
+        
+        response = self._get(self._path, params=params)
+        return [SearchResult.model_validate(item) for item in response]
+
+    def search_posts(self, query: str, **kwargs: Any) -> list[SearchResult]:
+        """Search only posts."""
+        return self.search(query, type="post", subtype="post", **kwargs)
+
+    def search_pages(self, query: str, **kwargs: Any) -> list[SearchResult]:
+        """Search only pages."""
+        return self.search(query, type="post", subtype="page", **kwargs)
+
+    def search_categories(self, query: str, **kwargs: Any) -> list[SearchResult]:
+        """Search only categories."""
+        return self.search(query, type="term", subtype="category", **kwargs)
+
+    def search_tags(self, query: str, **kwargs: Any) -> list[SearchResult]:
+        """Search only tags."""
+        return self.search(query, type="term", subtype="post_tag", **kwargs)
+
+    def search_all_content(self, query: str, **kwargs: Any) -> list[SearchResult]:
+        """Search all post types (posts, pages, custom post types)."""
+        return self.search(query, type="post", **kwargs)

src/wordpress_api/endpoints/settings.py

@@ -0,0 +1,55 @@
+"""Settings endpoint."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ..models.settings import Settings
+from .base import BaseEndpoint
+
+
+class SettingsEndpoint(BaseEndpoint):
+    """Endpoint for managing WordPress site settings."""
+
+    _path = "/wp/v2/settings"
+
+    def get(self) -> Settings:
+        """Get all site settings."""
+        response = self._get(self._path)
+        return Settings.model_validate(response)
+
+    def update(self, **settings: Any) -> Settings:
+        """Update site settings.
+        
+        Args:
+            **settings: Key-value pairs of settings to update.
+        """
+        response = self._post(self._path, data=settings)
+        return Settings.model_validate(response)
+
+    def get_title(self) -> str:
+        """Get the site title."""
+        settings = self.get()
+        return settings.title
+
+    def set_title(self, title: str) -> Settings:
+        """Set the site title."""
+        return self.update(title=title)
+
+    def get_description(self) -> str:
+        """Get the site description (tagline)."""
+        settings = self.get()
+        return settings.description
+
+    def set_description(self, description: str) -> Settings:
+        """Set the site description (tagline)."""
+        return self.update(description=description)
+
+    def get_timezone(self) -> str:
+        """Get the site timezone."""
+        settings = self.get()
+        return settings.timezone
+
+    def set_timezone(self, timezone: str) -> Settings:
+        """Set the site timezone."""
+        return self.update(timezone=timezone)

src/wordpress_api/endpoints/statuses.py

@@ -0,0 +1,56 @@
+"""Post Statuses endpoint."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel
+
+from .base import BaseEndpoint
+
+
+class PostStatusInfo(BaseModel):
+    """WordPress Post Status object."""
+
+    name: str = ""
+    slug: str = ""
+    public: bool = True
+    queryable: bool = True
+    date_floating: bool = False
+
+
+class StatusesEndpoint(BaseEndpoint):
+    """Endpoint for viewing WordPress post statuses."""
+
+    _path = "/wp/v2/statuses"
+
+    def list(self, **kwargs: Any) -> dict[str, PostStatusInfo]:
+        """List all registered post statuses."""
+        response = self._get(self._path, params=kwargs)
+        return {k: PostStatusInfo.model_validate(v) for k, v in response.items()}
+
+    def get(self, status: str, **kwargs: Any) -> PostStatusInfo:
+        """Get a specific post status by slug."""
+        response = self._get(f"{self._path}/{status}", params=kwargs)
+        return PostStatusInfo.model_validate(response)
+
+    def get_publish(self) -> PostStatusInfo:
+        """Get the 'publish' status."""
+        return self.get("publish")
+
+    def get_draft(self) -> PostStatusInfo:
+        """Get the 'draft' status."""
+        return self.get("draft")
+
+    def get_pending(self) -> PostStatusInfo:
+        """Get the 'pending' status."""
+        return self.get("pending")
+
+    def get_private(self) -> PostStatusInfo:
+        """Get the 'private' status."""
+        return self.get("private")
+
+    def list_public(self) -> dict[str, PostStatusInfo]:
+        """List only public post statuses."""
+        all_statuses = self.list()
+        return {k: v for k, v in all_statuses.items() if v.public}

src/wordpress_api/endpoints/tags.py

@@ -0,0 +1,79 @@
+"""Tags endpoint."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ..models.tag import Tag, TagCreate, TagUpdate
+from .base import CRUDEndpoint
+
+
+class TagsEndpoint(CRUDEndpoint[Tag]):
+    """Endpoint for managing WordPress tags."""
+
+    _path = "/wp/v2/tags"
+    _model_class = Tag
+
+    def list(
+        self,
+        page: int = 1,
+        per_page: int = 10,
+        search: str | None = None,
+        order: str = "asc",
+        orderby: str = "name",
+        hide_empty: bool = False,
+        post: int | None = None,
+        slug: str | list[str] | None = None,
+        include: list[int] | None = None,
+        exclude: list[int] | None = None,
+        **kwargs: Any,
+    ) -> list[Tag]:
+        """List tags with filtering options."""
+        params: dict[str, Any] = {
+            "page": page,
+            "per_page": per_page,
+            "order": order,
+            "orderby": orderby,
+            "hide_empty": hide_empty,
+        }
+        
+        if search:
+            params["search"] = search
+        if post is not None:
+            params["post"] = post
+        if slug:
+            if isinstance(slug, list):
+                params["slug"] = ",".join(slug)
+            else:
+                params["slug"] = slug
+        if include:
+            params["include"] = ",".join(map(str, include))
+        if exclude:
+            params["exclude"] = ",".join(map(str, exclude))
+
+        params.update(kwargs)
+        response = self._get(self._path, params=params)
+        return [Tag.model_validate(item) for item in response]
+
+    def create(self, data: TagCreate | dict[str, Any]) -> Tag:
+        """Create a new tag."""
+        return super().create(data)
+
+    def update(self, id: int, data: TagUpdate | dict[str, Any]) -> Tag:
+        """Update an existing tag."""
+        return super().update(id, data)
+
+    def get_by_slug(self, slug: str) -> Tag | None:
+        """Get a tag by its slug."""
+        tags = self.list(slug=slug)
+        return tags[0] if tags else None
+
+    def get_for_post(self, post_id: int) -> list[Tag]:
+        """Get tags assigned to a specific post."""
+        return self.list(post=post_id)
+
+    def get_popular(self, limit: int = 10) -> list[Tag]:
+        """Get the most popular tags by post count."""
+        all_tags = list(self.iterate_all(hide_empty=True))
+        sorted_tags = sorted(all_tags, key=lambda t: t.count, reverse=True)
+        return sorted_tags[:limit]

src/wordpress_api/endpoints/taxonomies.py

@@ -0,0 +1,41 @@
+"""Taxonomies endpoint."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ..models.taxonomy import Taxonomy
+from .base import BaseEndpoint
+
+
+class TaxonomiesEndpoint(BaseEndpoint):
+    """Endpoint for viewing WordPress taxonomies."""
+
+    _path = "/wp/v2/taxonomies"
+
+    def list(self, type: str | None = None, **kwargs: Any) -> dict[str, Taxonomy]:
+        """List all taxonomies.
+        
+        Args:
+            type: Limit results to taxonomies associated with a post type.
+        """
+        params: dict[str, Any] = {}
+        if type:
+            params["type"] = type
+        params.update(kwargs)
+        
+        response = self._get(self._path, params=params)
+        return {k: Taxonomy.model_validate(v) for k, v in response.items()}
+
+    def get(self, taxonomy: str, **kwargs: Any) -> Taxonomy:
+        """Get a specific taxonomy by slug."""
+        response = self._get(f"{self._path}/{taxonomy}", params=kwargs)
+        return Taxonomy.model_validate(response)
+
+    def get_category(self) -> Taxonomy:
+        """Get the category taxonomy."""
+        return self.get("category")
+
+    def get_post_tag(self) -> Taxonomy:
+        """Get the post_tag taxonomy."""
+        return self.get("post_tag")

src/wordpress_api/endpoints/themes.py

@@ -0,0 +1,51 @@
+"""Themes endpoint."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ..models.theme import Theme
+from .base import BaseEndpoint
+
+
+class ThemesEndpoint(BaseEndpoint):
+    """Endpoint for managing WordPress themes."""
+
+    _path = "/wp/v2/themes"
+
+    def list(self, status: str | list[str] | None = None, **kwargs: Any) -> list[Theme]:
+        """List installed themes.
+        
+        Args:
+            status: Filter by theme status (active, inactive).
+        """
+        params: dict[str, Any] = {}
+        if status:
+            if isinstance(status, list):
+                params["status"] = ",".join(status)
+            else:
+                params["status"] = status
+        params.update(kwargs)
+        
+        response = self._get(self._path, params=params)
+        return [Theme.model_validate(item) for item in response]
+
+    def get(self, stylesheet: str, **kwargs: Any) -> Theme:
+        """Get a specific theme.
+        
+        Args:
+            stylesheet: Theme stylesheet name.
+        """
+        response = self._get(f"{self._path}/{stylesheet}", params=kwargs)
+        return Theme.model_validate(response)
+
+    def get_active(self) -> Theme:
+        """Get the currently active theme."""
+        themes = self.list(status="active")
+        if themes:
+            return themes[0]
+        raise ValueError("No active theme found")
+
+    def list_inactive(self) -> list[Theme]:
+        """List all inactive themes."""
+        return self.list(status="inactive")