plexflow 0.0.64__py3-none-any.whl

plexflow/core/plex/discover/activity.py

@@ -0,0 +1,448 @@
+import datetime
+from typing import Optional, Any
+from dataclasses import dataclass, field
+from dataclasses_json import config, dataclass_json, Undefined
+from plexflow.core.plex.hooks.plex_authorized import PlexAuthorizedHttpHook
+from plexflow.core.plex.discover.comment import Comment, create_comment, get_comments
+
+
+@dataclass_json(undefined=Undefined.EXCLUDE)
+@dataclass
+class MetadataItem:
+    id: Optional[str] = None
+    images: Optional[dict] = None
+    userState: Optional[dict] = None
+    title: Optional[str] = None
+    key: Optional[str] = None
+    type: Optional[str] = None
+    index: Optional[int] = None
+    publicPagesURL: Optional[str] = None
+    parent: Optional[dict] = None
+    grandparent: Optional[dict] = None
+    publishedAt: Optional[str] = None
+    leafCount: Optional[int] = None
+    year: Optional[int] = None
+    originallyAvailableAt: Optional[str] = None
+    childCount: Optional[int] = None
+    catchall: Optional[Any] = field(default_factory=dict)
+
+    def __post_init__(self):
+        if self.parent:
+            self.parent = MetadataItem(**self.parent)
+        if self.grandparent:
+            self.grandparent = MetadataItem(**self.grandparent)
+        if self.images:
+            self.images = ImageUrls(**self.images)
+        if self.userState:
+            self.userState = UserState(**self.userState)
+
+@dataclass_json(undefined=Undefined.EXCLUDE)
+@dataclass
+class UserV2:
+    id: Optional[str] = None
+    username: Optional[str] = None
+    displayName: Optional[str] = None
+    avatar: Optional[str] = None
+    friendStatus: Optional[str] = None
+    isMuted: Optional[bool] = None
+    isBlocked: Optional[bool] = None
+    mutualFriends: Optional[dict] = None
+
+    def __post_init__(self):
+        if self.mutualFriends:
+            self.mutualFriends = MutualFriends(**self.mutualFriends)
+
+@dataclass_json(undefined=Undefined.EXCLUDE)
+@dataclass
+class ImageUrls:
+    coverArt: Optional[str] = None
+    coverPoster: Optional[str] = None
+    thumbnail: Optional[str] = None
+    art: Optional[str] = None
+
+@dataclass_json(undefined=Undefined.EXCLUDE)
+@dataclass
+class UserState:
+    viewCount: Optional[int] = None
+    viewedLeafCount: Optional[int] = None
+    watchlistedAt: Optional[str] = None
+
+@dataclass_json(undefined=Undefined.EXCLUDE)
+@dataclass
+class MutualFriends:
+    count: Optional[int] = None
+    friends: Optional[list] = None
+
+@dataclass_json(undefined=Undefined.EXCLUDE)
+@dataclass
+class ActivityData:
+    typename: Optional[str] = field(default= None, metadata=config(field_name="__typename"))
+    id: Optional[str] = None
+    date: Optional[str] = None
+    isPrimary: Optional[bool] = None
+    commentCount: Optional[int] = None
+    privacy: Optional[str] = None
+    isMuted: Optional[bool] = None
+    metadataItem: Optional[MetadataItem] = None
+    userV2: Optional[UserV2] = None
+    catchall: Optional[Any] = field(default_factory=dict)
+
+from datetime import datetime
+from typing import List
+import requests
+
+class Activity:
+    """
+    Represents an activity in Plex.
+
+    Attributes:
+        WATCH_HISTORY (str): Constant representing the watch history activity.
+        METADATA_MESSAGE (str): Constant representing the metadata message activity.
+        WATCHLIST (str): Constant representing the watchlist activity.
+    """
+
+    WATCH_HISTORY = "ActivityWatchHistory"
+    METADATA_MESSAGE = "ActivityMetadataMessage"
+    WATCHLIST = "ActivityWatchlist"
+    
+    def __init__(self, data: dict):
+        """
+        Initializes a new instance of the Activity class.
+
+        Args:
+            data (dict): The data for the activity.
+            hook (PlexAuthorizedHttpHook): The Plex authorized HTTP hook.
+        """
+        self.data = ActivityData.from_dict(data)
+
+    def __str__(self):
+        """
+        Returns a string representation of the activity.
+
+        Returns:
+            str: The string representation of the activity.
+        """
+        return f"{self.data.typename} with ID {self.data.id}"
+
+    def __repr__(self):
+        """
+        Returns a string representation of the activity.
+
+        Returns:
+            str: The string representation of the activity.
+        """
+        return f"{self.data.typename} with ID {self.data.id}"
+    
+    @property
+    def typename(self):
+        """
+        Gets the typename of the activity.
+
+        Returns:
+            str: The typename of the activity.
+        """
+        return self.data.typename
+    
+    @property
+    def id(self):
+        """
+        Gets the ID of the activity.
+
+        Returns:
+            str: The ID of the activity.
+        """
+        return self.data.id
+    
+    @property
+    def date(self):
+        """
+        Gets the date of the activity.
+
+        Returns:
+            datetime: The date of the activity.
+        """
+        return datetime.fromisoformat(self.data.date.replace("Z", "+00:00"))
+    
+    @property
+    def isPrimary(self):
+        """
+        Gets a value indicating whether the activity is primary.
+
+        Returns:
+            bool: True if the activity is primary, False otherwise.
+        """
+        return self.data.isPrimary
+    
+    @property
+    def commentCount(self):
+        """
+        Gets the comment count of the activity.
+
+        Returns:
+            int: The comment count of the activity.
+        """
+        return self.data.commentCount
+    
+    @property
+    def privacy(self):
+        """
+        Gets the privacy of the activity.
+
+        Returns:
+            str: The privacy of the activity.
+        """
+        return self.data.privacy
+    
+    @property
+    def isMuted(self):
+        """
+        Gets a value indicating whether the activity is muted.
+
+        Returns:
+            bool: True if the activity is muted, False otherwise.
+        """
+        return self.data.isMuted
+    
+    @property
+    def metadataItem(self):
+        """
+        Gets the metadata item of the activity.
+
+        Returns:
+            str: The metadata item of the activity.
+        """
+        return self.data.metadataItem
+    
+    @property
+    def userV2(self):
+        """
+        Gets the userV2 of the activity.
+
+        Returns:
+            str: The userV2 of the activity.
+        """
+        return self.data.userV2
+
+    @property
+    def comments(self) -> List[Comment]:
+        """
+        Gets the comments for the activity.
+
+        Returns:
+            list: The comments for the activity.
+        """
+        return get_comments(self.id)
+
+    def create_comment(self, message: str):
+        """
+        Creates a comment for the activity.
+
+        Args:
+            message (str): The message for the comment.
+        """
+        return create_comment(self.id, message)
+
+def get_activities(total: int = 24) -> List[Activity]:
+    """
+    Retrieves a list of activities from the Plex server.
+
+    Args:
+        total (int, optional): The maximum number of activities to retrieve. Defaults to 24.
+
+    Returns:
+        list: A list of Activity objects representing the retrieved activities.
+
+    Raises:
+        HTTPError: If there is an error in the HTTP request.
+
+    Example:
+        >>> activities = get_activities(total=10)
+        >>> for activity in activities:
+        ...     print(activity.metadataItem.title)
+    """
+    hook = PlexAuthorizedHttpHook(
+        method="POST", http_conn_id="plex_community", config_folder="config"
+    )
+
+    query = """
+        query GetActivityFeed($first: PaginationInt!, $after: String, $metadataID: ID, $types: [ActivityType!]!, $skipUserState: Boolean = false, $includeDescendants: Boolean = false, $skipWatchSession: Boolean = true) {
+            activityFeed(
+                first: $first
+                after: $after
+                metadataID: $metadataID
+                types: $types
+                includeDescendants: $includeDescendants
+            ) {
+                nodes {
+                    __typename
+                    id
+                    date
+                    isPrimary
+                    commentCount
+                    privacy
+                    isMuted
+                    metadataItem {
+                        id
+                        images {
+                            coverArt
+                            coverPoster
+                            thumbnail
+                            art
+                        }
+                        userState @skip(if: $skipUserState) {
+                            viewCount
+                            viewedLeafCount
+                            watchlistedAt
+                        }
+                        title
+                        key
+                        type
+                        index
+                        publicPagesURL
+                        parent {
+                            index
+                            title
+                            publishedAt
+                            key
+                            type
+                            images {
+                                coverArt
+                                coverPoster
+                                thumbnail
+                                art
+                            }
+                            userState @skip(if: $skipUserState) {
+                                viewCount
+                                viewedLeafCount
+                                watchlistedAt
+                            }
+                        }
+                        grandparent {
+                            index
+                            title
+                            publishedAt
+                            key
+                            type
+                            images {
+                                coverArt
+                                coverPoster
+                                thumbnail
+                                art
+                            }
+                            userState @skip(if: $skipUserState) {
+                                viewCount
+                                viewedLeafCount
+                                watchlistedAt
+                            }
+                        }
+                        publishedAt
+                        leafCount
+                        year
+                        originallyAvailableAt
+                        childCount
+                    }
+                    userV2 {
+                        id
+                        username
+                        displayName
+                        avatar
+                        friendStatus
+                        isMuted
+                        isBlocked
+                        mutualFriends {
+                            count
+                            friends {
+                                avatar
+                                displayName
+                                id
+                                username
+                            }
+                        }
+                    }
+                    ... on ActivityMetadataMessage {
+                        message
+                        otherRecipientsV2 {
+                            id
+                            username
+                            displayName
+                            avatar
+                            friendStatus
+                            isMuted
+                            isBlocked
+                            mutualFriends {
+                                count
+                                friends {
+                                    avatar
+                                    displayName
+                                    id
+                                    username
+                                }
+                            }
+                        }
+                    }
+                    ... on ActivityMetadataReport {
+                        message
+                        otherRecipientsV2 {
+                            id
+                            username
+                            displayName
+                            avatar
+                            friendStatus
+                            isMuted
+                            isBlocked
+                            mutualFriends {
+                                count
+                                friends {
+                                    avatar
+                                    displayName
+                                    id
+                                    username
+                                }
+                            }
+                        }
+                    }
+                    ... on ActivityRating {
+                        rating
+                    }
+                    ... on ActivityPost {
+                        message
+                    }
+                    ... on ActivityWatchHistory {
+                        watchSession @skip(if: $skipWatchSession)
+                    }
+                    ... on ActivityWatchSession {
+                        episodeCount
+                    }
+                    ... on ActivityWatchRating {
+                        rating
+                    }
+                }
+                pageInfo {
+                    endCursor
+                    hasNextPage
+                }
+            }
+        }
+    """
+
+    data = {
+        "query": query,
+        "variables": {
+            "first": total,
+            "types": ["METADATA_MESSAGE", "RATING", "WATCH_HISTORY", "WATCHLIST", "POST", "WATCH_SESSION", "WATCH_RATING"],
+            "includeDescendants": True,
+            "skipUserState": False,
+            "skipWatchSession": True
+        },
+        "operationName": "GetActivityFeed"
+    }
+
+    try:
+        response = hook.run(
+            endpoint="/api",
+            json=data,
+        )
+        response.raise_for_status()
+        return [Activity(node) for node in response.json()["data"]["activityFeed"]["nodes"]]
+    except requests.exceptions.HTTPError as e:
+        raise requests.HTTPError(f"HTTP request error: {e}")

plexflow/core/plex/discover/comment.py

@@ -0,0 +1,89 @@
+
+from plexflow.core.plex.hooks.plex_authorized import PlexAuthorizedHttpHook
+from dataclasses import dataclass
+from dataclasses_json import dataclass_json
+from dataclasses import dataclass
+from dataclasses_json import dataclass_json
+from typing import Optional
+
+@dataclass_json
+@dataclass
+class User:
+    id: Optional[str]
+    avatar: Optional[str]
+    username: Optional[str]
+    displayName: Optional[str]
+    isBlocked: Optional[bool]
+    isMuted: Optional[bool]
+    isHidden: Optional[bool]
+
+@dataclass_json
+@dataclass
+class Comment:
+    date: Optional[str]
+    id: Optional[str]
+    message: Optional[str]
+    user: Optional[User]
+
+def get_comments(activity_id):
+    """
+    Retrieves comments for a specific activity.
+
+    Args:
+        activity_id (str): The ID of the activity to retrieve comments for.
+
+    Returns:
+        list: A list of Comment objects representing the comments for the activity.
+
+    Raises:
+        HTTPError: If there was an error while making the API request.
+
+    Example:
+        >>> comments = get_comments("12345")
+        >>> for comment in comments:
+        ...     print(comment.message)
+    """
+    hook = PlexAuthorizedHttpHook(method="POST", http_conn_id="plex_community", config_folder="config")
+    
+    data = {
+        "query": "query getActivityComments($id: ID!, $first: PaginationInt, $after: String, $last: PaginationInt, $before: String) { activityComments(first: $first after: $after id: $id last: $last before: $before) { nodes { date id message user { id avatar username displayName isBlocked isMuted isHidden } } pageInfo { endCursor hasNextPage hasPreviousPage startCursor } } }",
+        "variables": {"first": 50, "id": activity_id},
+        "operationName": "getActivityComments"
+    }
+            
+    response = hook.run(
+        endpoint="/api",
+        json=data,
+    )
+    
+    response.raise_for_status()
+    
+    return [Comment.from_dict(node) for node in response.json()["data"]["activityComments"]["nodes"]]
+
+def create_comment(activity_id, message):
+    """
+    Create a comment for a given activity.
+
+    Args:
+        activity_id (str): The ID of the activity to create the comment for.
+        message (str): The content of the comment.
+
+    Returns:
+        Comment: The created comment object.
+
+    Raises:
+        HTTPError: If the request to create the comment fails.
+
+    Example:
+        >>> create_comment("12345", "Great work!")
+    """
+    hook = PlexAuthorizedHttpHook(method="POST", http_conn_id="plex_community", config_folder="config")
+    
+    data = {
+        "query": "mutation createComment($input: CreateCommentInput!) { createComment(input: $input) { date id message user { id avatar username displayName isHidden isMuted isBlocked } } }",
+        "variables": {"input": {"activity": activity_id, "message": message}},
+        "operationName": "createComment"
+    }
+    
+    response = hook.run(endpoint="/api", json=data)
+    response.raise_for_status()

plexflow/core/plex/discover/feed.py

@@ -0,0 +1,11 @@
+from typing import List
+from plexflow.core.plex.hooks.plex_authorized import PlexAuthorizedHttpHook
+from plexflow.core.plex.discover.activity import Activity, get_activities
+
+class ActivityFeed:
+    def __init__(self):
+        pass
+    
+    @property
+    def activities(self) -> List[Activity]:
+        return get_activities(total=100)

plexflow/core/plex/hooks/plex_authorized.py

@@ -0,0 +1,60 @@
+from typing import Optional, Dict, Any
+from plexflow.utils.hooks.http import UniversalHttpHook
+import requests
+from plexflow.core.plex.token.auto_token import PlexAutoToken
+
+class PlexAuthorizedHttpHook(UniversalHttpHook):
+    """
+    A subclass of UniversalHttpHook that includes the X-Plex-Token as a query parameter.
+    
+    When used with Airflow, connection details are fetched from Airflow Connections.
+    When used standalone, these details should be loaded from a YAML file named after the connection ID.
+    
+    Args:
+        plex_token (str): The Plex token.
+        method (str, optional): The HTTP method. Defaults to 'GET'.
+        http_conn_id (str, optional): The Airflow connection ID or the name for the YAML file. Defaults to None.
+        config_folder (str, optional): The folder where the YAML configuration file is located. Defaults to None.
+        
+    Attributes:
+        hook (HttpHook, optional): The Airflow HttpHook instance.
+        session (requests.Session, optional): The requests Session instance.
+        config (dict, optional): The configuration loaded from the YAML file.
+        
+    Examples:
+        Using PlexAuthorizedHttpHook with Airflow:
+            hook = PlexAuthorizedHttpHook(plex_token='my_plex_token', method='GET', http_conn_id='my_http_connection')
+            response = hook.run('/api/v1/resource')
+            
+        Using PlexAuthorizedHttpHook in standalone mode with a YAML configuration file:
+            hook = PlexAuthorizedHttpHook(plex_token='my_plex_token', method='POST', http_conn_id='my_http_connection', config_folder='/path/to/configs')
+            response = hook.run('/api/v1/resource', data={'key': 'value'})
+    """
+    
+    def __init__(self, plex_token: str = None, method: str = 'GET', http_conn_id: Optional[str] = None, config_folder: Optional[str] = None):
+        super().__init__(method, http_conn_id, config_folder)
+        self.plex_token = plex_token
+
+    def run(self, endpoint: str, data: Optional[Dict[str, Any]] = None, headers: Optional[Dict[str, str]] = None, extra_options: Optional[Dict[str, Any]] = None, query_params: Optional[Dict[str, str]] = None, json: Any = None) -> requests.Response:
+        """
+        Makes an HTTP request.
+        
+        Args:
+            endpoint (str): The endpoint for the HTTP request.
+            data (dict, optional): The data for the HTTP request. Defaults to None.
+            headers (dict, optional): The headers for the HTTP request. Defaults to None.
+            extra_options (dict, optional): Extra options for the HTTP request. Defaults to None.
+            query_params (dict, optional): The query parameters for the HTTP request. Defaults to None.
+        
+        Returns:
+            The response from the HTTP request.
+        """
+        query_params = query_params or {}
+        query_params['X-Plex-Token'] = PlexAutoToken(plex_token=self.plex_token).get_token()
+        
+        headers = headers or {}
+        headers["Accept"] = "application/json"
+        
+        print(query_params)
+        
+        return super().run(endpoint=endpoint, data=data, headers=headers, extra_options=extra_options, query_params=query_params, json=json)

plexflow/core/plex/hooks/plexflow_database.py

@@ -0,0 +1,6 @@
+from typing import Optional, Dict, Any
+from plexflow.utils.hooks.postgresql import UniversalPostgresqlHook
+
+class PlexflowDatabase(UniversalPostgresqlHook):
+    def __init__(self, postgres_conn_id: Optional[str] = None, config_folder: Optional[str] = None):
+        super().__init__(postgres_conn_id, config_folder)