VER: Release 0.22.0

CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 0.22.0 - 2024-08-27
+
+### Enhancements
+- Added `Intraday` variant to `DatasetCondition` in preparation for intraday data being
+ available from the historical API
+- Renamed `example` directory to `examples`
+- Renamed `test` directory to `tests`
+- Added new publisher values for `XCIS.BBOTRADES` and `XNYS.BBOTRADES`
+
+### Breaking changes
+- Removed previously deprecated `DatasetCondition::Bad` variant
+
 ## 0.21.0 - 2024-07-30
 
 ### Enhancements

CMakeLists.txt

@@ -4,7 +4,7 @@ cmake_minimum_required(VERSION 3.14)
 # Project details
 #
 
-project("databento" VERSION 0.21.0 LANGUAGES CXX)
+project("databento" VERSION 0.22.0 LANGUAGES CXX)
 string(TOUPPER ${PROJECT_NAME} PROJECT_NAME_UPPERCASE)
 
 #
@@ -421,12 +421,12 @@ if(${PROJECT_NAME_UPPERCASE}_ENABLE_UNIT_TESTING)
  unset(CMAKE_CXX_CLANG_TIDY) # disable clang-tidy for tests
  enable_testing()
  message(STATUS "Build unit tests for the project.")
- add_subdirectory(test)
+ add_subdirectory(tests)
 endif()
 
 if(${PROJECT_NAME_UPPERCASE}_ENABLE_EXAMPLES)
  unset(CMAKE_CXX_CPPCHECK) # disable cppcheck for examples
  unset(CMAKE_CXX_CLANG_TIDY) # disable clang-tidy for examples
  message(STATUS "Build examples for the project.")
- add_subdirectory(example)
+ add_subdirectory(examples)
 endif()

example/live/CMakeLists.txt → examples/live/CMakeLists.txt

@@ -2,3 +2,4 @@ cmake_minimum_required(VERSION 3.14)
 
 add_example_target(live-readme readme.cpp)
 add_example_target(simple simple.cpp)
+add_example_target(live-smoke-test live_smoke_test.cpp)

examples/live/live_smoke_test.cpp

@@ -0,0 +1,210 @@
+#include <cassert>
+#include <chrono>
+#include <cstdlib>
+#include <cstring>
+#include <databento/constants.hpp>
+#include <databento/datetime.hpp>
+#include <databento/enums.hpp>
+#include <databento/live.hpp>
+#include <databento/symbology.hpp>
+#include <iostream>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <unordered_map>
+
+using namespace databento;
+
+std::vector<std::string> SplitSymbols(const std::string& symbols) {
+ std::vector<std::string> result;
+ std::stringstream ss(symbols);
+
+ std::string buffer;
+ while (std::getline(ss, buffer, ',')) {
+ result.push_back(buffer);
+ }
+
+ return result;
+}
+
+std::pair<bool, UnixNanos> TryConvertToUnixNanos(const char* start) {
+ std::stringstream ss(start);
+ std::size_t pos;
+ const uint64_t result = std::stoul(start, &pos, 10);
+ if (pos != std::strlen(start)) {
+ return std::make_pair(false, UnixNanos{});
+ }
+
+ return std::make_pair(true, UnixNanos{std::chrono::nanoseconds(result)});
+}
+
+void ProcessRecords(LiveBlocking& client, Schema schema,
+ bool start_from_epoch) {
+ client.Start();
+
+ std::cout << "Starting client...\n";
+
+ // For start != 0 we stop at SymbolMappingMsg so that the tests can be run
+ // outside trading hours
+ auto expected_rtype = Record::RTypeFromSchema(schema);
+ if (!start_from_epoch) {
+ expected_rtype = databento::rtype::SymbolMapping;
+ }
+
+ constexpr auto timeout = std::chrono::seconds{30};
+
+ while (auto record = client.NextRecord(timeout)) {
+ if (record->RType() == expected_rtype) {
+ std::cout << "Received expected record type " << expected_rtype << '\n';
+ break;
+ } else if (auto* msg = record->GetIf<ErrorMsg>()) {
+ std::stringstream ss;
+ ss << "Received error " << msg->Err() << '\n';
+ std::cerr << ss.str();
+ throw std::runtime_error(ss.str());
+ }
+ }
+
+ std::cout << "Finished client\n";
+}
+
+void ProcessSnapshotRecords(LiveBlocking& client, Schema schema) {
+ client.Start();
+
+ std::cout << "Starting client...\n";
+
+ const auto expected_rtype = Record::RTypeFromSchema(schema);
+
+ constexpr auto timeout = std::chrono::seconds{30};
+
+ auto received_snapshot_record = false;
+
+ while (auto record = client.NextRecord(timeout)) {
+ if (auto* mbo_msg = record->GetIf<MboMsg>()) {
+ if (mbo_msg->flags.IsSnapshot()) {
+ received_snapshot_record = true;
+ } else {
+ std::cout << "Received expected record type " << expected_rtype << '\n';
+ break;
+ }
+ } else if (auto* error_msg = record->GetIf<ErrorMsg>()) {
+ std::stringstream ss;
+ ss << "Received error " << error_msg->Err() << '\n';
+ throw std::runtime_error(ss.str());
+ }
+ }
+
+ std::cout << "Finished client\n";
+
+ if (!received_snapshot_record) {
+ throw std::runtime_error("Did not receive snapshot record");
+ }
+}
+
+class ArgParser {
+ public:
+ struct Arg {
+ const std::string name;
+ const std::string arg;
+ const char* value = nullptr;
+ };
+
+ void Add(Arg arg) { args.emplace_back(arg); }
+
+ void Parse(int argc, char* argv[]) {
+ for (auto i = 1; i < argc;) {
+ const auto cur_arg = argv[i];
+ auto it = std::find_if(
+ args.begin(), args.end(),
+ [&cur_arg](const auto& arg) { return cur_arg == arg.arg; });
+ if (it != args.end()) {
+ it->value = argv[i + 1];
+ }
+ i += 2;
+ }
+ }
+
+ const char* Get(const std::string& arg_name) const {
+ auto it = std::find_if(
+ args.begin(), args.end(),
+ [&arg_name](const auto& arg) { return arg_name == arg.name; });
+
+ if (it == args.end()) {
+ return nullptr;
+ }
+
+ return it->value;
+ }
+
+ private:
+ std::vector<Arg> args;
+};
+
+ArgParser ParseArgs(int argc, char* argv[]
+
+) {
+ ArgParser parser;
+ parser.Add(ArgParser::Arg{"gateway", "--gateway"});
+ parser.Add(ArgParser::Arg{"port", "--port", "13000"});
+ parser.Add(ArgParser::Arg{"api_key_env_var", "--api-key-env-var",
+ "DATABENTO_API_KEY"});
+ parser.Add(ArgParser::Arg{"dataset", "--dataset"});
+ parser.Add(ArgParser::Arg{"schema", "--schema"});
+ parser.Add(ArgParser::Arg{"stype", "--stype"});
+ parser.Add(ArgParser::Arg{"symbols", "--symbols"});
+ parser.Add(ArgParser::Arg{"start", "--start"});
+ parser.Add(ArgParser::Arg{"use_snapshot", "--use-snapshot", "0"});
+
+ parser.Parse(argc, argv);
+
+ return parser;
+}
+
+int main(int argc, char* argv[]) {
+ const auto parser = ParseArgs(argc, argv);
+
+ const auto gateway = parser.Get("gateway");
+ const auto port = std::atoi(parser.Get("port"));
+ const auto api_key_env_var = parser.Get("api_key_env_var");
+ const auto dataset = FromString<Dataset>(parser.Get("dataset"));
+ const auto schema = FromString<Schema>(parser.Get("schema"));
+ const auto stype = FromString<SType>(parser.Get("stype"));
+ const auto symbols = SplitSymbols(parser.Get("symbols"));
+ const auto start = parser.Get("start");
+ const auto use_snapshot = std::atoi(parser.Get("use_snapshot"));
+
+ const auto api_key = std::getenv(api_key_env_var);
+ assert(api_key);
+
+ auto client = LiveBuilder{}
+ .SetAddress(gateway, static_cast<uint16_t>(port))
+ .SetKey(std::string{api_key})
+ .SetDataset(dataset)
+ .BuildBlocking();
+
+ bool start_from_epoch = false;
+
+ if (use_snapshot) {
+ client.SubscribeWithSnapshot(symbols, schema, stype);
+ } else if (start) {
+ const auto converted = TryConvertToUnixNanos(start);
+ if (converted.first) {
+ start_from_epoch = converted.second.time_since_epoch().count() == 0;
+ client.Subscribe(symbols, schema, stype, converted.second);
+ } else {
+ client.Subscribe(symbols, schema, stype, start);
+ }
+ } else {
+ client.Subscribe(symbols, schema, stype);
+ }
+
+ if (use_snapshot) {
+ ProcessSnapshotRecords(client, schema);
+ } else {
+ ProcessRecords(client, schema, start_from_epoch);
+ }
+
+ std::cout << "Finished client\n";
+
+ return 0;
+}

include/databento/enums.hpp

@@ -114,7 +114,7 @@ enum class DatasetCondition : std::uint8_t {
  Degraded,
  Pending,
  Missing,
- Bad, // Deprecated
+ Intraday,
 };
 
 // Sentinel values for different DBN record types.

include/databento/publishers.hpp

@@ -157,10 +157,14 @@ enum class Dataset : std::uint16_t {
  NdexImpact = 29,
  // Databento Equities Max
  DbeqMax = 30,
- // Nasdaq Basic (NLS+QBBO)
+ // Nasdaq Basic (NLS and QBBO)
  XnasBasic = 31,
  // Databento Equities Summary
  DbeqSummary = 32,
+ // NYSE National BBO and Trades
+ XcisBbotrades = 33,
+ // NYSE BBO and Trades
+ XnysBbotrades = 34,
 };
 
 // A specific Venue from a specific data source.
@@ -345,6 +349,10 @@ enum class Publisher : std::uint16_t {
  XnasBasicXpsx = 89,
  // Databento Equities Summary
  DbeqSummaryDbeq = 90,
+ // NYSE National BBO and Trades
+ XcisBbotradesXcis = 91,
+ // NYSE BBO and Trades
+ XnysBbotradesXnys = 92,
 };
 
 // Get a Publisher's Venue.

pkg/PKGBUILD

@@ -1,7 +1,7 @@
 # Maintainer: Databento <support@databento.com>
 _pkgname=databento-cpp
 pkgname=databento-cpp-git
-pkgver=0.21.0
+pkgver=0.22.0
 pkgrel=1
 pkgdesc="Official C++ client for Databento"
 arch=('any')

src/enums.cpp

@@ -251,8 +251,8 @@ const char* ToString(DatasetCondition condition) {
  case DatasetCondition::Missing: {
  return "missing";
  }
- case DatasetCondition::Bad: { // Deprecated
- return "bad";
+ case DatasetCondition::Intraday: {
+ return "intraday";
  }
  default: {
  return "unknown";
@@ -1104,8 +1104,8 @@ DatasetCondition FromString(const std::string& str) {
  if (str == "missing") {
  return DatasetCondition::Missing;
  }
- if (str == "bad") {
- return DatasetCondition::Bad; // Deprecated
+ if (str == "intraday") {
+ return DatasetCondition::Intraday;
  }
  throw InvalidArgumentError{"FromString<DatasetCondition>", "str",
  "unknown value '" + str + '\''};