Enum LseError 

#[non_exhaustive]
pub enum LseError {
    AmbiguousSlug {
        symbol: String,
        slug: String,
    },
    UnknownDataset(String),
    EnvVar(String),
    InvalidCredential(String),
    Http(Error),
    Api {
        status: u16,
        message: String,
    },
    RateLimited {
        retry_after: Option<Duration>,
    },
    Deserialize {
        message: String,
    },
    InvalidInput {
        message: String,
    },
    UnknownBondYieldCountry {
        requested: String,
        normalised: String,
    },
    UnknownBondYieldMaturity {
        country: String,
        requested: String,
        available: Vec<String>,
    },
    BondYieldRangeOutsideCoverage {
        country: String,
        maturity: Option<String>,
        start: NaiveDate,
        end: NaiveDate,
        first_date: NaiveDate,
        last_date: NaiveDate,
    },
    UnknownCalendarCountry {
        requested: String,
        normalised: String,
    },
    UnknownCalendarImpact {
        requested: String,
        available: Vec<String>,
    },
    CalendarRangeOutsideCoverage {
        start: NaiveDate,
        end: NaiveDate,
        earliest: NaiveDate,
        latest: NaiveDate,
    },
    UnsupportedInterval {
        interval: CandleInterval,
    },
    TimestampOverflow {
        open: DateTime<Utc>,
        interval: CandleInterval,
    },
    CursorOverflow {
        last_open: DateTime<Utc>,
    },
    UnexpectedCandleRange {
        symbol: String,
        cursor: DateTime<Utc>,
        page: usize,
        end: DateTime<Utc>,
    },
    NonMonotonicCandlePage {
        symbol: String,
        page: usize,
        previous_open: DateTime<Utc>,
        open: DateTime<Utc>,
    },
    UnexpectedCandleResolution {
        symbol: String,
        interval: CandleInterval,
        previous_open: DateTime<Utc>,
        open: DateTime<Utc>,
        actual: TimeDelta,
    },
    OptionFlowWindowSaturated {
        window_start: DateTime<Utc>,
        rows: usize,
    },
    UnexpectedOptionFlowRow {
        id: u64,
        message: String,
    },
    QuotaExceeded {
        status: Option<QuotaStatus>,
    },
    ExportFailed {
        job_id: String,
        status: String,
        message: String,
    },
    ExportTimeout {
        job_id: String,
        status: String,
    },
    IntegrityMismatch {
        path: PathBuf,
        expected: String,
        actual: String,
        discarded: bool,
    },
    ExportJobMismatch {
        job_id: String,
        field: String,
        requested: String,
        reported: String,
    },
    Io {
        message: String,
        source: Error,
    },
    UnsupportedSchema {
        columns: String,
    },
    UnsupportedColumnType {
        column: String,
        required: &'static str,
        found: String,
    },
    NullValue {
        column: &'static str,
    },
    SymbolMismatch {
        expected: String,
        found: String,
    },
    NonMonotonicTimestamps {
        previous: DateTime<Utc>,
        found: DateTime<Utc>,
    },
    TimestampNotRepresentable {
        micros: i64,
    },
    PriceNotRepresentable {
        value: f64,
        message: String,
    },
    UnknownInstrument {
        symbol: String,
        exchange: ExchangeId,
        registered: String,
    },
    AmbiguousInstrument {
        symbol: String,
        exchange: ExchangeId,
        instruments: String,
    },
    QuoteAssetMismatch {
        symbol: String,
        exchange: ExchangeId,
        expected: String,
        registered: String,
    },
    Parquet(ParquetError),
}

Errors produced by the London Strategic Edge integration.

#[non_exhaustive]: further variants are added alongside the endpoints that raise them.

Deliberately not Clone/PartialEq — Http wraps a reqwest::Error, which is neither, matching every other REST-backed integration in this crate.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

AmbiguousSlug

More than one distinct dataset series resolves to the requested slug, so no single dataset can be identified.

Returned rather than picking one, because the provider’s /dataset/info endpoint answers 200 for an ambiguous slug — silently serving whichever series it prefers. Two measured families produce this: eleven Eurex futures that publish both a bare and a .F series containing different data (the bare series is frequently the far larger one and has no slug of its own), and futures whose stripped symbol collides with an unrelated equity ticker.

Fields

symbol: String

slug: String

UnknownDataset(String)

The provided string does not name a known London Strategic Edge price dataset.

EnvVar(String)

A required environment variable is not set, or does not hold valid UTF-8 (see LseVaultClient::from_env).

The message names the variable and never its value, so a mis-encoded key cannot reach a log line through this error.

InvalidCredential(String)

The supplied API key cannot be encoded as an HTTP header value (e.g. non-ASCII bytes).

Http(Error)

The request could not be completed at the transport layer.

Api

The API returned a non-success status, or a success response this integration cannot use.

message is the provider’s own diagnostic, unwrapped from its response envelope and truncated to a bounded length — or, where status is a success code, this integration’s own diagnostic for a response that violated the contract that status implies. A 206 whose Content-Range is missing, unparseable, or does not resume where the Range asked, and a 200 page that repeats the cursor it was given, all arrive here: the status is the one the provider sent, so it stays reportable, but the fault is one only the client can see.

Fields

status: u16

message: String

RateLimited

The request rate was exceeded.

Terminal — this integration never sleeps and retries on the caller’s behalf. A paged fetch yields this and ends; resume by re-requesting from the last close_time received.

The provider permits calls_per_minute requests per minute, reported by usage.

Caveat

On the export endpoints an exhausted allowance is distinguished and reported as QuotaExceeded. On the candle path the provider offers no way to tell a per-minute rate limit from an exhausted byte allowance, so both arrive here. Either way it is observable and terminal, and never silently retried.

Fields

retry_after: Option<Duration>

Deserialize

A response body could not be decoded into the expected shape.

Fields

message: String

InvalidInput

The request is malformed in a way the caller must fix, detected before it is sent.

Fields

message: String

UnknownBondYieldCountry

The requested country is not one the provider publishes bond yields for.

Raised before the request is sent, because /bond-yields performs no validation of its own: a country it does not know answers 200 with count: 0, which is byte-for-byte indistinguishable from an unknown maturity and from a range that is simply empty. Measured: country=ZZ and country=GB both return 200 count=0, against country=UK returning rows.

normalised is what requested became before the lookup — the provider keys the United Kingdom UK, not the ISO-3166 GB its own country_iso2 column name implies, and that is the only divergence among its 34 codes. Both forms are reported so a caller can see which one was actually looked up.

Fields

requested: String

normalised: String

UnknownBondYieldMaturity

The requested maturity is not one the provider publishes for that country.

Raised before the request is sent, for the same reason as UnknownBondYieldCountry: measured, maturity=99Y answers 200 with count: 0 rather than an error.

available is the country’s published tenor list, carried in full because it is short (fifteen at the widest measured) and because a tenor is a provider label, not a duration — 5Y and 5Y TIPS are distinct series that report the same maturity_days, so there is nothing a caller can compute the right spelling from.

Fields

country: String

requested: String

available: Vec<String>

BondYieldRangeOutsideCoverage

The requested range lies entirely outside the published coverage of that series.

The third cause of a 200 count=0, and the one that membership alone cannot catch: a (country, maturity) pair can exist and still hold nothing in the window asked for. Measured on US 10Y TIPS and TR 2Y, both of which return zero rows for 2023-2024 and both of which report a first_date of 2025-07-07 — correct behaviour from the provider, and silent.

Raised only when the requested range and the published one are disjoint. A partial overlap is not an error: it returns the rows that exist, which is what was asked for.

Fields

country: String

maturity: Option<String>

None when the query named no maturity, so the bound is the country’s own coverage.

start: NaiveDate

end: NaiveDate

first_date: NaiveDate

last_date: NaiveDate

UnknownCalendarCountry

The requested country is not one the economic calendar publishes.

Raised before the request is sent, for the same reason as UnknownBondYieldCountry: the endpoint answers an unknown country with 200 and count: 0, indistinguishable from a quiet window.

normalised is what requested became before the lookup. The calendar keys the United Kingdom UK rather than GB, exactly as /bond-yields does — but the two vocabularies are not the same set: the calendar’s 108 codes also include EA and EU, which are not countries. Both forms are reported so a caller can see which one was actually looked up.

Fields

requested: String

normalised: String

UnknownCalendarImpact

The requested impact rating is not one the economic calendar publishes.

Measured: impact=Critical answers 200 with count: 0 rather than an error, so this is raised before the request is sent.

available is carried in full because the vocabulary is closed and short — exactly ["High", "Low", "Medium", "None"]. ⚠️ "None" in that list is a literal rating, not an absent value.

Fields

requested: String

available: Vec<String>

CalendarRangeOutsideCoverage

The requested range lies entirely outside the calendar’s published coverage.

⚠️ A global bound, not a per-country one, which makes this weaker than BondYieldRangeOutsideCoverage. /economic-calendar/stats publishes no per-country coverage at all, so a window inside this range may still legitimately return nothing — 88 of the 108 countries hold fewer than 100 events. That case is deliberately not an error: the library has no way to distinguish it from a quiet period, and inventing an error for it would mean inventing knowledge the provider does not publish.

🔴 latest has been 2026-03-24 across measurements two months apart — the feed is frozen, so every forward-looking window lands here.

Raised only when the requested range and the published one are disjoint. A partial overlap is not an error: it returns the events that exist, which is what was asked for.

Fields

start: NaiveDate

end: NaiveDate

earliest: NaiveDate

latest: NaiveDate

UnsupportedInterval

The requested resolution is not one the provider serves.

CandleInterval is the venue-agnostic union of every resolution any connector in this crate serves; this provider serves 14 of them. Rejected before the request is sent rather than relayed as a 400, so the caller gets a typed answer.

Fields

interval: CandleInterval

TimestampOverflow

A candle’s period-end boundary is not representable.

close_time == open_time + interval can overflow the representable DateTime<Utc> range. Surfaced rather than clamped: a silently substituted boundary would be a plausible-looking wrong timestamp on a real candle.

Fields

open: DateTime<Utc>

interval: CandleInterval

CursorOverflow

The pagination cursor could not be advanced past the last bar received.

The cursor steps one second past the newest open time on a page, which is not representable within a second of DateTime::MAX_UTC. Distinct from TimestampOverflow, which is a candle’s period end: the addend here is the cursor step, not the interval, and naming the interval would send a reader looking at arithmetic the code never performed.

Fields

last_open: DateTime<Utc>

UnexpectedCandleRange

The vault served a candle closing past the requested end.

The upper bound sent to the vault is exact by construction: it is end - interval + 1s against a parameter that is exclusive on open time, so the newest bar a compliant page can carry is the one whose close falls exactly on end. A later one means the range parameters were not honoured — the same silently-ignored-parameter failure as a page that repeats the cursor it was given, which is why both are terminal rather than quietly repaired.

Not symmetric with the lower bound, deliberately

The lower bound is widened by one interval on purpose, to readmit the bar whose close equals start, so a page legitimately carries bars closing before start and those are trimmed without comment. Nothing widens the upper bound, so there is no benign reading of a bar past it.

Every in-range bar on the offending page is yielded before this arrives: the page is scanned to the end first, so failing here costs none of the data the response did contain.

Fields

symbol: String

cursor: DateTime<Utc>

page: usize

end: DateTime<Utc>

NonMonotonicCandlePage

A candle page stepped backwards in open time.

Ascending order is how the vault answers today, not something it guarantees, and the pagination cursor depends on it being at least non-descending across pages: the cursor advances past the newest open a page carried, so a page served newest-first advances it to the end of the range immediately. The next page is then empty, which is the documented end-of-data signal, and collect_candles returns Ok with the last page of a multi-million bar range and no indication that the rest was skipped.

Terminal rather than repaired by sorting: a page arriving in an order the cursor arithmetic was not built for means the vault changed behaviour, and every later assumption in this module — the trim bounds, the cursor step, the end-of-data signal — was derived from the old one. The same property is a typed rejection on the Parquet path (NonMonotonicTimestamps).

Fields

symbol: String

page: usize

previous_open: DateTime<Utc>

open: DateTime<Utc>

UnexpectedCandleResolution

Two consecutive candles are spaced closer together than the interval they were asked for.

Impossible for a compliant fixed-interval series: consecutive bars are exactly one interval apart, and a gap (a weekend, a holiday, a quiet symbol) only ever makes the spacing wider. Spacing narrower than the interval means the candles are at a finer resolution than the one requested, so every close_time derived for them overlaps the bars that follow.

The failure this exists to catch, on the vault path

The vault answers 200 to a misspelled resolution parameter and silently defaults to 1-minute bars, in a byte-identical response shape (see the vault module docs). A Day1 request would then receive 1,440 one-minute rows per day, each stamped with a close_time of open + 24h by the historical module’s boundary arithmetic — overlapping, wrong, and invisible to every other check there, because the range bounds are still satisfied and the series still ascends. Spacing is the one property that distinguishes it.

And on the export path

parquet::read_export derives close_time from a caller-supplied interval, since nothing in a Parquet artifact records the resolution it was written at. The wrong resolution therefore reaches the same arithmetic from a different origin — the caller’s declaration rather than the provider’s answer — and produces the same overlapping bars, so the same check guards it: a file of 1-minute bars decoded as Day1 is rejected rather than yielding 390 “daily” bars per trading day. Reported in terms of the artifact’s ts column, which carries the bar’s open — the close is a value that decoder derived, and only the open is something a caller can find in the file itself.

Limits

Only the finer-than-asked-for direction is detectable. Coarser is not: daily bars taken for Min1 are spaced 24 hours apart, which is wider than 60 seconds and indistinguishable from a genuine gap. A single candle is not checked at all, having no pair to measure.

Only IntervalStep::Fixed resolutions are checked. A calendar step (month, quarter, year) has no single width to compare against, and February would false-positive against a 31-day one.

Fields

symbol: String

interval: CandleInterval

previous_open: DateTime<Utc>

open: DateTime<Utc>

actual: TimeDelta

OptionFlowWindowSaturated

A single second of the option print tape holds more prints than one page can carry.

The flow endpoint truncates silently at its row cap and accepts only whole-second bounds, so a one-second window that still comes back full cannot be narrowed further, and the prints beyond the cap cannot be read at all. Terminal rather than returned short: the alternative is a tape missing prints with nothing to say so.

Fields

window_start: DateTime<Utc>

rows: usize

UnexpectedOptionFlowRow

An option print came back outside the window or underlying it was requested for.

Means the provider ignored a request parameter, which it is known to do silently — the flow endpoint answers a ticker filter by returning every contract. Raised before any print of the offending window is yielded.

Fields

id: u64

message: String

QuotaExceeded

The shared allowance is exhausted.

Carries the allowance state at the point of rejection so the caller can decide how to pace. Terminal — never retried internally.

Raised by the export path only

The bulk-export endpoints report allowance exhaustion as a 429 carrying no Retry-After and no rate-limit headers, which this integration distinguishes from a per-minute rate limit and reports here, populating the position from usage. A candle fetch that runs into a limit still surfaces as RateLimited — the provider gives no way to tell the two apart on that path. status is None when the follow-up usage call itself failed. The allowance is still known to be exhausted — that is what the 429 said — but this integration will not fabricate a QuotaStatus to fill the field. One variant meaning “allowance gone, position unknown” is what lets a caller pace itself by matching a single variant; reporting the second case as a generic Api{ status: 429 } instead would make it silently miss half the cases.

Fields

status: Option<QuotaStatus>

ExportFailed

An export job reached a terminal state without producing an artifact.

expired means the artifact was built and has since been reaped — roughly 48 hours after it was created. Both are terminal; re-exporting costs another export.

Fields

job_id: String

status: String

message: String

ExportTimeout

An export job did not become ready within the caller’s timeout.

The job is not cancelled and the identifier stays valid — it keeps building, so polling export_status later picks it up without spending another export. This is a timeout on waiting, not on the job.

Fields

job_id: String

status: String

IntegrityMismatch

A downloaded artifact does not match the integrity metadata the job reported.

The destination is left untouched rather than holding a corrupt artifact.

discarded reports what happened to the partial file at path:

• false — it is retained, because it is incomplete rather than wrong: shorter than the artifact, so the bytes are a real prefix the next call resumes from with a Range request. For a multi-gigabyte artifact that is the difference between finishing and starting over.
• true — it was removed, because it is corrupt: longer than the artifact, or the right length at the wrong digest with nothing left to fetch. Retaining it would fail identically forever, so a re-call restarts instead.

Fields

path: PathBuf

expected: String

actual: String

discarded: bool

ExportJobMismatch

A ready export job does not describe the request it is being downloaded for.

The provider silently substitutes defaults for parameters it does not recognise, so a request it partly ignored still yields a ready job — covering something other than what was asked for. The job record echoes dataset, symbol, timeframe, start and end, and that echo is the only client-side evidence of what the artifact actually contains. Downloading it anyway would attribute one instrument’s or one range’s data to another, silently.

Not recoverable by re-downloading: the artifact is what it is. The request has to be corrected and re-exported, which costs one of the five hourly exports.

Fields

job_id: String

field: String

requested: String

reported: String

Io

A filesystem operation failed.

message names the operation and the path; the underlying std::io::Error is retained as the error source, so a caller can match on std::io::ErrorKind rather than parse a string.

Fields

message: String

source: Error

UnsupportedSchema

An export artifact’s columns match none of the layouts this integration decodes.

The provider’s tick schema varies by dataset — fx publishes bid/ask, stocks publishes price/volume, and the synthetic classes publish price/volume/ask — so the layout is resolved from the columns present. Reported rather than guessed at: a wrong column guess yields plausible numbers in the wrong field.

Also raised for a schema that is not flat. Columns are read by leaf index, which equals a top-level field’s position only when every field is a primitive: one nested group contributes several leaves and shifts every index after it. Every measured artifact is flat, so rather than support a nesting the provider has never emitted, it is rejected — the alternative is a decoder whose column mapping is silently wrong on a file it accepted, which for a bid/ask pair means reading one as the other.

Fields

columns: String

UnsupportedColumnType

A recognised export column does not have the type this integration decodes it as.

Distinct from UnsupportedSchema, which reports columns whose names match no known layout. Here the layout is recognised and one of its columns is the wrong type, so naming the column and both types is the whole diagnostic — reported up front rather than as an opaque decode failure on the first row.

Why a ts column that is not UTC-adjusted lands here

Timestamp { unit: MICROS, is_adjusted_to_utc: false } is physically identical to the UTC-adjusted form — same INT64, same legacy TIMESTAMP_MICROS converted type — and differs only in the origin its values are measured against. Read as epoch microseconds, a local-time column shifts every event by the venue’s UTC offset with nothing downstream able to notice: the timeline is still monotonic and the prices are still right, so a backtest simply trades on data it could not have had. This check is the only place that difference is visible.

Fields

column: String

required: &'static str

found: String

NullValue

A column the resolved layout has no substitute for is null on some row.

ts, symbol and the layout’s price columns are REQUIRED on every measured artifact, but a writer change would make them nullable without altering anything else the decoder keys on, so the schema check accepts OPTIONAL and this reports a value that is actually missing. None of them is substitutable: a null timestamp has no place on a timeline, a null symbol cannot be checked against the descriptor — the check that catches a mis-described file — and a null price would have to be invented.

Fields

column: &'static str

SymbolMismatch

A row’s symbol column does not match the symbol the export descriptor names.

Every export is single-symbol, so this means the file and its descriptor disagree — the artifact is not the one the caller thinks it is. Caught because attributing it to the descriptor’s instrument would be silent misattribution, and because BP and BP.L are different instruments quoted in different currencies.

Fields

expected: String

found: String

NonMonotonicTimestamps

An artifact’s timestamps do not advance as its layout requires.

A backtest fed an unsorted stream produces a non-monotonic clock and wrong results in release, with no failure point, so this is rejected at decode.

What counts as a violation depends on the layout

• Tick and quote tapes are non-decreasing: several prints routinely share a microsecond, so ties are permitted and only a step backwards is rejected.
• Candle artifacts at a fixed resolution are strictly ascending: two bars of one series cannot share an open, so they cannot share the close derived from it. A tie there means the file holds more than one series, or repeats a row. It does not mean the declared resolution is wrong — a fixed interval is a constant shift from open to close, so it cancels out of this comparison entirely and a mis-declared one produces distinct, strictly ascending closes. That is a separate check on bar spacing, which reports UnexpectedCandleResolution. Calendar intervals are exempt from strictness: month arithmetic clamps day-of-month, so two distinct opens can legitimately share a close.

Fields

previous: DateTime<Utc>

found: DateTime<Utc>

TimestampNotRepresentable

A row’s timestamp is outside the representable DateTime<Utc> range.

Fields

micros: i64

PriceNotRepresentable

A provider f64 has no rust_decimal::Decimal representation.

Surfaced rather than substituted: a zero or a clamp here would put a real-looking price into fees, PnL and risk notional.

Fields

value: f64

message: String

UnknownInstrument

No registered instrument is priced on this exchange under the requested display symbol: none has it as its data-side name there (its DataVenue’s, or its own when it declares none).

Raised when deriving an InstrumentIndex from the caller’s registry rather than accepting one. That derivation is what makes a fabricated index unrepresentable — the index is a public, unbounded usize and engine state indexes positionally — and it is the only check that catches a symbol typo, which would otherwise leave one instrument silently receiving no data at all.

Fields

symbol: String

exchange: ExchangeId

registered: String

AmbiguousInstrument

More than one registered instrument is priced on this exchange under the requested display symbol, such as one listing executed on two venues with both priced here.

A candle source delivers its symbol’s prices to a single instrument, so picking one would leave the other silently unpriced. instruments lists the name_internal of each.

Fields

symbol: String

exchange: ExchangeId

instruments: String

QuoteAssetMismatch

The registered instrument prices this symbol in a different asset than the provider quotes it in.

The provider publishes no unit alongside a price, so the asset the caller registered is the unit. Registering a .L listing against gbp rather than gbx is therefore not a naming preference: BP.L prints ~548 where BP trades around £5.48, so every notional, fee, unrealised PnL and balance derived from it is 100× wrong, and nothing downstream can tell.

Raised at the same boundary as UnknownInstrument, and for the same reason: it is the one place the provider’s view of a symbol and the caller’s registry meet, so it is the only place the disagreement is visible.

Compared on AssetNameInternal, because that is the identity the engine keys assets by — GBX and gbx are one asset, and GBP is a different one.

expected is derived, not published

It comes from quote_asset, which maps a venue suffix to an asset and defaults to USD for any suffix outside its table. So a correctly-registered listing on a venue that table does not cover is rejected here, with an expected the provider never stated. The message says “this integration derives” rather than “the provider quotes” for that reason. A caller in that position wants LseCandleSource::new, which carries no check.

Fields

symbol: String

exchange: ExchangeId

expected: String

registered: String

Parquet(ParquetError)

The Parquet artifact could not be read.

Implementations

impl LseError

pub fn kind(&self) -> LseErrorKind

Classify this error for a consumer deciding whether to retry, wait, or stop.

Exhaustive on purpose: a new variant must produce a compile error here rather than fall through to a default. Getting this wrong is not a visible failure — it silently retries something terminal, or abandons something that would have succeeded.

Trait Implementations

impl Debug for LseError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for LseError

fn fmt(&self, __formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Error for LseError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<Error> for LseError

fn from(source: Error) -> Self

Converts to this type from the input type.

impl From<LseError> for DataError

Available on crate feature lse only.

fn from(value: LseError) -> Self

Converts to this type from the input type.

impl From<ParquetError> for LseError

fn from(source: ParquetError) -> Self

Converts to this type from the input type.