feat: removed all wheel building from the repo, moved it to the codemp repo directly

feat: updated the plugin to latest glue.
feat: updated the bundled wheel

Former-commit-id: 59efd17b2225c700a6144572a1d44c873d1da268

Cargo.toml

@@ -1,22 +0,0 @@
-[package]
-name = "Codemp-Sublime"
-version = "0.6.1"
-edition = "2021"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-[lib]
-name = "codemp"
-crate-type = ["cdylib"]
-
-[dependencies]
-codemp = { git = "ssh://git@github.com/hexedtech/codemp.git", branch="glue"}
-codemp-proto = { git = "ssh://git@github.com/hexedtech/codemp-proto.git", tag = "v0.6.1" }
-pyo3 = { version = "0.20", features = ["extension-module"] }
-pyo3-asyncio = { version = "0.20", features = ["tokio-runtime"] }
-serde = { version = "1.0.196", features = ["derive"] }
-tokio = "1.29.1"
-tracing = "0.1.40"
-tracing-subscriber = "0.3.18"
-
-[build-dependencies]
-pyo3-build-config = "0.20"

bindings/Codemp_Sublime-0.6.1-cp38-cp38-macosx_11_0_arm64.whl.REMOVED.git-id

@@ -1 +0,0 @@
-38750f240dab1caf464d1f46f00f09a1042fa194

bindings/codemp-0.6.2-cp38-cp38-macosx_11_0_arm64.whl.REMOVED.git-id

@@ -0,0 +1 @@
+8d0c5dec04835cf686c98fd9666f20b981450d6e

build.rs

@@ -1,5 +0,0 @@
-use pyo3_build_config;
-
-fn main() {
-    pyo3_build_config::add_extension_module_link_args();
-}

plugin.py

@@ -1,3 +1,5 @@
+# pyright: reportIncompatibleMethodOverride=false
+
 import sublime
 import sublime_plugin
 
@@ -12,7 +14,6 @@ from .src.utils import status_log
 from .src.utils import safe_listener_detach
 from .src.utils import safe_listener_attach
 from .src import globals as g
-from .bindings.codemp import init_logger
 
 TEXT_LISTENER = None
 
@@ -27,7 +28,7 @@ def plugin_loaded():
     # pass in the exit_handler coroutine that will be called upon relasing the event loop.
     tm.acquire(disconnect_client)
 
-    logger = CodempLogger(init_logger(False))
+    logger = CodempLogger()
     tm.dispatch(logger.log(), "codemp-logger")
 
     TEXT_LISTENER = CodempClientTextChangeListener()
@@ -105,18 +106,18 @@ class CodempClientViewEventListener(sublime_plugin.ViewEventListener):
         g.ACTIVE_CODEMP_VIEW = self.view.id()
         # print("view {} activated".format(self.view.id()))
         global TEXT_LISTENER
-        safe_listener_attach(TEXT_LISTENER, self.view.buffer())
+        safe_listener_attach(TEXT_LISTENER, self.view.buffer())  # pyright: ignore
 
     def on_deactivated(self):
         g.ACTIVE_CODEMP_VIEW = None
         # print("view {} deactivated".format(self.view.id()))
         global TEXT_LISTENER
-        safe_listener_detach(TEXT_LISTENER)
+        safe_listener_detach(TEXT_LISTENER)  # pyright: ignore
 
     def on_pre_close(self):
         global TEXT_LISTENER
         if self.view.id() == g.ACTIVE_CODEMP_VIEW:
-            safe_listener_detach(TEXT_LISTENER)
+            safe_listener_detach(TEXT_LISTENER)  # pyright: ignore
 
         ws = client.get_workspace(self.view)
         if ws is None:
@@ -197,7 +198,7 @@ class CodempJoinCommand(sublime_plugin.WindowCommand):
 # Join Workspace Command
 #############################################################################
 class CodempJoinWorkspaceCommand(sublime_plugin.WindowCommand):
-    def run(self, workspace_id):
+    def run(self, workspace_id):  # pyright: ignore
         tm.dispatch(client.join_workspace(workspace_id))
 
     def input_description(self):
@@ -211,7 +212,7 @@ class CodempJoinWorkspaceCommand(sublime_plugin.WindowCommand):
 # Join Buffer Command
 #############################################################################
 class CodempJoinBufferCommand(sublime_plugin.WindowCommand):
-    def run(self, buffer_id):
+    def run(self, buffer_id):  # pyright: ignore
         if client.active_workspace is None:
             sublime.error_message(
                 "You haven't joined any worksapce yet. \
@@ -265,6 +266,7 @@ class ListBufferId(sublime_plugin.ListInputHandler):
         return "buffer_id"
 
     def list_items(self):
+        assert client.active_workspace is not None
         return client.active_workspace.handle.filetree()
 
     def next_input(self, args):

src/TaskManager.py

@@ -40,15 +40,15 @@ class TaskManager:
 
         return _store
 
-    def get_task(self, name) -> Optional:
+    def get_task(self, name) -> Optional[asyncio.Task]:
         return next((t for t in self.tasks if t.get_name() == name), None)
 
-    def get_task_idx(self, name) -> Optional:
+    def get_task_idx(self, name) -> Optional[int]:
         return next(
             (i for (i, t) in enumerate(self.tasks) if t.get_name() == name), None
         )
 
-    def pop_task(self, name) -> Optional:
+    def pop_task(self, name) -> Optional[asyncio.Task]:
         idx = self.get_task_idx(name)
         if id is not None:
             return self.tasks.pop(idx)

src/client.py

@@ -8,18 +8,21 @@ import tempfile
 import os
 import shutil
 
+from codemp import (
+    init_logger,
+    codemp_init,
+    CodempBufferController,
+    CodempWorkspace,
+    Client,
+)
 from ..src import globals as g
 from ..src.TaskManager import tm
-from ..src.wrappers import BufferController, Workspace, Client
 from ..src.utils import status_log, rowcol_to_region
 
 
 class CodempLogger:
-    def __init__(self, handle):
+    def __init__(self, debug: bool = False):
-        self.handle = handle
+        self.handle = init_logger(debug)
-
-    async def message(self):
-        return await self.handle.message()
 
     async def log(self):
         status_log("spinning up the logger...")
@@ -43,7 +46,7 @@ class VirtualBuffer:
         self,
         workspace: VirtualWorkspace,
         remote_id: str,
-        buffctl: BufferController,
+        buffctl: CodempBufferController,
     ):
         self.view = sublime.active_window().new_file()
         self.codemp_id = remote_id
@@ -106,7 +109,7 @@ class VirtualBuffer:
                         "end": text_change.end_excl,
                         "content": text_change.content,
                         "change_id": self.view.change_id(),
-                    },
+                    },  # pyright: ignore
                 )
 
         except asyncio.CancelledError:
@@ -126,7 +129,9 @@ class VirtualBuffer:
                     region.begin(), region.end(), change.str
                 )
             )
-            self.buffctl.send(region.begin(), region.end()+len(change.str)-1, change.str)
+            self.buffctl.send(
+                region.begin(), region.end() + len(change.str) - 1, change.str
+            )
 
     def send_cursor(self, vws: VirtualWorkspace):
         # TODO: only the last placed cursor/selection.
@@ -141,7 +146,7 @@ class VirtualBuffer:
 # A virtual workspace is a bridge class that aims to translate
 # events that happen to the codemp workspaces into sublime actions
 class VirtualWorkspace:
-    def __init__(self, workspace_id: str, handle: Workspace):
+    def __init__(self, workspace_id: str, handle: CodempWorkspace):
         self.id = workspace_id
         self.sublime_window = sublime.active_window()
         self.handle = handle
@@ -149,8 +154,8 @@ class VirtualWorkspace:
         self.isactive = False
 
         # mapping remote ids -> local ids
-        self.id_map: dict[str, str] = {}
+        self.id_map: dict[str, int] = {}
-        self.active_buffers: dict[str, VirtualBuffer] = {}  # local_id -> VBuff
+        self.active_buffers: dict[int, VirtualBuffer] = {}  # local_id -> VBuff
 
         # initialise the virtual filesystem
         tmpdir = tempfile.mkdtemp(prefix="codemp_")
@@ -158,7 +163,7 @@ class VirtualWorkspace:
         self.rootdir = tmpdir
 
         # and add a new "project folder"
-        proj_data = self.sublime_window.project_data()
+        proj_data: dict = self.sublime_window.project_data()  # pyright: ignore
         if proj_data is None:
             proj_data = {"folders": []}
 
@@ -167,7 +172,7 @@ class VirtualWorkspace:
         )
         self.sublime_window.set_project_data(proj_data)
 
-        s: dict = self.sublime_window.settings()
+        s: dict = self.sublime_window.settings()  # pyright: ignore
         if s.get(g.CODEMP_WINDOW_TAG, False):
             s[g.CODEMP_WINDOW_WORKSPACES].append(self.id)
         else:
@@ -184,7 +189,7 @@ class VirtualWorkspace:
 
         self.active_buffers = {}  # drop all buffers, let them be garbace collected (hopefully)
 
-        d = self.sublime_window.project_data()
+        d: dict = self.sublime_window.project_data()  # pyright: ignore
         newf = list(
             filter(
                 lambda f: f.get("name", "") != f"{g.WORKSPACE_FOLDER_PREFIX}{self.id}",
@@ -216,7 +221,7 @@ class VirtualWorkspace:
         self.id_map[remote_id] = vbuff.view.buffer_id()
         self.active_buffers[vbuff.view.buffer_id()] = vbuff
 
-    def get_by_local(self, local_id: str) -> Optional[VirtualBuffer]:
+    def get_by_local(self, local_id: int) -> Optional[VirtualBuffer]:
         return self.active_buffers.get(local_id)
 
     def get_by_remote(self, remote_id: str) -> Optional[VirtualBuffer]:
@@ -290,7 +295,7 @@ class VirtualWorkspace:
 
 class VirtualClient:
     def __init__(self):
-        self.handle: Client = Client()
+        self.handle: Client = codemp_init()
         self.workspaces: dict[str, VirtualWorkspace] = {}
         self.active_workspace: Optional[VirtualWorkspace] = None
 
@@ -341,7 +346,10 @@ class VirtualClient:
         status_log(f"Connected to '{server_host}' with user id: {id}")
 
     async def join_workspace(
-        self, workspace_id: str, user=f"user-{random.random()}", password="***REMOVED***"
+        self,
+        workspace_id: str,
+        user=f"user-{random.random()}",
+        password="***REMOVED***",
     ) -> Optional[VirtualWorkspace]:
         try:
             status_log(f"Logging into workspace: '{workspace_id}' with user: {user}")

src/lib.rs

@@ -1,555 +0,0 @@
-use pyo3::types::PyList;
-use std::{format, sync::Arc};
-use tokio::sync::{mpsc, Mutex, RwLock};
-use tracing;
-use tracing_subscriber;
-
-use ::codemp::errors::Error as CodempError;
-use ::codemp::prelude::*;
-use codemp_proto::{
-    common::Identity,
-    cursor::{CursorEvent, CursorPosition},
-    files::BufferNode,
-};
-
-use pyo3::{
-    exceptions::{PyBaseException, PyConnectionError, PyRuntimeError},
-    prelude::*,
-    types::{PyString, PyType},
-};
-
-// ERRORS And LOGGING ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-struct PyCodempError(CodempError);
-impl From<CodempError> for PyCodempError {
-    fn from(err: CodempError) -> Self {
-        PyCodempError(err)
-    }
-}
-
-impl From<PyCodempError> for PyErr {
-    fn from(err: PyCodempError) -> PyErr {
-        match err.0 {
-            CodempError::Transport { status, message } => {
-                PyConnectionError::new_err(format!("Transport error: ({}) {}", status, message))
-            }
-            CodempError::Channel { send } => {
-                PyConnectionError::new_err(format!("Channel error (send:{})", send))
-            }
-            CodempError::InvalidState { msg } => {
-                PyRuntimeError::new_err(format!("Invalid state: {}", msg))
-            }
-            CodempError::Deadlocked => PyRuntimeError::new_err(format!("Deadlock, retry.")),
-            CodempError::Filler { message } => {
-                PyBaseException::new_err(format!("Generic error: {}", message))
-            }
-        }
-    }
-}
-
-#[derive(Debug, Clone)]
-struct LoggerProducer(mpsc::Sender<String>);
-
-impl std::io::Write for LoggerProducer {
-    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
-        // TODO this is a LOSSY logger!!
-        let _ = self.0.try_send(String::from_utf8_lossy(buf).to_string()); // ignore: logger disconnected or with full buffer
-        Ok(buf.len())
-    }
-
-    fn flush(&mut self) -> std::io::Result<()> {
-        Ok(())
-    }
-}
-
-#[pyclass]
-struct PyLogger(Arc<Mutex<mpsc::Receiver<String>>>);
-
-#[pymethods]
-impl PyLogger {
-    fn message<'a>(&'a self, py: Python<'a>) -> PyResult<&'a PyAny> {
-        let rc = self.0.clone();
-
-        pyo3_asyncio::tokio::future_into_py(py, async move { Ok(rc.lock().await.recv().await) })
-    }
-}
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-// Workflow:
-// We first spin up an empty handler, that can connect to a server, and create a client.
-// We then use the client, to login into a workspace, and join it, obtaining a workspace object
-// We will then use that workspace object to interact with the buffers in that workspace.
-// In steps:
-//  1. Get Object that can initiate a connection
-//  2. Connect to a server
-//  3. Login to a workspace
-//  4. Join a workspace/get an already joined workspace
-//  5. Create a new buffer/attach to an existing one
-
-#[pyfunction]
-fn codemp_init<'a>(py: Python<'a>) -> PyResult<Py<PyClient>> {
-    Ok(Py::new(py, PyClient::default())?)
-}
-
-#[pyfunction]
-fn init_logger(py: Python<'_>, debug: Option<bool>) -> PyResult<Py<PyLogger>> {
-    let (tx, rx) = mpsc::channel(256);
-    let level = if debug.unwrap_or(false) {
-        tracing::Level::DEBUG
-    } else {
-        tracing::Level::INFO
-    };
-
-    let format = tracing_subscriber::fmt::format()
-        .without_time()
-        .with_level(true)
-        .with_target(true)
-        .with_thread_ids(false)
-        .with_thread_names(false)
-        .with_file(false)
-        .with_line_number(false)
-        .with_source_location(false)
-        .compact();
-
-    let _ = tracing_subscriber::fmt()
-        .with_ansi(false)
-        .event_format(format)
-        .with_max_level(level)
-        .with_writer(std::sync::Mutex::new(LoggerProducer(tx)))
-        .try_init();
-
-    Ok(Py::new(py, PyLogger(Arc::new(Mutex::new(rx))))?)
-}
-
-#[pyclass]
-struct PyClient(Arc<RwLock<Option<CodempClient>>>);
-
-impl Default for PyClient {
-    fn default() -> Self {
-        PyClient(Arc::new(RwLock::new(None)))
-    }
-}
-
-impl From<CodempClient> for PyClient {
-    fn from(value: CodempClient) -> Self {
-        PyClient(RwLock::new(Some(value)).into())
-    }
-}
-
-#[pymethods]
-impl PyClient {
-    fn connect<'a>(&'a self, py: Python<'a>, dest: String) -> PyResult<&'a PyAny> {
-        let cli = self.0.clone();
-
-        pyo3_asyncio::tokio::future_into_py(py, async move {
-            let client: CodempClient = CodempClient::new(dest.as_str())
-                .await
-                .map_err(PyCodempError::from)?;
-
-            let _ = cli.write().await.insert(client);
-
-            Ok(())
-        })
-    }
-
-    fn login<'a>(
-        &'a self,
-        py: Python<'a>,
-        user: String,
-        password: String,
-        workspace_id: Option<String>,
-    ) -> PyResult<&'a PyAny> {
-        let rc = self.0.clone();
-        pyo3_asyncio::tokio::future_into_py(py, async move {
-            let cli = rc.read().await;
-            if cli.is_none() {
-                return Err(PyConnectionError::new_err("Connect to a server first."));
-            };
-
-            cli.as_ref()
-                .unwrap()
-                .login(user, password, workspace_id)
-                .await
-                .map_err(PyCodempError::from)?;
-
-            Ok(())
-        })
-    }
-
-    fn join_workspace<'a>(&'a self, py: Python<'a>, workspace: String) -> PyResult<&'a PyAny> {
-        let rc = self.0.clone();
-
-        pyo3_asyncio::tokio::future_into_py(py, async move {
-            let mut cli = rc.write().await;
-            if cli.is_none() {
-                return Err(PyConnectionError::new_err("Connect to a server first."));
-            };
-
-            let workspace: PyWorkspace = cli
-                .as_mut()
-                .unwrap()
-                .join_workspace(workspace.as_str())
-                .await
-                .map_err(PyCodempError::from)?
-                .into();
-
-            Python::with_gil(|py| Ok(Py::new(py, workspace)?))
-        })
-    }
-
-    // join a workspace
-    fn get_workspace<'a>(&'a self, py: Python<'a>, id: String) -> PyResult<&'a PyAny> {
-        let rc = self.0.clone();
-
-        pyo3_asyncio::tokio::future_into_py(py, async move {
-            let cli = rc.read().await;
-            if cli.is_none() {
-                return Err(PyConnectionError::new_err("Connect to a server first."));
-            };
-
-            let Some(ws) = cli.as_ref().unwrap().get_workspace(id.as_str()) else {
-                return Ok(None);
-            };
-
-            Python::with_gil(|py| Ok(Some(Py::new(py, PyWorkspace(ws))?)))
-        })
-    }
-
-    fn user_id<'a>(&'a self, py: Python<'a>) -> PyResult<&'a PyAny> {
-        let rc = self.0.clone();
-        pyo3_asyncio::tokio::future_into_py(py, async move {
-            let cli = rc.read().await;
-            if cli.is_none() {
-                return Err(PyConnectionError::new_err("Connect to a server first."));
-            };
-            let id = cli.as_ref().unwrap().user_id().to_string();
-
-            Python::with_gil(|py| {
-                let id: Py<PyString> = PyString::new(py, id.as_str()).into_py(py);
-                Ok(id)
-            })
-        })
-    }
-}
-
-#[pyclass]
-struct PyWorkspace(Arc<CodempWorkspace>);
-
-impl From<Arc<CodempWorkspace>> for PyWorkspace {
-    fn from(value: Arc<CodempWorkspace>) -> Self {
-        PyWorkspace(value)
-    }
-}
-
-#[pymethods]
-impl PyWorkspace {
-    // join a workspace
-    fn create<'a>(&'a self, py: Python<'a>, path: String) -> PyResult<&'a PyAny> {
-        let ws = self.0.clone();
-
-        pyo3_asyncio::tokio::future_into_py(py, async move {
-            ws.create(path.as_str())
-                .await
-                .map_err(PyCodempError::from)?;
-            Ok(())
-        })
-    }
-
-    fn attach<'a>(&'a self, py: Python<'a>, path: String) -> PyResult<&'a PyAny> {
-        let ws = self.0.clone();
-
-        pyo3_asyncio::tokio::future_into_py(py, async move {
-            let buffctl: PyBufferController = ws
-                .attach(path.as_str())
-                .await
-                .map_err(PyCodempError::from)?
-                .into();
-            Python::with_gil(|py| Ok(Py::new(py, buffctl)?))
-        })
-    }
-
-    fn fetch_buffers<'a>(&'a self, py: Python<'a>) -> PyResult<&'a PyAny> {
-        let ws = self.0.clone();
-
-        pyo3_asyncio::tokio::future_into_py(py, async move {
-            ws.fetch_buffers().await.map_err(PyCodempError::from)?;
-            Ok(())
-        })
-    }
-
-    fn fetch_users<'a>(&'a self, py: Python<'a>) -> PyResult<&'a PyAny> {
-        let ws = self.0.clone();
-
-        pyo3_asyncio::tokio::future_into_py(py, async move {
-            ws.fetch_users().await.map_err(PyCodempError::from)?;
-            Ok(())
-        })
-    }
-
-    fn list_buffer_users<'a>(&'a self, py: Python<'a>, path: String) -> PyResult<&'a PyAny> {
-        let ws = self.0.clone();
-
-        pyo3_asyncio::tokio::future_into_py(py, async move {
-            let usrlist: Vec<PyId> = ws
-                .list_buffer_users(path.as_str())
-                .await
-                .map_err(PyCodempError::from)?
-                .into_iter()
-                .map(PyId::from)
-                .collect();
-
-            Ok(usrlist)
-        })
-    }
-
-    fn delete<'a>(&'a self, py: Python<'a>, path: String) -> PyResult<&'a PyAny> {
-        let ws = self.0.clone();
-
-        pyo3_asyncio::tokio::future_into_py(py, async move {
-            ws.delete(path.as_str())
-                .await
-                .map_err(PyCodempError::from)?;
-            Ok(())
-        })
-    }
-
-    fn id(&self, py: Python<'_>) -> Py<PyString> {
-        PyString::new(py, self.0.id().as_str()).into()
-    }
-
-    fn cursor(&self, py: Python<'_>) -> PyResult<Py<PyCursorController>> {
-        Ok(Py::new(py, PyCursorController::from(self.0.cursor()))?)
-    }
-
-    fn buffer_by_name(
-        &self,
-        py: Python<'_>,
-        path: String,
-    ) -> PyResult<Option<Py<PyBufferController>>> {
-        let Some(bufctl) = self.0.buffer_by_name(path.as_str()) else {
-            return Ok(None);
-        };
-
-        Ok(Some(Py::new(py, PyBufferController::from(bufctl))?))
-    }
-
-    fn filetree(&self, py: Python<'_>) -> Py<PyList> {
-        PyList::new(py, self.0.filetree()).into_py(py)
-    }
-}
-
-/* ########################################################################### */
-
-#[pyclass]
-struct PyCursorController(Arc<CodempCursorController>);
-
-impl From<Arc<CodempCursorController>> for PyCursorController {
-    fn from(value: Arc<CodempCursorController>) -> Self {
-        PyCursorController(value)
-    }
-}
-
-#[pymethods]
-impl PyCursorController {
-    fn send<'a>(&'a self, path: String, start: (i32, i32), end: (i32, i32)) -> PyResult<()> {
-        let pos = CursorPosition {
-            buffer: BufferNode { path },
-            start: start.into(),
-            end: end.into(),
-        };
-
-        Ok(self.0.send(pos).map_err(PyCodempError::from)?)
-    }
-
-    fn try_recv(&self, py: Python<'_>) -> PyResult<PyObject> {
-        match self.0.try_recv().map_err(PyCodempError::from)? {
-            Some(cur_event) => {
-                let evt = PyCursorEvent::from(cur_event);
-                Ok(evt.into_py(py))
-            }
-            None => Ok(py.None()),
-        }
-    }
-
-    fn recv<'a>(&'a self, py: Python<'a>) -> PyResult<&'a PyAny> {
-        let rc = self.0.clone();
-
-        pyo3_asyncio::tokio::future_into_py(py, async move {
-            let cur_event: PyCursorEvent = rc.recv().await.map_err(PyCodempError::from)?.into();
-            Python::with_gil(|py| Ok(Py::new(py, cur_event)?))
-        })
-    }
-
-    fn poll<'a>(&'a self, py: Python<'a>) -> PyResult<&'a PyAny> {
-        let rc = self.0.clone();
-
-        pyo3_asyncio::tokio::future_into_py(py, async move {
-            Ok(rc.poll().await.map_err(PyCodempError::from)?)
-        })
-    }
-}
-
-#[pyclass]
-struct PyBufferController(Arc<CodempBufferController>);
-
-impl From<Arc<CodempBufferController>> for PyBufferController {
-    fn from(value: Arc<CodempBufferController>) -> Self {
-        PyBufferController(value)
-    }
-}
-
-#[pymethods]
-impl PyBufferController {
-    fn content<'a>(&self, py: Python<'a>) -> &'a PyString {
-        PyString::new(py, self.0.content().as_str())
-    }
-
-    fn send(&self, start: usize, end: usize, txt: String) -> PyResult<()> {
-        let op = CodempTextChange {
-            span: start..end,
-            content: txt.into(),
-        };
-        Ok(self.0.send(op).map_err(PyCodempError::from)?)
-    }
-
-    fn try_recv(&self, py: Python<'_>) -> PyResult<PyObject> {
-        match self.0.try_recv().map_err(PyCodempError::from)? {
-            Some(txt_change) => {
-                let evt = PyTextChange::from(txt_change);
-                Ok(evt.into_py(py))
-            }
-            None => Ok(py.None()),
-        }
-    }
-
-    fn recv<'a>(&'a self, py: Python<'a>) -> PyResult<&'a PyAny> {
-        let rc = self.0.clone();
-
-        pyo3_asyncio::tokio::future_into_py(py, async move {
-            let txt_change: PyTextChange = rc.recv().await.map_err(PyCodempError::from)?.into();
-            Python::with_gil(|py| Ok(Py::new(py, txt_change)?))
-        })
-    }
-
-    fn poll<'a>(&'a self, py: Python<'a>) -> PyResult<&'a PyAny> {
-        let rc = self.0.clone();
-
-        pyo3_asyncio::tokio::future_into_py(py, async move {
-            Ok(rc.poll().await.map_err(PyCodempError::from)?)
-        })
-    }
-}
-
-/* ---------- Type Wrappers ----------*/
-// All these objects are not meant to be handled rust side.
-// Just to be sent to the python heap.
-
-#[pyclass]
-struct PyId {
-    #[pyo3(get, set)]
-    id: String,
-}
-
-impl From<Identity> for PyId {
-    fn from(value: Identity) -> Self {
-        PyId { id: value.id }
-    }
-}
-
-#[pyclass]
-struct PyCursorEvent {
-    #[pyo3(get, set)]
-    user: String,
-
-    #[pyo3(get, set)]
-    buffer: String,
-
-    #[pyo3(get, set)]
-    start: (i32, i32),
-
-    #[pyo3(get, set)]
-    end: (i32, i32),
-}
-
-impl From<CursorEvent> for PyCursorEvent {
-    fn from(value: CursorEvent) -> Self {
-        // todo, handle this optional better?
-        let pos = value.position;
-        PyCursorEvent {
-            user: value.user.id,
-            buffer: pos.buffer.path,
-            start: pos.start.into(),
-            end: pos.end.into(),
-        }
-    }
-}
-
-#[pyclass]
-struct PyTextChange(CodempTextChange);
-
-impl From<CodempTextChange> for PyTextChange {
-    fn from(value: CodempTextChange) -> Self {
-        PyTextChange(value)
-    }
-}
-
-#[pymethods]
-impl PyTextChange {
-    #[getter]
-    fn start_incl(&self) -> PyResult<usize> {
-        Ok(self.0.span.start)
-    }
-
-    #[getter]
-    fn end_excl(&self) -> PyResult<usize> {
-        Ok(self.0.span.end)
-    }
-
-    #[getter]
-    fn content(&self) -> PyResult<String> {
-        Ok(self.0.content.clone())
-    }
-
-    fn is_deletion(&self) -> bool {
-        self.0.is_deletion()
-    }
-
-    fn is_addition(&self) -> bool {
-        self.0.is_addition()
-    }
-
-    fn is_empty(&self) -> bool {
-        self.0.is_empty()
-    }
-
-    fn apply(&self, txt: &str) -> String {
-        self.0.apply(txt)
-    }
-
-    #[classmethod]
-    fn from_diff(_cls: &PyType, before: &str, after: &str) -> PyTextChange {
-        PyTextChange(CodempTextChange::from_diff(before, after))
-    }
-
-    #[classmethod]
-    fn index_to_rowcol(_cls: &PyType, txt: &str, index: usize) -> (i32, i32) {
-        CodempTextChange::index_to_rowcol(txt, index).into()
-    }
-}
-
-/* ------ Python module --------*/
-#[pymodule]
-fn codemp(_py: Python, m: &PyModule) -> PyResult<()> {
-    m.add_function(wrap_pyfunction!(codemp_init, m)?)?;
-    m.add_function(wrap_pyfunction!(init_logger, m)?)?;
-    m.add_class::<PyClient>()?;
-    m.add_class::<PyWorkspace>()?;
-    m.add_class::<PyCursorController>()?;
-    m.add_class::<PyBufferController>()?;
-    m.add_class::<PyLogger>()?;
-
-    m.add_class::<PyId>()?;
-    m.add_class::<PyCursorEvent>()?;
-    m.add_class::<PyTextChange>()?;
-
-    Ok(())
-}

src/wrappers.py

@@ -1,101 +0,0 @@
-from __future__ import annotations
-from typing import Optional
-from ..bindings.codemp import codemp_init, PyCursorEvent, PyTextChange, PyId
-
-######################################################################################
-# These are helper wrappers, that wrap the coroutines returned from the
-# pyo3 bindings into usable awaitable functions.
-# These should not be directly extended but rather use the higher
-# level "virtual" counterparts above.
-
-# All methods, without an explicit 'noexcept' are to be treated as failable
-# and can throw an error
-
-
-class CursorController:
-    def __init__(self, handle) -> None:  # noexcept
-        self.handle = handle
-
-    def send(self, path: str, start: tuple[int, int], end: tuple[int, int]) -> None:
-        self.handle.send(path, start, end)
-
-    def try_recv(self) -> Optional[PyCursorEvent]:
-        return self.handle.try_recv()
-
-    async def recv(self) -> PyCursorEvent:
-        return await self.handle.recv()
-
-    async def poll(self) -> None:
-        return await self.handle.poll()
-
-
-class BufferController:
-    def __init__(self, handle) -> None:  # noexcept
-        self.handle = handle
-
-    def send(self, start: int, end: int, txt: str) -> None:
-        self.handle.send(start, end, txt)
-
-    def try_recv(self) -> Optional[PyTextChange]:
-        return self.handle.try_recv()
-
-    async def recv(self) -> PyTextChange:
-        return await self.handle.recv()
-
-    async def poll(self) -> None:
-        return await self.handle.poll()
-
-
-class Workspace:
-    def __init__(self, handle) -> None:  # noexcept
-        self.handle = handle
-
-    async def create(self, path: str) -> None:
-        await self.handle.create(path)
-
-    async def attach(self, path: str) -> BufferController:
-        return BufferController(await self.handle.attach(path))
-
-    async def fetch_buffers(self) -> None:
-        await self.handle.fetch_buffers()
-
-    async def fetch_users(self) -> None:
-        await self.handle.fetch_users()
-
-    async def list_buffer_users(self, path: str) -> list[PyId]:
-        return await self.handle.list_buffer_users(path)
-
-    async def delete(self, path) -> None:
-        await self.handle.delete(path)
-
-    def id(self) -> str:  # noexcept
-        return self.handle.id()
-
-    def cursor(self) -> CursorController:
-        return CursorController(self.handle.cursor())
-
-    def buffer_by_name(self, path) -> BufferController:
-        return BufferController(self.handle.buffer_by_name(path))
-
-    def filetree(self) -> list[str]:  # noexcept
-        return self.handle.filetree()
-
-
-class Client:
-    def __init__(self) -> None:
-        self.handle = codemp_init()
-
-    async def connect(self, server_host: str) -> None:
-        await self.handle.connect(server_host)
-
-    async def login(self, user: str, password: str, workspace: Optional[str]) -> None:
-        await self.handle.login(user, password, workspace)
-
-    async def join_workspace(self, workspace: str) -> Workspace:
-        return Workspace(await self.handle.join_workspace(workspace))
-
-    async def get_workspace(self, id: str) -> Optional[Workspace]:
-        return Workspace(await self.handle.get_workspace(id))
-
-    async def user_id(self) -> str:
-        return await self.handle.user_id()