wp_python 0.1.0__py3-none-any.whl

src/wordpress_api/endpoints/comments.py

@@ -0,0 +1,127 @@
+"""Comments endpoint."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ..models.comment import Comment, CommentCreate, CommentUpdate, CommentStatus
+from .base import CRUDEndpoint
+
+
+class CommentsEndpoint(CRUDEndpoint[Comment]):
+    """Endpoint for managing WordPress comments."""
+
+    _path = "/wp/v2/comments"
+    _model_class = Comment
+
+    def list(
+        self,
+        page: int = 1,
+        per_page: int = 10,
+        search: str | None = None,
+        order: str = "desc",
+        orderby: str = "date_gmt",
+        status: str | CommentStatus | None = None,
+        post: int | list[int] | None = None,
+        parent: int | list[int] | None = None,
+        parent_exclude: list[int] | None = None,
+        author: int | list[int] | None = None,
+        author_exclude: list[int] | None = None,
+        author_email: str | None = None,
+        before: str | None = None,
+        after: str | None = None,
+        type: str | None = None,
+        password: str | None = None,
+        **kwargs: Any,
+    ) -> list[Comment]:
+        """List comments with filtering options."""
+        params: dict[str, Any] = {
+            "page": page,
+            "per_page": per_page,
+            "order": order,
+            "orderby": orderby,
+        }
+        
+        if search:
+            params["search"] = search
+        if status:
+            if isinstance(status, CommentStatus):
+                params["status"] = status.value
+            else:
+                params["status"] = status
+        if post is not None:
+            if isinstance(post, list):
+                params["post"] = ",".join(map(str, post))
+            else:
+                params["post"] = post
+        if parent is not None:
+            if isinstance(parent, list):
+                params["parent"] = ",".join(map(str, parent))
+            else:
+                params["parent"] = parent
+        if parent_exclude:
+            params["parent_exclude"] = ",".join(map(str, parent_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 author_email:
+            params["author_email"] = author_email
+        if before:
+            params["before"] = before
+        if after:
+            params["after"] = after
+        if type:
+            params["type"] = type
+        if password:
+            params["password"] = password
+
+        params.update(kwargs)
+        response = self._get(self._path, params=params)
+        return [Comment.model_validate(item) for item in response]
+
+    def create(self, data: CommentCreate | dict[str, Any]) -> Comment:
+        """Create a new comment."""
+        return super().create(data)
+
+    def update(self, id: int, data: CommentUpdate | dict[str, Any]) -> Comment:
+        """Update an existing comment."""
+        return super().update(id, data)
+
+    def approve(self, id: int) -> Comment:
+        """Approve a comment."""
+        return self.update(id, CommentUpdate(status=CommentStatus.APPROVED))
+
+    def unapprove(self, id: int) -> Comment:
+        """Put a comment on hold."""
+        return self.update(id, CommentUpdate(status=CommentStatus.HOLD))
+
+    def spam(self, id: int) -> Comment:
+        """Mark a comment as spam."""
+        return self.update(id, CommentUpdate(status=CommentStatus.SPAM))
+
+    def trash(self, id: int) -> Comment:
+        """Move a comment to trash."""
+        return self.update(id, CommentUpdate(status=CommentStatus.TRASH))
+
+    def list_for_post(self, post_id: int, **kwargs: Any) -> list[Comment]:
+        """List all comments for a specific post."""
+        return self.list(post=post_id, **kwargs)
+
+    def list_replies(self, parent_id: int, **kwargs: Any) -> list[Comment]:
+        """List replies to a specific comment."""
+        return self.list(parent=parent_id, **kwargs)
+
+    def get_thread(self, post_id: int) -> dict[int, list[Comment]]:
+        """Get comments organized by parent for threading."""
+        all_comments = list(self.iterate_all(post=post_id))
+        threads: dict[int, list[Comment]] = {}
+        for comment in all_comments:
+            parent = comment.parent
+            if parent not in threads:
+                threads[parent] = []
+            threads[parent].append(comment)
+        return threads

src/wordpress_api/endpoints/media.py

@@ -0,0 +1,164 @@
+"""Media endpoint."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, BinaryIO
+
+from ..models.media import Media, MediaCreate, MediaUpdate
+from .base import CRUDEndpoint
+
+
+class MediaEndpoint(CRUDEndpoint[Media]):
+    """Endpoint for managing WordPress media files."""
+
+    _path = "/wp/v2/media"
+    _model_class = Media
+
+    def list(
+        self,
+        page: int = 1,
+        per_page: int = 10,
+        search: str | None = None,
+        order: str = "desc",
+        orderby: str = "date",
+        media_type: str | None = None,
+        mime_type: str | None = None,
+        author: int | list[int] | None = None,
+        author_exclude: list[int] | None = None,
+        before: str | None = None,
+        after: str | None = None,
+        parent: int | list[int] | None = None,
+        parent_exclude: list[int] | None = None,
+        status: str | None = None,
+        slug: str | list[str] | None = None,
+        **kwargs: Any,
+    ) -> list[Media]:
+        """List media items with filtering options."""
+        params: dict[str, Any] = {
+            "page": page,
+            "per_page": per_page,
+            "order": order,
+            "orderby": orderby,
+        }
+        
+        if search:
+            params["search"] = search
+        if media_type:
+            params["media_type"] = media_type
+        if mime_type:
+            params["mime_type"] = mime_type
+        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 parent is not None:
+            if isinstance(parent, list):
+                params["parent"] = ",".join(map(str, parent))
+            else:
+                params["parent"] = parent
+        if parent_exclude:
+            params["parent_exclude"] = ",".join(map(str, parent_exclude))
+        if status:
+            params["status"] = status
+        if slug:
+            if isinstance(slug, list):
+                params["slug"] = ",".join(slug)
+            else:
+                params["slug"] = slug
+
+        params.update(kwargs)
+        response = self._get(self._path, params=params)
+        return [Media.model_validate(item) for item in response]
+
+    def upload(
+        self,
+        file: str | Path | BinaryIO,
+        filename: str | None = None,
+        title: str | None = None,
+        caption: str | None = None,
+        alt_text: str | None = None,
+        description: str | None = None,
+        post: int | None = None,
+        **kwargs: Any,
+    ) -> Media:
+        """Upload a media file.
+        
+        Args:
+            file: Path to file, Path object, or file-like object.
+            filename: Override filename (required if file is a file-like object).
+            title: Title for the media item.
+            caption: Caption for the media item.
+            alt_text: Alt text for images.
+            description: Description of the media item.
+            post: ID of the post to attach the media to.
+        """
+        if isinstance(file, (str, Path)):
+            file_path = Path(file)
+            filename = filename or file_path.name
+            with open(file_path, "rb") as f:
+                content = f.read()
+        else:
+            if not filename:
+                raise ValueError("filename required when uploading file-like object")
+            content = file.read()
+
+        headers = {
+            "Content-Disposition": f'attachment; filename="{filename}"',
+        }
+        
+        data: dict[str, Any] = {}
+        if title:
+            data["title"] = title
+        if caption:
+            data["caption"] = caption
+        if alt_text:
+            data["alt_text"] = alt_text
+        if description:
+            data["description"] = description
+        if post:
+            data["post"] = post
+        data.update(kwargs)
+
+        response = self._client._request(
+            "POST",
+            self._path,
+            content=content,
+            headers=headers,
+            params=data if data else None,
+        )
+        return Media.model_validate(response)
+
+    def update(self, id: int, data: MediaUpdate | dict[str, Any]) -> Media:
+        """Update an existing media item."""
+        return super().update(id, data)
+
+    def list_by_type(self, media_type: str, **kwargs: Any) -> list[Media]:
+        """List media items by type (image, video, audio, etc.)."""
+        return self.list(media_type=media_type, **kwargs)
+
+    def list_images(self, **kwargs: Any) -> list[Media]:
+        """List only image files."""
+        return self.list_by_type("image", **kwargs)
+
+    def list_videos(self, **kwargs: Any) -> list[Media]:
+        """List only video files."""
+        return self.list_by_type("video", **kwargs)
+
+    def list_audio(self, **kwargs: Any) -> list[Media]:
+        """List only audio files."""
+        return self.list_by_type("audio", **kwargs)
+
+    def get_sizes(self, id: int) -> dict[str, Any]:
+        """Get available sizes for an image."""
+        media = self.get(id)
+        if media.media_details and media.media_details.sizes:
+            return {k: v.model_dump() for k, v in media.media_details.sizes.items()}
+        return {}

src/wordpress_api/endpoints/menus.py

@@ -0,0 +1,120 @@
+"""Menus endpoint."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ..models.menu import Menu, MenuItem, MenuItemCreate, MenuItemUpdate
+from .base import BaseEndpoint
+
+
+class MenusEndpoint(BaseEndpoint):
+    """Endpoint for managing WordPress navigation menus."""
+
+    _menus_path = "/wp/v2/menus"
+    _items_path = "/wp/v2/menu-items"
+    _locations_path = "/wp/v2/menu-locations"
+
+    def list_menus(
+        self,
+        page: int = 1,
+        per_page: int = 100,
+        search: str | None = None,
+        **kwargs: Any,
+    ) -> list[Menu]:
+        """List navigation menus."""
+        params: dict[str, Any] = {
+            "page": page,
+            "per_page": per_page,
+        }
+        if search:
+            params["search"] = search
+        params.update(kwargs)
+        
+        response = self._get(self._menus_path, params=params)
+        return [Menu.model_validate(item) for item in response]
+
+    def get_menu(self, id: int) -> Menu:
+        """Get a specific menu by ID."""
+        response = self._get(f"{self._menus_path}/{id}")
+        return Menu.model_validate(response)
+
+    def create_menu(self, name: str, **kwargs: Any) -> Menu:
+        """Create a new menu."""
+        data = {"name": name, **kwargs}
+        response = self._post(self._menus_path, data=data)
+        return Menu.model_validate(response)
+
+    def update_menu(self, id: int, **kwargs: Any) -> Menu:
+        """Update a menu."""
+        response = self._post(f"{self._menus_path}/{id}", data=kwargs)
+        return Menu.model_validate(response)
+
+    def delete_menu(self, id: int, force: bool = True) -> dict[str, Any]:
+        """Delete a menu."""
+        return self._delete(f"{self._menus_path}/{id}", params={"force": force})
+
+    def list_items(
+        self,
+        menus: int | list[int] | None = None,
+        page: int = 1,
+        per_page: int = 100,
+        order: str = "asc",
+        orderby: str = "menu_order",
+        **kwargs: Any,
+    ) -> list[MenuItem]:
+        """List menu items."""
+        params: dict[str, Any] = {
+            "page": page,
+            "per_page": per_page,
+            "order": order,
+            "orderby": orderby,
+        }
+        if menus is not None:
+            if isinstance(menus, list):
+                params["menus"] = ",".join(map(str, menus))
+            else:
+                params["menus"] = menus
+        params.update(kwargs)
+        
+        response = self._get(self._items_path, params=params)
+        return [MenuItem.model_validate(item) for item in response]
+
+    def get_item(self, id: int) -> MenuItem:
+        """Get a specific menu item."""
+        response = self._get(f"{self._items_path}/{id}")
+        return MenuItem.model_validate(response)
+
+    def create_item(self, data: MenuItemCreate | dict[str, Any]) -> MenuItem:
+        """Create a new menu item."""
+        if isinstance(data, MenuItemCreate):
+            payload = data.model_dump(exclude_none=True)
+        else:
+            payload = data
+        response = self._post(self._items_path, data=payload)
+        return MenuItem.model_validate(response)
+
+    def update_item(self, id: int, data: MenuItemUpdate | dict[str, Any]) -> MenuItem:
+        """Update a menu item."""
+        if isinstance(data, MenuItemUpdate):
+            payload = data.model_dump(exclude_none=True)
+        else:
+            payload = data
+        response = self._post(f"{self._items_path}/{id}", data=payload)
+        return MenuItem.model_validate(response)
+
+    def delete_item(self, id: int, force: bool = True) -> dict[str, Any]:
+        """Delete a menu item."""
+        return self._delete(f"{self._items_path}/{id}", params={"force": force})
+
+    def list_locations(self) -> dict[str, Any]:
+        """List registered menu locations."""
+        return self._get(self._locations_path)
+
+    def get_location(self, location: str) -> dict[str, Any]:
+        """Get a specific menu location."""
+        return self._get(f"{self._locations_path}/{location}")
+
+    def get_menu_items(self, menu_id: int) -> list[MenuItem]:
+        """Get all items for a specific menu."""
+        return self.list_items(menus=menu_id)

src/wordpress_api/endpoints/pages.py

@@ -0,0 +1,109 @@
+"""Pages endpoint."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ..models.page import Page, PageCreate, PageUpdate
+from ..models.post import PostStatus
+from .base import CRUDEndpoint
+
+
+class PagesEndpoint(CRUDEndpoint[Page]):
+    """Endpoint for managing WordPress pages."""
+
+    _path = "/wp/v2/pages"
+    _model_class = Page
+
+    def list(
+        self,
+        page: int = 1,
+        per_page: int = 10,
+        search: str | None = None,
+        order: str = "asc",
+        orderby: str = "menu_order",
+        status: str | PostStatus | list[str] | None = None,
+        parent: int | list[int] | None = None,
+        parent_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,
+        menu_order: int | None = None,
+        slug: str | list[str] | None = None,
+        **kwargs: Any,
+    ) -> list[Page]:
+        """List pages with filtering options."""
+        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 parent is not None:
+            if isinstance(parent, list):
+                params["parent"] = ",".join(map(str, parent))
+            else:
+                params["parent"] = parent
+        if parent_exclude:
+            params["parent_exclude"] = ",".join(map(str, parent_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 menu_order is not None:
+            params["menu_order"] = menu_order
+        if slug:
+            if isinstance(slug, list):
+                params["slug"] = ",".join(slug)
+            else:
+                params["slug"] = slug
+
+        params.update(kwargs)
+        response = self._get(self._path, params=params)
+        return [Page.model_validate(item) for item in response]
+
+    def create(self, data: PageCreate | dict[str, Any]) -> Page:
+        """Create a new page."""
+        return super().create(data)
+
+    def update(self, id: int, data: PageUpdate | dict[str, Any]) -> Page:
+        """Update an existing page."""
+        return super().update(id, data)
+
+    def get_by_slug(self, slug: str) -> Page | None:
+        """Get a page by its slug."""
+        pages = self.list(slug=slug)
+        return pages[0] if pages else None
+
+    def get_children(self, parent_id: int, **kwargs: Any) -> list[Page]:
+        """Get child pages of a parent page."""
+        return self.list(parent=parent_id, **kwargs)
+
+    def get_hierarchy(self) -> dict[int, list[Page]]:
+        """Get all pages organized by parent ID."""
+        all_pages = list(self.iterate_all())
+        hierarchy: dict[int, list[Page]] = {}
+        for page in all_pages:
+            parent = page.parent
+            if parent not in hierarchy:
+                hierarchy[parent] = []
+            hierarchy[parent].append(page)
+        return hierarchy

src/wordpress_api/endpoints/plugins.py

@@ -0,0 +1,89 @@
+"""Plugins endpoint."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ..models.plugin import Plugin
+from .base import BaseEndpoint
+
+
+class PluginsEndpoint(BaseEndpoint):
+    """Endpoint for managing WordPress plugins."""
+
+    _path = "/wp/v2/plugins"
+
+    def list(
+        self,
+        search: str | None = None,
+        status: str | None = None,
+        **kwargs: Any,
+    ) -> list[Plugin]:
+        """List installed plugins.
+        
+        Args:
+            search: Limit results to those matching a string.
+            status: Filter by plugin status (active, inactive).
+        """
+        params: dict[str, Any] = {}
+        if search:
+            params["search"] = search
+        if status:
+            params["status"] = status
+        params.update(kwargs)
+        
+        response = self._get(self._path, params=params)
+        return [Plugin.model_validate(item) for item in response]
+
+    def get(self, plugin: str, **kwargs: Any) -> Plugin:
+        """Get a specific plugin.
+        
+        Args:
+            plugin: Plugin identifier (folder/file format, e.g., "akismet/akismet").
+        """
+        encoded_plugin = plugin.replace("/", "%2F")
+        response = self._get(f"{self._path}/{encoded_plugin}", params=kwargs)
+        return Plugin.model_validate(response)
+
+    def activate(self, plugin: str) -> Plugin:
+        """Activate a plugin.
+        
+        Args:
+            plugin: Plugin identifier (folder/file format).
+        """
+        encoded_plugin = plugin.replace("/", "%2F")
+        response = self._post(
+            f"{self._path}/{encoded_plugin}",
+            data={"status": "active"},
+        )
+        return Plugin.model_validate(response)
+
+    def deactivate(self, plugin: str) -> Plugin:
+        """Deactivate a plugin.
+        
+        Args:
+            plugin: Plugin identifier (folder/file format).
+        """
+        encoded_plugin = plugin.replace("/", "%2F")
+        response = self._post(
+            f"{self._path}/{encoded_plugin}",
+            data={"status": "inactive"},
+        )
+        return Plugin.model_validate(response)
+
+    def delete(self, plugin: str) -> dict[str, Any]:
+        """Delete a plugin.
+        
+        Args:
+            plugin: Plugin identifier (folder/file format).
+        """
+        encoded_plugin = plugin.replace("/", "%2F")
+        return self._delete(f"{self._path}/{encoded_plugin}")
+
+    def list_active(self) -> list[Plugin]:
+        """List all active plugins."""
+        return self.list(status="active")
+
+    def list_inactive(self) -> list[Plugin]:
+        """List all inactive plugins."""
+        return self.list(status="inactive")

src/wordpress_api/endpoints/post_types.py

@@ -0,0 +1,61 @@
+"""Post Types endpoint."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+from .base import BaseEndpoint
+
+
+class PostType(BaseModel):
+    """WordPress Post Type object."""
+
+    name: str = ""
+    slug: str = ""
+    description: str = ""
+    hierarchical: bool = False
+    has_archive: bool = False
+    rest_base: str = ""
+    rest_namespace: str = "wp/v2"
+    taxonomies: list[str] = Field(default_factory=list)
+    capabilities: dict[str, str] = Field(default_factory=dict)
+    labels: dict[str, str] = Field(default_factory=dict)
+    supports: dict[str, bool] = Field(default_factory=dict)
+    icon: str | None = None
+    viewable: bool = True
+    visibility: dict[str, bool] = Field(default_factory=dict)
+
+
+class PostTypesEndpoint(BaseEndpoint):
+    """Endpoint for viewing WordPress post types."""
+
+    _path = "/wp/v2/types"
+
+    def list(self, **kwargs: Any) -> dict[str, PostType]:
+        """List all registered post types."""
+        response = self._get(self._path, params=kwargs)
+        return {k: PostType.model_validate(v) for k, v in response.items()}
+
+    def get(self, post_type: str, **kwargs: Any) -> PostType:
+        """Get a specific post type by slug."""
+        response = self._get(f"{self._path}/{post_type}", params=kwargs)
+        return PostType.model_validate(response)
+
+    def get_post(self) -> PostType:
+        """Get the 'post' post type."""
+        return self.get("post")
+
+    def get_page(self) -> PostType:
+        """Get the 'page' post type."""
+        return self.get("page")
+
+    def get_attachment(self) -> PostType:
+        """Get the 'attachment' post type."""
+        return self.get("attachment")
+
+    def list_public(self) -> dict[str, PostType]:
+        """List only publicly viewable post types."""
+        all_types = self.list()
+        return {k: v for k, v in all_types.items() if v.viewable}