docs: revise explanation of Anki's architecture #3384

davidculley · 2024-08-24T04:29:05Z

Rewrote the documentation of Anki's architecture in my own words, mainly to understand the architecture better myself.

Feel free to correct or comment on any errors I introduced into the documentation.

brishtibheja · 2024-08-25T05:18:17Z

docs/architecture.md


-### GUI (aqt & ts)
+The code responsible for the actual logic (opening collections, fetching and answering cards, et cetera) — the "backend" methods — is written parts in Python, parts in Rust.


etc.?

Suggested change

The code responsible for the actual logic (opening collections, fetching and answering cards, et cetera) — the "backend" methods — is written parts in Python, parts in Rust.

The code responsible for the actual logic (opening collections, fetching and answering cards, etc.) — the "backend" methods — is written parts in Python, parts in Rust.

If you don't like etc./i.e. how about,

Suggested change

The code responsible for the actual logic (opening collections, fetching and answering cards, et cetera) — the "backend" methods — is written parts in Python, parts in Rust.

The code responsible for the actual logic (such as opening collections, fetching and answering cards) — the "backend" methods — is written parts in Python, parts in Rust.

How about "for example"?

docs/architecture.md

davidculley · 2024-08-25T13:12:02Z

@brishtibheja Thanks for your suggestions.

dae · 2024-08-29T12:30:03Z

docs/architecture.md

-The Python library (pylib) exports "backend" methods - opening collections,
-fetching and answering cards, and so on. It is used by Anki’s GUI, and can also
-be included in command line programs to access Anki decks without the GUI.
+Anki’s GUI is written parts in Python using the toolkit Qt (via Qt's Python bindings known as PyQt), and parts in a mix of TypeScript, HTML, and CSS.


Suggested change

Anki’s GUI is written parts in Python using the toolkit Qt (via Qt's Python bindings known as PyQt), and parts in a mix of TypeScript, HTML, and CSS.

Anki’s GUI is implemented in a mix of Python and TypeScript. The Python code primarily uses PyQt (Python bindings for the Qt toolkit), but also injects HTML and JavaScript into a webview in some older parts of the codebase. The TypeScript portions of the GUI mainly use the Svelte framework.

dae · 2024-08-29T12:30:43Z

docs/architecture.md


-The library is accessible in Python with "import anki". Its code lives in
-the `pylib/anki/` folder.
+The Python code that implements Anki’s GUI (using PyQt) is located in `qt/aqt/`. It’s made available as a Python package named `aqt` (installable with `pip install 'aqt[qt6]'`) and is accessible through `import aqt` in Python code.


Suggested change

The Python code that implements Anki’s GUI (using PyQt) is located in `qt/aqt/`. It’s made available as a Python package named `aqt` (installable with `pip install 'aqt[qt6]'`) and is accessible through `import aqt` in Python code.

The Python code that implements Anki’s GUI (using PyQt) is located in `qt/aqt/`, and is importable as `aqt`.

These docs are for people working with the codebase, so I don't think we need to document installing them separately here.

dae · 2024-08-29T12:32:12Z

docs/architecture.md


-These days, the majority of backend logic lives in a Rust library (rslib, located in `rslib/`). Calls to pylib proxy requests to rslib, and return the results.
+The web code is split between `ts/` and `qt/aqt/data/web/`.
+The majority of new code now goes into `ts/` rather than `qt/aqt/data/web/` and, during the build process, gets copied into `qt/aqt/data/web/` instead.


Suggested change

The majority of new code now goes into `ts/` rather than `qt/aqt/data/web/` and, during the build process, gets copied into `qt/aqt/data/web/` instead.

The majority of new code now goes into `ts/` rather than `qt/aqt/data/web/`.

The old text was incorrect - it's copied to a different location, and not really relevant.

dae · 2024-08-29T12:36:29Z

docs/architecture.md


-### GUI (aqt & ts)
+The code responsible for the actual logic (for example, opening collections, or fetching and answering cards) — the "backend" methods — is written parts in Python, parts in Rust.


Suggested change

The code responsible for the actual logic (for example, opening collections, or fetching and answering cards) — the "backend" methods — is written parts in Python, parts in Rust.

The code responsible for the business logic (for example, opening collections, or fetching and answering cards) is mainly implemented in Rust, in the `rslib/` folder. We tend to refer to this code as the "backend". This code is shared between the different Anki clients.

dae · 2024-08-29T12:38:05Z

docs/architecture.md


-### GUI (aqt & ts)
+The code responsible for the actual logic (for example, opening collections, or fetching and answering cards) — the "backend" methods — is written parts in Python, parts in Rust.
+Most of the logic previously implemented in Python was rewritten in Rust so that the code can be shared between the different Anki apps.


Suggested change

Most of the logic previously implemented in Python was rewritten in Rust so that the code can be shared between the different Anki apps.

dae · 2024-08-29T12:38:21Z

docs/architecture.md

-with the majority of new code being placed in the latter, and copied into the
-former at build time.
+- The parts of the library code written in Python are located in `pylib/` (more specifically, in `pylib/anki/`).
+- The parts of the library code written in Rust are located in `rslib/`.


Suggested change

- The parts of the library code written in Rust are located in `rslib/`.

dae · 2024-08-29T12:43:27Z

docs/architecture.md

+- The parts of the library code written in Python are located in `pylib/` (more specifically, in `pylib/anki/`).
+- The parts of the library code written in Rust are located in `rslib/`.
+
+The Python code serves as proxy for the Rust library and, when called, forwards the requests to the code in `rslib/` which does the actual computations and then returns the results to the code in `pylib/anki/`.


Suggested change

The Python code serves as proxy for the Rust library and, when called, forwards the requests to the code in `rslib/` which does the actual computations and then returns the results to the code in `pylib/anki/`.

A Python module in `pylib/rsbridge` exposes the Rust methods to Python. The `anki` module in `pylib/anki` uses this bridge to forward requests to Rust. The `Collection` class in the `anki` module has a hidden `_backend` property, which is an instance of the bridge. Most methods you call on a collection object end up forwarding the request through the bridge.

dae · 2024-08-29T12:44:01Z

docs/architecture.md

+- The parts of the library code written in Rust are located in `rslib/`.
+
+The Python code serves as proxy for the Rust library and, when called, forwards the requests to the code in `rslib/` which does the actual computations and then returns the results to the code in `pylib/anki/`.
+The way that is implemented is by way of a Python binding named `rsbridge` within `pylib/` (that is, `pylib/rsbridge/`) that wraps around the Rust code and makes the logic implemented in Rust accessible with Python code.


Suggested change

The way that is implemented is by way of a Python binding named `rsbridge` within `pylib/` (that is, `pylib/rsbridge/`) that wraps around the Rust code and makes the logic implemented in Rust accessible with Python code.

dae · 2024-08-29T12:44:09Z

docs/architecture.md

+The Python code serves as proxy for the Rust library and, when called, forwards the requests to the code in `rslib/` which does the actual computations and then returns the results to the code in `pylib/anki/`.
+The way that is implemented is by way of a Python binding named `rsbridge` within `pylib/` (that is, `pylib/rsbridge/`) that wraps around the Rust code and makes the logic implemented in Rust accessible with Python code.
+
+The Python library is made available as a Python package named `anki` and is accessible through `import anki` in Python code.


Suggested change

The Python library is made available as a Python package named `anki` and is accessible through `import anki` in Python code.

dae · 2024-08-29T12:46:02Z

docs/architecture.md

+
+The Python library is made available as a Python package named `anki` and is accessible through `import anki` in Python code.
+
+Anki’s GUI relies on this Python library (located in `pylib/anki/`) and you can use it too (by installing it with `pip install anki`) if you want to develop command line programs to programmatically access your Anki decks without the need of running Anki’s GUI.


Suggested change

Anki’s GUI relies on this Python library (located in `pylib/anki/`) and you can use it too (by installing it with `pip install anki`) if you want to develop command line programs to programmatically access your Anki decks without the need of running Anki’s GUI.

dae · 2024-10-02T09:45:13Z

Do you plan to return to this, or should I close it?

davidculley · 2024-10-06T12:28:01Z

Hi @dae, sorry for the late reply / being unresponsive. Some personal things got in the way. Yes, I do plan to continue this work.

davidculley added 4 commits August 24, 2024 06:12

docs: revise section about library code

530ab6d

docs: revise section about GUI code

4fcd01a

docs: revise section about architecture

07a7269

docs: switch sections about GUI and backend

758eec7

brishtibheja reviewed Aug 25, 2024

View reviewed changes

docs: use 'for example' rather than 'et cetera'

e16e887

dae reviewed Aug 29, 2024

View reviewed changes

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

docs: revise explanation of Anki's architecture #3384

docs: revise explanation of Anki's architecture #3384

davidculley commented Aug 24, 2024

brishtibheja Aug 25, 2024

davidculley Aug 25, 2024 •

edited

Loading

davidculley commented Aug 25, 2024

dae Aug 29, 2024

dae Aug 29, 2024

dae Aug 29, 2024

dae Aug 29, 2024

dae Aug 29, 2024

dae Aug 29, 2024

dae Aug 29, 2024

dae Aug 29, 2024

dae Aug 29, 2024

dae Aug 29, 2024

dae commented Oct 2, 2024

davidculley commented Oct 6, 2024


		### GUI (aqt & ts)
		The code responsible for the actual logic (opening collections, fetching and answering cards, et cetera) — the "backend" methods — is written parts in Python, parts in Rust.

	Anki’s GUI is written parts in Python using the toolkit Qt (via Qt's Python bindings known as PyQt), and parts in a mix of TypeScript, HTML, and CSS.
	Anki’s GUI is implemented in a mix of Python and TypeScript. The Python code primarily uses PyQt (Python bindings for the Qt toolkit), but also injects HTML and JavaScript into a webview in some older parts of the codebase. The TypeScript portions of the GUI mainly use the Svelte framework.

	The Python code that implements Anki’s GUI (using PyQt) is located in `qt/aqt/`. It’s made available as a Python package named `aqt` (installable with `pip install 'aqt[qt6]'`) and is accessible through `import aqt` in Python code.
	The Python code that implements Anki’s GUI (using PyQt) is located in `qt/aqt/`, and is importable as `aqt`.

	The majority of new code now goes into `ts/` rather than `qt/aqt/data/web/` and, during the build process, gets copied into `qt/aqt/data/web/` instead.
	The majority of new code now goes into `ts/` rather than `qt/aqt/data/web/`.

	The code responsible for the actual logic (for example, opening collections, or fetching and answering cards) — the "backend" methods — is written parts in Python, parts in Rust.
	The code responsible for the business logic (for example, opening collections, or fetching and answering cards) is mainly implemented in Rust, in the `rslib/` folder. We tend to refer to this code as the "backend". This code is shared between the different Anki clients.

	The Python code serves as proxy for the Rust library and, when called, forwards the requests to the code in `rslib/` which does the actual computations and then returns the results to the code in `pylib/anki/`.
	A Python module in `pylib/rsbridge` exposes the Rust methods to Python. The `anki` module in `pylib/anki` uses this bridge to forward requests to Rust. The `Collection` class in the `anki` module has a hidden `_backend` property, which is an instance of the bridge. Most methods you call on a collection object end up forwarding the request through the bridge.


		The Python library is made available as a Python package named `anki` and is accessible through `import anki` in Python code.

		Anki’s GUI relies on this Python library (located in `pylib/anki/`) and you can use it too (by installing it with `pip install anki`) if you want to develop command line programs to programmatically access your Anki decks without the need of running Anki’s GUI.

docs: revise explanation of Anki's architecture #3384

Are you sure you want to change the base?

docs: revise explanation of Anki's architecture #3384

Conversation

davidculley commented Aug 24, 2024

Choose a reason for hiding this comment

davidculley Aug 25, 2024 • edited Loading

Choose a reason for hiding this comment

davidculley commented Aug 25, 2024

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

dae commented Oct 2, 2024

davidculley commented Oct 6, 2024

davidculley Aug 25, 2024 •

edited

Loading