fixtureqa 0.9.1__tar.gz → 0.9.2__tar.gz

{fixtureqa-0.9.1/fixtureqa.egg-info → fixtureqa-0.9.2}/PKG-INFO

@@ -1,15 +1,16 @@
 Metadata-Version: 2.4
 Name: fixtureqa
-Version: 0.9.1
+Version: 0.9.2
 Summary: FIXture — FIX Protocol Testing Tool
 Requires-Python: >=3.10
 License-File: LICENSE
-Requires-Dist: fixcore-engine==0.8.1
+Requires-Dist: fixcore-engine==0.9.1
 Requires-Dist: fastapi>=0.111.0
 Requires-Dist: uvicorn[standard]>=0.29.0
 Requires-Dist: websockets>=12.0
 Requires-Dist: python-jose[cryptography]>=3.3.0
 Requires-Dist: passlib[bcrypt]>=1.7.4
+Requires-Dist: python-multipart>=0.0.9
 Requires-Dist: matplotlib>=3.7
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0; extra == "dev"

{fixtureqa-0.9.1 → fixtureqa-0.9.2}/fixture/api/app.py

@@ -12,13 +12,14 @@ from ..core.session_manager import SessionManager
 from ..core.scenario_store import ScenarioStore, ScenarioGroupStore
 from ..core.scenario_runner import ScenarioRunner
 from ..core.spec_overlay_store import SpecOverlayStore
+from ..core.spec_store import SpecStore
 from ..core.template_store import TemplateStore
 from ..core.user_store import UserStore
 from .connection_manager import ConnectionManager
 from ..core.perf_engine import RunRegistry
 from ..core.perf_writer import PerfWriter
 from ..core.perf_store import PerfStore
-from .routers import sessions, messages, ws, auth, setup, admin, fix_spec, templates, scenarios, branding, custom_tags, spec_overlay, perf
+from .routers import sessions, messages, ws, auth, setup, admin, fix_spec, templates, scenarios, branding, custom_tags, spec_overlay, specs, perf
 
 
 @asynccontextmanager
@@ -89,6 +90,7 @@ def create_app(
     app.state.scenario_group_store = ScenarioGroupStore(data_dir)
     app.state.custom_tag_store = CustomTagStore(data_dir)
     app.state.spec_overlay_store = SpecOverlayStore(data_dir)
+    app.state.spec_store = SpecStore(data_dir)
     perf_writer = PerfWriter(os.path.join(data_dir, "perf.db"))
     app.state.perf_writer = perf_writer
     app.state.perf_registry = RunRegistry(
@@ -114,6 +116,7 @@ def create_app(
     app.include_router(branding.router, prefix="/api")
     app.include_router(custom_tags.router, prefix="/api/custom-tags")
     app.include_router(spec_overlay.router, prefix="/api/spec-overlay")
+    app.include_router(specs.router, prefix="/api/specs")
     app.include_router(perf.router, prefix="/api/perf")
     app.include_router(ws.router)
 

{fixtureqa-0.9.1 → fixtureqa-0.9.2}/fixture/api/deps.py

@@ -12,6 +12,7 @@ from ..core.scenario_store import ScenarioStore, ScenarioGroupStore
 from ..core.scenario_runner import ScenarioRunner
 from ..core.custom_tag_store import CustomTagStore
 from ..core.spec_overlay_store import SpecOverlayStore
+from ..core.spec_store import SpecStore
 from .connection_manager import ConnectionManager
 
 oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/api/auth/login")
@@ -104,6 +105,10 @@ def get_spec_overlay_store(request: HTTPConnection) -> SpecOverlayStore:
     return request.app.state.spec_overlay_store
 
 
+def get_spec_store(request: HTTPConnection) -> SpecStore:
+    return request.app.state.spec_store
+
+
 def get_perf_registry(request: HTTPConnection):
     return request.app.state.perf_registry
 

{fixtureqa-0.9.1 → fixtureqa-0.9.2}/fixture/api/routers/fix_spec.py

@@ -2,17 +2,22 @@ from typing import Annotated
 
 from fastapi import APIRouter, Depends, HTTPException, Query
 
-from ...core.fix_spec_parser import get_fields, get_message, get_messages
+from ...core.fix_spec_parser import (
+    get_fields, get_message, get_messages, spec_ref_for_version,
+)
 from ...core.spec_overlay_store import SpecOverlayStore
+from ...core.spec_store import SpecStore
 from ...core.user_store import User
-from ..deps import get_current_user, get_spec_overlay_store
+from ..deps import get_current_user, get_spec_overlay_store, get_spec_store
 from ..schemas import FieldRefResponse, MessageDefResponse, MessageSummaryResponse
 
 router = APIRouter(tags=["fix-spec"])
 
 SUPPORTED = {"FIX.4.2", "FIX.4.4"}
+BUNDLED = {"FIX42.xml", "FIX44.xml"}
 
 SO = Annotated[SpecOverlayStore, Depends(get_spec_overlay_store)]
+SS = Annotated[SpecStore, Depends(get_spec_store)]
 CurrentUser = Annotated[User, Depends(get_current_user)]
 
 
@@ -24,16 +29,37 @@ def _validate_begin_string(begin_string: str) -> None:
         )
 
 
+def _resolve_spec_ref(
+    begin_string: str, spec: str | None, user: User, spec_store: SpecStore
+) -> str:
+    """The fixcore spec ref to browse: an explicit ``spec`` (a bundled name, or a
+    custom upload the caller owns) overrides the version-derived bundled spec.
+
+    A custom path the caller doesn't own is rejected so the browser can't be
+    used to read arbitrary files.
+    """
+    if spec:
+        if spec in BUNDLED:
+            return spec
+        if spec_store.owns_path(user.uid, spec):
+            return spec
+        raise HTTPException(status_code=403, detail="Spec not accessible")
+    _validate_begin_string(begin_string)
+    return spec_ref_for_version(begin_string)
+
+
 @router.get("/messages", response_model=list[MessageSummaryResponse])
 def list_messages(
     begin_string: str = Query("FIX.4.2"),
+    spec: str | None = Query(None),
     overlay_store: SO = ...,
+    spec_store: SS = ...,
     user: CurrentUser = ...,
 ):
-    _validate_begin_string(begin_string)
-    spec = [MessageSummaryResponse(msg_type=m.msg_type, name=m.name, category=m.category)
-            for m in get_messages(begin_string)]
-    spec_types = {m.msg_type for m in spec}
+    spec_ref = _resolve_spec_ref(begin_string, spec, user, spec_store)
+    spec_msgs = [MessageSummaryResponse(msg_type=m.msg_type, name=m.name, category=m.category)
+                 for m in get_messages(spec_ref)]
+    spec_types = {m.msg_type for m in spec_msgs}
 
     overlay = overlay_store.get_overlay(user.uid)
     extra = [
@@ -45,19 +71,21 @@ def list_messages(
         for om in overlay.get("messages", [])
         if om.get("msg_type") and om["msg_type"] not in spec_types
     ]
-    return spec + extra
+    return spec_msgs + extra
 
 
 @router.get("/messages/{msg_type}", response_model=MessageDefResponse)
 def get_message_def(
     msg_type: str,
     begin_string: str = Query("FIX.4.2"),
+    spec: str | None = Query(None),
     overlay_store: SO = ...,
+    spec_store: SS = ...,
     user: CurrentUser = ...,
 ):
-    _validate_begin_string(begin_string)
+    spec_ref = _resolve_spec_ref(begin_string, spec, user, spec_store)
 
-    msg = get_message(begin_string, msg_type)
+    msg = get_message(spec_ref, msg_type)
     if msg is not None:
         return MessageDefResponse(
             msg_type=msg.msg_type,
@@ -71,7 +99,7 @@ def get_message_def(
 
     # Check user's spec overlay for custom message types
     overlay = overlay_store.get_overlay(user.uid)
-    field_defs = get_fields(begin_string)
+    field_defs = get_fields(spec_ref)
     for om in overlay.get("messages", []):
         if om.get("msg_type") != msg_type:
             continue

{fixtureqa-0.9.1 → fixtureqa-0.9.2}/fixture/api/routers/sessions.py

@@ -5,16 +5,33 @@ from ...core.message_store import MessageStore
 from ...core.session_manager import SessionManager
 from ...core.models import SessionConfig, ConnectionType, SessionRole
 from ...core.user_store import User, UserStore
+from ...core.spec_store import SpecStore
 from ..schemas import SessionConfigRequest, SessionResponse, UpdateSessionRequest, SendMessageRequest, SeqNumRequest, SeqNumResponse
-from ..deps import get_session_manager, get_current_user, get_owned_session, get_user_store
+from ..deps import get_session_manager, get_current_user, get_owned_session, get_user_store, get_spec_store
 
 router = APIRouter(tags=["sessions"])
 
 SM = Annotated[SessionManager, Depends(get_session_manager)]
 US = Annotated[UserStore, Depends(get_user_store)]
+SS = Annotated[SpecStore, Depends(get_spec_store)]
 CurrentUser = Annotated[User, Depends(get_current_user)]
 OwnedSession = Annotated[SessionConfig, Depends(get_owned_session)]
 
+# Bundled spec names fixcore resolves by itself (see core.spec_store).
+_BUNDLED_SPECS = {"FIX42.xml", "FIX44.xml"}
+
+
+def _validate_data_dictionary(value: Optional[str], user: User, spec_store: SpecStore) -> None:
+    """A session may reference a bundled spec or a custom upload it owns — never
+    an arbitrary filesystem path (which would let it read any file on start)."""
+    if not value or value in _BUNDLED_SPECS:
+        return
+    if not spec_store.owns_path(user.uid, value):
+        raise HTTPException(
+            status_code=400,
+            detail="data_dictionary_path must be a bundled spec name or one of your uploaded specs",
+        )
+
 
 def _config_from_request(body: SessionConfigRequest, owner_uid: str) -> SessionConfig:
     """Map the request schema onto SessionConfig in one place — create and
@@ -116,7 +133,8 @@ def list_sessions(sm: SM, us: US, user: CurrentUser):
 
 
 @router.post("/", response_model=SessionResponse, status_code=201)
-async def create_session(body: SessionConfigRequest, sm: SM, us: US, user: CurrentUser):
+async def create_session(body: SessionConfigRequest, sm: SM, us: US, ss: SS, user: CurrentUser):
+    _validate_data_dictionary(body.data_dictionary_path, user, ss)
     cfg = _config_from_request(body, owner_uid=user.uid)
 
     try:
@@ -144,7 +162,7 @@ async def create_session(body: SessionConfigRequest, sm: SM, us: US, user: Curre
 
 
 @router.post("/import", response_model=list[SessionResponse], status_code=201)
-def import_sessions(body: list[SessionConfigRequest], sm: SM, us: US, user: CurrentUser):
+def import_sessions(body: list[SessionConfigRequest], sm: SM, us: US, ss: SS, user: CurrentUser):
     """
     Bulk-create sessions from an exported config file.
     Each entry is processed independently; invalid entries (bad enums, port
@@ -154,6 +172,7 @@ def import_sessions(body: list[SessionConfigRequest], sm: SM, us: US, user: Curr
     created = []
     for item in body:
         try:
+            _validate_data_dictionary(item.data_dictionary_path, user, ss)
             cfg = _config_from_request(item, owner_uid=user.uid)
             session_id = sm.add_session(cfg)
         except (HTTPException, ValueError, KeyError):
@@ -168,7 +187,9 @@ def get_session(session_id: str, _cfg: OwnedSession, sm: SM, us: US, user: Curre
 
 
 @router.patch("/{session_id}", response_model=SessionResponse)
-def update_session(session_id: str, body: UpdateSessionRequest, _cfg: OwnedSession, sm: SM, us: US, user: CurrentUser):
+def update_session(session_id: str, body: UpdateSessionRequest, _cfg: OwnedSession, sm: SM, us: US, ss: SS, user: CurrentUser):
+    if "data_dictionary_path" in body.model_fields_set:
+        _validate_data_dictionary(body.data_dictionary_path, user, ss)
     try:
         sm.update_session(session_id, body)
     except RuntimeError as e:

fixtureqa-0.9.2/fixture/api/routers/specs.py

@@ -0,0 +1,55 @@
+"""Custom FIX spec (DataDictionary) upload/list/delete.
+
+Bundled specs (FIX42.xml / FIX44.xml) ship inside fixcore; this router manages
+the per-user *custom* uploads and lists both together so the session builder can
+offer one combined dropdown.
+"""
+
+from typing import Annotated
+
+from fastapi import APIRouter, Depends, HTTPException, Response, UploadFile, status
+
+from ...core.spec_store import SpecStore, SpecValidationError
+from ...core.user_store import User
+from ..deps import get_current_user, get_spec_store
+
+router = APIRouter(tags=["specs"])
+
+SS = Annotated[SpecStore, Depends(get_spec_store)]
+CurrentUser = Annotated[User, Depends(get_current_user)]
+
+# Reject oversized uploads before reading them into memory (specs are XML text;
+# the full FIX 4.4 dictionary is ~320 KB, so 2 MB is a generous ceiling).
+_MAX_SPEC_BYTES = 2 * 1024 * 1024
+
+
+@router.get("")
+def list_specs(store: SS, user: CurrentUser) -> dict:
+    """Bundled + this user's uploaded custom specs (for the dictionary picker)."""
+    return store.list_specs(user.uid)
+
+
+@router.post("", status_code=status.HTTP_201_CREATED)
+async def upload_spec(file: UploadFile, store: SS, user: CurrentUser) -> dict:
+    raw = await file.read()
+    if len(raw) > _MAX_SPEC_BYTES:
+        raise HTTPException(status_code=413, detail="Spec file too large")
+    try:
+        text = raw.decode("utf-8")
+    except UnicodeDecodeError:
+        raise HTTPException(status_code=400, detail="Spec must be UTF-8 XML")
+    try:
+        return store.save_spec(user.uid, file.filename or "spec.xml", text)
+    except SpecValidationError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@router.delete("/{name}", status_code=status.HTTP_204_NO_CONTENT)
+def delete_spec(name: str, store: SS, user: CurrentUser) -> Response:
+    try:
+        deleted = store.delete_spec(user.uid, name)
+    except SpecValidationError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    if not deleted:
+        raise HTTPException(status_code=404, detail="Spec not found")
+    return Response(status_code=status.HTTP_204_NO_CONTENT)

{fixtureqa-0.9.1 → fixtureqa-0.9.2}/fixture/core/atomic_io.py

@@ -36,3 +36,25 @@ def atomic_write_json(path: str, data, *, indent: int = 2) -> None:
         except OSError:
             pass
         raise
+
+
+def atomic_write_text(path: str, text: str) -> None:
+    """Atomically write `text` to `path` (same unique-temp + fsync + rename
+    scheme as :func:`atomic_write_json`). Used for uploaded FIX spec XML."""
+    directory = os.path.dirname(path) or "."
+    os.makedirs(directory, exist_ok=True)
+    fd, tmp = tempfile.mkstemp(
+        prefix=os.path.basename(path) + ".", suffix=".tmp", dir=directory
+    )
+    try:
+        with os.fdopen(fd, "w") as f:
+            f.write(text)
+            f.flush()
+            os.fsync(f.fileno())
+        os.replace(tmp, path)
+    except BaseException:
+        try:
+            os.unlink(tmp)
+        except OSError:
+            pass
+        raise

fixtureqa-0.9.2/fixture/core/fix_spec_parser.py

@@ -0,0 +1,160 @@
+"""
+Structured FIX field/message definitions for the GUI spec browser.
+
+This is a thin adapter over fixcore's :class:`~fixcore.message.DataDictionary`
+— fixture no longer parses spec XML itself. fixcore 0.9.x bundles the FIX 4.2 /
+4.4 dictionaries and (crucially) expands ``<component>`` references, so the
+field lists here are complete for FIX 4.4 (NewOrderSingle's Instrument /
+OrderQtyData / Parties fields, etc.) where the old in-house parser silently
+dropped every component-sourced field.
+
+A *spec ref* is whatever fixcore's ``load_data_dictionary`` accepts: a bundled
+spec name (``"FIX42.xml"`` / ``"FIX44.xml"``) or an absolute path to a custom
+uploaded spec.
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass, field
+
+from fixcore.message import load_data_dictionary
+from fixcore.message.data_dictionary import GroupDef
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class FieldDef:
+    number: int
+    name: str
+    type: str                       # STRING, CHAR, INT, PRICE, etc.
+    values: dict[str, str]          # enum_value → description; empty if not enum
+
+
+@dataclass
+class FieldRef:
+    tag: int                        # 0 if unknown
+    name: str
+    type: str
+    required: bool
+    values: dict[str, str]
+
+
+@dataclass
+class MessageDef:
+    msg_type: str
+    name: str
+    category: str                   # 'admin' | 'app'
+    fields: list[FieldRef] = field(default_factory=list)
+
+
+# ---------------------------------------------------------------------------
+# Internal cache (per spec ref). fixcore caches the parsed DataDictionary
+# itself; this caches the adapter's per-message FieldRef lists.
+# ---------------------------------------------------------------------------
+
+@dataclass
+class _Spec:
+    field_defs: dict[int, FieldDef]
+    messages: dict[str, MessageDef]
+
+
+_CACHE: dict[str, _Spec] = {}
+
+
+def spec_ref_for_version(begin_string: str) -> str:
+    """The bundled spec name for a FIX version (fixcore resolves it)."""
+    return "FIX42.xml" if "4.2" in begin_string else "FIX44.xml"
+
+
+def _build_spec(spec_ref: str) -> _Spec:
+    dd = load_data_dictionary(spec_ref)
+
+    field_defs: dict[int, FieldDef] = {
+        tag: FieldDef(number=fd.number, name=fd.name, type=fd.type, values=dict(fd.values))
+        for tag, fd in dd.fields().items()
+    }
+
+    messages: dict[str, MessageDef] = {}
+    for m in dd.messages():
+        messages[m.msg_type] = MessageDef(
+            msg_type=m.msg_type,
+            name=m.name,
+            category="admin" if m.msg_cat == "admin" else "app",
+            fields=_message_field_refs(m, field_defs),
+        )
+    return _Spec(field_defs=field_defs, messages=messages)
+
+
+def _message_field_refs(msg, field_defs: dict[int, FieldDef]) -> list[FieldRef]:
+    """Flatten a message's fields into one ordered list for the browser.
+
+    fixcore keeps a message as required/optional tag *sets* plus repeating-group
+    structure; we present required fields first, then optional, then expand each
+    repeating group's members (as optional) — mirroring the old flat browser but
+    now component-complete.
+    """
+    refs: list[FieldRef] = []
+    seen: set[int] = set()
+
+    def add(tag: int, required: bool) -> None:
+        if tag in seen:
+            return
+        seen.add(tag)
+        fd = field_defs.get(tag)
+        refs.append(FieldRef(
+            tag=tag,
+            name=fd.name if fd else f"Tag{tag}",
+            type=fd.type if fd else "STRING",
+            required=required,
+            values=fd.values if fd else {},
+        ))
+
+    def add_group(gd: GroupDef) -> None:
+        for tag in gd.members:
+            add(tag, False)
+            nested = gd.nested_groups.get(tag)
+            if nested is not None:
+                add_group(nested)
+
+    for tag in sorted(msg.required):
+        add(tag, True)
+    for tag in sorted(msg.optional):
+        add(tag, False)
+    for counter, gd in msg.groups.items():
+        add(counter, counter in msg.required)
+        add_group(gd)
+    return refs
+
+
+def _get_spec(spec_ref: str) -> _Spec:
+    if spec_ref not in _CACHE:
+        try:
+            _CACHE[spec_ref] = _build_spec(spec_ref)
+        except Exception as e:
+            logger.error("Failed to load FIX spec %s: %s", spec_ref, e)
+            _CACHE[spec_ref] = _Spec(field_defs={}, messages={})
+    return _CACHE[spec_ref]
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+def get_messages(spec_ref: str) -> list[MessageDef]:
+    """All message definitions for a spec, app messages first then by name."""
+    spec = _get_spec(spec_ref)
+    result = list(spec.messages.values())
+    result.sort(key=lambda m: (m.category != "app", m.name))
+    return result
+
+
+def get_message(spec_ref: str, msg_type: str) -> MessageDef | None:
+    """The full message definition for one MsgType, or None."""
+    return _get_spec(spec_ref).messages.get(msg_type)
+
+
+def get_fields(spec_ref: str) -> dict[int, FieldDef]:
+    """All field definitions keyed by tag number."""
+    return _get_spec(spec_ref).field_defs

{fixtureqa-0.9.1 → fixtureqa-0.9.2}/fixture/core/session.py

@@ -421,11 +421,21 @@ class Session:
         return SessionSettings.from_string("\n".join(lines))
 
     def _resolve_data_dictionary(self) -> str:
-        if self.config.data_dictionary_path:
-            return os.path.abspath(self.config.data_dictionary_path)
-        here = os.path.dirname(os.path.abspath(__file__))
-        fname = "FIX42.xml" if "4.2" in self.config.begin_string else "FIX44.xml"
-        return os.path.abspath(os.path.join(here, "..", "fix_specs", fname))
+        """The DataDictionary value for this session — a bundled spec name that
+        fixcore resolves from its packaged dictionaries, or an absolute path to
+        a custom uploaded spec.
+
+        fixcore's ``load_data_dictionary`` (used by both the transport and
+        :meth:`data_dictionary`) checks disk first and only then falls back to a
+        bundled name, so a real file always wins.
+        """
+        val = self.config.data_dictionary_path
+        if val:
+            # A custom spec is stored as an on-disk path; anything else (e.g.
+            # "FIX44.xml") is a bundled spec name fixcore resolves by itself.
+            return os.path.abspath(val) if os.path.isfile(val) else val
+        # Default: fixcore's bundled dictionary for this session's FIX version.
+        return "FIX42.xml" if "4.2" in self.config.begin_string else "FIX44.xml"
 
     def data_dictionary(self):
         """The loaded DataDictionary for this session's spec (cached by fixcore),

fixtureqa-0.9.2/fixture/core/spec_store.py

@@ -0,0 +1,147 @@
+"""
+Per-user custom FIX spec (DataDictionary XML) storage.
+
+Custom specs are uploaded QuickFIX-format XML files persisted at
+``data/<uid>/specs/<filename>.xml`` — same per-user directory layout as the
+JSON stores, but the payload is raw XML (validated by parsing it through
+fixcore's DataDictionary before it is accepted).
+
+The bundled FIX 4.2 / 4.4 dictionaries are *not* stored here — they ship inside
+fixcore (``fixcore.message.bundled_specs()``). :func:`SpecStore.list_specs`
+returns the bundled specs alongside the user's uploaded ones so the UI can show
+one combined dropdown.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import threading
+
+from fixcore.message import bundled_specs, load_data_dictionary
+
+from .atomic_io import atomic_write_text
+
+# A custom spec filename is restricted to a safe, predictable set of characters
+# (it becomes a path segment under the user's data dir) and must end in .xml.
+_SAFE_NAME = re.compile(r"^[A-Za-z0-9._-]+\.xml$")
+
+
+class SpecValidationError(ValueError):
+    """Raised when an uploaded spec is not a parseable FIX XML dictionary."""
+
+
+class SpecStore:
+    def __init__(self, data_dir: str):
+        self._data_dir = data_dir
+        self._lock = threading.RLock()
+
+    # ------------------------------------------------------------------
+    # Paths
+    # ------------------------------------------------------------------
+    def _dir(self, uid: str) -> str:
+        return os.path.join(self._data_dir, uid, "specs")
+
+    def _path(self, uid: str, name: str) -> str:
+        return os.path.join(self._dir(uid), name)
+
+    @staticmethod
+    def _sanitize(name: str) -> str:
+        """Reduce an uploaded filename to its basename and force a .xml suffix.
+
+        Rejects anything that isn't a plain ``<word>.xml`` after stripping the
+        directory — no path traversal, no surprises as a path segment.
+        """
+        base = os.path.basename(name or "").strip()
+        if not base.lower().endswith(".xml"):
+            base += ".xml"
+        if not _SAFE_NAME.match(base):
+            raise SpecValidationError(
+                "Spec filename must be alphanumeric (plus . _ -) and end in .xml"
+            )
+        return base
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+    def save_spec(self, uid: str, filename: str, xml_text: str) -> dict:
+        """Validate and persist an uploaded spec; return its descriptor.
+
+        Raises :class:`SpecValidationError` if the XML doesn't parse as a FIX
+        DataDictionary (so a bad upload never lands on disk).
+        """
+        name = self._sanitize(filename)
+        version = _validate_xml(xml_text)
+        with self._lock:
+            atomic_write_text(self._path(uid, name), xml_text)
+        return {"name": name, "version": version, "kind": "custom",
+                "value": self._path(uid, name)}
+
+    def list_specs(self, uid: str) -> dict:
+        """Return the bundled specs and this user's uploaded custom specs.
+
+        Shape::
+
+            {"bundled": [{"name", "value", "kind": "bundled"}, ...],
+             "custom":  [{"name", "value", "version", "kind": "custom"}, ...]}
+
+        ``value`` is what gets stored in ``SessionConfig.data_dictionary_path``:
+        a bare bundled name (e.g. ``"FIX44.xml"``, resolved by fixcore) for
+        bundled specs, and an absolute path for custom ones.
+        """
+        bundled = [{"name": n, "value": n, "kind": "bundled"}
+                   for n in bundled_specs()]
+        custom: list[dict] = []
+        d = self._dir(uid)
+        if os.path.isdir(d):
+            for fn in sorted(os.listdir(d)):
+                if not fn.lower().endswith(".xml"):
+                    continue
+                path = os.path.join(d, fn)
+                version = ""
+                try:
+                    version = load_data_dictionary(path).version
+                except Exception:
+                    pass
+                custom.append({"name": fn, "value": path,
+                               "version": version, "kind": "custom"})
+        return {"bundled": bundled, "custom": custom}
+
+    def delete_spec(self, uid: str, name: str) -> bool:
+        name = self._sanitize(name)
+        with self._lock:
+            path = self._path(uid, name)
+            if not os.path.isfile(path):
+                return False
+            os.remove(path)
+            return True
+
+    def owns_path(self, uid: str, path: str) -> bool:
+        """True if *path* is a custom spec file inside *uid*'s spec directory.
+
+        Used to authorise a ``data_dictionary_path`` a session references — a
+        user may only point a session at a bundled spec or their own upload.
+        """
+        if not path:
+            return False
+        try:
+            d = os.path.realpath(self._dir(uid))
+            p = os.path.realpath(path)
+        except OSError:
+            return False
+        return os.path.isfile(p) and os.path.dirname(p) == d
+
+
+def _validate_xml(xml_text: str) -> str:
+    """Parse *xml_text* as a FIX DataDictionary; return its version string.
+
+    Raises :class:`SpecValidationError` on any parse failure.
+    """
+    from fixcore.message import DataDictionary
+    try:
+        dd = DataDictionary.from_string(xml_text)
+    except Exception as e:  # noqa: BLE001 — surface a clean 4xx, not a 500
+        raise SpecValidationError(f"Not a valid FIX dictionary XML: {e}") from e
+    if not dd.fields():
+        raise SpecValidationError("Spec defines no fields")
+    return dd.version