VER: Release 0.38.0

Author: threecgreen

CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 0.38.0 - TBD
+
+### Breaking changes
+- Renamed `Compression::ZStd` to `Zstd` for consistency
+- Removed duplicated `flags` constants in `enums` module. Use the top-level `flags`
+  constants instead
+- Renamed to `SCHEMA_COUNT` to `Schema::COUNT`
+
+### Bug fixes
+- Relaxed requirement of `input_version` parameter to the Python `Transcoder` to only
+  be required when transcoding to CSV without `Metadata`, where previously it was always
+  required when transcoding data without `Metadata`
+- Added missing methods to Python for `StatUpdateAction` enum
+
 ## 0.37.1 - 2025-07-15
 
 ### Bug fixes

Cargo.lock

@@ -11,7 +11,7 @@ resolver = "2"
 [workspace.package]
 authors = ["Databento <[email protected]>"]
 edition = "2021"
-version = "0.37.1"
+version = "0.38.0"
 documentation = "https://databento.com/docs"
 repository = "https://github.com/databento/dbn"
 license = "Apache-2.0"

Cargo.toml

@@ -6,7 +6,7 @@ use std::{
 
 use dbn::{
     encode::{csv, json, DbnEncodable, EncodeRecordRef},
-    rtype, rtype_dispatch, RecordHeader, RecordRef, Schema,
+    rtype_dispatch, RType, RecordHeader, RecordRef, Schema,
 };
 
 use crate::cfile::CFileRef;
@@ -235,7 +235,7 @@ pub unsafe extern "C" fn schema_from_rtype(rtype: u8, res: *mut Schema) -> bool
     if res.is_null() {
         return false;
     }
-    if let Some(schema) = rtype::try_into_schema(rtype) {
+    if let Some(schema) = RType::try_into_schema(rtype) {
         *res = schema;
         true
     } else {

c/src/text_serialization.rs

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "databento-dbn"
-version = "0.37.1"
+version = "0.38.0"
 description = "Python bindings for encoding and decoding Databento Binary Encoding (DBN)"
 authors = ["Databento <[email protected]>"]
 license = "Apache-2.0"
@@ -17,7 +17,7 @@ build-backend = "maturin"
 
 [project]
 name = "databento-dbn"
-version = "0.37.1"
+version = "0.38.0"
 authors = [
     { name = "Databento", email = "[email protected]" }
 ]

python/pyproject.toml

@@ -455,6 +455,8 @@ class Encoding(Enum):
     @classmethod
     def from_str(cls, value: str) -> Encoding: ...
     @classmethod
+    def from_int(cls, value: int) -> Encoding: ...
+    @classmethod
     def variants(cls) -> Iterable[Encoding]: ...
 
 class Compression(Enum):
@@ -474,6 +476,8 @@ class Compression(Enum):
     @classmethod
     def from_str(cls, value: str) -> Compression: ...
     @classmethod
+    def from_int(cls, value: int) -> Compression: ...
+    @classmethod
     def variants(cls) -> Iterable[Compression]: ...
 
 class SecurityUpdateAction(Enum):
@@ -909,8 +913,6 @@ class Metadata(SupportsBytes):
         version: int | None = None,
     ) -> None: ...
     def __bytes__(self) -> bytes: ...
-    def __eq__(self, other) -> bool: ...
-    def __ne__(self, other) -> bool: ...
     @property
     def version(self) -> int:
         """
@@ -1178,8 +1180,6 @@ class Record(SupportsBytes):
     _timestamp_fields: ClassVar[list[str]]
 
     def __bytes__(self) -> bytes: ...
-    def __eq__(self, other) -> bool: ...
-    def __ne__(self, other) -> bool: ...
     @property
     def hd(self) -> RecordHeader:
         """

python/python/databento_dbn/_lib.pyi

@@ -200,19 +200,15 @@ impl<const OUTPUT_ENC: u8> Inner<OUTPUT_ENC> {
         let mut output = DynWriter::new(BufWriter::new(file), compression)?;
         let map_symbols = map_symbols.unwrap_or(true);
         if !has_metadata {
-            let Some(input_version) = input_version else {
-                return Err(PyValueError::new_err(
-                    "must specify input_version when has_metadata=False",
-                ));
-            };
             // if there's metadata, the header will be encoded when the metadata is processed
             Self::encode_header_if_csv(
                 &mut output,
                 pretty_px,
                 pretty_ts,
                 ts_out,
                 map_symbols,
-                upgrade_policy.output_version(input_version),
+                upgrade_policy,
+                input_version,
                 schema,
             )?;
         }
@@ -324,10 +320,8 @@ impl<const OUTPUT_ENC: u8> Inner<OUTPUT_ENC> {
             self.use_pretty_ts,
             self.fsm.ts_out(),
             self.map_symbols,
-            self.fsm
-                .upgrade_policy()
-                // Input version will be populated after decoding metadata
-                .output_version(self.fsm.input_dbn_version().unwrap()),
+            self.fsm.upgrade_policy(),
+            self.fsm.input_dbn_version(),
             self.schema,
         )
     }
@@ -338,10 +332,17 @@ impl<const OUTPUT_ENC: u8> Inner<OUTPUT_ENC> {
         use_pretty_ts: bool,
         ts_out: bool,
         map_symbols: bool,
-        output_version: u8,
+        upgrade_policy: VersionUpgradePolicy,
+        input_version: Option<u8>,
         schema: Option<Schema>,
     ) -> PyResult<()> {
         if OUTPUT_ENC == Encoding::Csv as u8 {
+            let Some(input_version) = input_version else {
+                return Err(PyValueError::new_err(
+                    "must specify input_version when has_metadata=False",
+                ));
+            };
+            let output_version = upgrade_policy.output_version(input_version);
             let Some(schema) = schema else {
                 return Err(PyValueError::new_err(
                     "A schema must be specified when transcoding mixed schema DBN to CSV",

python/src/transcoder.rs

@@ -16,7 +16,7 @@ name = "dbn"
 path = "src/main.rs"
 
 [dependencies]
-dbn = { path = "../dbn", version = "=0.37.1", default-features = false }
+dbn = { path = "../dbn", version = "=0.38.0", default-features = false }
 
 anyhow = { workspace = true }
 clap = { version = "4.5", features = ["derive", "wrap_help"] }

rust/dbn-cli/Cargo.toml

@@ -222,7 +222,7 @@ impl Args {
 /// aren't already explicitly set.
 pub fn infer_encoding(args: &Args) -> anyhow::Result<(Encoding, Compression, u8)> {
     let compression = if args.zstd {
-        Compression::ZStd
+        Compression::Zstd
     } else {
         Compression::None
     };
@@ -234,19 +234,19 @@ pub fn infer_encoding(args: &Args) -> anyhow::Result<(Encoding, Compression, u8)
         OutputEncoding::Infer => {
             if let Some(output) = args.output.as_ref().map(|o| o.to_string_lossy()) {
                 if output.ends_with(".dbn.zst") {
-                    Ok((Encoding::Dbn, Compression::ZStd, 0))
+                    Ok((Encoding::Dbn, Compression::Zstd, 0))
                 } else if output.ends_with(".dbn") {
                     Ok((Encoding::Dbn, Compression::None, 0))
                 } else if output.ends_with(".csv.zst") {
-                    Ok((Encoding::Csv, Compression::ZStd, b','))
+                    Ok((Encoding::Csv, Compression::Zstd, b','))
                 } else if output.ends_with(".csv") {
                     Ok((Encoding::Csv, Compression::None, b','))
                 } else if output.ends_with(".tsv.zst") || output.ends_with(".xls.zst") {
-                    Ok((Encoding::Csv, Compression::ZStd, b'\t'))
+                    Ok((Encoding::Csv, Compression::Zstd, b'\t'))
                 } else if output.ends_with(".tsv") || output.ends_with(".xls") {
                     Ok((Encoding::Csv, Compression::None, b'\t'))
                 } else if output.ends_with(".json.zst") {
-                    Ok((Encoding::Json, Compression::ZStd, 0))
+                    Ok((Encoding::Json, Compression::Zstd, 0))
                 } else if output.ends_with(".json") {
                     Ok((Encoding::Json, Compression::None, 0))
                 } else {
@@ -321,15 +321,15 @@ mod tests {
         b'\t'
     )]
     #[case(false, false, false, true, false, Encoding::Dbn, Compression::None, 0)]
-    #[case(true, false, false, false, true, Encoding::Json, Compression::ZStd, 0)]
+    #[case(true, false, false, false, true, Encoding::Json, Compression::Zstd, 0)]
     #[case(
         false,
         true,
         false,
         false,
         true,
         Encoding::Csv,
-        Compression::ZStd,
+        Compression::Zstd,
         b','
     )]
     #[case(
@@ -339,10 +339,10 @@ mod tests {
         false,
         true,
         Encoding::Csv,
-        Compression::ZStd,
+        Compression::Zstd,
         b'\t'
     )]
-    #[case(false, false, false, true, true, Encoding::Dbn, Compression::ZStd, 0)]
+    #[case(false, false, false, true, true, Encoding::Dbn, Compression::Zstd, 0)]
     fn test_infer_encoding_and_compression_explicit(
         #[case] json: bool,
         #[case] csv: bool,
@@ -370,11 +370,11 @@ mod tests {
     #[case("out.tsv", Encoding::Csv, Compression::None, b'\t')]
     #[case("out.xls", Encoding::Csv, Compression::None, b'\t')]
     #[case("out.dbn", Encoding::Dbn, Compression::None, 0)]
-    #[case("out.json.zst", Encoding::Json, Compression::ZStd, 0)]
-    #[case("out.csv.zst", Encoding::Csv, Compression::ZStd, b',')]
-    #[case("out.tsv.zst", Encoding::Csv, Compression::ZStd, b'\t')]
-    #[case("out.xls.zst", Encoding::Csv, Compression::ZStd, b'\t')]
-    #[case("out.dbn.zst", Encoding::Dbn, Compression::ZStd, 0)]
+    #[case("out.json.zst", Encoding::Json, Compression::Zstd, 0)]
+    #[case("out.csv.zst", Encoding::Csv, Compression::Zstd, b',')]
+    #[case("out.tsv.zst", Encoding::Csv, Compression::Zstd, b'\t')]
+    #[case("out.xls.zst", Encoding::Csv, Compression::Zstd, b'\t')]
+    #[case("out.dbn.zst", Encoding::Dbn, Compression::Zstd, 0)]
     fn test_infer_encoding_and_compression_inference(
         #[case] output: &str,
         #[case] exp_enc: Encoding,

rust/dbn-cli/src/lib.rs

@@ -25,7 +25,7 @@ serde = ["dep:serde", "time/parsing", "time/serde"]
 trivial_copy = []
 
 [dependencies]
-dbn-macros = { version = "=0.37.1", path = "../dbn-macros" }
+dbn-macros = { version = "=0.38.0", path = "../dbn-macros" }
 
 async-compression = { version = "0.4.25", features = ["tokio", "zstd"], optional = true }
 csv = { workspace = true }