feat: Adds new classes and methods

feat: Adds class LemmyLocalUser
feat: Adds class LemmyRegistrationApplication
feat: adds method get_registration_applications

Author: db0

examples/regapps_class.py

@@ -0,0 +1,56 @@
+## python examples/regapps_class
+
+import argparse
+import os
+from pythorhead import Lemmy
+
+arg_parser = argparse.ArgumentParser()
+arg_parser.add_argument(
+    "-d",
+    "--lemmy_domain",
+    action="store",
+    required=False,
+    type=str,
+    help="the domain in which to look for this user",
+)
+arg_parser.add_argument(
+    "-u",
+    "--lemmy_username",
+    action="store",
+    required=False,
+    type=str,
+    help="Which user to authenticate as",
+)
+arg_parser.add_argument(
+    "-p",
+    "--lemmy_password",
+    action="store",
+    required=False,
+    type=str,
+    help="Which password to authenticate with",
+)
+args = arg_parser.parse_args()
+
+
+lemmy_domain = args.lemmy_domain
+if not lemmy_domain:
+    lemmy_domain = os.getenv("LEMMY_DOMAIN", "lemmy.dbzer0.com")
+if not lemmy_domain:
+    raise Exception("You need to provide a lemmy domain via env var or arg")
+
+lemmy_username = args.lemmy_username
+if not lemmy_username:
+    lemmy_username = os.getenv("LEMMY_USERNAME")
+
+lemmy_password = args.lemmy_password
+if not lemmy_password:
+    lemmy_password = os.getenv("LEMMY_PASSWORD")
+
+lemmy = Lemmy(f"https://{lemmy_domain}", raise_exceptions=True, request_timeout=2)
+if lemmy_username and lemmy_password:
+    login = lemmy.log_in(lemmy_username, lemmy_password)
+regapps = lemmy.get_registration_applications(limit=10)
+if not regapps:
+    print("No registration applications found")
+for regapp in regapps:
+    print(f"Application from user '{regapp.creator.name}' {regapp.get_application_status()}")

examples/user_class.py

@@ -1,7 +1,6 @@
 ## python examples/user.py db0
 
 import argparse
-import json
 import os
 from pythorhead import Lemmy
 
@@ -51,7 +50,7 @@
 lemmy = Lemmy(f"https://{lemmy_domain}", raise_exceptions=True, request_timeout=2)
 if lemmy_username and lemmy_password:
     login = lemmy.log_in(lemmy_username, lemmy_password)
-user = lemmy.user.get(username=args.username, return_user_object = True)
+user = lemmy.get_user(username=args.username)
 if user:
     print(user.asjson(indent=4))
 else:

pythorhead/class_methods.py

@@ -0,0 +1,29 @@
+from pythorhead.classes.admin import LemmyRegistrationApplication, LemmyLocalUser
+from pythorhead.classes.user import LemmyUser
+
+def get_user(lemmy, **kwargs) -> LemmyUser | None:
+    return_json = lemmy.user.get(**kwargs)
+    if return_json is None:
+        return
+    data_dict = return_json['person_view']['person']
+    data_dict['is_admin'] = return_json['person_view']['is_admin']
+    data_dict['comments'] = return_json['comments']
+    data_dict['posts'] = return_json['posts']
+    return LemmyUser.from_dict(data_dict, lemmy)
+
+def get_applications(lemmy, **kwargs) -> list[LemmyRegistrationApplication]:
+    return_json = lemmy.admin.list_applications(**kwargs)
+    regapps = []
+    if return_json is None:
+        return regapps
+    for data in return_json["registration_applications"]:
+        data_dict = data["registration_application"]
+        data_dict["creator_local_user"] = LemmyLocalUser.from_dict(data["creator_local_user"], lemmy)
+        data_dict["creator"] = LemmyUser.from_dict(data["creator"], lemmy)
+        data_dict["admin"] = None
+        if data.get("admin"):
+            admin_dict = data["admin"]
+            admin_dict["is_admin"] = True
+            data_dict["admin"] = LemmyUser.from_dict(admin_dict, lemmy)
+        regapps.append(LemmyRegistrationApplication.from_dict(data_dict, lemmy))
+    return regapps

pythorhead/classes/admin.py

@@ -0,0 +1,95 @@
+from datetime import datetime
+from dateutil import parser
+from pythorhead.classes.base import LemmyBaseClass
+from pythorhead.classes.user import LemmyUser
+from dataclasses import dataclass
+from pythorhead.types import SortType, ListingType, LanguageType
+from enum import Enum
+
+# TODO: Convert to StrEnum in python 3.11
+class ApplicationStatus(str, Enum):
+    Pending = "pending"
+    Accepted = "accepted"
+    Denied = "denied"
+
+
+@dataclass
+class LemmyLocalUser(LemmyBaseClass):
+    id: int
+    person_id: int
+    email: str
+    show_nsfw: bool
+    theme: str
+    default_sort_type: SortType
+    default_listing_type: ListingType
+    interface_language: LanguageType
+    show_avatars: bool
+    send_notifications_to_email: bool
+    show_scores: bool
+    show_bot_accounts: bool
+    show_read_posts: bool
+    email_verified: bool
+    accepted_application: bool
+    open_links_in_new_tab: bool
+    blur_nsfw: bool
+    auto_expand: bool
+    infinite_scroll_enabled: bool
+    admin: bool
+    post_listing_mode: str
+    totp_2fa_enabled: bool
+    enable_keyboard_navigation: bool
+    enable_animated_images: bool
+    collapse_bot_comments: bool
+    published: datetime | None = None
+    
+    @classmethod
+    def from_dict(cls, data_dict: dict, lemmy) -> 'LemmyRegistrationApplication':
+        # Convert string to datetime for ban_expires if it exists
+        for key in {'published'}:
+            if key in data_dict and data_dict[key]:
+                data_dict[key] = parser.isoparse(data_dict[key])
+        for key in {'default_sort_type','default_listing_type'}:
+            if key in data_dict and data_dict[key]:
+              data_dict[key] = cls.__annotations__[key](data_dict[key])
+        for key in {'interface_language'}:
+            if key in data_dict and data_dict[key]:
+              data_dict[key] = cls.__annotations__[key][data_dict[key].upper()]
+        new_class = cls(**data_dict)
+        new_class._lemmy = lemmy
+        new_class._origin = data_dict        
+        return new_class
+
+
+
+@dataclass
+class LemmyRegistrationApplication(LemmyBaseClass):
+    id: int
+    local_user_id: int
+    answer: str
+    published: datetime
+    creator_local_user: dict
+    creator: LemmyUser
+    creator_local_user: LemmyLocalUser
+    creator: LemmyUser
+    admin_id: int | None = None
+    deny_reason: str | None = None
+    admin: LemmyUser | None = None
+    
+    
+    @classmethod
+    def from_dict(cls, data_dict: dict, lemmy) -> 'LemmyRegistrationApplication':
+        # Convert string to datetime for ban_expires if it exists
+        for key in {'published'}:
+            if key in data_dict and data_dict[key]:
+                data_dict[key] = parser.isoparse(data_dict[key])
+        new_class = cls(**data_dict)
+        new_class._lemmy = lemmy
+        new_class._origin = data_dict        
+        return new_class
+
+    def get_application_status(self) -> str:
+        if self.creator_local_user.accepted_application:
+            return ApplicationStatus.Accepted
+        elif self.deny_reason:
+            return ApplicationStatus.Denied
+        return ApplicationStatus.Pending

pythorhead/classes/base.py

@@ -0,0 +1,22 @@
+from dataclasses import dataclass, asdict, field
+from pythorhead.utils import json_serializer
+
+import json
+
+
+@dataclass
+class LemmyBaseClass:
+    # The owning lemmy instance. We use it to reach the API classes
+    _lemmy: 'Lemmy' = field(init=None)
+    # The original data dict from which we created this class
+    _origin: dict = field(init=None)
+    
+    def asdict(self):
+        selfdict = asdict(self)
+        del selfdict['_lemmy']
+        del selfdict['_origin']
+        return selfdict
+
+    def asjson(self, indent=4):      
+        return json.dumps(self.asdict(), indent=indent, default=json_serializer)
+    

pythorhead/classes/user.py

@@ -1,12 +1,10 @@
-from dataclasses import dataclass, asdict
 from datetime import datetime
 from dateutil import parser
-from pythorhead.utils import json_serializer
-
-import json
+from pythorhead.classes.base import LemmyBaseClass
+from dataclasses import dataclass
 
 @dataclass
-class LemmyUser:
+class LemmyUser(LemmyBaseClass):
     id: int
     name: str
     banned: bool
@@ -16,28 +14,29 @@ class LemmyUser:
     deleted: bool
     bot_account: bool
     instance_id: int
-    is_admin: bool
+    is_admin: bool = False
     display_name: str | None = None
     bio: str | None = None
     avatar: str | None = None
     banner: str | None = None
     matrix_user_id: str | None = None
     ban_expires: datetime | None = None
     updated: datetime | None = None
+    #TODO Convert to classes
     comments: list[dict] = None
     posts: list[dict] = None
-    # The owning lemmy instance. We use it to reach the API classes
-    lemmy = None
 
     @classmethod
-    def from_dict(cls, person_dict: dict, lemmy) -> 'LemmyUser':
+    def from_dict(cls, data_dict: dict, lemmy) -> 'LemmyUser':
         # Convert string to datetime for ban_expires if it exists
+        
         for key in {'ban_expires', 'updates', 'published'}:
-            if key in person_dict and person_dict[key]:
-                person_dict[key] = parser.isoparse(person_dict[key])
-        new_user = cls(**person_dict)
-        new_user.lemmy = lemmy
-        return new_user
+            if key in data_dict and data_dict[key]:
+                data_dict[key] = parser.isoparse(data_dict[key])
+        new_class = cls(**data_dict)
+        new_class._lemmy = lemmy
+        new_class._origin = data_dict
+        return new_class
 
     def refresh(self) -> None:
         """
@@ -46,7 +45,7 @@ def refresh(self) -> None:
         Args:
             new_data: Dictionary containing updated user data
         """
-        fresh_data = self.lemmy.user.get(person_id=self.id)
+        fresh_data = self._lemmy.user.get(person_id=self.id)
         user_dict = fresh_data['person_view']['person']
         user_dict['is_admin'] = fresh_data['person_view']['is_admin']
         user_dict['comments'] = fresh_data['comments']
@@ -60,15 +59,15 @@ def refresh(self) -> None:
 
 
     def purge(self) -> None:
-        self.lemmy.user.purge(person_id=self.person_id)
+        self._lemmy.user.purge(person_id=self.person_id)
 
     def ban(self,
             ban: bool = True, 
             expires: datetime | int | None = None, 
             reason: str | None = None, 
             remove_data: bool | None = None
         ) -> None:
-        self.lemmy.user.ban(
+        self._lemmy.user.ban(
             person_id=self.person_id,
             ban = ban,
             expires = expires,
@@ -78,9 +77,9 @@ def ban(self,
         self.refresh()
 
     def update(self):
-        if self.lemmy.user._requestor.logged_in_username != self.name:
+        if self._lemmy.user._requestor.logged_in_username != self.name:
             raise Exception("Cannot update user details for anyone but the currently logged-in user.")
-        self.lemmy.user.save_user_settings(
+        self._lemmy.user.save_user_settings(
             avatar=self.avatar,
             banner=self.banner,
             display_name=self.display_name,
@@ -91,20 +90,13 @@ def update(self):
         self.refresh()
 
     def set_settings(self, **kwargs):
-        if self.lemmy.user._requestor.logged_in_username != self.name:
+        if self._lemmy.user._requestor.logged_in_username != self.name:
             raise Exception("Cannot update user settings for anyone but the currently logged-in user.")
-        self.lemmy.user.save_user_settings(**kwargs)
+        self._lemmy.user.save_user_settings(**kwargs)
         self.refresh()
-
-    def asdict(self):
-        return asdict(self)
-
-    def asjson(self, indent=4):      
-        selfdict = self.asdict()
-        return json.dumps(selfdict, indent=indent, default=json_serializer)
 
     def pm(self, content):
-        self.lemmy.private_message(
+        self._lemmy.private_message(
             content=content,
             recipient_id=self.id,
         )

pythorhead/comment.py

@@ -2,7 +2,7 @@
 
 from pythorhead.requestor import Request, Requestor
 from pythorhead.types import CommentSortType, LanguageType, ListingType
-
+import logging
 
 class Comment:
     def __init__(self, _requestor: Requestor):
@@ -47,6 +47,8 @@ def list(  # noqa: A003
             list_comment["community_name"] = community_name
         if limit is not None:
             list_comment["limit"] = limit
+            if max_depth is not None:
+                logging.warning("list comments 'limit' param is ignored when 'max_depth' is set")
         if max_depth is not None:
             list_comment["max_depth"] = max_depth
         if page is not None:
@@ -61,7 +63,6 @@ def list(  # noqa: A003
             list_comment["sort"] = sort.value
         if type_ is not None:
             list_comment["type_"] = type_.value
-
         if data := self._requestor.api(Request.GET, "/comment/list", params=list_comment):
             return data["comments"]
         return []