From 62673302d96fee025121f5c5410e33b79e8cfc48 Mon Sep 17 00:00:00 2001 From: Zach Sailer Date: Wed, 23 Mar 2022 16:37:10 -0700 Subject: [PATCH] naming is hard --- .../services/sessions/sessionmanager.py | 54 ++++++------- tests/services/sessions/test_manager.py | 78 +++++++++---------- 2 files changed, 66 insertions(+), 66 deletions(-) diff --git a/jupyter_server/services/sessions/sessionmanager.py b/jupyter_server/services/sessions/sessionmanager.py index 70290d98a..538a0a681 100644 --- a/jupyter_server/services/sessions/sessionmanager.py +++ b/jupyter_server/services/sessions/sessionmanager.py @@ -27,14 +27,14 @@ from dataclasses import fields -class KernelRecordConflict(Exception): +class KernelSessionRecordConflict(Exception): """An exception raised when""" pass @dataclass -class KernelRecord: +class KernelSessionRecord: """A record object for tracking a Jupyter Server Kernel Session. Two records are equal if they share the @@ -43,8 +43,8 @@ class KernelRecord: session_id: Union[None, str] = None kernel_id: Union[None, str] = None - def __eq__(self, other: "KernelRecord") -> bool: - if isinstance(other, KernelRecord): + def __eq__(self, other: "KernelSessionRecord") -> bool: + if isinstance(other, KernelSessionRecord): condition1 = self.kernel_id and self.kernel_id == other.kernel_id condition2 = all( [ @@ -64,22 +64,22 @@ def __eq__(self, other: "KernelRecord") -> bool: self.kernel_id != other.kernel_id, ] ): - raise KernelRecordConflict( + raise KernelSessionRecordConflict( "A single session_id can only have one kernel_id " - "associated with. These two KernelRecords share the same " + "associated with. These two KernelSessionRecords share the same " "session_id but have different kernel_ids. This should " "not be possible and is likely an issue with the session " "records." ) return False - def update(self, other: "KernelRecord") -> None: + def update(self, other: "KernelSessionRecord") -> None: """Updates in-place a kernel from other (only accepts positive updates""" - if not isinstance(other, KernelRecord): - raise TypeError("'other' must be an instance of KernelRecord.") + if not isinstance(other, KernelSessionRecord): + raise TypeError("'other' must be an instance of KernelSessionRecord.") if other.kernel_id and self.kernel_id and other.kernel_id != self.kernel_id: - raise KernelRecordConflict( + raise KernelSessionRecordConflict( "Could not update the record from 'other' because the two records conflict." ) @@ -88,8 +88,8 @@ def update(self, other: "KernelRecord") -> None: setattr(self, field.name, getattr(other, field.name)) -class KernelRecordList: - """Handy object for storing and managing a list of KernelRecords. +class KernelSessionRecordList: + """Handy object for storing and managing a list of KernelSessionRecords. When adding a record to the list, first checks if the record already exists. If it does, the record will be updated with @@ -104,9 +104,9 @@ def __init__(self, *records): def __str__(self): return str(self._records) - def __contains__(self, record: Union[KernelRecord, str]): + def __contains__(self, record: Union[KernelSessionRecord, str]): """Search for records by kernel_id and session_id""" - if isinstance(record, KernelRecord) and record in self._records: + if isinstance(record, KernelSessionRecord) and record in self._records: return True if isinstance(record, str): @@ -118,18 +118,18 @@ def __contains__(self, record: Union[KernelRecord, str]): def __len__(self): return len(self._records) - def get(self, record: Union[KernelRecord, str]) -> KernelRecord: + def get(self, record: Union[KernelSessionRecord, str]) -> KernelSessionRecord: if isinstance(record, str): for r in self._records: if record == r.kernel_id or record == r.session_id: return r - elif isinstance(record, KernelRecord): + elif isinstance(record, KernelSessionRecord): for r in self._records: if record == r: return record - raise ValueError(f"{record} not found in KernelRecordList.") + raise ValueError(f"{record} not found in KernelSessionRecordList.") - def update(self, record: KernelRecord) -> None: + def update(self, record: KernelSessionRecord) -> None: """Update a record in-place or append it if not in the list.""" try: idx = self._records.index(record) @@ -137,7 +137,7 @@ def update(self, record: KernelRecord) -> None: except ValueError: self._records.append(record) - def remove(self, record: KernelRecord) -> None: + def remove(self, record: KernelSessionRecord) -> None: """Remove a record if its found in the list. If it's not found, do nothing. """ @@ -187,7 +187,7 @@ def _validate_database_filepath(self, proposal): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) - self._pending_kernels = KernelRecordList() + self._pending_sessions = KernelSessionRecordList() # Session database initialized below _cursor = None @@ -249,8 +249,8 @@ async def create_session( ): """Creates a session and returns its model""" session_id = self.new_session_id() - record = KernelRecord(session_id=session_id) - self._pending_kernels.update(record) + record = KernelSessionRecord(session_id=session_id) + self._pending_sessions.update(record) if kernel_id is not None and kernel_id in self.kernel_manager: pass else: @@ -258,11 +258,11 @@ async def create_session( session_id, path, name, type, kernel_name ) record.kernel_id = kernel_id - self._pending_kernels.update(record) + self._pending_sessions.update(record) result = await self.save_session( session_id, path=path, name=name, type=type, kernel_id=kernel_id ) - self._pending_kernels.remove(record) + self._pending_sessions.remove(record) return result async def start_kernel_for_session(self, session_id, path, name, type, kernel_name): @@ -441,9 +441,9 @@ async def list_sessions(self): async def delete_session(self, session_id): """Deletes the row in the session database with given session_id""" - record = KernelRecord(session_id=session_id) - self._pending_kernels.update(record) + record = KernelSessionRecord(session_id=session_id) + self._pending_sessions.update(record) session = await self.get_session(session_id=session_id) await ensure_async(self.kernel_manager.shutdown_kernel(session["kernel"]["id"])) self.cursor.execute("DELETE FROM session WHERE session_id=?", (session_id,)) - self._pending_kernels.remove(record) + self._pending_sessions.remove(record) diff --git a/tests/services/sessions/test_manager.py b/tests/services/sessions/test_manager.py index bc0625305..0e870dd8f 100644 --- a/tests/services/sessions/test_manager.py +++ b/tests/services/sessions/test_manager.py @@ -8,9 +8,9 @@ from jupyter_server._tz import utcnow from jupyter_server.services.contents.manager import ContentsManager from jupyter_server.services.kernels.kernelmanager import MappingKernelManager -from jupyter_server.services.sessions.sessionmanager import KernelRecord -from jupyter_server.services.sessions.sessionmanager import KernelRecordConflict -from jupyter_server.services.sessions.sessionmanager import KernelRecordList +from jupyter_server.services.sessions.sessionmanager import KernelSessionRecord +from jupyter_server.services.sessions.sessionmanager import KernelSessionRecordConflict +from jupyter_server.services.sessions.sessionmanager import KernelSessionRecordList from jupyter_server.services.sessions.sessionmanager import SessionManager @@ -63,10 +63,10 @@ def session_manager(): def test_kernel_record_equals(): - record1 = KernelRecord(session_id="session1") - record2 = KernelRecord(session_id="session1", kernel_id="kernel1") - record3 = KernelRecord(session_id="session2", kernel_id="kernel1") - record4 = KernelRecord(session_id="session1", kernel_id="kernel2") + record1 = KernelSessionRecord(session_id="session1") + record2 = KernelSessionRecord(session_id="session1", kernel_id="kernel1") + record3 = KernelSessionRecord(session_id="session2", kernel_id="kernel1") + record4 = KernelSessionRecord(session_id="session1", kernel_id="kernel2") assert record1 == record2 assert record2 == record3 @@ -74,55 +74,55 @@ def test_kernel_record_equals(): assert record1 != record3 assert record3 != record4 - with pytest.raises(KernelRecordConflict): + with pytest.raises(KernelSessionRecordConflict): assert record2 == record4 def test_kernel_record_update(): - record1 = KernelRecord(session_id="session1") - record2 = KernelRecord(session_id="session1", kernel_id="kernel1") + record1 = KernelSessionRecord(session_id="session1") + record2 = KernelSessionRecord(session_id="session1", kernel_id="kernel1") record1.update(record2) assert record1.kernel_id == "kernel1" - record1 = KernelRecord(session_id="session1") - record2 = KernelRecord(kernel_id="kernel1") + record1 = KernelSessionRecord(session_id="session1") + record2 = KernelSessionRecord(kernel_id="kernel1") record1.update(record2) assert record1.kernel_id == "kernel1" - record1 = KernelRecord(kernel_id="kernel1") - record2 = KernelRecord(session_id="session1") + record1 = KernelSessionRecord(kernel_id="kernel1") + record2 = KernelSessionRecord(session_id="session1") record1.update(record2) assert record1.session_id == "session1" - record1 = KernelRecord(kernel_id="kernel1") - record2 = KernelRecord(session_id="session1", kernel_id="kernel1") + record1 = KernelSessionRecord(kernel_id="kernel1") + record2 = KernelSessionRecord(session_id="session1", kernel_id="kernel1") record1.update(record2) assert record1.session_id == "session1" - record1 = KernelRecord(kernel_id="kernel1") - record2 = KernelRecord(session_id="session1", kernel_id="kernel2") - with pytest.raises(KernelRecordConflict): + record1 = KernelSessionRecord(kernel_id="kernel1") + record2 = KernelSessionRecord(session_id="session1", kernel_id="kernel2") + with pytest.raises(KernelSessionRecordConflict): record1.update(record2) - record1 = KernelRecord(kernel_id="kernel1", session_id="session1") - record2 = KernelRecord(kernel_id="kernel2") - with pytest.raises(KernelRecordConflict): + record1 = KernelSessionRecord(kernel_id="kernel1", session_id="session1") + record2 = KernelSessionRecord(kernel_id="kernel2") + with pytest.raises(KernelSessionRecordConflict): record1.update(record2) - record1 = KernelRecord(kernel_id="kernel1", session_id="session1") - record2 = KernelRecord(kernel_id="kernel2", session_id="session1") - with pytest.raises(KernelRecordConflict): + record1 = KernelSessionRecord(kernel_id="kernel1", session_id="session1") + record2 = KernelSessionRecord(kernel_id="kernel2", session_id="session1") + with pytest.raises(KernelSessionRecordConflict): record1.update(record2) - record1 = KernelRecord(session_id="session1", kernel_id="kernel1") - record2 = KernelRecord(session_id="session2", kernel_id="kernel1") + record1 = KernelSessionRecord(session_id="session1", kernel_id="kernel1") + record2 = KernelSessionRecord(session_id="session2", kernel_id="kernel1") record1.update(record2) assert record1.session_id == "session2" def test_kernel_record_list(): - records = KernelRecordList() - r = KernelRecord(kernel_id="kernel1") + records = KernelSessionRecordList() + r = KernelSessionRecord(kernel_id="kernel1") records.update(r) assert r in records assert "kernel1" in records @@ -137,12 +137,12 @@ def test_kernel_record_list(): with pytest.raises(ValueError): records.get("badkernel") - r_update = KernelRecord(kernel_id="kernel1", session_id="session1") + r_update = KernelSessionRecord(kernel_id="kernel1", session_id="session1") records.update(r_update) assert len(records) == 1 assert "session1" in records - r2 = KernelRecord(kernel_id="kernel2") + r2 = KernelSessionRecord(kernel_id="kernel2") records.update(r2) assert r2 in records assert len(records) == 2 @@ -482,23 +482,23 @@ async def test_pending_kernel(): ) task = asyncio.create_task(fut) await asyncio.sleep(0.1) - assert len(session_manager._pending_kernels) == 1 + assert len(session_manager._pending_sessions) == 1 # Get a handle on the record - record = session_manager._pending_kernels._records[0] + record = session_manager._pending_sessions._records[0] session = await task # Check that record is cleared after the task has completed. - assert record not in session_manager._pending_kernels + assert record not in session_manager._pending_sessions # Check pending kernel list when sessions are fut = session_manager.delete_session(session_id=session["id"]) task = asyncio.create_task(fut) await asyncio.sleep(0.1) - assert len(session_manager._pending_kernels) == 1 + assert len(session_manager._pending_sessions) == 1 # Get a handle on the record - record = session_manager._pending_kernels._records[0] + record = session_manager._pending_sessions._records[0] session = await task # Check that record is cleared after the task has completed. - assert record not in session_manager._pending_kernels + assert record not in session_manager._pending_sessions # Test multiple, parallel pending kernels fut1 = session_manager.create_session( @@ -511,9 +511,9 @@ async def test_pending_kernel(): await asyncio.sleep(0.1) task2 = asyncio.create_task(fut2) await asyncio.sleep(0.1) - assert len(session_manager._pending_kernels) == 2 + assert len(session_manager._pending_sessions) == 2 await task1 await task2 session1, session2 = await asyncio.gather(task1, task2) - assert len(session_manager._pending_kernels) == 0 + assert len(session_manager._pending_sessions) == 0