fixtureqa 0.9.1__tar.gz → 0.9.3__tar.gz

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

@@ -1,15 +1,16 @@
 Metadata-Version: 2.4
 Name: fixtureqa
-Version: 0.9.1
+Version: 0.9.3
 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.2
 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.3}/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.3}/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.3}/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.3}/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.3/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.3}/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.3/fixture/core/fix_builder.py

@@ -0,0 +1,69 @@
+"""
+Group-aware construction of outbound FIX messages from a raw string.
+
+The naive path — parse_raw() into a {tag: value} dict, then set_field() per tag —
+collapses repeating groups: duplicate member tags (e.g. three NoAllocs rows) all
+overwrite down to the last value, while the NoXxx count survives as a literal. So
+the wire ends up claiming N instances but carrying only one.
+
+This builder instead keeps fields in order and hands them to fixcore's
+``Message.from_fields`` (the lenient, fields-based counterpart to ``decode``),
+which splits repeating groups using each group's spec definition when a
+DataDictionary is supplied — the same code path the engine uses to decode
+inbound messages, so the two can't drift. Header / seqnum / checksum tags are
+dropped here; the session stamps them on send.
+
+Without a DataDictionary (or for a count tag the spec doesn't define) it falls
+back to flat fields — no worse than before, but standard groups now round-trip.
+"""
+from __future__ import annotations
+
+from typing import Optional
+
+from fixcore.message import DataDictionary, Message
+
+SOH = "\x01"
+
+# Tags the transport owns; never copied from the user's raw into the body.
+CONTROL_TAGS = frozenset({8, 9, 10, 34, 49, 52, 56})
+_MSG_TYPE = 35
+_TRANSACT_TIME = 60
+
+
+def _ordered_pairs(raw: str) -> list[tuple[int, str]]:
+    """Parse raw FIX into an ORDERED list of (tag, value), preserving duplicates."""
+    norm = raw if SOH in raw else raw.replace("|", SOH)
+    pairs: list[tuple[int, str]] = []
+    for part in norm.split(SOH):
+        if "=" not in part:
+            continue
+        tag_str, _, value = part.partition("=")
+        try:
+            pairs.append((int(tag_str), value))
+        except ValueError:
+            continue
+    return pairs
+
+
+def build_message_from_raw(
+    raw: str,
+    data_dictionary: Optional[DataDictionary] = None,
+    *,
+    transact_time: Optional[str] = None,
+) -> Message:
+    """Build a fixcore Message from raw FIX, preserving repeating-group structure
+    when *data_dictionary* is supplied. Injects TransactTime(60) when
+    *transact_time* is given and absent. Raises ValueError if MsgType is missing."""
+    pairs = _ordered_pairs(raw)
+    msg_idx = next((i for i, (t, _) in enumerate(pairs) if t == _MSG_TYPE), None)
+    if msg_idx is None:
+        raise ValueError("Missing MsgType (tag 35)")
+
+    # Drop transport-owned tags; MsgType (35) stays — from_fields routes it to
+    # the header. The session stamps the control tags on send.
+    fields = [(t, v) for t, v in pairs if t not in CONTROL_TAGS]
+    if transact_time is not None and not any(t == _TRANSACT_TIME for t, _ in fields):
+        idx = next(i for i, (t, _) in enumerate(fields) if t == _MSG_TYPE)
+        fields.insert(idx + 1, (_TRANSACT_TIME, transact_time))
+
+    return Message.from_fields(fields, data_dictionary)

fixtureqa-0.9.3/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.3}/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),