datamorph-python 1.22.2

Python bindings for the DataMorph transformation engine

DataMorph

DataMorph is a transformation language and runtime for teams that need to work across more than one document format.

It is designed for integration work where JSON is only part of the story. Typical use cases include:

• XML to JSON
• CSV to XML
• YAML to JSON
• text or binary payloads with headers, attributes, and runtime variables
• the same mapping reused in Java, Apache Camel, Apache NiFi, and the browser Playground

DataMorph is also designed for portability at the runtime level. Because the core is implemented in Rust, the same engine can be packaged more naturally as native libraries, services, CLIs, or thin language bindings than a JVM-first transformation engine. That makes it easier to carry the same transformation engine across platforms and integration stacks over time.

DataMorph is free to use with no expiration. The commercial model is paid support, onboarding, implementation help, and integration services, not runtime licensing.

Who Should Evaluate It

DataMorph is worth evaluating if your team wants:

• one mapping language across Java, Camel, NiFi, and browser tooling
• multi-format transformation instead of JSON-only mapping
• a runtime that can see payload, headers, attributes, and vars
• portable mapping bundles that can be imported and exported between environments
• a runtime core that is portable beyond one host platform or one JVM-only packaging model

If someone wants the closest like-for-like comparison, start with DataSonnet. It is the only close language-level comparison. Tools like Jolt and JSONata are narrower adjacent tools, not direct peers.

What An External Team Can Test

An evaluator does not need access to this repository.

There are four practical entry points:

1. Playground
   • browser-based evaluation of the language and format handling
2. Java SDK
   • embeddable host API for Java applications
3. Apache Camel
   • route integration through Camel components
4. Apache NiFi
   • processor, controller service, custom UI, and NAR packaging

Supported Runtime Formats

Implemented in the current Java SDK and plugin-facing runtime:

• JSON
• XML
• CSV
• YAML
• plain text
• NDJSON
• URL-encoded
• multipart
• DM and DML
• binary as application/octet-stream
• Excel (.xlsx read/write, .xls read-only) as application/xlsx

Recognized but not implemented today:

• Avro
• Protobuf
• Flatfile

External Evaluation Paths

1. Java SDK

Use Maven Central:

<dependency>
  <groupId>io.github.arminmajerie</groupId>
  <artifactId>data-morph-java-sdk</artifactId>
  <version>1.21.1</version>
</dependency>

If 1.21.1 has not finished propagating through Maven Central yet, use the latest visible version or request the evaluation package directly from the maintainer.

See Java SDK README.

2. Apache Camel

Use the Camel modules from Maven Central once they are published:

• io.github.arminmajerie:datamorph-camel-component:1.21.1
• io.github.arminmajerie:datamorph-camel-dataformat:1.21.1
• io.github.arminmajerie:datamorph-camel-language:1.21.1
• io.github.arminmajerie:datamorph-camel-spring-boot-starter:1.21.1

If the 1.21.1 artifacts are not visible in Central yet, request a prebuilt evaluation package while publication completes.

See Camel Quickstart.

3. Apache NiFi

The main NiFi runtime artifact is:

• io.github.arminmajerie:datamorph-nifi-nar:1.21.1

The NAR can be published through Maven Central or handed over directly as a file for evaluation.

See NiFi Quickstart.

4. Playground

The public Playground is the fastest way to understand the language:

• https://amkserver.myddns.rocks/DataMorph-Playground/

Why Teams Look At DataMorph

• One language reused across SDK, Camel, NiFi, and browser tooling
• Multi-format input and output instead of a JSON-only model
• Runtime scope supports payload, headers, attributes, and vars
• Portable mapping bundles make import and export part of the product story
• The Java SDK is embeddable instead of being tied to one vendor runtime
• The core runtime is Rust-based, which makes cross-platform packaging and thin host bindings easier over time
• The language is free to use, so evaluation is not blocked by license negotiation

Closest Comparison

The closest real comparison is DataSonnet.

Why:

• both are transformation-first languages rather than only JSON patch tools
• both can be embedded into integration runtimes
• both are relevant in Camel discussions

Where DataMorph is trying to differentiate:

• a more expressive transformation language
• stronger date and time handling
• richer mapping ergonomics
• one consistent model across XML, CSV, JSON, YAML, text, and runtime metadata
• a runtime core that is easier to carry across platforms and integration stacks over time
• one stack spanning Java SDK, Camel, NiFi, and portable bundles

Camel already has official DataSonnet support through camel-datasonnet, but NiFi does not appear to ship a built-in official DataSonnet processor in the current NiFi component docs. That makes the NiFi story one of the clearest practical differences today.

Honest Status

What is already strong:

• Java SDK exists and is publishable through Maven Central
• Camel integration is implemented and tested
• NiFi processor, controller service, custom UI, and NAR are implemented
• NiFi runtime deployment was smoke-tested in a real NiFi 2.8.0 instance
• Portable mapping bundles work across SDK, Camel, and NiFi

What still needs polish:

• public release flow for the Camel modules
• polished public release flow for the NiFi NAR
• real macOS JNI binaries for the Java SDK
• more examples and onboarding material for new teams

So the core product exists. The main remaining work is packaging, release flow, and adoption polish.

How To Position DataMorph

Do not pitch DataMorph as “the only thing on the market.”

The honest pitch is:

• the closest apples-to-apples comparison is DataSonnet
• DataMorph is interesting because it combines multi-format transforms, an embeddable Java SDK, Camel integration, NiFi integration, and portable bundles in one stack
• the Rust core makes the runtime easier to repackage across native libraries, CLIs, services, and thin bindings over time
• DataSonnet is the real language-level comparison
• JSON-focused tools like Jolt and JSONata solve narrower problems and should not be treated as equivalent alternatives

See Product Comparison.

Recommended Short Pitch

“DataMorph is a free-to-use transformation language for teams that need more than JSON-to-JSON mapping. It is strongest when the same mapping needs to run in Java, Camel, NiFi, and browser tooling while handling formats like XML, JSON, CSV, YAML, and text.”

Maintainer Links

These are useful if you are working on the project itself:

• Java SDK README
• Camel Quickstart
• NiFi Quickstart
• Product Comparison
• Camel and NiFi implementation status