evserver 0.1.0__py3-none-any.whl

evserver/__init__.py

@@ -0,0 +1,308 @@
+import uuid
+from contextlib import asynccontextmanager
+from http.client import HTTPException
+from pathlib import Path
+from typing import TYPE_CHECKING, Annotated, TypedDict
+
+from fastapi import Depends, FastAPI
+from starlette.responses import Content
+
+from evserver.stores import DirectoryStore, FileStore, Store
+from evserver.types import (
+    ContentId,
+    Manifest,
+    ManifestId,
+    Reference,
+    ReferenceId,
+    Snapshot,
+    SnapshotId,
+    User,
+    UserId,
+    Workspace,
+    WorkspaceId,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import AsyncGenerator
+
+    from fastapi.requests import HTTPConnection
+
+
+UserKey = UserId
+WorkspaceKey = tuple[UserId, WorkspaceId]
+SnapshotKey = tuple[UserId, SnapshotId]
+ManifestKey = tuple[UserId, ManifestId]
+ReferenceKey = tuple[UserId, ReferenceId]
+ContentKey = tuple[UserId, ContentId]
+
+
+UserStore = Store[UserId, User]
+WorkspaceStore = Store[WorkspaceKey, Workspace]
+SnapshotStore = Store[SnapshotKey, Snapshot]
+ManifestStore = Store[ManifestKey, Manifest]
+ReferenceStore = Store[ReferenceKey, Reference]
+ContentStore = Store[ContentKey, Content]
+
+
+class State(TypedDict):
+    user_store: UserStore
+    workspace_store: WorkspaceStore
+    snapshot_store: SnapshotStore
+    manifest_store: ManifestStore
+    reference_store: ReferenceStore
+    content_store: ContentStore
+
+
+@asynccontextmanager
+async def lifespan(_: FastAPI) -> AsyncGenerator[State]:
+    user_store = FileStore(Path("data/users.dill"))
+    workspace_store = FileStore(Path("data/workspaces.dill"))
+    snapshot_store = FileStore(Path("data/snapshots.dill"))
+    manifest_store = FileStore(Path("data/manifests.dill"))
+    reference_store = FileStore(Path("data/references.dill"))
+    content_store = DirectoryStore(Path("data/contents"))
+    yield State(
+        user_store=user_store,
+        workspace_store=workspace_store,
+        snapshot_store=snapshot_store,
+        manifest_store=manifest_store,
+        reference_store=reference_store,
+        content_store=content_store,
+    )
+
+
+app = FastAPI(lifespan=lifespan)
+
+
+def get_user_store(httpconnection: HTTPConnection) -> UserStore:
+    return httpconnection.state.user_store
+
+
+def get_workspace_store(httpconnection: HTTPConnection) -> WorkspaceStore:
+    return httpconnection.state.workspace_store
+
+
+def get_snapshot_store(httpconnection: HTTPConnection) -> SnapshotStore:
+    return httpconnection.state.snapshot_store
+
+
+def get_manifest_store(httpconnection: HTTPConnection) -> ManifestStore:
+    return httpconnection.state.manifest_store
+
+
+def get_reference_store(httpconnection: HTTPConnection) -> ReferenceStore:
+    return httpconnection.state.referenc_store
+
+
+def get_content_store(httpconnection: HTTPConnection) -> ContentStore:
+    return httpconnection.state.content_store
+
+
+@app.post("/user/register")
+async def register_user(
+    user_store: Annotated[UserStore, Depends(get_user_store)],
+) -> UserId:
+    user_id = uuid.uuid4().hex
+    user = User(user_id, set())
+    await user_store.set(user_id, user)
+    return user_id
+
+
+@app.post("/user/register/{user_id}")
+async def claim_user(
+    user_id: UserId,
+    user_store: Annotated[UserStore, Depends(get_user_store)],
+) -> None:
+    if await user_store.contains(user_id):
+        raise HTTPException(404, f'User: "{user_id}" already exists.')
+    await user_store.set(user_id, User.from_id(user_id))
+
+
+@app.delete("/user/{user_id}")
+async def delete_user(
+    user_id: UserId,
+    user_store: Annotated[UserStore, Depends(get_user_store)],
+) -> None:
+    if not await user_store.contains(user_id):
+        raise HTTPException(404, f'User: "{user_id}" does not exists.')
+    await user_store.delete(user_id)
+
+
+@app.get("/user/{user_id}")
+async def get_user(
+    user_id: UserId,
+    user_store: Annotated[UserStore, Depends(get_user_store)],
+) -> User:
+    if not await user_store.contains(user_id):
+        raise HTTPException(404, f'User: "{user_id}" does not exists.')
+    return await user_store.get(user_id)
+
+
+@app.get("/user/{user_id}/workspace/{workspace_id}")
+async def get_workspace(
+    user_id: UserId,
+    workspace_id: WorkspaceId,
+    workspace_store: Annotated[WorkspaceStore, Depends(get_workspace_store)],
+) -> Workspace:
+    workspace_key = (user_id, workspace_id)
+    if not await workspace_store.contains(workspace_key):
+        raise HTTPException(404, f'Workspace: "{workspace_key}" does not exists.')
+    return await workspace_store.get(workspace_key)
+
+
+@app.put("/user/{user_id}/workspace/{workspace_id}")
+async def set_workspace(
+    user_id: UserId,
+    workspace_id: WorkspaceId,
+    workspace: Workspace,
+    workspace_store: Annotated[WorkspaceStore, Depends(get_workspace_store)],
+) -> None:
+    await workspace_store.set((user_id, workspace_id), workspace)
+
+
+@app.delete("/user/{user_id}/workspace/{workspace_id}")
+async def delete_workspace(
+    user_id: UserId,
+    workspace_id: WorkspaceId,
+    workspace_store: Annotated[WorkspaceStore, Depends(get_workspace_store)],
+) -> None:
+    workspace_key = (user_id, workspace_id)
+    if not await workspace_store.contains(workspace_key):
+        raise HTTPException(404, f'Workspace: "{workspace_key}" does not exists.')
+    await workspace_store.delete(workspace_key)
+
+
+@app.get("/user/{user_id}/snapshot/{snapshot_id}")
+async def get_snapshot(
+    user_id: UserId,
+    snapshot_id: SnapshotId,
+    snapshot_store: Annotated[SnapshotStore, Depends(get_snapshot_store)],
+) -> Snapshot:
+    snapshot_key = (user_id, snapshot_id)
+    if not await snapshot_store.contains(snapshot_key):
+        raise HTTPException(404, f'Snapshot: "{snapshot_key}" does not exists.')
+    return await snapshot_store.get(snapshot_key)
+
+
+@app.put("/user/{user_id}/snapshot/{snapshot_id}")
+async def set_snapshot(
+    user_id: UserId,
+    snapshot_id: SnapshotId,
+    snapshot: Snapshot,
+    snapshot_store: Annotated[SnapshotStore, Depends(get_snapshot_store)],
+) -> None:
+    await snapshot_store.set((user_id, snapshot_id), snapshot)
+
+
+@app.delete("/user/{user_id}/snapshot/{snapshot_id}")
+async def delete_snapshot(
+    user_id: UserId,
+    snapshot_id: SnapshotId,
+    snapshot_store: Annotated[SnapshotStore, Depends(get_snapshot_store)],
+) -> None:
+    snapshot_key = (user_id, snapshot_id)
+    if not await snapshot_store.contains(snapshot_key):
+        raise HTTPException(404, f'Snapshot: "{snapshot_key}" does not exists.')
+    await snapshot_store.delete(snapshot_key)
+
+
+@app.get("/user/{user_id}/manifest/{manifest_id}")
+async def get_manifest(
+    user_id: UserId,
+    manifest_id: ManifestId,
+    manifest_store: Annotated[ManifestStore, Depends(get_manifest_store)],
+) -> Manifest:
+    manifest_key = (user_id, manifest_id)
+    if not await manifest_store.contains(manifest_key):
+        raise HTTPException(404, f'Manifest: "{manifest_key}" does not exists.')
+    return await manifest_store.get(manifest_key)
+
+
+@app.put("/user/{user_id}/manifest/{manifest_id}")
+async def set_manifest(
+    user_id: UserId,
+    manifest_id: ManifestId,
+    manifest: Manifest,
+    manifest_store: Annotated[ManifestStore, Depends(get_manifest_store)],
+) -> None:
+    await manifest_store.set((user_id, manifest_id), manifest)
+
+
+@app.delete("/user/{user_id}/manifest/{manifest_id}")
+async def delete_manifest(
+    user_id: UserId,
+    manifest_id: ManifestId,
+    manifest_store: Annotated[ManifestStore, Depends(get_manifest_store)],
+) -> None:
+    manifest_key = (user_id, manifest_id)
+    if not await manifest_store.contains(manifest_key):
+        raise HTTPException(404, f'Manifest: "{manifest_key}" does not exists.')
+    await manifest_store.delete(manifest_key)
+
+
+@app.get("/user/{user_id}/manifest/{manifest_id}")
+async def get_reference(
+    user_id: UserId,
+    reference_id: ReferenceId,
+    reference_store: Annotated[ReferenceStore, Depends(get_reference_store)],
+) -> Reference:
+    reference_key = (user_id, reference_id)
+    if not await reference_store.contains(reference_key):
+        raise HTTPException(404, f'Reference: "{reference_key}" does not exists.')
+    return await reference_store.get(reference_key)
+
+
+@app.put("/user/{user_id}/reference/{reference_id}")
+async def set_reference(
+    user_id: UserId,
+    reference_id: ReferenceId,
+    reference: Reference,
+    reference_store: Annotated[ReferenceStore, Depends(get_reference_store)],
+) -> None:
+    await reference_store.set((user_id, reference_id), reference)
+
+
+@app.delete("/user/{user_id}/reference/{reference_id}")
+async def delete_reference(
+    user_id: UserId,
+    reference_id: ReferenceId,
+    reference_store: Annotated[ManifestStore, Depends(get_manifest_store)],
+) -> None:
+    manifest_key = (user_id, reference_id)
+    if not await reference_store.contains(manifest_key):
+        raise HTTPException(404, f'Reference: "{manifest_key}" does not exists.')
+    await reference_store.delete(manifest_key)
+
+
+@app.get("/user/{user_id}/manifest/{manifest_id}")
+async def get_content(
+    user_id: UserId,
+    content_id: ContentId,
+    content_store: Annotated[ContentStore, Depends(get_content_store)],
+) -> Content:
+    content_key = (user_id, content_id)
+    if not await content_store.contains(content_key):
+        raise HTTPException(404, f'Content: "{content_key}" does not exists.')
+    return await content_store.get(content_key)
+
+
+@app.put("/user/{user_id}/content/{content_id}")
+async def set_content(
+    user_id: UserId,
+    content_id: ContentId,
+    content: Content,
+    content_store: Annotated[ContentStore, Depends(get_content_store)],
+) -> None:
+    await content_store.set((user_id, content_id), content)
+
+
+@app.delete("/user/{user_id}/content/{content_id}")
+async def delete_content(
+    user_id: UserId,
+    content_id: ContentId,
+    content_store: Annotated[ManifestStore, Depends(get_manifest_store)],
+) -> None:
+    manifest_key = (user_id, content_id)
+    if not await content_store.contains(manifest_key):
+        raise HTTPException(404, f'Content: "{manifest_key}" does not exists.')
+    await content_store.delete(manifest_key)

evserver/stores.py

@@ -0,0 +1,152 @@
+import asyncio
+from abc import ABC, abstractmethod
+from collections.abc import Hashable
+from pathlib import Path
+from typing import TYPE_CHECKING, Protocol, override
+
+import aiofiles
+import dill
+from blake3 import blake3
+
+if TYPE_CHECKING:
+    from collections.abc import Awaitable
+
+    from evserver.types import Digest
+
+
+class Store[K, V](Protocol):
+    def get(self, key: K) -> Awaitable[V]: ...
+
+    def set(self, key: K, value: V) -> Awaitable[None]: ...
+
+    def delete(self, key: K) -> Awaitable[None]: ...
+
+    def keys(self) -> Awaitable[tuple[K, ...]]: ...
+
+    def contains(self, key: K) -> Awaitable[bool]: ...
+
+    def values(self) -> Awaitable[tuple[V, ...]]: ...
+
+    def length(self) -> Awaitable[int]: ...
+
+
+class BaseStore[K, V](ABC):
+    @abstractmethod
+    def get(self, key: K) -> Awaitable[V]: ...
+
+    @abstractmethod
+    def set(self, key: K, value: V) -> Awaitable[None]: ...
+
+    @abstractmethod
+    def delete(self, key: K) -> Awaitable[None]: ...
+
+    @abstractmethod
+    def keys(self) -> Awaitable[tuple[K, ...]]: ...
+
+    async def contains(self, key: K) -> bool:
+        return key in await self.keys()
+
+    async def values(self) -> tuple[V, ...]:
+        return tuple(await asyncio.gather(*[self.get(k) for k in await self.keys()]))
+
+    async def length(self) -> int:
+        return len(await self.keys())
+
+
+class MemoryStore[K: Hashable, V](BaseStore[K, V]):
+    def __init__(self) -> None:
+        self._store: dict[K, V] = {}
+
+    @override
+    async def get(self, key: K) -> V:
+        return self._store[key]
+
+    @override
+    async def set(self, key: K, value: V) -> None:
+        self._store[key] = value
+
+    @override
+    async def delete(self, key: K) -> None:
+        self._store.pop(key, None)
+
+    @override
+    async def keys(self) -> tuple[K, ...]:
+        return tuple(self._store.keys())
+
+
+class FileStore[K: Hashable, V](BaseStore[K, V]):
+    def __init__(self, path: Path) -> None:
+        self.path = path
+
+    @classmethod
+    def load(cls, path: Path) -> dict[K, V]:
+        if path.exists():
+            return dill.loads(path.read_bytes())  # noqa: S301
+        return {}
+
+    @classmethod
+    def save(cls, path: Path, key_values: dict[K, V]) -> None:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_bytes(dill.dumps(key_values))
+
+    @override
+    async def get(self, key: K) -> V:
+        key_values = FileStore[K, V].load(self.path)
+        return key_values[key]
+
+    @override
+    async def set(self, key: K, value: V) -> None:
+        key_values = FileStore[K, V].load(self.path)
+        key_values[key] = value
+        FileStore[K, V].save(self.path, key_values)
+
+    @override
+    async def delete(self, key: K) -> None:
+        key_values = FileStore[K, V].load(self.path)
+        key_values.pop(key)
+        FileStore[K, V].save(self.path, key_values)
+
+    @override
+    async def keys(self) -> tuple[K, ...]:
+        return tuple(FileStore[K, V].load(self.path).keys())
+
+
+class DirectoryStore[K, V](BaseStore[K, V]):
+    def __init__(self, directory: Path) -> None:
+        self.directory = directory
+        self.key_store = FileStore[K, Path](directory / "index.dill")
+
+    @classmethod
+    def digest(cls, key: K) -> Digest:
+        return blake3(dill.dumps(key)).hexdigest()
+
+    def filepath(self, key: K) -> Path:
+        return self.directory / self.digest(key)
+
+    @override
+    async def get(self, key: K) -> V:
+        filepath = await self.key_store.get(key)
+        async with aiofiles.open(filepath, mode="rb") as f:
+            data = await f.read()
+        return dill.loads(data)  # noqa: S301
+
+    @override
+    async def set(self, key: K, value: V) -> None:
+        self.directory.mkdir(parents=True, exist_ok=True)
+        filepath = self.filepath(key)
+        await self.key_store.set(key, filepath)
+        data = dill.dumps(value)
+        async with aiofiles.open(filepath, mode="wb") as f:
+            await f.write(data)
+        await self.key_store.set(key, filepath)
+
+    @override
+    async def delete(self, key: K) -> None:
+        filepath = await self.key_store.get(key)
+        if filepath and filepath.exists():
+            filepath.unlink()
+        await self.key_store.delete(key)
+
+    @override
+    async def keys(self) -> tuple[K, ...]:
+        return await self.key_store.keys()

evserver/types.py

@@ -0,0 +1,67 @@
+import uuid
+from pathlib import Path  # noqa: TC003
+
+import dill
+from blake3 import blake3
+from pydantic.dataclasses import dataclass
+
+Digest = str
+UserId = str
+WorkspaceId = Digest
+SnapshotId = Digest
+ManifestId = Digest
+ReferenceId = Digest
+ContentId = Digest
+
+
+@dataclass(frozen=True, slots=True)
+class Reference:
+    file_path: Path
+    content_digest: ContentId
+
+    @property
+    def id(self) -> ReferenceId:
+        return blake3(dill.dumps((self.file_path, self.content_digest))).hexdigest()
+
+
+@dataclass(frozen=True, slots=True)
+class Manifest:
+    reference_ids: tuple[ReferenceId, ...]
+
+    @property
+    def id(self) -> ManifestId:
+        return blake3(dill.dumps(self.reference_ids)).hexdigest()
+
+
+@dataclass(frozen=True, slots=True)
+class Snapshot:
+    comment: str | None
+    manifest_id: ManifestId
+
+    @property
+    def id(self) -> SnapshotId:
+        return blake3(dill.dumps(self.comment, self.manifest_id)).hexdigest()
+
+
+@dataclass(frozen=True, slots=True)
+class Workspace:
+    directory: Path
+    snapshot_ids: tuple[SnapshotId, ...]
+
+    @property
+    def id(self) -> SnapshotId:
+        return blake3(dill.dumps(self.directory)).hexdigest()
+
+
+@dataclass(frozen=True, slots=True)
+class User:
+    id: UserId
+    workspace_ids: set[WorkspaceId]
+
+    @classmethod
+    def random(cls) -> User:
+        return User(uuid.uuid4().hex, set())
+
+    @classmethod
+    def from_id(cls, user_id: UserId) -> User:
+        return User(user_id, set())

evserver-0.1.0.dist-info/METADATA

@@ -0,0 +1,156 @@
+Metadata-Version: 2.3
+Name: evserver
+Version: 0.1.0
+Summary: Add your description here
+Author: Wannes Vantorre
+Author-email: Wannes Vantorre <vantorrewannes@gmail.com>
+Requires-Dist: aiofiles>=25.1.0
+Requires-Dist: blake3>=1.0.9
+Requires-Dist: dill>=0.4.1
+Requires-Dist: fastapi[standard]>=0.140.7
+Requires-Dist: pydantic>=2.13.4
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+
+# EasyVersion
+
+### Goals
+
+- **Many Archives:** Can store in many archives at once.
+- **Emergent Complexity:** Small implementation surface but reasonable usage requirements.
+
+## Commands
+
+- **`ev [COMMANDS | OPTIONS | ARGUMENTS | FLAGS]... [--help | -h]`:** List all sub commands + a small description of the intended usage.
+- **`ev archive <archive:URL> register [user:ID]`:** Request to claim a new user ID on the given archive URL.
+- **`ev archive <archive:URL> unregister <user:ID>`:** Request to be forgotten with the passed user ID on the given archive URL.
+- **`ev <workspace:PATH> login <api:URL> <user:ID>`:** Add this api URL + user ID to the list of active archives for the specified workspace.
+- **`ev <workspace:PATH> logout <api:URL> <user:ID>`:** Remove this api URL + user ID from the list of active archives for the specified workspace.
+- **`ev <workspace:PATH> logout <api:URL> <user:ID>`:** Remove this api URL + user ID from the list of active archives for the specified workspace.
+- **`ev <workspace:PATH> save [--note <comment:TEXT> | -n <comment:TEXT>]`:** Save the current state of this workspace as a new version. With the specified comment if provided.
+- **`ev <workspace:PATH> list [--version <version:NUMBER> | -v <version:NUMBER>]`:** List every version of the passed workspace so far or just the specific one requested. With their respective notes if set.
+- **`ev <source:PATH> clone <target:PATH> [--version <version:NUMBER> | -v <version:NUMBER>]`:** Clone the source workspace to the target workspace. Target may not exist yet. Clone the workspace as it was on the specified version if passed.
+- **`ev <source:PATH> forget {--version <version:NUMBER> | -v <version:NUMBER> | --all | -a}`:** Request the active workspaces to forget the selected version. Or all if requested. Does not clear the current workspace state.
+
+## Archive
+
+- **URL Specified:** Each archive only be accessed programatically by users through its URL.
+
+### Endpoints
+
+#### Accounts
+
+##### `POST /user/register`
+
+- Claims an available user.
+- If successful returns the claimed user.
+
+##### `POST /user/register:id`
+
+- Attempts to claim the specfied user.
+
+##### `DELETE /user/:user_id/`
+
+- Attempts to forget the provided user.
+
+##### `GET /user/:user_id/`
+
+- Returns an object containing:
+  - An array of all workspace IDs for the given user.
+
+#### Workspace
+
+##### `GET /user/:user_id/workspace/:workspace_id`
+
+- Returns a workspace object containing:
+  - An array of all snapshot IDs for the given user's workspace.
+
+##### `PUT /user/:user_id/workspace/:workspace_id`
+
+- Replace the user's specified workspace with the new workspace object containing:
+  - An array of all snapshot IDs for the given user's workspace.
+
+##### `DELETE /user/:user_id/workspace/:workspace_id`
+
+- Forget the user's specified workspace.
+
+#### Snapshot
+
+##### `GET /user/:user_id/snapshot/:snapshot_id`
+
+- Returns an object containing:
+  - An array of all manifest IDs for the given user's snapshot.
+  - An optional note string for the given user's snapshot.
+
+##### `PUT /user/:user_id/snapshot/:snapshot_id`
+
+- Create the user's specified snapshot from the provided snapshot object containing:
+  - A manifest IDs for the given user's snapshot.
+  - An optional note string for the given user's snapshot.
+
+##### `DELETE /user/:user_id/snapshot/:snapshot_id`
+
+- Forget the user's specified snapshot.
+
+#### Manifest
+
+##### `GET /user/:user_id/manifest/:manifest_id`
+
+- Returns an object containing:
+  - An array of all reference IDs for the given user's manifest.
+
+##### `PUT /user/:user_id/manifest/:manifest_id`
+
+- Create the user's specified manifest from the provided manifest object containing:
+  - An array of all reference IDs for the given user's manifest.
+
+##### `DELETE /user/:user_id/manifest/:manifest_id`
+
+- Forget the user's specified manifest.
+
+#### Reference
+
+##### `GET /user/:user_id/reference/:reference_id`
+
+- Returns an object containing:
+  - The reference's relative file path.
+  - The reference's content digest.
+
+##### `PUT /user/:user_id/reference/:reference_id`
+
+- Create the user's specified reference from the provided reference object containing:
+  - The reference's relative file path.
+  - The reference's content digest.
+
+##### `DELETE /user/:user_id/reference/:reference_id`
+
+- Forget the user's specified reference.
+
+#### Content
+
+##### `GET /user/:user_id/content/:content_id`
+
+- Returns a byte stream containing:
+  - The encoded content data.
+
+##### `PUT /user/:user_id/content/:content_id`
+
+- Create the user's specified reference from the provided content byte stream containing:
+  - The encoded content data.
+
+##### `DELETE /user/:user_id/content/:content_id`
+
+- Forget the user's specified reference.
+
+### Invariants
+
+- All non user IDs are blake3 hashes.
+
+## Client
+
+### Invariants
+
+- All config information is stored in the `.ev` folder at the workspace root.
+- The workspace login command appends the provided archive configuration to the currently active archive configurations in `.ev/archives`.
+- If an internal error happens the program should never continue.
+- User IDs are provided and used as is by the archive. No extra mapping.

evserver-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+evserver/__init__.py,sha256=b0DUOaLzIPxj2TnwCUVejUUktK5ZQeukIBrUGoXKZiI,9958
+evserver/stores.py,sha256=8mmk2HbSMLEwcWEEtrSiToB-SNcaloodllJZwZblCKY,4315
+evserver/types.py,sha256=cAWigocXGlDkPnPzMB8gCGJF8R5sO608rBtwFVytzR4,1460
+evserver-0.1.0.dist-info/WHEEL,sha256=l3MmIxu8qaet7ng2J9fFoJnYGj8IREj7jXTbgsuzmy4,81
+evserver-0.1.0.dist-info/entry_points.txt,sha256=rUTLIaSTSJNKeXwZZKPQD4oujonzFjiknApX90NoG4o,44
+evserver-0.1.0.dist-info/METADATA,sha256=S37JRrWBcgGq0It3pzZS4cIUGkhBSya6pzJD5CrKk4I,5554
+evserver-0.1.0.dist-info/RECORD,,

evserver-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.11.32
+Root-Is-Purelib: true
+Tag: py3-none-any

evserver-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+evserver = evserver:main
+