overleaf-sync 1.1.6__tar.gz → 2.0.0a1__tar.gz

overleaf_sync-2.0.0a1/PKG-INFO

@@ -0,0 +1,139 @@
+Metadata-Version: 2.4
+Name: overleaf-sync
+Version: 2.0.0a1
+Summary: Overleaf Two-Way Sync Tool
+Keywords: overleaf,sync,latex,tex
+Author-email: Moritz Glöckl <moritzgloeckl@users.noreply.github.com>
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+License-File: LICENSE
+Requires-Dist: requests >=2.31,<3
+Requires-Dist: beautifulsoup4 >=4.12,<5
+Requires-Dist: yaspin >=3,<4
+Requires-Dist: python-dateutil >=2.8,<3
+Requires-Dist: click >=8.1,<9
+Requires-Dist: socketIO-client ==0.5.7.2
+Requires-Dist: websocket-client >=1,<2
+Requires-Dist: pytest >=8 ; extra == "dev"
+Requires-Dist: pytest-cov >=5 ; extra == "dev"
+Requires-Dist: responses >=0.25 ; extra == "dev"
+Requires-Dist: ruff >=0.6 ; extra == "dev"
+Requires-Dist: PySide6 >=6.5,<7 ; extra == "gui"
+Project-URL: Homepage, https://github.com/moritzgloeckl/overleaf-sync
+Project-URL: Issues, https://github.com/moritzgloeckl/overleaf-sync/issues
+Provides-Extra: dev
+Provides-Extra: gui
+
+# Overleaf-Sync
+### Easy Overleaf Two-Way Synchronization
+
+![Made In Austria](https://img.shields.io/badge/Made%20in-Austria-%23ED2939.svg) ![PyPI - License](https://img.shields.io/pypi/l/overleaf-sync.svg) ![PyPI](https://img.shields.io/pypi/v/overleaf-sync.svg) ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/overleaf-sync.svg)
+
+This tool provides an easy way to synchronize Overleaf projects from and to your local computer. No paid account necessary.
+
+----
+
+## Features
+- Sync your locally modified `.tex` (and other) files to your Overleaf projects
+- Sync your remotely modified `.tex` (and other) files to computer
+- Works with free Overleaf account
+- No Git or Dropbox required
+- Does not steal or store your login credentials (works with a persisted cookie, logging in is done on the original Overleaf website)
+
+## How To Use
+### Install
+The package is available via [PyPI](https://pypi.org/project/overleaf-sync/) and needs Python 3.11 or newer. Install it including the login window (`gui` extra):
+
+```
+moritz@github:~/test$ pip3 install "overleaf-sync[gui]"
+```
+
+Depending on your local Python installation, you might need to use `pip` instead of `pip3`. [pipx](https://pipx.pypa.io/) works too: `pipx install "overleaf-sync[gui]"`.
+
+> **2.0 pre-release:** Overleaf changed its website in a way that broke version 1.2.0. The fixes are available as a pre-release: `pip3 install --pre "overleaf-sync[gui]"`. Please report any problems in the [issues](https://github.com/moritzgloeckl/overleaf-sync/issues).
+
+### Prerequisites
+- Create your project on [Overleaf](https://www.overleaf.com/project), for example a project named `test`. Overleaf-sync is not able to create projects (yet).
+- Create a folder, preferably with the same name as the project (`test`) on your computer.
+- Execute the script from that folder (`test`).
+- If you do not specify the project name, overleaf-sync uses the current folder's name as the project name.
+
+### Usage
+#### Login
+```
+moritz@github:~/test$ ols login [--path]
+Login successful. Cookie persisted as `.olauth`. You may now sync your project.
+```
+
+Logging in will be handled by a mini web browser opening on your device (using Qt via PySide6, from the `gui` extra). You can then enter your username and password securely on the official Overleaf website. You might get asked to solve a CAPTCHA in the process. Your credentials are sent to Overleaf over HTTPS.
+
+It then stores your *cookie* (**not** your login credentials) in a hidden file called `.olauth` in the same folder you run the command from. It is possible to store the cookie elsewhere using the `--path` option. The cookie file will not be synced to or from Overleaf.
+
+Keep the `.olauth` file save, as it can be used to log in into your account.
+
+### Listing all projects
+```
+moritz@github:~/test$ ols list [--store-path -v/--verbose]
+10/31/2021, 01:23:45 - Project A
+09/21/2020, 01:23:45 - Project B
+08/11/2019, 01:23:45 - Project C
+07/01/2018, 01:23:45 - Project D
+```
+
+Use `ols list` to conveniently list all projects in your account available for syncing. 
+
+### Downloading project's PDF
+```
+moritz@github:~/test$ ols download [--name --download-path --store-path -v/--verbose]
+```
+
+Use `ols download` to compile and download your project's PDF. Specify a download path if you do not want to store the PDF file in the current folder. Currently only downloads the first PDF file it finds.
+
+### Syncing
+```
+moritz@github:~/test$ ols [-l/--local-only -r/--remote-only --store-path -p/--path -i/--olignore]
+```
+
+Just calling `ols` will two-way sync your project. When there are changes both locally, and remotely you will be asked which file to keep. Using the `-l` or `-r` option you can specify to either sync local project files to Overleaf only or Overleaf files to local ones only respectively. When using these options you can also sync deleted files. If a file has been deleted it can either be deleted on the target (remote when `-l`, local when `-r`) as well, restored on the source (local when `-l`, remote when `-r`) or ignored.
+
+The option `--store-path` specifies the path of the cookie file created by the `login` command. If you did not change its path, you do not need to specify this argument. The `-p/--path` option allows you to specify a different sync folder than the one you're calling `ols` from. The `-i/--olignore` option allows you to specify the path of an `.olignore` file. It uses `fnmatch` internally, so it may have some similarity to `.gitignore` but doesn't work exactly the same. For example, if you wish to exclude a specific folder named `out`, you need to specify it as `out/*`. See [here](https://docs.python.org/3/library/fnmatch.html) for more information.
+
+Sample Output:
+
+```
+Project queried successfully.
+✅  Querying project
+Project downloaded successfully.
+✅  Downloading project
+
+Syncing files from remote to local
+====================
+
+[SYNCING] report.tex
+report.tex does not exist on local. Creating file.
+
+[SYNCING] other-report.tex
+other-report.tex does not exist on local. Creating file.
+
+
+✅  Syncing files from remote to local
+```
+
+## Known Bugs
+- When modifying a file on Overleaf and immediately syncing afterwards, the tool might not detect the changes. Please allow 1-2 minutes after modifying a file on Overleaf before syncing it to your local computer.
+
+## Contributing
+
+All pull requests and change/feature requests are welcome.
+
+## Disclaimer
+THE AUTHOR OF THIS SOFTWARE AND THIS SOFTWARE IS NOT ENDORSED BY, DIRECTLY AFFILIATED WITH, MAINTAINED, AUTHORIZED, OR SPONSORED BY OVERLEAF OR WRITELATEX LIMITED. ALL PRODUCT AND COMPANY NAMES ARE THE REGISTERED TRADEMARKS OF THEIR ORIGINAL OWNERS. THE USE OF ANY TRADE NAME OR TRADEMARK IS FOR IDENTIFICATION AND REFERENCE PURPOSES ONLY AND DOES NOT IMPLY ANY ASSOCIATION WITH THE TRADEMARK HOLDER OF THEIR PRODUCT BRAND.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+THIS SOFTWARE WAS DESIGNED TO BE USED ONLY FOR RESEARCH PURPOSES. THIS SOFTWARE COMES WITH NO WARRANTIES OF ANY KIND WHATSOEVER. USE IT AT YOUR OWN RISK! IF THESE TERMS ARE NOT ACCEPTABLE, YOU AREN'T ALLOWED TO USE THE CODE.
+
+

{overleaf-sync-1.1.6 → overleaf_sync-2.0.0a1}/README.md

@@ -16,13 +16,15 @@ This tool provides an easy way to synchronize Overleaf projects from and to your
 
 ## How To Use
 ### Install
-The package is available via [PyPI](https://pypi.org/project/overleaf-sync/). Just run:
+The package is available via [PyPI](https://pypi.org/project/overleaf-sync/) and needs Python 3.11 or newer. Install it including the login window (`gui` extra):
 
 ```
-moritz@github:~/test$ pip3 install overleaf-sync
+moritz@github:~/test$ pip3 install "overleaf-sync[gui]"
 ```
 
-That's it! Depending on your local Python installation, you might need to use `pip` instead of `pip3`.
+Depending on your local Python installation, you might need to use `pip` instead of `pip3`. [pipx](https://pipx.pypa.io/) works too: `pipx install "overleaf-sync[gui]"`.
+
+> **2.0 pre-release:** Overleaf changed its website in a way that broke version 1.2.0. The fixes are available as a pre-release: `pip3 install --pre "overleaf-sync[gui]"`. Please report any problems in the [issues](https://github.com/moritzgloeckl/overleaf-sync/issues).
 
 ### Prerequisites
 - Create your project on [Overleaf](https://www.overleaf.com/project), for example a project named `test`. Overleaf-sync is not able to create projects (yet).
@@ -37,7 +39,7 @@ moritz@github:~/test$ ols login [--path]
 Login successful. Cookie persisted as `.olauth`. You may now sync your project.
 ```
 
-Logging in will be handled by a mini web browser opening on your device (using Qt5). You can then enter your username and password securely on the official Overleaf website. You might get asked to solve a CAPTCHA in the process. Your credentials are sent to Overleaf over HTTPS.
+Logging in will be handled by a mini web browser opening on your device (using Qt via PySide6, from the `gui` extra). You can then enter your username and password securely on the official Overleaf website. You might get asked to solve a CAPTCHA in the process. Your credentials are sent to Overleaf over HTTPS.
 
 It then stores your *cookie* (**not** your login credentials) in a hidden file called `.olauth` in the same folder you run the command from. It is possible to store the cookie elsewhere using the `--path` option. The cookie file will not be synced to or from Overleaf.
 
@@ -54,12 +56,21 @@ moritz@github:~/test$ ols list [--store-path -v/--verbose]
 
 Use `ols list` to conveniently list all projects in your account available for syncing. 
 
+### Downloading project's PDF
+```
+moritz@github:~/test$ ols download [--name --download-path --store-path -v/--verbose]
+```
+
+Use `ols download` to compile and download your project's PDF. Specify a download path if you do not want to store the PDF file in the current folder. Currently only downloads the first PDF file it finds.
+
 ### Syncing
 ```
 moritz@github:~/test$ ols [-l/--local-only -r/--remote-only --store-path -p/--path -i/--olignore]
 ```
 
-Just calling `ols` will two-way sync your project. When there are changes both locally and remotely you will be asked which file to keep. Using the `-l` or `-r` option you can specify to either sync local project files to Overleaf only or Overleaf files to local ones only respectively. The option `--store-path` specifies the path of the cookie file created by the `login` command. If you did not change its path, you do not need to specify this argument. The `-p/--path` option allows you to specify a different sync folder than the one you're calling `ols` from. The `-i/--olignore` option allows you to specify the path of an `.olignore` file which works exactly like `.gitignore`.
+Just calling `ols` will two-way sync your project. When there are changes both locally, and remotely you will be asked which file to keep. Using the `-l` or `-r` option you can specify to either sync local project files to Overleaf only or Overleaf files to local ones only respectively. When using these options you can also sync deleted files. If a file has been deleted it can either be deleted on the target (remote when `-l`, local when `-r`) as well, restored on the source (local when `-l`, remote when `-r`) or ignored.
+
+The option `--store-path` specifies the path of the cookie file created by the `login` command. If you did not change its path, you do not need to specify this argument. The `-p/--path` option allows you to specify a different sync folder than the one you're calling `ols` from. The `-i/--olignore` option allows you to specify the path of an `.olignore` file. It uses `fnmatch` internally, so it may have some similarity to `.gitignore` but doesn't work exactly the same. For example, if you wish to exclude a specific folder named `out`, you need to specify it as `out/*`. See [here](https://docs.python.org/3/library/fnmatch.html) for more information.
 
 Sample Output:
 

{overleaf-sync-1.1.6 → overleaf_sync-2.0.0a1}/olsync/__init__.py

@@ -1,3 +1,3 @@
 """Overleaf Two-Way Sync Tool"""
 
-__version__ = '1.1.6'
+__version__ = '2.0.0a1'

{overleaf-sync-1.1.6 → overleaf_sync-2.0.0a1}/olsync/olbrowserlogin.py

@@ -6,12 +6,12 @@
 # Description: Overleaf Browser Login Utility
 # Author: Moritz Glöckl
 # License: MIT
-# Version: 1.1.6
 ##################################################
 
-from PyQt5.QtCore import *
-from PyQt5.QtWidgets import *
-from PyQt5.QtWebEngineWidgets import *
+from PySide6.QtCore import *
+from PySide6.QtWidgets import *
+from PySide6.QtWebEngineWidgets import *
+from PySide6.QtWebEngineCore import QWebEngineProfile, QWebEngineSettings, QWebEnginePage
 
 # Where to get the CSRF Token and where to send the login request to
 LOGIN_URL = "https://www.overleaf.com/login"
@@ -60,7 +60,7 @@ class OlBrowserLoginWindow(QMainWindow):
 
         if self.webview.url().toString() == PROJECT_URL:
             self.webview.page().runJavaScript(
-                JAVASCRIPT_CSRF_EXTRACTOR, callback
+                JAVASCRIPT_CSRF_EXTRACTOR, 0, callback
             )
 
     def handle_cookie_added(self, cookie):
@@ -82,6 +82,11 @@ class OlBrowserLoginWindow(QMainWindow):
 
 
 def login():
+    from PySide6.QtCore import QLoggingCategory
+    QLoggingCategory.setFilterRules('''\
+    qt.webenginecontext.info=false
+    ''')
+
     app = QApplication([])
     ol_browser_login_window = OlBrowserLoginWindow()
     ol_browser_login_window.show()

overleaf_sync-2.0.0a1/olsync/olclient.py

@@ -0,0 +1,404 @@
+"""Overleaf Client"""
+##################################################
+# MIT License
+##################################################
+# File: olclient.py
+# Description: Overleaf API Wrapper
+# Author: Moritz Glöckl
+# License: MIT
+##################################################
+
+import requests as reqs
+from bs4 import BeautifulSoup
+import json
+import ssl
+import uuid
+import websocket
+from socketIO_client import SocketIO
+import time
+
+# socketIO_client/transports.py has `except websocket.SSLError`, an attribute
+# recent websocket-client (1.9.0+) no longer exposes; that raises AttributeError
+# and masks whatever the actual connection error is. Keep this shim for as long
+# as we depend on socketIO-client.
+if not hasattr(websocket, "SSLError"):
+    websocket.SSLError = ssl.SSLError
+
+# Where to get the CSRF Token and where to send the login request to
+LOGIN_URL = "https://www.overleaf.com/login"
+PROJECT_URL = "https://www.overleaf.com/project"  # The dashboard URL
+# The URL to download all the files in zip format
+DOWNLOAD_URL = "https://www.overleaf.com/project/{}/download/zip"
+UPLOAD_URL = "https://www.overleaf.com/project/{}/upload"  # The URL to upload files
+FOLDER_URL = "https://www.overleaf.com/project/{}/folder"  # The URL to create folders
+DELETE_URL = "https://www.overleaf.com/project/{}/doc/{}"  # The URL to delete files
+COMPILE_URL = "https://www.overleaf.com/project/{}/compile?enable_pdf_caching=true"  # The URL to compile the project
+BASE_URL = "https://www.overleaf.com"  # The Overleaf Base URL
+PATH_SEP = "/"  # Use hardcoded path separator for both windows and posix system
+
+class OverleafClient(object):
+    """
+    Overleaf API Wrapper
+    Supports login, querying all projects, querying a specific project, downloading a project and
+    uploading a file to a project.
+    """
+
+    @staticmethod
+    def filter_projects(json_content, more_attrs=None):
+        more_attrs = more_attrs or {}
+        for p in json_content:
+            if not p.get("archived") and not p.get("trashed"):
+                if all(p.get(k) == v for k, v in more_attrs.items()):
+                    yield p
+
+    def __init__(self, cookie=None, csrf=None):
+        self._cookie = cookie  # Store the cookie for authenticated requests
+        self._csrf = csrf  # Store the CSRF token since it is needed for some requests
+
+    def login(self, username, password):
+        """
+        WARNING - DEPRECATED - Not working as Overleaf introduced captchas
+        Login to the Overleaf Service with a username and a password
+        Params: username, password
+        Returns: Dict of cookie and CSRF
+        """
+
+        get_login = reqs.get(LOGIN_URL)
+        self._csrf = BeautifulSoup(get_login.content, 'html.parser').find(
+            'input', {'name': '_csrf'}).get('value')
+        login_json = {
+            "_csrf": self._csrf,
+            "email": username,
+            "password": password
+        }
+        post_login = reqs.post(LOGIN_URL, json=login_json,
+                               cookies=get_login.cookies)
+
+        # On a successful authentication the Overleaf API returns a new authenticated cookie.
+        # If the cookie is different than the cookie of the GET request the authentication was successful
+        if post_login.status_code == 200 and get_login.cookies["overleaf_session2"] != post_login.cookies[
+            "overleaf_session2"]:
+            self._cookie = post_login.cookies
+
+            # Enrich cookie with GCLB cookie from GET request above
+            self._cookie['GCLB'] = get_login.cookies['GCLB']
+
+            # CSRF changes after making the login request, new CSRF token will be on the projects page
+            projects_page = reqs.get(PROJECT_URL, cookies=self._cookie)
+            self._csrf = BeautifulSoup(projects_page.content, 'html.parser').find('meta', {'name': 'ol-csrfToken'}) \
+                .get('content')
+
+            return {"cookie": self._cookie, "csrf": self._csrf}
+
+    @staticmethod
+    def _extract_projects(page_content):
+        """
+        Extract the project list from the Overleaf dashboard page.
+
+        Overleaf used to embed the list as a bare JSON array in a
+        <meta name="ol-projects"> tag. It now embeds
+        {"totalSize": N, "projects": [...]} in a
+        <meta name="ol-prefetchedProjectsBlob"> tag instead. Support both so
+        this keeps working if Overleaf reverts or if an older cookie/page is
+        cached somewhere.
+        """
+        soup = BeautifulSoup(page_content, 'html.parser')
+        tag = soup.find('meta', {'name': 'ol-prefetchedProjectsBlob'}) or soup.find('meta', {'name': 'ol-projects'})
+        json_content = json.loads(tag.get('content'))
+        if isinstance(json_content, dict):
+            json_content = json_content.get('projects', [])
+        return json_content
+
+    def all_projects(self):
+        """
+        Get all of a user's active projects (= not archived and not trashed)
+        Returns: List of project objects
+        """
+        projects_page = reqs.get(PROJECT_URL, cookies=self._cookie)
+        json_content = OverleafClient._extract_projects(projects_page.content)
+        return list(OverleafClient.filter_projects(json_content))
+
+    def get_project(self, project_name):
+        """
+        Get a specific project by project_name
+        Params: project_name, the name of the project
+        Returns: project object
+        """
+
+        projects_page = reqs.get(PROJECT_URL, cookies=self._cookie)
+        json_content = OverleafClient._extract_projects(projects_page.content)
+        return next(OverleafClient.filter_projects(json_content, {"name": project_name}), None)
+
+    def download_project(self, project_id):
+        """
+        Download project in zip format
+        Params: project_id, the id of the project
+        Returns: bytes string (zip file)
+        """
+        r = reqs.get(DOWNLOAD_URL.format(project_id),
+                     stream=True, cookies=self._cookie)
+        return r.content
+
+    def create_folder(self, project_id, parent_folder_id, folder_name):
+        """
+        Create a new folder in a project
+
+        Params:
+        project_id: the id of the project
+        parent_folder_id: the id of the parent folder, root is the project_id
+        folder_name: how the folder will be named
+
+        Returns: folder id or None
+        """
+
+        params = {
+            "parent_folder_id": parent_folder_id,
+            "name": folder_name
+        }
+        headers = {
+            "X-Csrf-Token": self._csrf
+        }
+        r = reqs.post(FOLDER_URL.format(project_id),
+                      cookies=self._cookie, headers=headers, json=params)
+
+        if r.ok:
+            return json.loads(r.content)
+        elif r.status_code == 400:
+            # Folder already exists. status_code is an int; comparing to
+            # str(400) was always False, so this branch never actually
+            # fired -- a real folder-exists response fell through to the
+            # HTTPError below instead of silently continuing.
+            return
+        else:
+            raise reqs.HTTPError()
+
+    def get_project_infos(self, project_id):
+        """
+        Get detailed project infos about the project
+
+        Params:
+        project_id: the id of the project
+
+        Returns: project details
+        """
+        project_infos = None
+
+        # Callback for the joinProjectResponse event the server pushes right
+        # after a successful connect+auto-join (see below) -- delivered as a
+        # plain named event, not as an ack to an explicit emit, and shaped as
+        # {"publicId": ..., "project": {...}}. Downstream code (upload_file,
+        # delete_file) indexes project_infos['rootFolder'][0][...] directly,
+        # so unwrap to the inner "project" dict here rather than returning
+        # the wrapper.
+        def set_project_infos(data):
+            nonlocal project_infos
+            project_infos = data.get('project')
+
+        # The Socket.IO handshake below (done again internally by the SocketIO()
+        # constructor) has Overleaf issue a *fresh* load-balancer affinity cookie
+        # (currently named GCLB, see olbrowserlogin.COOKIE_NAMES and commit
+        # 0cc61e7) on its response -- but socketIO_client calls requests.get()
+        # directly rather than through a Session, so that Set-Cookie is silently
+        # dropped, and the WebSocket upgrade that follows then 502s without it.
+        # Perform the same handshake ourselves first, purely to capture that
+        # cookie, and merge it into the header used for the real connection.
+        # (Built from whatever cookies are present rather than hardcoded names:
+        # a session may not carry every cookie -- this previously raised
+        # KeyError here even though overleaf_session2 alone is enough to connect.)
+        handshake = reqs.get(
+            "{}/socket.io/1/".format(BASE_URL),
+            params={"t": int(time.time() * 1000)},
+            cookies=self._cookie,
+        )
+        cookie_dict = dict(self._cookie)
+        cookie_dict.update(handshake.cookies.get_dict())
+        cookie = "; ".join(
+            "{}={}".format(name, value) for name, value in cookie_dict.items()
+        )
+
+        # projectId must be a query parameter on THIS handshake -- the one
+        # socketIO_client performs internally when SocketIO() connects, not
+        # the pre-fetch above. Overleaf now binds the session to a project at
+        # handshake time and rejects the connection otherwise
+        # (connectionRejected: "missing/bad ?projectId=... query flag on
+        # handshake"); confirmed it rejects even when projectId is only on
+        # the WebSocket upgrade URL -- it must be on the initial
+        # /socket.io/1/ GET specifically.
+        socket_io = SocketIO(
+            BASE_URL,
+            params={'t': int(time.time()), 'projectId': project_id},
+            headers={'Cookie': cookie}
+        )
+
+        # Wait until we connect to the socket
+        socket_io.on('connect', lambda: None)
+        socket_io.wait_for_callbacks()
+
+        # With projectId on the handshake, the server auto-joins and pushes
+        # the result as a joinProjectResponse event -- no explicit joinProject
+        # emit needed (confirmed live: the emit's ack callback never fires
+        # since the server responds with a named event, not an ack).
+        # wait_for_callbacks() only waits for a pending *ack* callback, which
+        # .on() never registers -- it would return immediately without
+        # reading anything. Wait in short slices instead, stopping as soon as
+        # the event has actually been processed.
+        socket_io.on('joinProjectResponse', set_project_infos)
+        for _ in range(20):
+            if project_infos is not None:
+                break
+            socket_io.wait(seconds=1)
+
+        # Disconnect from the socket if still connected
+        if socket_io.connected:
+            socket_io.disconnect()
+
+        return project_infos
+
+    def upload_file(self, project_id, project_infos, file_name, file_size, file):
+        """
+        Upload a file to the project
+
+        Params:
+        project_id: the id of the project
+        file_name: how the file will be named
+        file_size: the size of the file in bytes
+        file: the file itself
+
+        Returns: True on success, False on fail
+        """
+
+        # Set the folder_id to the id of the root folder
+        folder_id = project_infos['rootFolder'][0]['_id']
+
+        # The file name contains path separators, check folders
+        if PATH_SEP in file_name:
+            local_folders = file_name.split(PATH_SEP)[:-1]  # Remove last item since this is the file name
+            current_overleaf_folder = project_infos['rootFolder'][0]['folders']  # Set the current remote folder
+
+            for local_folder in local_folders:
+                exists_on_remote = False
+                for remote_folder in current_overleaf_folder:
+                    # Check if the folder exists on remote, continue with the new folder structure
+                    if local_folder.lower() == remote_folder['name'].lower():
+                        exists_on_remote = True
+                        folder_id = remote_folder['_id']
+                        current_overleaf_folder = remote_folder['folders']
+                        break
+                # Create the folder if it doesn't exist
+                if not exists_on_remote:
+                    new_folder = self.create_folder(project_id, folder_id, local_folder)
+                    current_overleaf_folder.append(new_folder)
+                    folder_id = new_folder['_id']
+                    current_overleaf_folder = new_folder['folders']
+        params = {
+            "folder_id": folder_id,
+            "_csrf": self._csrf,
+            "qquuid": str(uuid.uuid4()),
+            "qqfilename": file_name,
+            "qqtotalfilesize": file_size,
+        }
+        files = {
+            # Overleaf's upload endpoint now rejects the request with 422
+            # {"success":false,"error":"invalid_filename"} unless the
+            # filename is also present as a plain multipart field, not just
+            # in qqfilename above. Confirmed live: identical request without
+            # this field gets 422; with it, 200 and the file is actually
+            # updated. It must be the bare file name: Overleaf rejects names
+            # containing "/" (SafePath), the folder is chosen via folder_id.
+            "name": (None, file_name.split(PATH_SEP)[-1]),
+            "qqfile": file
+        }
+
+        # Upload the file to the predefined folder
+        r = reqs.post(UPLOAD_URL.format(project_id), cookies=self._cookie, params=params, files=files)
+
+        # status_code is an int; comparing to str(200) was always False here,
+        # so this reported failure on every call regardless of the real
+        # result. Harmless today only because callers don't check the return
+        # value, but worth fixing since it's the only signal this method
+        # gives back.
+        return r.status_code == 200 and json.loads(r.content)["success"]
+
+    def delete_file(self, project_id, project_infos, file_name):
+        """
+        Deletes a project's file
+
+        Params:
+        project_id: the id of the project
+        file_name: how the file will be named
+
+        Returns: True on success, False on fail
+        """
+
+        file = None
+
+        # The file name contains path separators, check folders
+        if PATH_SEP in file_name:
+            local_folders = file_name.split(PATH_SEP)[:-1]  # Remove last item since this is the file name
+            current_overleaf_folder = project_infos['rootFolder'][0]['folders']  # Set the current remote folder
+
+            for local_folder in local_folders:
+                for remote_folder in current_overleaf_folder:
+                    if local_folder.lower() == remote_folder['name'].lower():
+                        file = next((v for v in remote_folder['docs'] if v['name'] == file_name.split(PATH_SEP)[-1]),
+                                    None)
+                        current_overleaf_folder = remote_folder['folders']
+                        break
+        # File is in root folder
+        else:
+            file = next((v for v in project_infos['rootFolder'][0]['docs'] if v['name'] == file_name), None)
+
+        # File not found!
+        if file is None:
+            return False
+
+        headers = {
+            "X-Csrf-Token": self._csrf
+        }
+
+        r = reqs.delete(DELETE_URL.format(project_id, file['_id']), cookies=self._cookie, headers=headers, json={})
+
+        # status_code is an int; comparing to str(204) was always False
+        # regardless of the real result, same bug class as upload_file and
+        # create_folder above.
+        return r.status_code == 204
+
+    def download_pdf(self, project_id):
+        """
+        Compiles and returns a project's PDF
+
+        Params:
+        project_id: the id of the project
+
+        Returns: PDF file name and content on success
+        """
+        headers = {
+            "X-Csrf-Token": self._csrf
+        }
+
+        body = {
+            "check": "silent",
+            "draft": False,
+            "incrementalCompilesEnabled": True,
+            "rootDoc_id": "",
+            "stopOnFirstError": False
+        }
+
+        r = reqs.post(COMPILE_URL.format(project_id), cookies=self._cookie, headers=headers, json=body)
+
+        if not r.ok:
+            raise reqs.HTTPError()
+
+        compile_result = json.loads(r.content)
+
+        if compile_result["status"] != "success":
+            raise reqs.HTTPError()
+
+        pdf_file = next(v for v in compile_result['outputFiles'] if v['type'] == 'pdf')
+
+        download_req = reqs.get(BASE_URL + pdf_file['url'], cookies=self._cookie, headers=headers)
+
+        if download_req.ok:
+            return pdf_file['path'], download_req.content
+
+        return None