From 70c591fb113555f30fdfcf357ba2afa9f14eed7d Mon Sep 17 00:00:00 2001 From: Carter Green Date: Tue, 10 Dec 2024 09:29:59 -0600 Subject: [PATCH 1/4] DOC: Add release dates --- CHANGELOG.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 3b08ee9..62d677c 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,6 +1,6 @@ # Changelog -## 0.25.0 - TBD +## 0.25.0 - 2024-11-12 ### Enhancements - Added new IntelligentCross venues `ASPN`, `ASMT`, and `ASPI` From c635b158ef1472909f40a2ed078bb3d0dba86a53 Mon Sep 17 00:00:00 2001 From: Carter Green Date: Wed, 11 Dec 2024 17:07:24 -0600 Subject: [PATCH 2/4] DEL: Remove deprecated packaging option --- CHANGELOG.md | 6 ++++++ include/databento/batch.hpp | 4 +--- include/databento/enums.hpp | 13 ----------- include/databento/historical.hpp | 12 +++++------ src/batch.cpp | 1 - src/enums.cpp | 37 -------------------------------- src/historical.cpp | 23 +++++++------------- tests/src/batch_tests.cpp | 2 -- 8 files changed, 20 insertions(+), 78 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 62d677c..766ec78 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,11 @@ # Changelog +## 0.26.0 - TBD + +### Breaking changes +- Removed deprecated `Packaging` enum and `packaging` field that's no longer supported + by the API + ## 0.25.0 - 2024-11-12 ### Enhancements diff --git a/include/databento/batch.hpp b/include/databento/batch.hpp index ff7ad92..d42fe5c 100644 --- a/include/databento/batch.hpp +++ b/include/databento/batch.hpp @@ -5,7 +5,7 @@ #include #include -#include "databento/enums.hpp" // JobState, Delivery, Packaging, Schema, SType +#include "databento/enums.hpp" // JobState, Delivery, Schema, SType namespace databento { // Description of a batch job. @@ -31,8 +31,6 @@ struct BatchJob { SplitDuration split_duration; std::uint64_t split_size; bool split_symbols; - // NOTE: deprecated and will be removed in a future version - Packaging packaging; Delivery delivery; std::uint64_t record_count; // Size in bytes. diff --git a/include/databento/enums.hpp b/include/databento/enums.hpp index a044052..b80a4a5 100644 --- a/include/databento/enums.hpp +++ b/include/databento/enums.hpp @@ -85,15 +85,6 @@ enum class SplitDuration : std::uint8_t { None, }; -// Represents how a batch job will be packaged. -// -// NOTE: Deprecated now that all batch jobs can be downloaded as a ZIP file. -enum class Packaging : std::uint8_t { - None = 0, - Zip, - TarDeprecated, -}; - // Represents how a batch job will be delivered. enum class Delivery : std::uint8_t { Download, @@ -462,7 +453,6 @@ const char* ToString(FeedMode mode); const char* ToString(Compression compression); const char* ToString(SType stype); const char* ToString(SplitDuration duration_interval); -const char* ToString(Packaging packaging); const char* ToString(Delivery delivery); const char* ToString(JobState state); const char* ToString(DatasetCondition condition); @@ -487,7 +477,6 @@ std::ostream& operator<<(std::ostream& out, FeedMode mode); std::ostream& operator<<(std::ostream& out, Compression compression); std::ostream& operator<<(std::ostream& out, SType stype); std::ostream& operator<<(std::ostream& out, SplitDuration duration_interval); -std::ostream& operator<<(std::ostream& out, Packaging packaging); std::ostream& operator<<(std::ostream& out, Delivery delivery); std::ostream& operator<<(std::ostream& out, JobState state); std::ostream& operator<<(std::ostream& out, DatasetCondition condition); @@ -522,8 +511,6 @@ SType FromString(const std::string& str); template <> SplitDuration FromString(const std::string& str); template <> -Packaging FromString(const std::string& str); -template <> Delivery FromString(const std::string& str); template <> JobState FromString(const std::string& str); diff --git a/include/databento/historical.hpp b/include/databento/historical.hpp index 3e9ab6f..0068257 100644 --- a/include/databento/historical.hpp +++ b/include/databento/historical.hpp @@ -9,7 +9,7 @@ #include "databento/datetime.hpp" // DateRange, DateTimeRange, UnixNanos #include "databento/dbn_file_store.hpp" #include "databento/detail/http_client.hpp" // HttpClient -#include "databento/enums.hpp" // BatchState, Delivery, DurationInterval, Packaging, Schema, SType +#include "databento/enums.hpp" // BatchState, Delivery, DurationInterval, Schema, SType #include "databento/metadata.hpp" // DatasetConditionDetail, DatasetRange, FieldDetail, PublisherDetail, UnitPricesForMode #include "databento/symbology.hpp" // SymbologyResolution #include "databento/timeseries.hpp" // KeepGoing, MetadataCallback, RecordCallback @@ -52,9 +52,8 @@ class Historical { Encoding encoding, Compression compression, bool pretty_px, bool pretty_ts, bool map_symbols, bool split_symbols, SplitDuration split_duration, - std::uint64_t split_size, Packaging packaging, - Delivery delivery, SType stype_in, SType stype_out, - std::uint64_t limit); + std::uint64_t split_size, Delivery delivery, + SType stype_in, SType stype_out, std::uint64_t limit); BatchJob BatchSubmitJob(const std::string& dataset, const std::vector& symbols, Schema schema, @@ -62,9 +61,8 @@ class Historical { Encoding encoding, Compression compression, bool pretty_px, bool pretty_ts, bool map_symbols, bool split_symbols, SplitDuration split_duration, - std::uint64_t split_size, Packaging packaging, - Delivery delivery, SType stype_in, SType stype_out, - std::uint64_t limit); + std::uint64_t split_size, Delivery delivery, + SType stype_in, SType stype_out, std::uint64_t limit); std::vector BatchListJobs(); std::vector BatchListJobs(const std::vector& states, UnixNanos since); diff --git a/src/batch.cpp b/src/batch.cpp index 748f7cb..6dd37a0 100644 --- a/src/batch.cpp +++ b/src/batch.cpp @@ -40,7 +40,6 @@ std::ostream& operator<<(std::ostream& stream, const BatchJob& batch_job) { .AddField("split_duration", batch_job.split_duration) .AddField("split_size", batch_job.split_size) .AddField("split_symbols", batch_job.split_symbols) - .AddField("packaging", batch_job.packaging) .AddField("delivery", batch_job.delivery) .AddField("record_count", batch_job.record_count) .AddField("billed_size", batch_job.billed_size) diff --git a/src/enums.cpp b/src/enums.cpp index 9aa8e5d..475e805 100644 --- a/src/enums.cpp +++ b/src/enums.cpp @@ -180,23 +180,6 @@ const char* ToString(SplitDuration duration_interval) { } } -const char* ToString(Packaging packaging) { - switch (packaging) { - case Packaging::None: { - return "none"; - } - case Packaging::Zip: { - return "zip"; - } - case Packaging::TarDeprecated: { - return "tar"; - } - default: { - return "unknown"; - } - } -} - const char* ToString(Delivery delivery) { switch (delivery) { case Delivery::Download: { @@ -804,11 +787,6 @@ std::ostream& operator<<(std::ostream& out, SplitDuration duration_interval) { return out; } -std::ostream& operator<<(std::ostream& out, Packaging packaging) { - out << ToString(packaging); - return out; -} - std::ostream& operator<<(std::ostream& out, Delivery delivery) { out << ToString(delivery); return out; @@ -1042,21 +1020,6 @@ SplitDuration FromString(const std::string& str) { "unknown value '" + str + '\''}; } -template <> -Packaging FromString(const std::string& str) { - if (str == "none") { - return Packaging::None; - } - if (str == "zip") { - return Packaging::Zip; - } - if (str == "tar") { - return Packaging::TarDeprecated; - } - throw InvalidArgumentError{"FromString", "str", - "unknown value '" + str + '\''}; -} - template <> Delivery FromString(const std::string& str) { if (str == "download") { diff --git a/src/historical.cpp b/src/historical.cpp index 62bdb58..4e7df61 100644 --- a/src/historical.cpp +++ b/src/historical.cpp @@ -65,7 +65,6 @@ databento::BatchJob Parse(const std::string& endpoint, using databento::Encoding; using databento::JobState; using databento::JsonResponseError; - using databento::Packaging; using databento::Schema; using databento::SplitDuration; using databento::SType; @@ -100,8 +99,6 @@ databento::BatchJob Parse(const std::string& endpoint, endpoint, json, "split_duration", SplitDuration::None); res.split_size = ParseAt(endpoint, json, "split_size"); res.split_symbols = ParseAt(endpoint, json, "split_symbols"); - res.packaging = FromCheckedAtStringOrNull( - endpoint, json, "packaging", Packaging::None); res.delivery = FromCheckedAtString(endpoint, json, "delivery"); res.record_count = ParseAt(endpoint, json, "record_count"); res.billed_size = ParseAt(endpoint, json, "billed_size"); @@ -170,26 +167,24 @@ databento::BatchJob Historical::BatchSubmitJob( Schema schema, const DateTimeRange& datetime_range) { return this->BatchSubmitJob(dataset, symbols, schema, datetime_range, kDefaultEncoding, kDefaultCompression, {}, {}, {}, - {}, SplitDuration::Day, {}, Packaging::None, - Delivery::Download, kDefaultSTypeIn, - kDefaultSTypeOut, {}); + {}, SplitDuration::Day, {}, Delivery::Download, + kDefaultSTypeIn, kDefaultSTypeOut, {}); } databento::BatchJob Historical::BatchSubmitJob( const std::string& dataset, const std::vector& symbols, Schema schema, const DateTimeRange& datetime_range) { return this->BatchSubmitJob(dataset, symbols, schema, datetime_range, kDefaultEncoding, kDefaultCompression, {}, {}, {}, - {}, SplitDuration::Day, {}, Packaging::None, - Delivery::Download, kDefaultSTypeIn, - kDefaultSTypeOut, {}); + {}, SplitDuration::Day, {}, Delivery::Download, + kDefaultSTypeIn, kDefaultSTypeOut, {}); } databento::BatchJob Historical::BatchSubmitJob( const std::string& dataset, const std::vector& symbols, Schema schema, const DateTimeRange& datetime_range, Encoding encoding, Compression compression, bool pretty_px, bool pretty_ts, bool map_symbols, bool split_symbols, SplitDuration split_duration, - std::uint64_t split_size, Packaging packaging, Delivery delivery, - SType stype_in, SType stype_out, std::uint64_t limit) { + std::uint64_t split_size, Delivery delivery, SType stype_in, + SType stype_out, std::uint64_t limit) { httplib::Params params{ {"dataset", dataset}, {"start", ToString(datetime_range.start)}, @@ -202,7 +197,6 @@ databento::BatchJob Historical::BatchSubmitJob( {"map_symbols", std::to_string(map_symbols)}, {"split_symbols", std::to_string(split_symbols)}, {"split_duration", ToString(split_duration)}, - {"packaging", ToString(packaging)}, {"delivery", ToString(delivery)}, {"stype_in", ToString(stype_in)}, {"stype_out", ToString(stype_out)}}; @@ -216,8 +210,8 @@ databento::BatchJob Historical::BatchSubmitJob( Schema schema, const DateTimeRange& datetime_range, Encoding encoding, Compression compression, bool pretty_px, bool pretty_ts, bool map_symbols, bool split_symbols, SplitDuration split_duration, - std::uint64_t split_size, Packaging packaging, Delivery delivery, - SType stype_in, SType stype_out, std::uint64_t limit) { + std::uint64_t split_size, Delivery delivery, SType stype_in, + SType stype_out, std::uint64_t limit) { httplib::Params params{ {"dataset", dataset}, {"start", datetime_range.start}, @@ -230,7 +224,6 @@ databento::BatchJob Historical::BatchSubmitJob( {"map_symbols", std::to_string(map_symbols)}, {"split_symbols", std::to_string(split_symbols)}, {"split_duration", ToString(split_duration)}, - {"packaging", ToString(packaging)}, {"delivery", ToString(delivery)}, {"stype_in", ToString(stype_in)}, {"stype_out", ToString(stype_out)}}; diff --git a/tests/src/batch_tests.cpp b/tests/src/batch_tests.cpp index 2cfc0bf..0aba32f 100644 --- a/tests/src/batch_tests.cpp +++ b/tests/src/batch_tests.cpp @@ -27,7 +27,6 @@ TEST(BatchTests, TestBatchJobToString) { SplitDuration::Week, {}, false, - Packaging::Zip, Delivery::Download, 10250, 35000000, @@ -61,7 +60,6 @@ TEST(BatchTests, TestBatchJobToString) { split_duration = week, split_size = 0, split_symbols = false, - packaging = zip, delivery = download, record_count = 10250, billed_size = 35000000, From f097ae3c01eb0dd55a798dbc143b7e1f757cda4f Mon Sep 17 00:00:00 2001 From: Carter Green Date: Fri, 13 Dec 2024 17:14:05 -0600 Subject: [PATCH 3/4] REF: Refactor DBN versioning in C++ client --- CHANGELOG.md | 7 + cmake/SourcesAndHeaders.cmake | 4 +- include/databento/compat.hpp | 201 ++-------------------------- include/databento/enums.hpp | 2 +- include/databento/live.hpp | 2 +- include/databento/v1.hpp | 209 ++++++++++++++++++++++++++++++ include/databento/v2.hpp | 32 +++++ src/dbn.cpp | 2 +- src/dbn_decoder.cpp | 4 +- src/enums.cpp | 2 +- src/historical.cpp | 3 +- src/{compat.cpp => v1.cpp} | 62 ++++----- tests/src/dbn_decoder_tests.cpp | 6 +- tests/src/live_blocking_tests.cpp | 2 +- 14 files changed, 307 insertions(+), 231 deletions(-) create mode 100644 include/databento/v1.hpp create mode 100644 include/databento/v2.hpp rename src/{compat.cpp => v1.cpp} (88%) diff --git a/CHANGELOG.md b/CHANGELOG.md index 766ec78..4fc9dea 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,6 +5,13 @@ ### Breaking changes - Removed deprecated `Packaging` enum and `packaging` field that's no longer supported by the API +- Renamed `VersionUpgradePolicy::Upgrade` to `UpgradeToV2` in preparation for a future + DBN version 3 + +### Enhancements +- Created separate namespaces for each DBN version to create a consistent way to refer + to record types from a particular DBN version regardless of whether the record changed + between versions ## 0.25.0 - 2024-11-12 diff --git a/cmake/SourcesAndHeaders.cmake b/cmake/SourcesAndHeaders.cmake index 4436e03..3f1fd92 100644 --- a/cmake/SourcesAndHeaders.cmake +++ b/cmake/SourcesAndHeaders.cmake @@ -31,13 +31,14 @@ set(headers include/databento/symbol_map.hpp include/databento/symbology.hpp include/databento/timeseries.hpp + include/databento/v1.hpp + include/databento/v2.hpp include/databento/with_ts_out.hpp src/stream_op_helper.hpp ) set(sources src/batch.cpp - src/compat.cpp src/datetime.cpp src/dbn.cpp src/dbn_constants.hpp @@ -65,4 +66,5 @@ set(sources src/record.cpp src/symbol_map.cpp src/symbology.cpp + src/v1.cpp ) diff --git a/include/databento/compat.hpp b/include/databento/compat.hpp index a79eab3..a3e6a10 100644 --- a/include/databento/compat.hpp +++ b/include/databento/compat.hpp @@ -4,201 +4,24 @@ #include // size_t #include -#include "databento/constants.hpp" // kSymbolCstrLen -#include "databento/datetime.hpp" // UnixNanos -#include "databento/enums.hpp" -#include "databento/record.hpp" +#include "databento/v1.hpp" +#include "databento/v2.hpp" namespace databento { -static constexpr std::size_t kSymbolCstrLenV1 = 22; -static constexpr std::size_t kSymbolCstrLenV2 = kSymbolCstrLen; +static constexpr std::size_t kSymbolCstrLenV1 = v1::kSymbolCstrLen; +static constexpr std::size_t kSymbolCstrLenV2 = v2::kSymbolCstrLen; constexpr std::size_t VersionSymbolCstrLen(std::uint8_t version) { return version < 2 ? kSymbolCstrLenV1 : kSymbolCstrLenV2; } -using InstrumentDefMsgV2 = InstrumentDefMsg; -using ErrorMsgV2 = ErrorMsg; -using SymbolMappingMsgV2 = SymbolMappingMsg; -using SystemMsgV2 = SystemMsg; - +using InstrumentDefMsgV1 = v1::InstrumentDefMsg; +using InstrumentDefMsgV2 = v2::InstrumentDefMsg; +using ErrorMsgV1 = v1::ErrorMsg; +using ErrorMsgV2 = v2::ErrorMsg; +using SymbolMappingMsgV1 = v1::SymbolMappingMsg; +using SymbolMappingMsgV2 = v2::SymbolMappingMsg; +using SystemMsgV1 = v1::SystemMsg; +using SystemMsgV2 = v2::SystemMsg; // DBN version 1 instrument definition. -struct InstrumentDefMsgV1 { - static bool HasRType(RType rtype) { return rtype == RType::InstrumentDef; } - - InstrumentDefMsgV2 ToV2() const; - const char* Currency() const { return currency.data(); } - const char* SettlCurrency() const { return settl_currency.data(); } - const char* SecSubType() const { return secsubtype.data(); } - const char* RawSymbol() const { return raw_symbol.data(); } - const char* Group() const { return group.data(); } - const char* Exchange() const { return exchange.data(); } - const char* Asset() const { return asset.data(); } - const char* Cfi() const { return cfi.data(); } - const char* SecurityType() const { return security_type.data(); } - const char* UnitOfMeasure() const { return unit_of_measure.data(); } - const char* Underlying() const { return underlying.data(); } - const char* StrikePriceCurrency() const { - return strike_price_currency.data(); - } - - RecordHeader hd; - UnixNanos ts_recv; - std::int64_t min_price_increment; - std::int64_t display_factor; - UnixNanos expiration; - UnixNanos activation; - std::int64_t high_limit_price; - std::int64_t low_limit_price; - std::int64_t max_price_variation; - std::int64_t trading_reference_price; - std::int64_t unit_of_measure_qty; - std::int64_t min_price_increment_amount; - std::int64_t price_ratio; - std::int32_t inst_attrib_value; - std::uint32_t underlying_id; - std::uint32_t raw_instrument_id; - std::int32_t market_depth_implied; - std::int32_t market_depth; - std::uint32_t market_segment_id; - std::uint32_t max_trade_vol; - std::int32_t min_lot_size; - std::int32_t min_lot_size_block; - std::int32_t min_lot_size_round_lot; - std::uint32_t min_trade_vol; - std::array _reserved2; - std::int32_t contract_multiplier; - std::int32_t decay_quantity; - std::int32_t original_contract_size; - std::array _reserved3; - std::uint16_t trading_reference_date; - std::int16_t appl_id; - std::uint16_t maturity_year; - std::uint16_t decay_start_date; - std::uint16_t channel_id; - std::array currency; - std::array settl_currency; - std::array secsubtype; - std::array raw_symbol; - std::array group; - std::array exchange; - std::array asset; - std::array cfi; - std::array security_type; - std::array unit_of_measure; - std::array underlying; - std::array strike_price_currency; - InstrumentClass instrument_class; - std::array _reserved4; - std::int64_t strike_price; - std::array _reserved5; - MatchAlgorithm match_algorithm; - std::uint8_t md_security_trading_status; - std::uint8_t main_fraction; - std::uint8_t price_display_format; - std::uint8_t settl_price_type; - std::uint8_t sub_fraction; - std::uint8_t underlying_product; - SecurityUpdateAction security_update_action; - std::uint8_t maturity_month; - std::uint8_t maturity_day; - std::uint8_t maturity_week; - UserDefinedInstrument user_defined_instrument; - std::int8_t contract_multiplier_unit; - std::int8_t flow_schedule_type; - std::uint8_t tick_rule; - // padding for alignment - std::array dummy; -}; -static_assert(sizeof(InstrumentDefMsgV1) == 360, "Size must match Rust"); -static_assert(alignof(InstrumentDefMsgV1) == 8, "Must have 8-byte alignment"); - -// An error message from the Live Subscription Gateway (LSG). This will never -// be present in historical data. -struct ErrorMsgV1 { - static bool HasRType(RType rtype) { return rtype == RType::Error; } - - ErrorMsgV2 ToV2() const; - UnixNanos IndexTs() const { return hd.ts_event; } - const char* Err() const { return err.data(); } - - RecordHeader hd; - std::array err; -}; -static_assert(sizeof(ErrorMsgV1) == 80, "ErrorMsg size must match Rust"); -static_assert(alignof(ErrorMsgV1) == 8, "Must have 8-byte alignment"); - -/// A symbol mapping message. -struct SymbolMappingMsgV1 { - static bool HasRType(RType rtype) { return rtype == RType::SymbolMapping; } - - SymbolMappingMsgV2 ToV2() const; - const char* STypeInSymbol() const { return stype_in_symbol.data(); } - const char* STypeOutSymbol() const { return stype_out_symbol.data(); } - - RecordHeader hd; - std::array stype_in_symbol; - std::array stype_out_symbol; - // padding for alignment - std::array dummy; - UnixNanos start_ts; - UnixNanos end_ts; -}; -static_assert(sizeof(SymbolMappingMsgV1) == 80, "Size must match Rust"); -static_assert(alignof(SymbolMappingMsgV1) == 8, "Must have 8-byte alignment"); - -struct SystemMsgV1 { - static bool HasRType(RType rtype) { return rtype == RType::System; } - - SystemMsgV2 ToV2() const; - UnixNanos IndexTs() const { return hd.ts_event; } - const char* Msg() const { return msg.data(); } - bool IsHeartbeat() const { - return std::strncmp(msg.data(), "Heartbeat", 9) == 0; - } - - RecordHeader hd; - std::array msg; -}; -static_assert(sizeof(SystemMsgV1) == 80, "SystemMsg size must match Rust"); -static_assert(alignof(SystemMsgV1) == 8, "Must have 8-byte alignment"); - -bool operator==(const InstrumentDefMsgV1& lhs, const InstrumentDefMsgV1& rhs); -inline bool operator!=(const InstrumentDefMsgV1& lhs, - const InstrumentDefMsgV1& rhs) { - return !(lhs == rhs); -} -inline bool operator==(const ErrorMsgV1& lhs, const ErrorMsgV1& rhs) { - return std::tie(lhs.hd, lhs.err) == std::tie(rhs.hd, rhs.err); -} -inline bool operator!=(const ErrorMsgV1& lhs, const ErrorMsgV1& rhs) { - return !(lhs == rhs); -} -inline bool operator==(const SymbolMappingMsgV1& lhs, - const SymbolMappingMsgV1& rhs) { - return std::tie(lhs.hd, lhs.stype_in_symbol, lhs.stype_out_symbol, - lhs.start_ts, lhs.end_ts) == - std::tie(rhs.hd, rhs.stype_in_symbol, rhs.stype_out_symbol, - rhs.start_ts, rhs.end_ts); -} -inline bool operator!=(const SymbolMappingMsgV1& lhs, - const SymbolMappingMsgV1& rhs) { - return !(lhs == rhs); -} -inline bool operator==(const SystemMsgV1& lhs, const SystemMsgV1& rhs) { - return std::tie(lhs.hd, lhs.msg) == std::tie(rhs.hd, rhs.msg); -} -inline bool operator!=(const SystemMsgV1& lhs, const SystemMsgV1& rhs) { - return !(lhs == rhs); -} -std::string ToString(const InstrumentDefMsgV1& instr_def_msg); -std::ostream& operator<<(std::ostream& stream, - const InstrumentDefMsgV1& instr_def_msg); -std::string ToString(const ErrorMsgV1& err_msg); -std::ostream& operator<<(std::ostream& stream, const ErrorMsgV1& err_msg); -std::string ToString(const SymbolMappingMsgV1& symbol_mapping_msg); -std::ostream& operator<<(std::ostream& stream, - const SymbolMappingMsgV1& symbol_mapping_msg); -std::string ToString(const SystemMsgV1& sys_msg); -std::ostream& operator<<(std::ostream& stream, const SystemMsgV1& sys_msg); } // namespace databento diff --git a/include/databento/enums.hpp b/include/databento/enums.hpp index b80a4a5..8dea2bb 100644 --- a/include/databento/enums.hpp +++ b/include/databento/enums.hpp @@ -297,7 +297,7 @@ enum class StatUpdateAction : std::uint8_t { // How to handle decoding DBN data from a prior version. enum class VersionUpgradePolicy : std::uint8_t { AsIs = 0, - Upgrade = 1, + UpgradeToV2 = 1, }; namespace status_action { diff --git a/include/databento/live.hpp b/include/databento/live.hpp index c0f5352..ca498c4 100644 --- a/include/databento/live.hpp +++ b/include/databento/live.hpp @@ -52,7 +52,7 @@ class LiveBuilder { std::string key_; std::string dataset_; bool send_ts_out_{false}; - VersionUpgradePolicy upgrade_policy_{VersionUpgradePolicy::Upgrade}; + VersionUpgradePolicy upgrade_policy_{VersionUpgradePolicy::UpgradeToV2}; std::chrono::seconds heartbeat_interval_{}; }; } // namespace databento diff --git a/include/databento/v1.hpp b/include/databento/v1.hpp new file mode 100644 index 0000000..bdd3865 --- /dev/null +++ b/include/databento/v1.hpp @@ -0,0 +1,209 @@ +#pragma once + +#include "databento/datetime.hpp" // UnixNanos +#include "databento/enums.hpp" +#include "databento/record.hpp" +#include "databento/v2.hpp" + +namespace databento { +namespace v1 { +static constexpr std::size_t kSymbolCstrLen = 22; + +using MboMsg = databento::MboMsg; +using TradeMsg = databento::TradeMsg; +using Mbp1Msg = databento::Mbp1Msg; +using TbboMsg = databento::TbboMsg; +using Mbp10Msg = databento::Mbp10Msg; +using BboMsg = databento::BboMsg; +using Bbo1SMsg = databento::Bbo1SMsg; +using Bbo1MMsg = databento::Bbo1MMsg; +using Cmbp1Msg = databento::Cmbp1Msg; +using TcbboMsg = databento::TcbboMsg; +using CbboMsg = databento::CbboMsg; +using Cbbo1SMsg = databento::Cbbo1SMsg; +using Cbbo1MMsg = databento::Cbbo1MMsg; +using OhlcvMsg = databento::OhlcvMsg; +using StatusMsg = databento::StatusMsg; +using ImbalanceMsg = databento::ImbalanceMsg; +using StatMsg = databento::StatMsg; + +struct InstrumentDefMsg { + static bool HasRType(RType rtype) { return rtype == RType::InstrumentDef; } + + v2::InstrumentDefMsg ToV2() const; + const char* Currency() const { return currency.data(); } + const char* SettlCurrency() const { return settl_currency.data(); } + const char* SecSubType() const { return secsubtype.data(); } + const char* RawSymbol() const { return raw_symbol.data(); } + const char* Group() const { return group.data(); } + const char* Exchange() const { return exchange.data(); } + const char* Asset() const { return asset.data(); } + const char* Cfi() const { return cfi.data(); } + const char* SecurityType() const { return security_type.data(); } + const char* UnitOfMeasure() const { return unit_of_measure.data(); } + const char* Underlying() const { return underlying.data(); } + const char* StrikePriceCurrency() const { + return strike_price_currency.data(); + } + + RecordHeader hd; + UnixNanos ts_recv; + std::int64_t min_price_increment; + std::int64_t display_factor; + UnixNanos expiration; + UnixNanos activation; + std::int64_t high_limit_price; + std::int64_t low_limit_price; + std::int64_t max_price_variation; + std::int64_t trading_reference_price; + std::int64_t unit_of_measure_qty; + std::int64_t min_price_increment_amount; + std::int64_t price_ratio; + std::int32_t inst_attrib_value; + std::uint32_t underlying_id; + std::uint32_t raw_instrument_id; + std::int32_t market_depth_implied; + std::int32_t market_depth; + std::uint32_t market_segment_id; + std::uint32_t max_trade_vol; + std::int32_t min_lot_size; + std::int32_t min_lot_size_block; + std::int32_t min_lot_size_round_lot; + std::uint32_t min_trade_vol; + std::array _reserved2; + std::int32_t contract_multiplier; + std::int32_t decay_quantity; + std::int32_t original_contract_size; + std::array _reserved3; + std::uint16_t trading_reference_date; + std::int16_t appl_id; + std::uint16_t maturity_year; + std::uint16_t decay_start_date; + std::uint16_t channel_id; + std::array currency; + std::array settl_currency; + std::array secsubtype; + std::array raw_symbol; + std::array group; + std::array exchange; + std::array asset; + std::array cfi; + std::array security_type; + std::array unit_of_measure; + std::array underlying; + std::array strike_price_currency; + InstrumentClass instrument_class; + std::array _reserved4; + std::int64_t strike_price; + std::array _reserved5; + MatchAlgorithm match_algorithm; + std::uint8_t md_security_trading_status; + std::uint8_t main_fraction; + std::uint8_t price_display_format; + std::uint8_t settl_price_type; + std::uint8_t sub_fraction; + std::uint8_t underlying_product; + SecurityUpdateAction security_update_action; + std::uint8_t maturity_month; + std::uint8_t maturity_day; + std::uint8_t maturity_week; + UserDefinedInstrument user_defined_instrument; + std::int8_t contract_multiplier_unit; + std::int8_t flow_schedule_type; + std::uint8_t tick_rule; + // padding for alignment + std::array dummy; +}; +static_assert(sizeof(InstrumentDefMsg) == 360, "Size must match Rust"); +static_assert(alignof(InstrumentDefMsg) == 8, "Must have 8-byte alignment"); + +// An error message from the Live Subscription Gateway (LSG). This will never +// be present in historical data. +struct ErrorMsg { + static bool HasRType(RType rtype) { return rtype == RType::Error; } + + v2::ErrorMsg ToV2() const; + UnixNanos IndexTs() const { return hd.ts_event; } + const char* Err() const { return err.data(); } + + RecordHeader hd; + std::array err; +}; +static_assert(sizeof(ErrorMsg) == 80, "ErrorMsg size must match Rust"); +static_assert(alignof(ErrorMsg) == 8, "Must have 8-byte alignment"); + +/// A symbol mapping message. +struct SymbolMappingMsg { + static bool HasRType(RType rtype) { return rtype == RType::SymbolMapping; } + + v2::SymbolMappingMsg ToV2() const; + const char* STypeInSymbol() const { return stype_in_symbol.data(); } + const char* STypeOutSymbol() const { return stype_out_symbol.data(); } + + RecordHeader hd; + std::array stype_in_symbol; + std::array stype_out_symbol; + // padding for alignment + std::array dummy; + UnixNanos start_ts; + UnixNanos end_ts; +}; +static_assert(sizeof(SymbolMappingMsg) == 80, "Size must match Rust"); +static_assert(alignof(SymbolMappingMsg) == 8, "Must have 8-byte alignment"); + +struct SystemMsg { + static bool HasRType(RType rtype) { return rtype == RType::System; } + + v2::SystemMsg ToV2() const; + UnixNanos IndexTs() const { return hd.ts_event; } + const char* Msg() const { return msg.data(); } + bool IsHeartbeat() const { + return std::strncmp(msg.data(), "Heartbeat", 9) == 0; + } + + RecordHeader hd; + std::array msg; +}; +static_assert(sizeof(SystemMsg) == 80, "SystemMsg size must match Rust"); +static_assert(alignof(SystemMsg) == 8, "Must have 8-byte alignment"); + +bool operator==(const InstrumentDefMsg& lhs, const InstrumentDefMsg& rhs); +inline bool operator!=(const InstrumentDefMsg& lhs, + const InstrumentDefMsg& rhs) { + return !(lhs == rhs); +} +inline bool operator==(const ErrorMsg& lhs, const ErrorMsg& rhs) { + return std::tie(lhs.hd, lhs.err) == std::tie(rhs.hd, rhs.err); +} +inline bool operator!=(const ErrorMsg& lhs, const ErrorMsg& rhs) { + return !(lhs == rhs); +} +inline bool operator==(const SymbolMappingMsg& lhs, + const SymbolMappingMsg& rhs) { + return std::tie(lhs.hd, lhs.stype_in_symbol, lhs.stype_out_symbol, + lhs.start_ts, lhs.end_ts) == + std::tie(rhs.hd, rhs.stype_in_symbol, rhs.stype_out_symbol, + rhs.start_ts, rhs.end_ts); +} +inline bool operator!=(const SymbolMappingMsg& lhs, + const SymbolMappingMsg& rhs) { + return !(lhs == rhs); +} +inline bool operator==(const SystemMsg& lhs, const SystemMsg& rhs) { + return std::tie(lhs.hd, lhs.msg) == std::tie(rhs.hd, rhs.msg); +} +inline bool operator!=(const SystemMsg& lhs, const SystemMsg& rhs) { + return !(lhs == rhs); +} +std::string ToString(const InstrumentDefMsg& instr_def_msg); +std::ostream& operator<<(std::ostream& stream, + const InstrumentDefMsg& instr_def_msg); +std::string ToString(const ErrorMsg& err_msg); +std::ostream& operator<<(std::ostream& stream, const ErrorMsg& err_msg); +std::string ToString(const SymbolMappingMsg& symbol_mapping_msg); +std::ostream& operator<<(std::ostream& stream, + const SymbolMappingMsg& symbol_mapping_msg); +std::string ToString(const SystemMsg& sys_msg); +std::ostream& operator<<(std::ostream& stream, const SystemMsg& sys_msg); +} // namespace v1 +} // namespace databento diff --git a/include/databento/v2.hpp b/include/databento/v2.hpp new file mode 100644 index 0000000..c303f23 --- /dev/null +++ b/include/databento/v2.hpp @@ -0,0 +1,32 @@ +#pragma once + +#include "databento/constants.hpp" // kSymbolCstrLen +#include "databento/record.hpp" + +namespace databento { +namespace v2 { +static constexpr std::size_t kSymbolCstrLen = databento::kSymbolCstrLen; + +using MboMsg = databento::MboMsg; +using TradeMsg = databento::TradeMsg; +using Mbp1Msg = databento::Mbp1Msg; +using TbboMsg = databento::TbboMsg; +using Mbp10Msg = databento::Mbp10Msg; +using BboMsg = databento::BboMsg; +using Bbo1SMsg = databento::Bbo1SMsg; +using Bbo1MMsg = databento::Bbo1MMsg; +using Cmbp1Msg = databento::Cmbp1Msg; +using TcbboMsg = databento::TcbboMsg; +using CbboMsg = databento::CbboMsg; +using Cbbo1SMsg = databento::Cbbo1SMsg; +using Cbbo1MMsg = databento::Cbbo1MMsg; +using OhlcvMsg = databento::OhlcvMsg; +using StatusMsg = databento::StatusMsg; +using InstrumentDefMsg = databento::InstrumentDefMsg; +using ImbalanceMsg = databento::ImbalanceMsg; +using StatMsg = databento::StatMsg; +using ErrorMsg = databento::ErrorMsg; +using SymbolMappingMsg = databento::SymbolMappingMsg; +using SystemMsg = databento::SystemMsg; +} // namespace v2 +} // namespace databento diff --git a/src/dbn.cpp b/src/dbn.cpp index ad7af28..070c8a2 100644 --- a/src/dbn.cpp +++ b/src/dbn.cpp @@ -17,7 +17,7 @@ TsSymbolMap Metadata::CreateSymbolMap() const { return TsSymbolMap{*this}; } void Metadata::Upgrade(VersionUpgradePolicy upgrade_policy) { if (version < kDbnVersion && - upgrade_policy == VersionUpgradePolicy::Upgrade) { + upgrade_policy == VersionUpgradePolicy::UpgradeToV2) { version = kDbnVersion; symbol_cstr_len = kSymbolCstrLen; } diff --git a/src/dbn_decoder.cpp b/src/dbn_decoder.cpp index 27a2021..d2eb1c2 100644 --- a/src/dbn_decoder.cpp +++ b/src/dbn_decoder.cpp @@ -75,7 +75,7 @@ DbnDecoder::DbnDecoder(ILogReceiver* log_receiver, InFileStream file_stream) DbnDecoder::DbnDecoder(ILogReceiver* log_receiver, std::unique_ptr input) : DbnDecoder(log_receiver, std::move(input), - VersionUpgradePolicy::Upgrade) {} + VersionUpgradePolicy::UpgradeToV2) {} DbnDecoder::DbnDecoder(ILogReceiver* log_receiver, std::unique_ptr input, @@ -228,7 +228,7 @@ databento::Record UpgradeRecord( databento::Record DbnDecoder::DecodeRecordCompat( std::uint8_t version, VersionUpgradePolicy upgrade_policy, bool ts_out, std::array* compat_buffer, Record rec) { - if (version == 1 && upgrade_policy == VersionUpgradePolicy::Upgrade) { + if (version == 1 && upgrade_policy == VersionUpgradePolicy::UpgradeToV2) { if (rec.RType() == RType::InstrumentDef) { return UpgradeRecord( ts_out, compat_buffer, rec); diff --git a/src/enums.cpp b/src/enums.cpp index 475e805..8a034d6 100644 --- a/src/enums.cpp +++ b/src/enums.cpp @@ -748,7 +748,7 @@ const char* ToString(VersionUpgradePolicy upgrade_policy) { case VersionUpgradePolicy::AsIs: { return "AsIs"; } - case VersionUpgradePolicy::Upgrade: { + case VersionUpgradePolicy::UpgradeToV2: { return "Upgrade"; } default: { diff --git a/src/historical.cpp b/src/historical.cpp index 4e7df61..ffcc312 100644 --- a/src/historical.cpp +++ b/src/historical.cpp @@ -974,7 +974,8 @@ databento::DbnFileStore Historical::TimeseriesGetRangeToFile( databento::DbnFileStore Historical::TimeseriesGetRangeToFile( const HttplibParams& params, const std::string& file_path) { StreamToFile(kTimeseriesGetRangePath, params, file_path); - return DbnFileStore{log_receiver_, file_path, VersionUpgradePolicy::Upgrade}; + return DbnFileStore{log_receiver_, file_path, + VersionUpgradePolicy::UpgradeToV2}; } using databento::HistoricalBuilder; diff --git a/src/compat.cpp b/src/v1.cpp similarity index 88% rename from src/compat.cpp rename to src/v1.cpp index 398a5c5..19728cd 100644 --- a/src/compat.cpp +++ b/src/v1.cpp @@ -1,4 +1,4 @@ -#include "databento/compat.hpp" +#include "databento/v1.hpp" #include // copy #include @@ -8,11 +8,12 @@ #include "stream_op_helper.hpp" // MakeString, StreamOpBuilder namespace databento { -InstrumentDefMsgV2 InstrumentDefMsgV1::ToV2() const { - InstrumentDefMsgV2 ret{ - RecordHeader{sizeof(InstrumentDefMsgV2) / RecordHeader::kLengthMultiplier, - RType::InstrumentDef, hd.publisher_id, hd.instrument_id, - hd.ts_event}, +namespace v1 { +v2::InstrumentDefMsg InstrumentDefMsg::ToV2() const { + v2::InstrumentDefMsg ret{ + RecordHeader{ + sizeof(v2::InstrumentDefMsg) / RecordHeader::kLengthMultiplier, + RType::InstrumentDef, hd.publisher_id, hd.instrument_id, hd.ts_event}, ts_recv, min_price_increment, display_factor, @@ -93,9 +94,9 @@ InstrumentDefMsgV2 InstrumentDefMsgV1::ToV2() const { return ret; } -ErrorMsgV2 ErrorMsgV1::ToV2() const { - ErrorMsgV2 ret{ - RecordHeader{sizeof(ErrorMsgV2) / RecordHeader::kLengthMultiplier, +v2::ErrorMsg ErrorMsg::ToV2() const { + v2::ErrorMsg ret{ + RecordHeader{sizeof(v2::ErrorMsg) / RecordHeader::kLengthMultiplier, RType::Error, hd.publisher_id, hd.instrument_id, hd.ts_event}, {}, @@ -105,11 +106,11 @@ ErrorMsgV2 ErrorMsgV1::ToV2() const { return ret; } -SymbolMappingMsgV2 SymbolMappingMsgV1::ToV2() const { - SymbolMappingMsgV2 ret{ - RecordHeader{sizeof(SymbolMappingMsgV2) / RecordHeader::kLengthMultiplier, - RType::SymbolMapping, hd.publisher_id, hd.instrument_id, - hd.ts_event}, +v2::SymbolMappingMsg SymbolMappingMsg::ToV2() const { + v2::SymbolMappingMsg ret{ + RecordHeader{ + sizeof(v2::SymbolMappingMsg) / RecordHeader::kLengthMultiplier, + RType::SymbolMapping, hd.publisher_id, hd.instrument_id, hd.ts_event}, // Intentionally invalid // NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange) static_cast(std::numeric_limits::max()), @@ -127,9 +128,9 @@ SymbolMappingMsgV2 SymbolMappingMsgV1::ToV2() const { return ret; } -SystemMsgV2 SystemMsgV1::ToV2() const { - SystemMsgV2 ret{ - RecordHeader{sizeof(SystemMsgV2) / RecordHeader::kLengthMultiplier, +v2::SystemMsg SystemMsg::ToV2() const { + v2::SystemMsg ret{ + RecordHeader{sizeof(v2::SystemMsg) / RecordHeader::kLengthMultiplier, RType::System, hd.publisher_id, hd.instrument_id, hd.ts_event}, {}, @@ -138,7 +139,7 @@ SystemMsgV2 SystemMsgV1::ToV2() const { return ret; } -bool operator==(const InstrumentDefMsgV1& lhs, const InstrumentDefMsgV1& rhs) { +bool operator==(const InstrumentDefMsg& lhs, const InstrumentDefMsg& rhs) { return lhs.hd == rhs.hd && lhs.ts_recv == rhs.ts_recv && lhs.min_price_increment == rhs.min_price_increment && lhs.display_factor == rhs.display_factor && @@ -195,14 +196,14 @@ bool operator==(const InstrumentDefMsgV1& lhs, const InstrumentDefMsgV1& rhs) { lhs.tick_rule == rhs.tick_rule; } -std::string ToString(const InstrumentDefMsgV1& instr_def_msg) { +std::string ToString(const InstrumentDefMsg& instr_def_msg) { return MakeString(instr_def_msg); } std::ostream& operator<<(std::ostream& stream, - const InstrumentDefMsgV1& instr_def_msg) { + const InstrumentDefMsg& instr_def_msg) { return StreamOpBuilder{stream} .SetSpacer("\n ") - .SetTypeName("InstrumentDefMsg") + .SetTypeName("v1::InstrumentDefMsg") .Build() .AddField("hd", instr_def_msg.hd) .AddField("ts_recv", instr_def_msg.ts_recv) @@ -272,24 +273,24 @@ std::ostream& operator<<(std::ostream& stream, .AddField("tick_rule", instr_def_msg.tick_rule) .Finish(); } -std::string ToString(const ErrorMsgV1& err_msg) { return MakeString(err_msg); } -std::ostream& operator<<(std::ostream& stream, const ErrorMsgV1& err_msg) { +std::string ToString(const ErrorMsg& err_msg) { return MakeString(err_msg); } +std::ostream& operator<<(std::ostream& stream, const ErrorMsg& err_msg) { return StreamOpBuilder{stream} .SetSpacer("\n ") - .SetTypeName("ErrorMsgV1") + .SetTypeName("v1::ErrorMsg") .Build() .AddField("hd", err_msg.hd) .AddField("err", err_msg.err) .Finish(); } -std::string ToString(const SymbolMappingMsgV1& symbol_mapping_msg) { +std::string ToString(const SymbolMappingMsg& symbol_mapping_msg) { return MakeString(symbol_mapping_msg); } std::ostream& operator<<(std::ostream& stream, - const SymbolMappingMsgV1& symbol_mapping_msg) { + const SymbolMappingMsg& symbol_mapping_msg) { return StreamOpBuilder{stream} .SetSpacer("\n ") - .SetTypeName("SymbolMappingMsgV1") + .SetTypeName("v1::SymbolMappingMsg") .Build() .AddField("hd", symbol_mapping_msg.hd) .AddField("stype_in_symbol", symbol_mapping_msg.stype_in_symbol) @@ -298,16 +299,17 @@ std::ostream& operator<<(std::ostream& stream, .AddField("end_ts", symbol_mapping_msg.end_ts) .Finish(); } -std::string ToString(const SystemMsgV1& system_msg) { +std::string ToString(const SystemMsg& system_msg) { return MakeString(system_msg); } -std::ostream& operator<<(std::ostream& stream, const SystemMsgV1& system_msg) { +std::ostream& operator<<(std::ostream& stream, const SystemMsg& system_msg) { return StreamOpBuilder{stream} .SetSpacer("\n ") - .SetTypeName("SystemMsgV1") + .SetTypeName("v1::SystemMsg") .Build() .AddField("hd", system_msg.hd) .AddField("msg", system_msg.msg) .Finish(); } +} // namespace v1 } // namespace databento diff --git a/tests/src/dbn_decoder_tests.cpp b/tests/src/dbn_decoder_tests.cpp index 460ebcf..3c0000e 100644 --- a/tests/src/dbn_decoder_tests.cpp +++ b/tests/src/dbn_decoder_tests.cpp @@ -114,7 +114,7 @@ TEST_F(DbnDecoderTests, TestDecodeDbz) { } TEST_F(DbnDecoderTests, TestDecodeDefinitionUpgrade) { - ReadFromFile("definition", ".dbn", 1, VersionUpgradePolicy::Upgrade); + ReadFromFile("definition", ".dbn", 1, VersionUpgradePolicy::UpgradeToV2); const Metadata ch_metadata = channel_target_->DecodeMetadata(); const Metadata f_metadata = file_target_->DecodeMetadata(); @@ -165,7 +165,7 @@ TEST_F(DbnDecoderTests, TestUpgradeSymbolMappingWithTsOut) { sym_map, UnixNanos{std::chrono::system_clock::now()}}; std::array compat_buffer{}; const auto res = - DbnDecoder::DecodeRecordCompat(1, VersionUpgradePolicy::Upgrade, true, + DbnDecoder::DecodeRecordCompat(1, VersionUpgradePolicy::UpgradeToV2, true, &compat_buffer, Record{&orig.rec.hd}); const auto& upgraded = res.Get>(); EXPECT_EQ(orig.rec.hd.rtype, upgraded.rec.hd.rtype); @@ -206,7 +206,7 @@ TEST_F(DbnDecoderTests, TestUpgradeMbp1WithTsOut) { {std::chrono::system_clock::now()}}; std::array compat_buffer{}; const auto res = - DbnDecoder::DecodeRecordCompat(1, VersionUpgradePolicy::Upgrade, true, + DbnDecoder::DecodeRecordCompat(1, VersionUpgradePolicy::UpgradeToV2, true, &compat_buffer, Record{&orig.rec.hd}); const auto& upgraded = res.Get>(); // compat buffer unused and pointer unchanged diff --git a/tests/src/live_blocking_tests.cpp b/tests/src/live_blocking_tests.cpp index f672edf..6bcb0b7 100644 --- a/tests/src/live_blocking_tests.cpp +++ b/tests/src/live_blocking_tests.cpp @@ -60,7 +60,7 @@ TEST_F(LiveBlockingTests, TestStartAndUpgrade) { constexpr auto kTsOut = true; for (const auto policy_and_version : {std::make_pair(VersionUpgradePolicy::AsIs, 1), - std::make_pair(VersionUpgradePolicy::Upgrade, 2)}) { + std::make_pair(VersionUpgradePolicy::UpgradeToV2, 2)}) { const mock::MockLsgServer mock_server{dataset::kGlbxMdp3, kTsOut, [](mock::MockLsgServer& self) { self.Accept(); From ec5a0756f23f8dd898e44304b65a3bec03c6133e Mon Sep 17 00:00:00 2001 From: Carter Green Date: Tue, 17 Dec 2024 10:14:59 -0600 Subject: [PATCH 4/4] VER: Release 0.26.0 --- CHANGELOG.md | 2 +- CMakeLists.txt | 2 +- pkg/PKGBUILD | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 4fc9dea..9035742 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,6 +1,6 @@ # Changelog -## 0.26.0 - TBD +## 0.26.0 - 2024-12-17 ### Breaking changes - Removed deprecated `Packaging` enum and `packaging` field that's no longer supported diff --git a/CMakeLists.txt b/CMakeLists.txt index ff306bf..2878e20 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -4,7 +4,7 @@ cmake_minimum_required(VERSION 3.14) # Project details # -project("databento" VERSION 0.25.0 LANGUAGES CXX) +project("databento" VERSION 0.26.0 LANGUAGES CXX) string(TOUPPER ${PROJECT_NAME} PROJECT_NAME_UPPERCASE) # diff --git a/pkg/PKGBUILD b/pkg/PKGBUILD index 5069f9c..0c06586 100644 --- a/pkg/PKGBUILD +++ b/pkg/PKGBUILD @@ -1,7 +1,7 @@ # Maintainer: Databento _pkgname=databento-cpp pkgname=databento-cpp-git -pkgver=0.25.0 +pkgver=0.26.0 pkgrel=1 pkgdesc="Official C++ client for Databento" arch=('any')