MOD: Remove or change metadata endpoints

Author: cjdsellers

CHANGELOG.md

@@ -3,6 +3,9 @@
 ## 0.5.0 - TBD
 - Added `Historical::MetadataGetDatasetRange`
 - Changed `MetadataGetDatasetCondition` to return `vector<DatasetConditionDetail>`
+- Removed `MetadataListCompressions` (redundant with docs)
+- Removed `MetadataListEncodings` (redundant with docs)
+- Removed optional `start` and `end` params from `MetadataListSchemas` (redundant)
 - Renamed `FileBento` to `DbnFileStore`
 
 ## 0.4.0 - 2023-03-02

example/historical/metadata.cpp

@@ -43,13 +43,6 @@ int main() {
   }
   std::cout << '\n';
 
-  const auto encodings = client.MetadataListEncodings();
-  std::cout << "Encodings:\n";
-  for (const auto encoding : encodings) {
-    std::cout << "- " << encoding << '\n';
-  }
-  std::cout << '\n';
-
   const auto dataset_conditions = client.MetadataGetDatasetCondition(
       "GLBX.MDP3", "2019-06-01", "2019-08-01");
   std::cout << "Conditions:\n";
@@ -58,13 +51,6 @@ int main() {
   }
   std::cout << '\n';
 
-  const auto compressions = client.MetadataListCompressions();
-  std::cout << "Compressions:\n";
-  for (const auto compression : compressions) {
-    std::cout << "- " << compression << '\n';
-  }
-  std::cout << '\n';
-
   const auto all_unit_prices = client.MetadataListUnitPrices(kGlbxMdp3);
   std::cout << "Unit prices:\n";
   for (const auto& mode_and_prices : all_unit_prices) {

include/databento/historical.hpp

@@ -76,16 +76,11 @@ class Historical {
   std::vector<std::string> MetadataListDatasets(const std::string& start_date,
                                                 const std::string& end_date);
   std::vector<Schema> MetadataListSchemas(const std::string& dataset);
-  std::vector<Schema> MetadataListSchemas(const std::string& dataset,
-                                          const std::string& start_date,
-                                          const std::string& end_date);
   FieldsByDatasetEncodingAndSchema MetadataListFields();
   FieldsByDatasetEncodingAndSchema MetadataListFields(
       const std::string& dataset);
   FieldsByDatasetEncodingAndSchema MetadataListFields(
       const std::string& dataset, Encoding encoding, Schema schema);
-  std::vector<Encoding> MetadataListEncodings();
-  std::vector<Compression> MetadataListCompressions();
   PriceByFeedModeAndSchema MetadataListUnitPrices(const std::string& dataset);
   PriceBySchema MetadataListUnitPrices(const std::string& dataset,
                                        FeedMode mode);

src/historical.cpp

@@ -489,16 +489,9 @@ std::vector<std::string> Historical::MetadataListDatasets(
 
 std::vector<databento::Schema> Historical::MetadataListSchemas(
     const std::string& dataset) {
-  return this->MetadataListSchemas(dataset, {}, {});
-}
-std::vector<databento::Schema> Historical::MetadataListSchemas(
-    const std::string& dataset, const std::string& start_date,
-    const std::string& end_date) {
   static const std::string kEndpoint = "Historical::MetadataListSchemas";
   static const std::string kPath = ::BuildMetadataPath(".list_schemas");
   httplib::Params params{{"dataset", dataset}};
-  ::SetIfNotEmpty(&params, "start_date", start_date);
-  ::SetIfNotEmpty(&params, "end_date", end_date);
   const nlohmann::json json = client_.GetJson(kPath, params);
   if (!json.is_array()) {
     throw JsonResponseError::TypeMismatch(kEndpoint, "array", json);
@@ -583,44 +576,6 @@ databento::FieldsByDatasetEncodingAndSchema Historical::MetadataListFields(
   return fields;
 }
 
-std::vector<databento::Encoding> Historical::MetadataListEncodings() {
-  static const std::string kEndpoint = "Historical::MetadataListEncodings";
-  static const std::string kPath = ::BuildMetadataPath(".list_encodings");
-  const nlohmann::json json = client_.GetJson(kPath, {});
-  if (!json.is_array()) {
-    throw JsonResponseError::TypeMismatch(kEndpoint, "array", json);
-  }
-  std::vector<Encoding> encodings;
-  for (const auto& encoding_json : json.items()) {
-    if (!encoding_json.value().is_string()) {
-      throw JsonResponseError::TypeMismatch(
-          kEndpoint, "string", encoding_json.key(), encoding_json.value());
-    }
-    encodings.emplace_back(FromString<Encoding>(encoding_json.value()));
-  }
-  return encodings;
-}
-
-std::vector<databento::Compression> Historical::MetadataListCompressions() {
-  static const std::string kEndpoint = "Historical::MetadataListCompressions";
-  static const std::string kPath = ::BuildMetadataPath(".list_compressions");
-  const nlohmann::json json = client_.GetJson(kPath, {});
-  if (!json.is_array()) {
-    throw JsonResponseError::TypeMismatch(kEndpoint, "array", json);
-  }
-  std::vector<Compression> compressions;
-  for (const auto& compression_json : json.items()) {
-    if (!compression_json.value().is_string()) {
-      throw JsonResponseError::TypeMismatch(kEndpoint, "string",
-                                            compression_json.key(),
-                                            compression_json.value());
-    }
-    compressions.emplace_back(
-        FromString<Compression>(compression_json.value()));
-  }
-  return compressions;
-}
-
 static const std::string kListUnitPricesEndpoint =
     "Historical::MetadataListUnitPrices";
 static const std::string kListUnitPricesPath =

test/src/historical_tests.cpp

@@ -322,15 +322,13 @@ TEST_F(HistoricalTests, TestMetadataListSchemas_Simple) {
 TEST_F(HistoricalTests, TestMetadataListSchemas_Full) {
   const nlohmann::json kResp{"mbo", "mbp-1", "ohlcv-1m", "ohlcv-1h",
                              "ohlcv-1d"};
-  mock_server_.MockGetJson(
-      "/v0/metadata.list_schemas",
-      {{"dataset", dataset::kGlbxMdp3}, {"end_date", "2020-01-01"}}, kResp);
+  mock_server_.MockGetJson("/v0/metadata.list_schemas",
+                           {{"dataset", dataset::kGlbxMdp3}}, kResp);
   const auto port = mock_server_.ListenOnThread();
 
   databento::Historical target{kApiKey, "localhost",
                                static_cast<std::uint16_t>(port)};
-  const auto res =
-      target.MetadataListSchemas(dataset::kGlbxMdp3, {}, "2020-01-01");
+  const auto res = target.MetadataListSchemas(dataset::kGlbxMdp3);
   const std::vector<Schema> kExp{Schema::Mbo, Schema::Mbp1, Schema::Ohlcv1M,
                                  Schema::Ohlcv1H, Schema::Ohlcv1D};
   ASSERT_EQ(res.size(), kResp.size());
@@ -372,31 +370,6 @@ TEST_F(HistoricalTests, TestMetadataListFields) {
   EXPECT_EQ(tradesRes.at("dataset_id"), "uint16_t");
 }
 
-TEST_F(HistoricalTests, TestMetadataListEncodings) {
-  const nlohmann::json kResp{"dbn", "csv", "json"};
-  mock_server_.MockGetJson("/v0/metadata.list_encodings", kResp);
-  const auto port = mock_server_.ListenOnThread();
-
-  databento::Historical target{kApiKey, "localhost",
-                               static_cast<std::uint16_t>(port)};
-  const auto res = target.MetadataListEncodings();
-  const std::vector<Encoding> kExp{Encoding::Dbn, Encoding::Csv,
-                                   Encoding::Json};
-  EXPECT_EQ(res, kExp);
-}
-
-TEST_F(HistoricalTests, TestMetadataListCompressions) {
-  const nlohmann::json kResp{"none", "zstd"};
-  mock_server_.MockGetJson("/v0/metadata.list_compressions", kResp);
-  const auto port = mock_server_.ListenOnThread();
-
-  databento::Historical target{kApiKey, "localhost",
-                               static_cast<std::uint16_t>(port)};
-  const auto res = target.MetadataListCompressions();
-  const std::vector<Compression> kExp{Compression::None, Compression::Zstd};
-  EXPECT_EQ(res, kExp);
-}
-
 TEST_F(HistoricalTests, TestMetadataGetDatasetCondition) {
   const nlohmann::json kResp{
       {{"date", "2022-11-07"}, {"condition", "available"}},