AsyncClient

class replit_bot.AsyncClient.Client(sid: str, ratelimit: int = 5)

Bases: AsyncIOEventEmitter

async cached_post_wrapper() → None

async gql(query: str, vars: Dict[str, Any] = {}) → Dict[str, Any]

Always sends to server with client sid

async graphql(sid: str, query: str, vars: Dict[str, Any] = {}) → Dict[str, Any]

Specify sid for post

async login(username: str, password: str) → str

async post(query: str, vars: Dict[str, Any] = {}, raw: bool = False, retry_for_internal_errors: bool = True, _Client__different_endpoint: str = None, connection: str = None)

Post query with vars to replit graph query language

requests() → module

async resolve_cached_post() → None

Resolves top x cached posts

async search(query: str, options: Dict[str, Any] = {})

async uploadImage(datauri: str) → str

class replit_bot.AsyncClient.Comment(client, parent=None)

Bases: object

async delete() → None

Delete comment

async reply(body: str, **options: Dict[str, Any])

Reply comment

async update(data: Dict[str, Any])

class replit_bot.AsyncClient.CommentManager(client, parent_class)

Bases: object

async fetch(commentResolvable=None, **arguements: Dict[str, Any])

class replit_bot.AsyncClient.CurrentUser(client)

Bases: User

async auth()

async cannySSOToken()

async change(options: Dict[str, Any] = {})

async update(data: Dict[str, Any] = {})

Update profile

class replit_bot.AsyncClient.Env(pyDict: Dict[str, Any] = {})

Bases: object

class replit_bot.AsyncClient.FollowersManager(client, user)

Bases: object

async fetch(options: Dict[str, Any] = {}) → Dict[str, Any]

class replit_bot.AsyncClient.FollowingManager(client, user)

Bases: object

async fetch(options: Dict[str, Any] = {}) → Dict[str, Any]

async setFollowing(userResolvable, should_follow: bool = True, options: Dict[str, Any] = {'cache': True}) → bool

class replit_bot.AsyncClient.MultiplayerManager(client, repl)

Bases: object

async invite(userResolvable) → None

async remove(userResolvable) → None

class replit_bot.AsyncClient.Notification(client)

Bases: object

async update(data: Dict[str, Any])

class replit_bot.AsyncClient.NotificationManager(client: Client, seconds: int = 30)

Bases: object

async fetch(options: Dict[str, Any] = {}) → None

async fetch_all(options: Dict[str, Any] = {}) → None

async markAsRead() → None

async startEvents() → None

async stopEvents() → None

class replit_bot.AsyncClient.Post(client)

Bases: object

async reply(body: str, **kwargs: Dict[str, Any]) → Dict[str, Any]

async update(data: Dict[str, Any])

class replit_bot.AsyncClient.PostManager(client, parent)

Bases: object

async fetch(**kwargs: Dict[str, Any]) → None

async trending(options: Dict[str, Any] = {}) → Dict[str, Any]

class replit_bot.AsyncClient.Repl(client)

Bases: object

async change(options: Dict[str, Any] = {})

async comment(body: str, options: Dict[str, Any] = {'cache': True})

async delete() → None

async fetchThreads(options: Dict[str, Any] = {'cache': True}) → Dict[str, Any]

async fork(options: Dict[str, Any] = {})

async layoutState()

async likes() → List[str]

async report(reason: str) → str

async update(data: Dict[str, Any] = {})

class replit_bot.AsyncClient.ReplManager(client, user=None)

Bases: object

async create(options: Dict[str, Any] = {})

async delete(replResolvable)

async fetch(replResolvable=None, **kwargs)

async generateTitle() → str

class replit_bot.AsyncClient.Team(client)

Bases: object

async update(data: Dict[str, Any])

class replit_bot.AsyncClient.Template(client)

Bases: object

async update(data: Dict[str, Any])

class replit_bot.AsyncClient.Thread(client)

Bases: object

async update(data: Dict[str, Any])

class replit_bot.AsyncClient.ThreadMessage(client)

Bases: object

async update(data: Dict[str, Any])

class replit_bot.AsyncClient.Track(func: Callable[[...], Any], ms: int)

Bases: AsyncIOEventEmitter

async start() → None

async stop() → None

class replit_bot.AsyncClient.User(client)

Bases: object

User object. Follow and blocking

async setBlock(should_block: bool = True) → bool

Blocks a user and return whether they are blocking you

async setFollowing(should_follow: bool = True) → bool

Follow a user and return whether they are following you

async update(data: Dict[str, Any])

Update profile

class replit_bot.AsyncClient.UserEvent(client)

Bases: object

async update(data: Dict[str, Any])

class replit_bot.AsyncClient.UserEventManager(client)

Bases: object

async fetch(options: Dict[str, Any] = {}) → Dict[str, Any]

class replit_bot.AsyncClient.UserManager(client)

Bases: object

async fetch(userResolvable, options: Dict[str, Any] = {})

async search(query: str, options: Dict[str, Any] = {})

class replit_bot.AsyncClient.module

Bases: object