fps_file_id 0.1.0__tar.gz

fps_file_id-0.1.0/.gitignore

@@ -0,0 +1,349 @@
+
+# Created by https://www.toptal.com/developers/gitignore/api/git,linux,macos,python,windows,pycharm,jupyternotebook,vscode
+# Edit at https://www.toptal.com/developers/gitignore?templates=git,linux,macos,python,windows,pycharm,jupyternotebook,vscode
+
+.fps_cli_args.toml
+
+### Git ###
+# Created by git for backups. To disable backups in Git:
+# $ git config --global mergetool.keepBackup false
+*.orig
+
+# Created by git when using merge tools for conflicts
+*.BACKUP.*
+*.BASE.*
+*.LOCAL.*
+*.REMOTE.*
+*_BACKUP_*.txt
+*_BASE_*.txt
+*_LOCAL_*.txt
+*_REMOTE_*.txt
+
+#!! ERROR: jupyternotebook is undefined. Use list command to see defined gitignore types !!#
+
+### Linux ###
+*~
+
+# temporary files which can be created if a process still has a handle open of a deleted file
+.fuse_hidden*
+
+# KDE directory preferences
+.directory
+
+# Linux trash folder which might appear on any partition or disk
+.Trash-*
+
+# .nfs files are created when an open file is removed but is still being accessed
+.nfs*
+
+### macOS ###
+# General
+.DS_Store
+.AppleDouble
+.LSOverride
+
+# Icon must end with two \r
+Icon
+
+
+# Thumbnails
+._*
+
+# Files that might appear in the root of a volume
+.DocumentRevisions-V100
+.fseventsd
+.Spotlight-V100
+.TemporaryItems
+.Trashes
+.VolumeIcon.icns
+.com.apple.timemachine.donotpresent
+
+# Directories potentially created on remote AFP share
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+.apdisk
+
+### PyCharm ###
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio, WebStorm and Rider
+# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
+
+# User-specific stuff
+.idea/**/workspace.xml
+.idea/**/tasks.xml
+.idea/**/usage.statistics.xml
+.idea/**/dictionaries
+.idea/**/shelf
+
+# AWS User-specific
+.idea/**/aws.xml
+
+# Generated files
+.idea/**/contentModel.xml
+
+# Sensitive or high-churn files
+.idea/**/dataSources/
+.idea/**/dataSources.ids
+.idea/**/dataSources.local.xml
+.idea/**/sqlDataSources.xml
+.idea/**/dynamic.xml
+.idea/**/uiDesigner.xml
+.idea/**/dbnavigator.xml
+
+# Gradle
+.idea/**/gradle.xml
+.idea/**/libraries
+
+# Gradle and Maven with auto-import
+# When using Gradle or Maven with auto-import, you should exclude module files,
+# since they will be recreated, and may cause churn.  Uncomment if using
+# auto-import.
+# .idea/artifacts
+# .idea/compiler.xml
+# .idea/jarRepositories.xml
+# .idea/modules.xml
+# .idea/*.iml
+# .idea/modules
+# *.iml
+# *.ipr
+
+# CMake
+cmake-build-*/
+
+# Mongo Explorer plugin
+.idea/**/mongoSettings.xml
+
+# File-based project format
+*.iws
+
+# IntelliJ
+out/
+
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Cursive Clojure plugin
+.idea/replstate.xml
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+fabric.properties
+
+# Editor-based Rest Client
+.idea/httpRequests
+
+# Android studio 3.1+ serialized cache file
+.idea/caches/build_file_checksums.ser
+
+### PyCharm Patch ###
+# Comment Reason: https://github.com/joeblau/gitignore.io/issues/186#issuecomment-215987721
+
+# *.iml
+# modules.xml
+# .idea/misc.xml
+# *.ipr
+
+# Sonarlint plugin
+# https://plugins.jetbrains.com/plugin/7973-sonarlint
+.idea/**/sonarlint/
+
+# SonarQube Plugin
+# https://plugins.jetbrains.com/plugin/7238-sonarqube-community-plugin
+.idea/**/sonarIssues.xml
+
+# Markdown Navigator plugin
+# https://plugins.jetbrains.com/plugin/7896-markdown-navigator-enhanced
+.idea/**/markdown-navigator.xml
+.idea/**/markdown-navigator-enh.xml
+.idea/**/markdown-navigator/
+
+# Cache file creation bug
+# See https://youtrack.jetbrains.com/issue/JBR-2257
+.idea/$CACHE_FILE$
+
+# CodeStream plugin
+# https://plugins.jetbrains.com/plugin/12206-codestream
+.idea/codestream.xml
+
+### Python ###
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+#!! ERROR: vscode is undefined. Use list command to see defined gitignore types !!#
+
+### Windows ###
+# Windows thumbnail cache files
+Thumbs.db
+Thumbs.db:encryptable
+ehthumbs.db
+ehthumbs_vista.db
+
+# Dump file
+*.stackdump
+
+# Folder config file
+[Dd]esktop.ini
+
+# Recycle Bin used on file shares
+$RECYCLE.BIN/
+
+# Windows Installer files
+*.cab
+*.msi
+*.msix
+*.msm
+*.msp
+
+# Windows shortcuts
+*.lnk
+
+# End of https://www.toptal.com/developers/gitignore/api/git,linux,macos,python,windows,pycharm,jupyternotebook,vscode
+
+.jupyter_ystore.db
+.jupyter_ystore.db-journal
+fps_cli_args.toml
+
+# pixi environments
+.pixi

fps_file_id-0.1.0/COPYING.md

@@ -0,0 +1,59 @@
+# Licensing terms
+
+This project is licensed under the terms of the Modified BSD License
+(also known as New or Revised or 3-Clause BSD), as follows:
+
+- Copyright (c) 2025-, Jupyter Development Team
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this
+list of conditions and the following disclaimer.
+
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+Neither the name of the Jupyter Development Team nor the names of its
+contributors may be used to endorse or promote products derived from this
+software without specific prior written permission.
+
+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.
+
+## About the Jupyter Development Team
+
+The Jupyter Development Team is the set of all contributors to the Jupyter project.
+This includes all of the Jupyter subprojects.
+
+The core team that coordinates development on GitHub can be found here:
+https://github.com/jupyter/.
+
+## Our Copyright Policy
+
+Jupyter uses a shared copyright model. Each contributor maintains copyright
+over their contributions to Jupyter. But, it is important to note that these
+contributions are typically only changes to the repositories. Thus, the Jupyter
+source code, in its entirety is not the copyright of any single person or
+institution. Instead, it is the collective copyright of the entire Jupyter
+Development Team. If individual contributors want to maintain a record of what
+changes/contributions they have specific copyright on, they should indicate
+their copyright in the commit message of the change, when they commit the
+change to one of the Jupyter repositories.
+
+With this in mind, the following banner should be used in any source code file
+to indicate the copyright and license terms:
+
+    # Copyright (c) Jupyter Development Team.
+    # Distributed under the terms of the Modified BSD License.

fps_file_id-0.1.0/PKG-INFO

@@ -0,0 +1,19 @@
+Metadata-Version: 2.4
+Name: fps_file_id
+Version: 0.1.0
+Summary: An FPS plugin for the file ID API
+Project-URL: Homepage, https://jupyter.org
+Author-email: Jupyter Development Team <jupyter@googlegroups.com>
+License: BSD 3-Clause License
+License-File: COPYING.md
+Keywords: fastapi,jupyter,plugins,server
+Requires-Python: >=3.9
+Requires-Dist: anyio<5,>=3.6.2
+Requires-Dist: jupyverse-api<0.10.0,>=0.9.0
+Requires-Dist: sqlite-anyio<0.3.0,>=0.2.0
+Requires-Dist: watchfiles<2,>=1.0.4
+Description-Content-Type: text/markdown
+
+# fps-contents
+
+An FPS plugin for the file ID API.

fps_file_id-0.1.0/README.md

@@ -0,0 +1,3 @@
+# fps-contents
+
+An FPS plugin for the file ID API.

fps_file_id-0.1.0/fps_file_id/__init__.py

@@ -0,0 +1,6 @@
+import importlib.metadata
+
+try:
+    __version__ = importlib.metadata.version("fps_file_id")
+except importlib.metadata.PackageNotFoundError:
+    __version__ = "unknown"

fps_file_id-0.1.0/fps_file_id/file_id.py

@@ -0,0 +1,229 @@
+from __future__ import annotations
+
+import logging
+import sqlite3
+from uuid import uuid4
+
+import structlog
+from anyio import Event, Lock, Path
+from sqlite_anyio import connect
+from watchfiles import Change, awatch
+
+from jupyverse_api.file_id import FileId
+
+logger = structlog.get_logger()
+watchfiles_logger = logging.getLogger("watchfiles")
+watchfiles_logger.setLevel(logging.WARNING)
+
+
+class Watcher:
+    def __init__(self, path: str) -> None:
+        self.path = path
+        self._event = Event()
+
+    def __aiter__(self):
+        return self
+
+    async def __anext__(self):
+        await self._event.wait()
+        self._event = Event()
+        return self._change
+
+    def notify(self, change):
+        self._change = change
+        self._event.set()
+
+
+class _FileId(FileId):
+    db_path: str
+    initialized: Event
+    watchers: dict[str, list[Watcher]]
+    lock: Lock
+
+    def __init__(self, db_path: str = ".fileid.db"):
+        self.db_path = db_path
+        self.initialized = Event()
+        self.watchers = {}
+        self.stop_event = Event()
+        self.lock = Lock()
+
+    async def start(self) -> None:
+        self._db = await connect(self.db_path)
+        try:
+            await self.watch_files()
+        except sqlite3.ProgrammingError:
+            pass
+
+    async def stop(self) -> None:
+        await self._db.close()
+        self.stop_event.set()
+
+    async def get_id(self, path: str) -> str | None:
+        await self.initialized.wait()
+        async with self.lock:
+            cursor = await self._db.cursor()
+            await cursor.execute("SELECT id FROM fileids WHERE path = ?", (path,))
+            for (idx,) in await cursor.fetchall():
+                return idx
+            return None
+
+    async def get_path(self, idx: str) -> str | None:
+        await self.initialized.wait()
+        async with self.lock:
+            cursor = await self._db.cursor()
+            await cursor.execute("SELECT path FROM fileids WHERE id = ?", (idx,))
+            for (path,) in await cursor.fetchall():
+                return path
+            return None
+
+    async def index(self, path: str) -> str | None:
+        await self.initialized.wait()
+        async with self.lock:
+            apath = Path(path)
+            if not await apath.exists():
+                return None
+
+            idx = uuid4().hex
+            mtime = (await apath.stat()).st_mtime
+            cursor = await self._db.cursor()
+            await cursor.execute("INSERT INTO fileids VALUES (?, ?, ?)", (idx, path, mtime))
+            await self._db.commit()
+            return idx
+
+    async def watch_files(self):
+        async with self.lock:
+            cursor = await self._db.cursor()
+            await cursor.execute("DROP TABLE IF EXISTS fileids")
+            await cursor.execute(
+                "CREATE TABLE fileids "
+                "(id TEXT PRIMARY KEY, path TEXT NOT NULL UNIQUE, mtime REAL NOT NULL)"
+            )
+            await self._db.commit()
+
+        # index files
+        async with self.lock:
+            cursor = await self._db.cursor()
+            async for path in Path().rglob("*"):
+                idx = uuid4().hex
+                try:
+                    mtime = (await path.stat()).st_mtime
+                except FileNotFoundError:
+                    pass
+                else:
+                    await cursor.execute(
+                        "INSERT INTO fileids VALUES (?, ?, ?)", (idx, str(path), mtime)
+                    )
+            await self._db.commit()
+            self.initialized.set()
+
+        async for changes in awatch(".", stop_event=self.stop_event):
+            async with self.lock:
+                deleted_paths = set()
+                added_paths = set()
+                cursor = await self._db.cursor()
+                for change, changed_path in changes:
+                    # get relative path
+                    changed_path = Path(changed_path).relative_to(await Path().absolute())
+                    changed_path_str = str(changed_path)
+
+                    if change == Change.deleted:
+                        logger.debug("File was deleted", path=changed_path_str)
+                        await cursor.execute(
+                            "SELECT COUNT(*) FROM fileids WHERE path = ?", (changed_path_str,)
+                        )
+                        if not (await cursor.fetchone())[0]:
+                            # path is not indexed, ignore
+                            logger.debug(
+                                "File is not indexed, ignoring",
+                                path=changed_path_str,
+                            )
+                            continue
+                        # path is indexed
+                        await maybe_rename(
+                            self._db, changed_path_str, deleted_paths, added_paths, False
+                        )
+                    elif change == Change.added:
+                        logger.debug("File was added", path=changed_path_str)
+                        await maybe_rename(
+                            self._db, changed_path_str, added_paths, deleted_paths, True
+                        )
+                    elif change == Change.modified:
+                        logger.debug("File was modified", path=changed_path_str)
+                        if changed_path_str == self.db_path:
+                            continue
+                        await cursor.execute(
+                            "SELECT COUNT(*) FROM fileids WHERE path = ?", (changed_path_str,)
+                        )
+                        if not (await cursor.fetchone())[0]:
+                            # path is not indexed, ignore
+                            logger.debug(
+                                "File is not indexed, ignoring",
+                                path=changed_path_str,
+                            )
+                            continue
+                        mtime = (await changed_path.stat()).st_mtime
+                        await cursor.execute(
+                            "UPDATE fileids SET mtime = ? WHERE path = ?",
+                            (mtime, changed_path_str),
+                        )
+
+                for path in deleted_paths - added_paths:
+                    logger.debug("Unindexing file", path=path)
+                    await cursor.execute("DELETE FROM fileids WHERE path = ?", (path,))
+                await self._db.commit()
+
+            for change in changes:
+                changed_path = change[1]
+                # get relative path
+                relative_changed_path = str(Path(changed_path).relative_to(await Path().absolute()))
+                relative_change = (change[0], relative_changed_path)
+                for watcher in self.watchers.get(relative_changed_path, []):
+                    watcher.notify(relative_change)
+
+    def watch(self, path: str) -> Watcher:
+        watcher = Watcher(path)
+        self.watchers.setdefault(path, []).append(watcher)
+        return watcher
+
+    def unwatch(self, path: str, watcher: Watcher):
+        self.watchers[path].remove(watcher)
+
+
+async def get_mtime(path, db) -> float | None:
+    if db:
+        cursor = await db.cursor()
+        await cursor.execute("SELECT mtime FROM fileids WHERE path = ?", (path,))
+        for (mtime,) in await cursor.fetchall():
+            return mtime
+        # deleted file is not in database, shouldn't happen
+        return None
+    try:
+        mtime = (await Path(path).stat()).st_mtime
+    except FileNotFoundError:
+        return None
+    return mtime
+
+
+async def maybe_rename(
+    db, changed_path: str, changed_paths: set[str], other_paths: set[str], is_added_path: bool
+) -> None:
+    # check if the same file was added/deleted, this would be a rename
+    db_or_fs1, db_or_fs2 = db, None
+    if is_added_path:
+        db_or_fs1, db_or_fs2 = db_or_fs2, db_or_fs1
+    mtime1 = await get_mtime(changed_path, db_or_fs1)
+    if mtime1 is None:
+        return
+    for other_path in other_paths:
+        mtime2 = await get_mtime(other_path, db_or_fs2)
+        if mtime1 == mtime2:
+            # same files, according to modification times
+            path1, path2 = changed_path, other_path
+            if is_added_path:
+                path1, path2 = path2, path1
+            logger.debug("File was renamed", from_path=path1, to_path=path2)
+            cursor = await db.cursor()
+            await cursor.execute("UPDATE fileids SET path = ? WHERE path = ?", (path2, path1))
+            other_paths.remove(other_path)
+            return
+    changed_paths.add(changed_path)

fps_file_id-0.1.0/fps_file_id/main.py

@@ -0,0 +1,16 @@
+from anyio import create_task_group
+from fps import Module
+
+from jupyverse_api.file_id import FileId
+
+from .file_id import _FileId
+
+
+class FileIdModule(Module):
+    async def prepare(self) -> None:
+        self.file_id = _FileId()
+
+        async with create_task_group() as tg:
+            tg.start_soon(self.file_id.start)
+            self.put(self.file_id, FileId, teardown_callback=self.file_id.stop)
+            self.done()

fps_file_id-0.1.0/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = [ "hatchling",]
+build-backend = "hatchling.build"
+
+[project]
+name = "fps_file_id"
+description = "An FPS plugin for the file ID API"
+keywords = ["jupyter", "server", "fastapi", "plugins"]
+requires-python = ">=3.9"
+dependencies = [
+    "watchfiles >=1.0.4,<2",
+    "sqlite-anyio >=0.2.0,<0.3.0",
+    "anyio>=3.6.2,<5",
+    "jupyverse-api >=0.9.0,<0.10.0",
+]
+version = "0.1.0"
+[[project.authors]]
+name = "Jupyter Development Team"
+email = "jupyter@googlegroups.com"
+
+[project.readme]
+file = "README.md"
+content-type = "text/markdown"
+
+[project.license]
+text = "BSD 3-Clause License"
+
+[project.urls]
+Homepage = "https://jupyter.org"
+
+[project.entry-points]
+"fps.modules"       = {file_id = "fps_file_id.main:FileIdModule"}
+"jupyverse.modules" = {file_id = "fps_file_id.main:FileIdModule"}