flatterer VS strop

This tool was built for this purpose https://github.com/kindly/flatterer

I have been working on this Rust based JSON flattener (https://github.com/kindly/flatterer) to XLSX/CSV/SQLITE/PARQUET/POSTGRES for about 2 years. I finally made a WASM based one for CSV/XLSX which is really easy to play with. You can use it via a url (if the data has CORS headers), for example https://lite.flatterer.dev?url=https%3A%2F%2Fdummyjson.com%2....

The main difference with other converters/flatteners is that for one-to-many relationships (lists of objects in JSON) it produces a multi table output with keys to help join the tables together. Essentially produces a relational schema, along with some type information, of the JSON provided. For simple non-nested JSON it works too, but is a bit overkill.

Its all opensource and free, and I think that it will become more and more useful as JSON/Graphql APIs proliferate.

flatterer is the easiest option and will do this for you. It will also load the data into a sqlite or postgres database for you.

I have also written something similar but higher level flatterer which is python but is a binding to libflatterer. Its main difference is when there is a list of objects it treats it a one to many and creates a separate CSV file.

flatterer (github) is designed for this.

This looks great and using duckdb as a backend us a great choice. For JSON I suggest using flatterer https://flatterer.opendata.coop/ . Which will convert most JSON into CSV/Parquet with very little technical knowledge.

My project flatterer (used for flattening JSON into tables) also is mainly a python cli/libarary but is written in Rust for speed/memory efficiency and better concurrency.

I have been working on a similar tool for the last while called flatterer (github). It has a similar aim and works with most kinds of JSON well (but not very well with top level objects like yours).

You could try Option B with flatterer https://flatterer.opendata.coop/ which purpose is to convert nested JSON into other formats without a schema upfront including parquet.

flatterer docs (github)

I am completely rewriting strop, (the code sucks, and I know Rust a lot better than when I started, so I wanted to make it a bit better structured and more idiomatic). And I like to have static analysis make sure my code has certain qualities, so I stick this:

Do you think it's an architecture for strop then? It has a focus on code-generation on platforms not well supported by mainstream compilers

Here is a project for generating code for CPUs that do not have much support from mainstream compilers. Currently supported are the 6502 and the STM8 (I'll possibly be adding others in the future, feature requests welcome).

I could use some help on my project strop. Feel free to take a look and see if it's the kind of thing you feel you could contribute to! but be aware that the quality of the codebase is poor. There's a pull request to address this though.

It is my first time of making a Rust library. Actually, my project strop has been a binary crate and only recently have I started trying to use it from a different crate. This is happening on the breakapart branch.

Still working on a big rewrite of strop.

If you're offering free help, then I could use some help with my project strop. (TL;DR: instead of compiling code, it's evolving code. And it has a focus on architectures that don't have good support from mainstream compilers, but I'm open to adding other architectures as well).

My frustration with this kind of situation (and PICs are not unique here, the 6502, CP1600 and other very low end chips have similarly problematic toolchaining) led me to invent strop, for evolving code sequences. It has some basic PIC support.

Hadn't thought of this. I even encountered it recently too.

I am still working on strop. (TL;DR alternative to compiled code, it's evolved code. Tell it which function you want and which registers to use, and it'll randomly generate an assembly language program that does what you wanted)