VER: Release 0.41.0

Author: threecgreen

CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.41.0 - 2025-08-12
+
+### Enhancements
+- Added static `Builder()` methods to the clients
+- Improved debug logging in live clients
+- Added `PUBLISHER_SPECIFIC` flag
+
+### Breaking changes
+- Removed unused `Received` variant from `JobState` enum
+
 ## 0.40.0 - 2025-07-29
 
 ### Enhancements

CMakeLists.txt

@@ -6,7 +6,7 @@ cmake_minimum_required(VERSION 3.24..4.0)
 
 project(
   databento
-  VERSION 0.40.0
+  VERSION 0.41.0
   LANGUAGES CXX
   DESCRIPTION "Official Databento client library"
 )

README.md

@@ -97,27 +97,26 @@ Here is a simple program that fetches 10 seconds of trades for all ES mini futur
 #include <iostream>
 #include <thread>
 
-using namespace databento;
+namespace db = databento;
 
 int main() {
-  PitSymbolMap symbol_mappings;
+  db::PitSymbolMap symbol_mappings;
 
-  auto client = LiveBuilder{}
+  auto client = db::LiveThreaded::Builder()
                     .SetKeyFromEnv()
-                    .SetDataset(Dataset::GlbxMdp3)
+                    .SetDataset(db::Dataset::GlbxMdp3)
                     .BuildThreaded();
 
-  auto handler = [&symbol_mappings](const Record& rec) {
+  auto handler = [&symbol_mappings](const db::Record& rec) {
     symbol_mappings.OnRecord(rec);
-    if (const auto* trade = rec.GetIf<TradeMsg>()) {
-      std::cout << "Received trade for "
-                << symbol_mappings[trade->hd.instrument_id] << ':' << *trade
-                << '\n';
+    if (const auto* trade = rec.GetIf<db::TradeMsg>()) {
+      std::cout << "Received trade for " << symbol_mappings[trade->hd.instrument_id]
+                << ':' << *trade << '\n';
     }
-    return KeepGoing::Continue;
+    return db::KeepGoing::Continue;
   };
 
-  client.Subscribe({"ES.FUT"}, Schema::Trades, SType::Parent);
+  client.Subscribe({"ES.FUT"}, db::Schema::Trades, db::SType::Parent);
   client.Start(handler);
   std::this_thread::sleep_for(std::chrono::seconds{10});
   return 0;
@@ -135,24 +134,23 @@ Here is a simple program that fetches 10 minutes worth of historical trades for
 #include <databento/symbol_map.hpp>
 #include <iostream>
 
-using namespace databento;
+namespace db = databento;
 
 int main() {
-  auto client = HistoricalBuilder{}.SetKey("$YOUR_API_KEY").Build();
-  TsSymbolMap symbol_map;
-  auto decode_symbols = [&symbol_map](const Metadata& metadata) {
+  auto client = db::Historical::Builder().SetKey("$YOUR_API_KEY").Build();
+  db::TsSymbolMap symbol_map;
+  auto decode_symbols = [&symbol_map](const db::Metadata& metadata) {
     symbol_map = metadata.CreateSymbolMap();
   };
-  auto print_trades = [&symbol_map](const Record& record) {
-    const auto& trade_msg = record.Get<TradeMsg>();
-    std::cout << "Received trade for " << symbol_map.At(trade_msg) << ": "
-              << trade_msg << '\n';
-    return KeepGoing::Continue;
+  auto print_trades = [&symbol_map](const db::Record& record) {
+    const auto& trade_msg = record.Get<db::TradeMsg>();
+    std::cout << "Received trade for " << symbol_map.At(trade_msg) << ": " << trade_msg
+              << '\n';
+    return db::KeepGoing::Continue;
   };
-  client.TimeseriesGetRange(
-      "GLBX.MDP3", {"2022-06-10T14:30", "2022-06-10T14:40"}, kAllSymbols,
-      Schema::Trades, SType::RawSymbol, SType::InstrumentId, {}, decode_symbols,
-      print_trades);
+  client.TimeseriesGetRange("GLBX.MDP3", {"2022-06-10T14:30", "2022-06-10T14:40"},
+                            {"ESM2", "NQZ2"}, db::Schema::Trades, db::SType::RawSymbol,
+                            db::SType::InstrumentId, {}, decode_symbols, print_trades);
 }
 ```
 

examples/historical/batch.cpp

@@ -3,20 +3,22 @@
 #include <algorithm>  // find_if
 #include <iostream>
 
-#include "databento/constants.hpp"
 #include "databento/historical.hpp"
+#include "databento/publishers.hpp"  // Dataset
+
+namespace db = databento;
 
 int main() {
-  auto client = databento::HistoricalBuilder{}.SetKeyFromEnv().Build();
+  auto client = db::Historical::Builder().SetKeyFromEnv().Build();
 
   const auto job =
-      client.BatchSubmitJob(databento::dataset::kGlbxMdp3, {"GEZ2"},
-                            databento::Schema::Trades, {"2022-08-26", "2022-09-27"});
+      client.BatchSubmitJob(db::ToString(db::Dataset::GlbxMdp3), {"GEZ2"},
+                            db::Schema::Trades, {"2022-08-26", "2022-09-27"});
   const auto all_jobs = client.BatchListJobs();
 
-  const auto all_job_it = std::find_if(
-      all_jobs.begin(), all_jobs.end(),
-      [&job](const databento::BatchJob& a_job) { return job.id == a_job.id; });
+  const auto all_job_it =
+      std::find_if(all_jobs.begin(), all_jobs.end(),
+                   [&job](const db::BatchJob& a_job) { return job.id == a_job.id; });
 
   if (all_job_it == all_jobs.end()) {
     std::cout << "Couldn't find submitted job\n";

examples/historical/metadata.cpp

@@ -1,14 +1,16 @@
 #include <cstddef>
 #include <iostream>
 
-#include "databento/constants.hpp"
 #include "databento/enums.hpp"
 #include "databento/historical.hpp"
+#include "databento/publishers.hpp"
+
+namespace db = databento;
 
 int main() {
-  using databento::dataset::kGlbxMdp3;
+  const char* glbx_dataset = db::ToString(db::Dataset::GlbxMdp3);
 
-  auto client = databento::HistoricalBuilder{}.SetKeyFromEnv().Build();
+  auto client = db::Historical::Builder().SetKeyFromEnv().Build();
 
   const auto publishers = client.MetadataListPublishers();
   std::cout << "Publishers:\n";
@@ -24,15 +26,14 @@ int main() {
   }
   std::cout << '\n';
 
-  const auto schemas = client.MetadataListSchemas(kGlbxMdp3);
+  const auto schemas = client.MetadataListSchemas(glbx_dataset);
   std::cout << "Schemas(GLBX):\n";
   for (const auto& schema : schemas) {
     std::cout << "- " << schema << '\n';
   }
   std::cout << '\n';
 
-  const auto fields =
-      client.MetadataListFields(databento::Encoding::Dbn, databento::Schema::Trades);
+  const auto fields = client.MetadataListFields(db::Encoding::Dbn, db::Schema::Trades);
   std::cout << "Fields:\n";
   for (const auto& field_detail : fields) {
     std::cout << "- " << field_detail << '\n';
@@ -47,7 +48,7 @@ int main() {
   }
   std::cout << '\n';
 
-  const auto all_unit_prices = client.MetadataListUnitPrices(kGlbxMdp3);
+  const auto all_unit_prices = client.MetadataListUnitPrices(glbx_dataset);
   std::cout << "Unit prices:\n";
   for (const auto& [mode, unit_prices] : all_unit_prices) {
     const auto* mode_str = ToString(mode);
@@ -58,16 +59,16 @@ int main() {
   std::cout << '\n';
 
   const auto record_count = client.MetadataGetRecordCount(
-      kGlbxMdp3, {"2020-12-28", "2020-12-29"}, {"ESH1"}, databento::Schema::Mbo);
+      glbx_dataset, {"2020-12-28", "2020-12-29"}, {"ESH1"}, db::Schema::Mbo);
   std::cout << "Record count: " << record_count << "\n\n";
 
   const std::size_t billable_size = client.MetadataGetBillableSize(
-      kGlbxMdp3, {"2020-12-28", "2020-12-29"}, {"ESH1"}, databento::Schema::Mbo,
-      databento::SType::RawSymbol, {});
+      glbx_dataset, {"2020-12-28", "2020-12-29"}, {"ESH1"}, db::Schema::Mbo,
+      db::SType::RawSymbol, {});
   std::cout << "Billable size (uncompressed binary bytes): " << billable_size << "\n\n";
 
-  const auto cost = client.MetadataGetCost(kGlbxMdp3, {"2020-12-28", "2020-12-29"},
-                                           {"ESH1"}, databento::Schema::Mbo);
+  const auto cost = client.MetadataGetCost(glbx_dataset, {"2020-12-28", "2020-12-29"},
+                                           {"ESH1"}, db::Schema::Mbo);
   std::cout << "Cost (in cents): " << cost << '\n';
 
   return 0;

examples/historical/readme.cpp

@@ -1,27 +1,25 @@
 // Duplicate of the example usage code from the README.md to ensure
 // it compiles and to be able to clang-format it.
-// NOLINTBEGIN(google-build-using-namespace)
 #include <databento/dbn.hpp>
 #include <databento/historical.hpp>
 #include <databento/symbol_map.hpp>
 #include <iostream>
 
-using namespace databento;
+namespace db = databento;
 
 int main() {
-  auto client = HistoricalBuilder{}.SetKey("$YOUR_API_KEY").Build();
-  TsSymbolMap symbol_map;
-  auto decode_symbols = [&symbol_map](const Metadata& metadata) {
+  auto client = db::Historical::Builder().SetKey("$YOUR_API_KEY").Build();
+  db::TsSymbolMap symbol_map;
+  auto decode_symbols = [&symbol_map](const db::Metadata& metadata) {
     symbol_map = metadata.CreateSymbolMap();
   };
-  auto print_trades = [&symbol_map](const Record& record) {
-    const auto& trade_msg = record.Get<TradeMsg>();
+  auto print_trades = [&symbol_map](const db::Record& record) {
+    const auto& trade_msg = record.Get<db::TradeMsg>();
     std::cout << "Received trade for " << symbol_map.At(trade_msg) << ": " << trade_msg
               << '\n';
-    return KeepGoing::Continue;
+    return db::KeepGoing::Continue;
   };
   client.TimeseriesGetRange("GLBX.MDP3", {"2022-06-10T14:30", "2022-06-10T14:40"},
-                            {"ESM2", "NQZ2"}, Schema::Trades, SType::RawSymbol,
-                            SType::InstrumentId, {}, decode_symbols, print_trades);
+                            {"ESM2", "NQZ2"}, db::Schema::Trades, db::SType::RawSymbol,
+                            db::SType::InstrumentId, {}, decode_symbols, print_trades);
 }
-// NOLINTEND(google-build-using-namespace)

examples/historical/symbology_resolve.cpp

@@ -6,24 +6,25 @@
 #include "databento/historical.hpp"
 #include "databento/symbology.hpp"
 
+namespace db = databento;
+
 int main(int argc, char* argv[]) {
   if (argc < 6) {
     std::cerr << "USAGE: symbology-resolve <DATASET> <STYPE_IN> <STYPE_OUT> "
                  "<DATE> <SYMBOLS...>\n";
     return 1;
   }
-  const auto stype_in = databento::FromString<databento::SType>(argv[2]);
-  const auto stype_out = databento::FromString<databento::SType>(argv[3]);
+  const auto stype_in = db::FromString<db::SType>(argv[2]);
+  const auto stype_out = db::FromString<db::SType>(argv[3]);
 
   std::vector<std::string> symbols;
   for (int i = 5; i < argc; ++i) {
     symbols.emplace_back(argv[i]);
   }
 
-  auto client = databento::HistoricalBuilder{}.SetKeyFromEnv().Build();
-  const databento::SymbologyResolution resolution =
-      client.SymbologyResolve(argv[1], symbols, stype_in, stype_out,
-                              databento::DateTimeRange<std::string>{argv[4]});
+  auto client = db::Historical::Builder().SetKeyFromEnv().Build();
+  const db::SymbologyResolution resolution = client.SymbologyResolve(
+      argv[1], symbols, stype_in, stype_out, db::DateTimeRange<std::string>{argv[4]});
   std::cout << resolution << '\n';
 
   return 0;

examples/historical/timeseries_get_range.cpp

@@ -4,19 +4,19 @@
 #include "databento/enums.hpp"
 #include "databento/historical.hpp"
 
+namespace db = databento;
+
 int main() {
-  auto client = databento::HistoricalBuilder{}.SetKeyFromEnv().Build();
+  auto client = db::Historical::Builder().SetKeyFromEnv().Build();
   const auto limit = 1000;
   client.TimeseriesGetRange(
-      databento::dataset::kGlbxMdp3,
-      databento::DateTimeRange<std::string>{"2022-10-03"}, {"ESZ2"},
-      databento::Schema::Trades, databento::SType::RawSymbol,
-      databento::SType::InstrumentId, limit,
-      [](databento::Metadata&& metadata) { std::cout << metadata << '\n'; },
-      [](const databento::Record& record) {
-        const auto& trade_msg = record.Get<databento::TradeMsg>();
+      db::dataset::kGlbxMdp3, db::DateTimeRange<std::string>{"2022-10-03"}, {"ESZ2"},
+      db::Schema::Trades, db::SType::RawSymbol, db::SType::InstrumentId, limit,
+      [](db::Metadata&& metadata) { std::cout << metadata << '\n'; },
+      [](const db::Record& record) {
+        const auto& trade_msg = record.Get<db::TradeMsg>();
         std::cout << trade_msg << '\n';
-        return databento::KeepGoing::Continue;
+        return db::KeepGoing::Continue;
       });
 
   return 0;

examples/historical/timeseries_get_range_to_file.cpp

@@ -1,26 +1,23 @@
-#include <chrono>
-#include <ctime>
-#include <iomanip>
-#include <iostream>  // setw
-
 #include "databento/constants.hpp"
 #include "databento/datetime.hpp"
 #include "databento/dbn_file_store.hpp"
 #include "databento/enums.hpp"
 #include "databento/historical.hpp"
 #include "databento/record.hpp"
 
+namespace db = databento;
+
 int main() {
-  auto client = databento::HistoricalBuilder{}.SetKeyFromEnv().Build();
+  auto client = db::Historical::Builder().SetKeyFromEnv().Build();
   const auto limit = 1000;
-  databento::DbnFileStore dbn_file_store = client.TimeseriesGetRangeToFile(
-      databento::dataset::kGlbxMdp3, {"2022-10-03T00:00", "2022-10-04T00:00"}, {"ESZ2"},
-      databento::Schema::Ohlcv1M, databento::SType::RawSymbol,
-      databento::SType::InstrumentId, limit, "ESZ2-ohlcv1m-20201003-20201004.dbn.zst");
-  dbn_file_store.Replay([](const databento::Record record) {
-    const auto& ohlcv_bar = record.Get<databento::OhlcvMsg>();
+  db::DbnFileStore dbn_file_store = client.TimeseriesGetRangeToFile(
+      db::dataset::kGlbxMdp3, {"2022-10-03T00:00", "2022-10-04T00:00"}, {"ESZ2"},
+      db::Schema::Ohlcv1M, db::SType::RawSymbol, db::SType::InstrumentId, limit,
+      "ESZ2-ohlcv1m-20201003-20201004.dbn.zst");
+  dbn_file_store.Replay([](const db::Record record) {
+    const auto& ohlcv_bar = record.Get<db::OhlcvMsg>();
     std::cout << ohlcv_bar << '\n';
-    return databento::KeepGoing::Continue;
+    return db::KeepGoing::Continue;
   });
   return 0;
 }