Spaces:
Running
Running
| """ | |
| YapStation EngineWrapper - All methods in snake_case to match server.py calls | |
| """ | |
| import engine_user | |
| import engine_messaging | |
| import engine_content | |
| import engine_station | |
| class Engine: | |
| def __init__(self): | |
| pass | |
| # ======================== | |
| # AUTH | |
| # ======================== | |
| def register_user(self, fn, ln, gender, uname, email, pw, theme=5): | |
| engine_user.register_user(fn, ln, gender, uname, email, pw, theme) | |
| def login(self, username, password): | |
| return engine_user.login(username, password) | |
| def is_developer(self, username): | |
| return engine_user.is_developer(username) | |
| # ======================== | |
| # USERS | |
| # ======================== | |
| def get_user_by_username(self, username): | |
| return engine_user.get_user_by_username(username) | |
| def get_all_users(self): | |
| return engine_user.get_all_users() | |
| def user_exists(self, username): | |
| return engine_user.user_exists(username) | |
| def get_all_users_detailed(self): | |
| return engine_user.get_all_users_detailed() | |
| def get_all_users_detailed(self): | |
| return engine_user.get_all_users_detailed() | |
| def get_username(self, user_input): | |
| return engine_user.get_username(user_input) | |
| def get_avatar(self, username): | |
| return engine_user.get_avatar(username) | |
| def update_avatar(self, username, avatar_base64): | |
| engine_user.update_avatar(username, avatar_base64) | |
| def get_hero_banner(self, username): | |
| return engine_user.get_hero_banner(username) | |
| def update_hero_banner(self, username, hero_banner_base64): | |
| engine_user.update_hero_banner(username, hero_banner_base64) | |
| def get_theme(self, username): | |
| return engine_user.get_theme(username) | |
| def update_theme(self, username, theme): | |
| engine_user.update_theme(username, theme) | |
| def update_user_basic(self, current_username, new_username, email, bio): | |
| return engine_user.update_user_basic(current_username, new_username, email, bio) | |
| def update_password(self, username, old_pass, new_pass): | |
| return engine_user.update_password(username, old_pass, new_pass) | |
| def create_password_reset_token(self, username): | |
| return engine_user.create_password_reset_token(username) | |
| def validate_password_reset_token(self, token_plain): | |
| return engine_user.validate_password_reset_token(token_plain) | |
| def get_user_public_for_reset(self, username): | |
| return engine_user.get_user_public_for_reset(username) | |
| def confirm_password_reset(self, token_plain, new_password): | |
| return engine_user.confirm_password_reset(token_plain, new_password) | |
| def delete_user(self, username): | |
| return engine_user.delete_user(username) | |
| def set_visibility(self, username, visibility): | |
| return engine_user.set_visibility(username, visibility) | |
| def follow_user(self, follower, following): | |
| return engine_user.follow_user(follower, following) | |
| def unfollow_user(self, follower, following): | |
| return engine_user.unfollow_user(follower, following) | |
| def approve_follow(self, follower, following): | |
| return engine_user.approve_follow(follower, following) | |
| def reject_follow(self, follower, following): | |
| return engine_user.reject_follow(follower, following) | |
| def get_pending_follows(self, username): | |
| return engine_user.get_pending_follows(username) | |
| def get_follow_status(self, follower, following): | |
| return engine_user.get_follow_status(follower, following) | |
| def get_followers(self, username): | |
| return engine_user.get_followers(username) | |
| def get_following(self, username): | |
| return engine_user.get_following(username) | |
| def block_user(self, blocker, blocked): | |
| success = engine_user.block_user(blocker, blocked) | |
| if success: | |
| engine_station.cleanup_station_memberships_on_block(blocker, blocked) | |
| return success | |
| def unblock_user(self, blocker, blocked): | |
| return engine_user.unblock_user(blocker, blocked) | |
| def is_blocked(self, blocker, blocked): | |
| return engine_user.is_blocked(blocker, blocked) | |
| def is_blocked_either_way(self, user1, user2): | |
| return engine_user.is_blocked_either_way(user1, user2) | |
| def get_blocked_users(self, blocker): | |
| return engine_user.get_blocked_users(blocker) | |
| def get_blockers(self, blocked): | |
| return engine_user.get_blockers(blocked) | |
| # ======================== | |
| # CONVERSATIONS | |
| # ======================== | |
| def create_conversation(self, users, is_group, name, admin_username=None): | |
| return engine_messaging.create_conversation(users, is_group, name, admin_username) | |
| def delete_conversation(self, conversation_id): | |
| engine_messaging.delete_conversation(conversation_id) | |
| def restore_conversation(self, conversation_id, username): | |
| engine_messaging.restore_conversation(conversation_id, username) | |
| def soft_delete_conversation(self, conversation_id, username): | |
| engine_messaging.soft_delete_conversation(conversation_id, username) | |
| def get_conversation_users(self, convo_id): | |
| return engine_messaging.get_conversation_users(convo_id) | |
| def add_user_to_conversation(self, convo_id, username): | |
| return engine_messaging.add_user_to_conversation(convo_id, username) | |
| def remove_user_from_conversation(self, convo_id, username): | |
| return engine_messaging.remove_user_from_conversation(convo_id, username) | |
| def get_conversation_details(self, convo_id): | |
| return engine_messaging.get_conversation_details(convo_id) | |
| def get_conversation_avatar(self, conv_id): | |
| return engine_messaging.get_conversation_avatar(conv_id) | |
| def update_conversation_avatar(self, conv_id, avatar): | |
| engine_messaging.update_conversation_avatar(conv_id, avatar) | |
| def update_conversation_name(self, conv_id, name): | |
| engine_messaging.update_conversation_name(conv_id, name) | |
| def get_user_conversations(self, username): | |
| return engine_messaging.get_user_conversations(username) | |
| def get_conversation_users(self, conversation_id): | |
| return engine_messaging.get_conversation_users(conversation_id) | |
| def find_conversation(self, users, name): | |
| return engine_messaging.find_conversation(users, name) | |
| def get_or_create_bitai_conversation(self, username): | |
| return engine_messaging.get_or_create_bitai_conversation(username) | |
| def get_conversations_summary(self, username): | |
| return engine_messaging.get_conversations_summary(username) | |
| # ======================== | |
| # MESSAGES | |
| # ======================== | |
| def send_message(self, sender, conversation_id, content, msg_type, media_path="", reply_to=None): | |
| return engine_messaging.send_message(sender, conversation_id, content, msg_type, media_path, reply_to) | |
| def get_messages(self, convo_id): | |
| return engine_messaging.get_messages(convo_id) | |
| def get_last_message(self, convo_id): | |
| return engine_messaging.get_last_message(convo_id) | |
| def has_unread(self, username, convo_id): | |
| return engine_messaging.has_unread(convo_id, username) | |
| def mark_seen(self, username, convo_id): | |
| engine_messaging.mark_seen(username, convo_id) | |
| def get_last_interaction(self, username, convo_id): | |
| return engine_messaging.get_last_interaction(convo_id, username) | |
| # ======================== | |
| # POSTS | |
| # ======================== | |
| def create_post(self, username, content, media_path): | |
| return engine_content.create_post(username, content, media_path) | |
| def delete_post(self, post_id, username): | |
| return engine_content.delete_post(post_id, username) | |
| def like_post(self, post_id, username): | |
| return engine_content.like_post(post_id, username) | |
| def unlike_post(self, post_id, username): | |
| return engine_content.unlike_post(post_id, username) | |
| def modify_likes(self, post_id, delta): | |
| return engine_content.modify_likes(post_id, delta) | |
| def get_feed(self, viewer=""): | |
| return engine_content.get_feed(viewer) | |
| def get_user_posts(self, username, viewer=""): | |
| return engine_content.get_user_posts(username, viewer) | |
| def get_post(self, post_id, viewer=""): | |
| return engine_content.get_post(post_id, viewer) | |
| # ======================== | |
| # COMMENTS | |
| # ======================== | |
| def add_comment(self, post_id, username, content): | |
| return engine_content.add_comment(post_id, username, content) | |
| def get_comments(self, post_id, viewer=""): | |
| return engine_content.get_comments(post_id, viewer) | |
| # ======================== | |
| # STATIONS | |
| # ======================== | |
| def create_station(self, station_name, admin_username, bio=""): | |
| return engine_station.create_station(station_name, admin_username, bio) | |
| def delete_station(self, station_name, username): | |
| return engine_station.delete_station(station_name, username) | |
| def force_delete_station(self, station_name): | |
| return engine_station.force_delete_station(station_name) | |
| def update_station_name(self, old_name, new_name): | |
| return engine_station.update_station_name(old_name, new_name) | |
| def add_user_to_station(self, station_name, admin_username, user_to_add): | |
| return engine_station.add_user_to_station(station_name, admin_username, user_to_add) | |
| def remove_user_from_station(self, station_name, admin_username, user_to_remove): | |
| return engine_station.remove_user_from_station(station_name, admin_username, user_to_remove) | |
| def request_to_join(self, station_name, username): | |
| return engine_station.request_to_join(station_name, username) | |
| def check_pending_request(self, station_name, username): | |
| return engine_station.check_pending_request(station_name, username) | |
| def approve_request(self, station_name, admin_username, user_to_approve): | |
| return engine_station.approve_request(station_name, admin_username, user_to_approve) | |
| def reject_request(self, station_name, admin_username, user_to_reject): | |
| return engine_station.reject_request(station_name, admin_username, user_to_reject) | |
| def get_pending_requests(self, station_name, admin_username): | |
| return engine_station.get_pending_requests(station_name, admin_username) | |
| def create_station_post(self, station_name, username, content, media_path): | |
| return engine_station.create_station_post(station_name, username, content, media_path) | |
| def delete_station_post(self, post_id, station_name, username): | |
| return engine_station.delete_station_post(post_id, station_name, username) | |
| def get_station_posts(self, station_name, viewer=""): | |
| return engine_station.get_station_posts(station_name, viewer) | |
| def get_station(self, station_name, viewer=""): | |
| return engine_station.get_station(station_name, viewer) | |
| def get_station_members(self, station_name, viewer=""): | |
| return engine_station.get_station_members(station_name, viewer) | |
| def get_all_stations(self, viewer=""): | |
| return engine_station.get_all_stations(viewer) | |
| def get_station_bio(self, station_name): | |
| return engine_station.get_station_bio(station_name) | |
| def get_station_hero_banner(self, station_name): | |
| return engine_station.get_station_hero_banner(station_name) | |
| def get_station_profile_pic(self, station_name): | |
| return engine_station.get_station_profile_pic(station_name) | |
| def get_station_admin(self, station_name): | |
| return engine_station.get_station_admin(station_name) | |
| def update_station_bio(self, station_name, bio): | |
| return engine_station.update_station_bio(station_name, bio) | |
| def update_station_hero_banner(self, station_name, hero_banner_base64): | |
| return engine_station.update_station_hero_banner(station_name, hero_banner_base64) | |
| def update_station_profile_pic(self, station_name, profile_pic_base64): | |
| return engine_station.update_station_profile_pic(station_name, profile_pic_base64) | |
| def get_bulk_station_posts(self, station_names, viewer=""): | |
| return engine_station.get_bulk_station_posts(station_names, viewer) | |
| def get_bulk_pending_requests(self, station_names, username): | |
| return engine_station.get_bulk_pending_requests(station_names, username) | |
| # ======================== | |
| # BITAI SETTINGS | |
| # ======================== | |
| def get_bit_ai_settings(self, username): | |
| return engine_messaging.get_bit_ai_settings(username) | |
| def update_bit_ai_settings(self, username, ai_name=None, personality=None, is_initialized=None): | |
| return engine_messaging.update_bit_ai_settings(username, ai_name, personality, is_initialized) | |
| def clear_bit_ai_messages(self, username): | |
| return engine_messaging.clear_bit_ai_messages(username) | |