General cleanup of the library

.gitignore

@@ -162,4 +162,8 @@ cython_debug/
 #.idea/
 
 /local
-/local*.py
+/local*.py
+/local*.json
+
+# ruff
+.ruff_cache/

CONTRIBUTING.md

@@ -0,0 +1,34 @@
+## Contributing to pyvolt
+
+First off, thanks for taking the time to contribute. It makes the library muuuuch better.
+
+The following is a set of guidelines for contributing to the repository. These are guidelines, not hard rules.
+
+## Submitting a Pull Request
+
+Submitting a pull request is fairly simple, just make sure it focuses on a single aspect and doesn't manage to have scope creep and it's probably good to go. It would be incredibly lovely if the style is consistent to that found in the project. This project follows PEP-8 guidelines (mostly) with a column limit of 125.
+
+### Git Commit Guidelines
+
+- Use present tense (e.g. "Add feature" not "Added feature")
+- Limit all lines to 72 characters or less.
+- Reference issues or pull requests outside of the first line.
+    - Please use the shorthand `#123` and not the full URL.
+- Commits regarding the commands extension must be prefixed with `[commands]`
+
+If you do not meet any of these guidelines, don't fret. Chances are they will be fixed upon rebasing but please do try to meet them to remove some of the workload.
+
+### Code Style
+
+Use following order in models:
+```py
+@define(slots=True)
+class Foo(Base):
+    # ... attrs properties
+    # ... getters (``get_x``)
+    # ... dunder methods (eq, hash, str), in alphabet order
+    # ... internal methods (`_update`, `_react`)
+    # ... properties
+    # ... async methods, in alphabet order
+    # ... methods
+```

README.rst

@@ -0,0 +1,50 @@
+pyvolt
+======
+
+A simple, flexible API wrapper for Revolt.
+
+.. warning::
+    This is alpha software. Please report bugs on GitHub issues if you will find any.
+
+Key Features
+-------------
+
+- Built on ``asyncio``.
+- Probably handles ratelimiting.
+- Fast. Really faster than Revolt.py and voltage.
+- Low memory usage.
+- Customizable architecture. Build object parser in Rust to achieve high speeds.
+- Focuses on supporting both, bot and user accounts.
+
+Quick Example
+--------------
+
+.. code:: py
+
+    from pyvolt import Client, ReadyEvent, MessageCreateEvent
+
+    class MyClient(Client):
+        @Client.listens_on(ReadyEvent)
+        async def on_ready(self, _):
+            print('Logged on as', self.me)
+
+        @Client.listens_on(MessageCreateEvent)
+        async def on_message(self, event):
+            message = event.message
+            # don't respond to ourselves
+            if message.author_id == self.me.id:
+                return
+
+            if message.content == 'ping':
+                await message.channel.send('pong')
+
+    # You can pass ``bot=False`` to run as user account
+    client = MyClient(token='token')
+    client.run()
+
+Links
+------
+
+- `Documentation <https://pyvolt.readthedocs.io/en/latest/index.html>`_
+- `Official Revolt Server <https://rvlt.gg/ZZQb4sxx>`_
+- `Revolt API <https://rvlt.gg/API>`_

TODO.md

@@ -0,0 +1,30 @@
+# TODO
+
+* TODO: events
+
+  Source: https://github.com/MCausc78/pyvolt/blob/ready/pyvolt/cache.py#L149C7-L149C19
+
+* TODO: Remove when backend will tell us to update all channels. (ServerUpdate event)
+
+  Source: https://github.com/MCausc78/pyvolt/blob/ready/pyvolt/events.py#L234C11-L234C94
+
+* TODO: What we should do in case of mentions? This solution sucks.
+
+  Source: https://github.com/MCausc78/pyvolt/blob/ready/pyvolt/events.py#L321C15-L321C80
+
+* TODO: Handle 10053?
+
+  Source: https://github.com/MCausc78/pyvolt/blob/ready/pyvolt/http.py#L285C19-L285C38
+
+* TODO: Remove when Revolt will fix this
+
+  Source: https://github.com/MCausc78/pyvolt/blob/ready/pyvolt/http.py#L408C11-L408C49
+
+* TODO: Remove when Revolt will fix this
+
+  Source: https://github.com/MCausc78/pyvolt/blob/ready/pyvolt/http.py#L484C11-L484C49
+
+* TODO: Handle 10053?
+
+  Source: https://github.com/MCausc78/pyvolt/blob/ready/pyvolt/shard.py#L353C19-L353C38
+

bench/__main__.py

@@ -0,0 +1,32 @@
+import asyncio
+
+from .bench_channel import bench_dm_channels, bench_group_channels, bench_text_channels
+from .bench_member import bench_members
+from .bench_message import bench_messages
+from .bench_server import bench_servers
+from .bench_user import bench_users
+
+async def main():
+    print('Benchmarking DMChannel parsing.')
+    await bench_dm_channels()
+
+    print('Benchmarking GroupChannel parsing.')
+    await bench_group_channels()
+
+    print('Benchmarking TextChannel parsing.')
+    await bench_text_channels()
+
+    print('Benchmarking Member parsing.')
+    await bench_members()
+
+    print('Benchmarking Message parsing.')
+    await bench_messages()
+
+    print('Benchmarking Server parsing.')
+    await bench_servers()
+
+    print('Benchmarking User parsing.')
+    await bench_users()
+
+
+asyncio.run(main())

bench/bench_channel.py

@@ -0,0 +1,172 @@
+import asyncio
+
+import json
+import pyvolt
+
+import revolt
+import revolt.http
+import revolt.state
+
+import timeit
+import typing
+import voltage
+import voltage.internals
+
+async def bench_dm_channels():
+    with open('./tests/data/channels/dm.json', 'r') as fp:
+        payload = json.load(fp)
+
+    state = pyvolt.State()
+    parser = pyvolt.Parser(state)
+    state.setup(parser=parser)
+
+    def using_pyvolt():
+        return parser.parse_direct_message_channel(payload)
+
+    import aiohttp
+    session = aiohttp.ClientSession()
+
+    api_info: typing.Any = {
+        'features': {
+            'autumn': {
+                'url': 'https://autumn.revolt.chat/'
+            }
+        }
+    }
+    rpy_http = revolt.http.HttpClient(
+        session,
+        '',
+        'https://api.revolt.chat/',
+        api_info
+    )
+    rpy_state = revolt.state.State(rpy_http, api_info, 1000)
+
+    def using_revoltpy():
+        return revolt.DMChannel(data=payload, state=rpy_state)
+
+    vpy_http = voltage.internals.http.HTTPHandler(session, '')
+    vpy_cache = voltage.internals.cache.CacheHandler(vpy_http, asyncio.get_event_loop())
+
+    def using_voltage():
+        return voltage.DMChannel(data=payload, cache=vpy_cache)
+
+    time_pyvolt = timeit.timeit(using_pyvolt,     number=100_000)
+    time_revoltpy = timeit.timeit(using_revoltpy, number=100_000)
+    time_voltage = timeit.timeit(using_voltage,   number=100_000)
+
+    print(f"[DMChannel] Time using pyvolt ----: {time_pyvolt:.6f} seconds")
+    print(f"[DMChannel] Time using revolt.py -: {time_revoltpy:.6f} seconds")
+    print(f"[DMChannel] Time using voltage ---: {time_voltage:.6f} seconds")
+
+    await session.close()
+
+async def bench_group_channels():
+    with open('./tests/data/channels/group.json', 'r') as fp:
+        payload = json.load(fp)
+
+    state = pyvolt.State()
+    parser = pyvolt.Parser(state)
+    state.setup(parser=parser)
+
+    def using_pyvolt():
+        return parser.parse_group_channel(payload, (True, payload['recipients']))
+
+    import aiohttp
+    session = aiohttp.ClientSession()
+
+    api_info: typing.Any = {
+        'features': {
+            'autumn': {
+                'url': 'https://autumn.revolt.chat/'
+            }
+        }
+    }
+    rpy_http = revolt.http.HttpClient(
+        session,
+        '',
+        'https://api.revolt.chat/',
+        api_info
+    )
+    rpy_state = revolt.state.State(rpy_http, api_info, 1000)
+
+    def using_revoltpy():
+        return revolt.GroupDMChannel(data=payload, state=rpy_state)
+
+    vpy_http = voltage.internals.http.HTTPHandler(session, '')
+    vpy_cache = voltage.internals.cache.CacheHandler(vpy_http, asyncio.get_event_loop())
+
+    with open('./tests/data/users/me.json', 'r') as fp:
+        me = json.load(fp)
+        vpy_cache.add_user(me)
+
+    with open('./tests/data/users/mecha.json', 'r') as fp:
+        mecha = json.load(fp)
+        vpy_cache.add_user(mecha)
+
+
+    def using_voltage():
+        return voltage.GroupDMChannel(data=payload, cache=vpy_cache)
+
+    time_pyvolt = timeit.timeit(using_pyvolt,     number=100_000)
+    time_revoltpy = timeit.timeit(using_revoltpy, number=100_000)
+    time_voltage = timeit.timeit(using_voltage,   number=100_000)
+
+    print(f"[GroupChannel] Time using pyvolt ----: {time_pyvolt:.6f} seconds")
+    print(f"[GroupChannel] Time using revolt.py -: {time_revoltpy:.6f} seconds")
+    print(f"[GroupChannel] Time using voltage ---: {time_voltage:.6f} seconds")
+
+    await session.close()
+
+async def bench_text_channels():
+    with open('./tests/data/channels/rules_channel.json', 'r') as fp:
+        payload = json.load(fp)
+
+    with open('./tests/data/servers/server.json', 'r') as fp:
+        server_payload = json.load(fp)
+
+    state = pyvolt.State()
+    parser = pyvolt.Parser(state)
+    state.setup(parser=parser)
+
+    def using_pyvolt():
+        return parser.parse_text_channel(payload)
+
+    import aiohttp
+    session = aiohttp.ClientSession()
+
+    api_info: typing.Any = {
+        'features': {
+            'autumn': {
+                'url': 'https://autumn.revolt.chat/'
+            }
+        }
+    }
+    rpy_http = revolt.http.HttpClient(
+        session,
+        '',
+        'https://api.revolt.chat/',
+        api_info
+    )
+    rpy_state = revolt.state.State(rpy_http, api_info, 1000)
+
+    def using_revoltpy():
+        return revolt.TextChannel(data=payload, state=rpy_state)
+
+    vpy_http = voltage.internals.http.HTTPHandler(session, '')
+    vpy_cache = voltage.internals.cache.CacheHandler(vpy_http, asyncio.get_event_loop())
+    server_id = payload['server']
+    vpy_server = voltage.Server(data=server_payload, cache=vpy_cache)
+    vpy_cache.servers[vpy_server.id] = vpy_server
+
+    def using_voltage():
+        return voltage.TextChannel(data=payload, cache=vpy_cache, server_id=server_id)
+
+    time_pyvolt = timeit.timeit(using_pyvolt,     number=100_000)
+    time_revoltpy = timeit.timeit(using_revoltpy, number=100_000)
+    time_voltage = timeit.timeit(using_voltage,   number=100_000)
+
+    print(f"[TextChannel] Time using pyvolt ----: {time_pyvolt:.6f} seconds")
+    print(f"[TextChannel] Time using revolt.py -: {time_revoltpy:.6f} seconds")
+    print(f"[TextChannel] Time using voltage ---: {time_voltage:.6f} seconds")
+
+    await session.close()