MOD: Update databento-cpp for metadata API changes

Author: threecgreen

CHANGELOG.md

@@ -1,12 +1,27 @@
 # Changelog
 
-## 0.10.1 - TBD
+## 0.11.0 - TBD
 
 #### Enhancements
 - Added `raw_instrument_id` to definition schema
+- Added `operator==` and `operator!=` implementations for `DatasetConditionDetail` and
+  `DatasetRange`
+
+#### Breaking changes
+- Changed `MetadataListPublishers` to return a `vector<PublisherDetail>`
+- `MetadataListFields`:
+  - Changed return type to `vector<FieldDetail>`
+  - Made `encoding` and `schema` parameters required
+  - Removed `dataset` parameter
+- `MetadataListUnitPrices`:
+  - Changed return type to `vector<UnitPricesForMode>`
+  - Made `dataset` parameter required
+  - Removed `mode` and `schema` parameters
 
 #### Bug fixes
 - Fixed installation of `nlohmann_json` when using bundled version
+- Added missing `operator!=` implementations for `Metadata`, `MappingInterval`, and
+  `SymbolMapping`
 
 ## 0.10.0 - 2023-07-20
 

example/historical/metadata.cpp

@@ -13,7 +13,7 @@ int main() {
   const auto publishers = client.MetadataListPublishers();
   std::cout << "Publishers:\n";
   for (const auto& publisher : publishers) {
-    std::cout << "- " << publisher.first << ": " << publisher.second << '\n';
+    std::cout << "- " << publisher << '\n';
   }
   std::cout << '\n';
 
@@ -31,15 +31,11 @@ int main() {
   }
   std::cout << '\n';
 
-  const auto fields = client.MetadataListFields(
-      kGlbxMdp3, databento::Encoding::Dbn, databento::Schema::Trades);
+  const auto fields = client.MetadataListFields(databento::Encoding::Dbn,
+                                                databento::Schema::Trades);
   std::cout << "Fields:\n";
-  const auto& dbn_trades_fields = fields.at("GLBX.MDP3")
-                                      .at(databento::Encoding::Dbn)
-                                      .at(databento::Schema::Trades);
-  for (const auto& field_and_type : dbn_trades_fields) {
-    std::cout << "- " << field_and_type.first << ": " << field_and_type.second
-              << '\n';
+  for (const auto& field_detail : fields) {
+    std::cout << "- " << field_detail << '\n';
   }
   std::cout << '\n';
 
@@ -54,8 +50,8 @@ int main() {
   const auto all_unit_prices = client.MetadataListUnitPrices(kGlbxMdp3);
   std::cout << "Unit prices:\n";
   for (const auto& mode_and_prices : all_unit_prices) {
-    const auto* mode_str = ToString(mode_and_prices.first);
-    for (const auto& schema_and_price : mode_and_prices.second) {
+    const auto* mode_str = ToString(mode_and_prices.mode);
+    for (const auto& schema_and_price : mode_and_prices.unit_prices) {
       std::cout << "- (" << mode_str << ", " << schema_and_price.first
                 << "): " << schema_and_price.second << '\n';
     }
@@ -67,29 +63,6 @@ int main() {
                                     {"ESH1"}, databento::Schema::Mbo);
   std::cout << "Record count: " << record_count << "\n\n";
 
-  const auto live_unit_prices =
-      client.MetadataListUnitPrices(kGlbxMdp3, databento::FeedMode::Live);
-  std::cout << "Unit prices (live):\n";
-  for (const auto& schema_and_price : live_unit_prices) {
-    std::cout << "- (" << schema_and_price.first
-              << "): " << schema_and_price.second << '\n';
-  }
-  std::cout << '\n';
-
-  const auto trades_unit_prices =
-      client.MetadataListUnitPrices(kGlbxMdp3, databento::Schema::Trades);
-  std::cout << "Unit prices (trades):\n";
-  for (const auto& mode_and_price : trades_unit_prices) {
-    std::cout << "- (" << mode_and_price.first << "): " << mode_and_price.second
-              << '\n';
-  }
-  std::cout << '\n';
-
-  const auto unit_price = client.MetadataListUnitPrices(
-      kGlbxMdp3, databento::FeedMode::Historical, databento::Schema::Trades);
-  std::cout << "Unit price (GLBX.MDP3, Historical, Trades): " << unit_price
-            << "\n\n";
-
   const std::size_t billable_size = client.MetadataGetBillableSize(
       kGlbxMdp3, {"2020-12-28", "2020-12-29"}, {"ESH1"}, databento::Schema::Mbo,
       databento::SType::RawSymbol, {});

include/databento/dbn.hpp

@@ -71,10 +71,16 @@ inline bool operator==(const MappingInterval& lhs, const MappingInterval& rhs) {
   return lhs.start_date == rhs.start_date && lhs.end_date == rhs.end_date &&
          lhs.symbol == rhs.symbol;
 }
+inline bool operator!=(const MappingInterval& lhs, const MappingInterval& rhs) {
+  return !(lhs == rhs);
+}
 
 inline bool operator==(const SymbolMapping& lhs, const SymbolMapping& rhs) {
   return lhs.raw_symbol == rhs.raw_symbol && lhs.intervals == rhs.intervals;
 }
+inline bool operator!=(const SymbolMapping& lhs, const SymbolMapping& rhs) {
+  return !(lhs == rhs);
+}
 
 inline bool operator==(const Metadata& lhs, const Metadata& rhs) {
   return lhs.version == rhs.version && lhs.dataset == rhs.dataset &&
@@ -88,6 +94,9 @@ inline bool operator==(const Metadata& lhs, const Metadata& rhs) {
          lhs.symbols == rhs.symbols && lhs.partial == rhs.partial &&
          lhs.not_found == rhs.not_found && lhs.mappings == rhs.mappings;
 }
+inline bool operator!=(const Metadata& lhs, const Metadata& rhs) {
+  return !(lhs == rhs);
+}
 
 std::string ToString(const Metadata& metadata);
 std::ostream& operator<<(std::ostream& stream, const Metadata& metadata);

include/databento/detail/json_helpers.hpp

@@ -80,6 +80,9 @@ template <>
 std::uint64_t ParseAt(const std::string& endpoint, const nlohmann::json& json,
                       const std::string& key);
 template <>
+std::uint16_t ParseAt(const std::string& endpoint, const nlohmann::json& json,
+                      const std::string& key);
+template <>
 double ParseAt(const std::string& endpoint, const nlohmann::json& json,
                const std::string& key);
 template <>

include/databento/historical.hpp

@@ -1,7 +1,7 @@
 #pragma once
 
 #include <cstdint>
-#include <map>  // map, multimap
+#include <map>  // multimap
 #include <string>
 #include <vector>
 
@@ -10,7 +10,7 @@
 #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/metadata.hpp"  // DatasetConditionDetail, DatasetRange, FieldsByDatasetEncodingAndSchema, PriceByFeedMode, PriceByFeedModeAndSchema, PriceBySchema
+#include "databento/metadata.hpp"  // DatasetConditionDetail, DatasetRange, FieldDetail, PublisherDetail, UnitPricesForMode
 #include "databento/symbology.hpp"  // SymbologyResolution
 #include "databento/timeseries.hpp"  // KeepGoing, MetadataCallback, RecordCallback
 
@@ -80,22 +80,13 @@ class Historical {
    */
 
   // Retrievs a mapping of publisher name to publisher ID.
-  std::map<std::string, std::int32_t> MetadataListPublishers();
+  std::vector<PublisherDetail> MetadataListPublishers();
   std::vector<std::string> MetadataListDatasets();
   std::vector<std::string> MetadataListDatasets(const DateRange& date_range);
   std::vector<Schema> MetadataListSchemas(const std::string& dataset);
-  FieldsByDatasetEncodingAndSchema MetadataListFields();
-  FieldsByDatasetEncodingAndSchema MetadataListFields(
+  std::vector<FieldDetail> MetadataListFields(Encoding encoding, Schema schema);
+  std::vector<UnitPricesForMode> MetadataListUnitPrices(
       const std::string& dataset);
-  FieldsByDatasetEncodingAndSchema MetadataListFields(
-      const std::string& dataset, Encoding encoding, Schema schema);
-  PriceByFeedModeAndSchema MetadataListUnitPrices(const std::string& dataset);
-  PriceBySchema MetadataListUnitPrices(const std::string& dataset,
-                                       FeedMode mode);
-  PriceByFeedMode MetadataListUnitPrices(const std::string& dataset,
-                                         Schema schema);
-  double MetadataListUnitPrices(const std::string& dataset, FeedMode mode,
-                                Schema schema);
   std::vector<DatasetConditionDetail> MetadataGetDatasetCondition(
       const std::string& dataset);
   std::vector<DatasetConditionDetail> MetadataGetDatasetCondition(
@@ -245,8 +236,6 @@ class Historical {
   std::uint64_t MetadataGetRecordCount(const HttplibParams& params);
   std::uint64_t MetadataGetBillableSize(const HttplibParams& params);
   double MetadataGetCost(const HttplibParams& params);
-  FieldsByDatasetEncodingAndSchema MetadataListFields(
-      const HttplibParams& params);
   void TimeseriesGetRange(const HttplibParams& params,
                           const MetadataCallback& metadata_callback,
                           const RecordCallback& record_callback);

include/databento/metadata.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <cstdint>
 #include <map>
 #include <ostream>
 #include <string>
@@ -8,15 +9,22 @@
 #include "databento/enums.hpp"  // FeedMode, DatasetCondition, Schema
 
 namespace databento {
-// mapping of field name to type name
-using FieldDefinition = std::map<std::string, std::string>;
-using FieldsByEncodingAndSchema =
-    std::map<Encoding, std::map<Schema, FieldDefinition>>;
-using FieldsByDatasetEncodingAndSchema =
-    std::map<std::string, FieldsByEncodingAndSchema>;
-using PriceBySchema = std::map<Schema, double>;
-using PriceByFeedModeAndSchema = std::map<FeedMode, PriceBySchema>;
-using PriceByFeedMode = std::map<FeedMode, double>;
+struct PublisherDetail {
+  std::uint16_t publisher_id;
+  std::string dataset;
+  std::string venue;
+  std::string description;
+};
+
+struct FieldDetail {
+  std::string name;
+  std::string type;
+};
+
+struct UnitPricesForMode {
+  FeedMode mode;
+  std::map<Schema, double> unit_prices;
+};
 
 struct DatasetConditionDetail {
   std::string date;
@@ -29,6 +37,52 @@ struct DatasetRange {
   std::string end_date;
 };
 
+inline bool operator==(const PublisherDetail& lhs, const PublisherDetail& rhs) {
+  return lhs.publisher_id == rhs.publisher_id && lhs.dataset == rhs.dataset &&
+         lhs.venue == rhs.venue && lhs.description == rhs.description;
+}
+inline bool operator!=(const PublisherDetail& lhs, const PublisherDetail& rhs) {
+  return !(lhs == rhs);
+}
+
+inline bool operator==(const FieldDetail& lhs, const FieldDetail& rhs) {
+  return lhs.name == rhs.name && lhs.type == rhs.type;
+}
+inline bool operator!=(const FieldDetail& lhs, const FieldDetail& rhs) {
+  return !(lhs == rhs);
+}
+
+inline bool operator==(const UnitPricesForMode& lhs,
+                       const UnitPricesForMode& rhs) {
+  return lhs.mode == rhs.mode && lhs.unit_prices == rhs.unit_prices;
+}
+inline bool operator!=(const UnitPricesForMode& lhs,
+                       const UnitPricesForMode& rhs) {
+  return !(lhs == rhs);
+}
+
+inline bool operator==(const DatasetConditionDetail& lhs,
+                       const DatasetConditionDetail& rhs) {
+  return lhs.date == rhs.date && lhs.condition == rhs.condition &&
+         lhs.last_modified_date == rhs.last_modified_date;
+}
+inline bool operator!=(const DatasetConditionDetail& lhs,
+                       const DatasetConditionDetail& rhs) {
+  return !(lhs == rhs);
+}
+
+inline bool operator==(const DatasetRange& lhs, const DatasetRange& rhs) {
+  return lhs.start_date == rhs.start_date && lhs.end_date == rhs.end_date;
+}
+inline bool operator!=(const DatasetRange& lhs, const DatasetRange& rhs) {
+  return !(lhs == rhs);
+}
+
+std::string ToString(const PublisherDetail& publisher_detail);
+std::ostream& operator<<(std::ostream& stream,
+                         const PublisherDetail& publisher_detail);
+std::string ToString(const FieldDetail& field_detail);
+std::ostream& operator<<(std::ostream& stream, const FieldDetail& field_detail);
 std::string ToString(const DatasetConditionDetail& condition_detail);
 std::ostream& operator<<(std::ostream& stream,
                          const DatasetConditionDetail& condition_detail);

src/detail/json_helpers.cpp

@@ -71,6 +71,20 @@ std::uint64_t ParseAt(const std::string& endpoint, const nlohmann::json& json,
   return val_json;
 }
 
+template <>
+std::uint16_t ParseAt(const std::string& endpoint, const nlohmann::json& json,
+                      const std::string& key) {
+  const auto& val_json = CheckedAt(endpoint, json, key);
+  if (val_json.is_null()) {
+    return 0;
+  }
+  if (!val_json.is_number_unsigned()) {
+    throw JsonResponseError::TypeMismatch(endpoint, key + " unsigned number",
+                                          val_json);
+  }
+  return val_json;
+}
+
 template <>
 double ParseAt(const std::string& endpoint, const nlohmann::json& json,
                const std::string& key) {