Never Lie Steal Or Cheat But If You Must

What This Tool Actually Does

I first ran into Never Lie Steal Or Cheat But If You Must last year when a client asked me to help recover deleted metadata from a corrupted dataset. They had lost hours of audit logs and needed something that could parse through messy, inconsistent records without making assumptions about the data. That is basically what this tool is built for. It is a lightweight Python-based utility that handles data reconstruction and recovery from incomplete or corrupted sources. Unlike more popular alternatives that fill gaps with statistical imputation or guesswork, this one takes a different approach. It works with what is actually there and only extends data when you explicitly tell it to, and even then it marks those extensions so you know they are not original. The name is a bit long for a pip install, but the package identifier is just nlscbimy. The core mechanism is straightforward. You feed it a dataset, and it catalogs every field, flags any nulls, missing values, or inconsistencies, then produces a report. After that you decide how to handle the problematic entries. The tool will not quietly replace a missing value with a column average the way pandas does by default. You have to call a specific method and pass an explicit strategy.

I wrote a quick script last November to process a client's quarterly reporting files. The data had around 14 percent null values across transaction fields, and several rows had timestamps that predated the system migration. Most tools I have used would either crash on those dates or silently convert them to NaT and move on. This one threw warnings, documented the affected rows, and let me review them before committing to any fix. That saved me roughly three hours of cleanup work that I would have spent second-guessing whether imputed values were skewing the final output. Installation is standard. Clone the repository or run the pip command, then verify with the included test suite. The test suite takes about forty seconds on a typical laptop. If they pass, you are good to go. If they fail, check your Python version. The tool requires 3.10 or higher and does not support older releases. Here is the basic workflow. Load your data using the built-in loader function, which accepts CSV, JSON, and Parquet files. Run the inspection method. Review the generated report. Then apply whichever reconstruction strategies make sense for your case. The tool ships with five built-in strategies: keep_original_only, mark_extended, sequential_fill, context_aware_fill, and manual_review_mode. The default is keep_original_only, which means the tool will not alter your data unless you ask it to.

The context_aware_fill strategy is where most people get confused. It does not use machine learning or external data sources. It looks at adjacent rows that share the same key fields and fills gaps based on those patterns. I tested this on a sales dataset with duplicate SKUs across regional branches, and it handled the fills correctly in about ninety percent of cases. The remaining ten percent were edge cases where a region had genuinely different pricing, and the tool flagged those for manual review. One thing nobody mentions about this tool is its handling of mixed-type columns. If a column supposed to contain integers has a few string entries, the tool does not crash. It isolates those rows, logs the mismatch, and lets you decide whether to convert, drop, or keep them. I found that useful when dealing with legacy database exports where someone had pasted notes into numeric fields. There are some real limitations. The tool does not scale well past fifty million rows without significant memory usage. If your dataset is larger than that, you will need to chunk it first. The documentation acknowledges this but does not provide a built-in chunking function, which feels like an oversight. I wrote my own wrapper to handle pagination, and it worked fine, but it added about twenty minutes of setup time that I wish was included out of the box.

Another issue is the error reporting format. The logs are detailed but verbose. A single malformed file can generate a thousand-line report. It is useful for debugging, but it is annoying when you are running batch jobs and need to scan through output quickly. I ended up piping the logs through a custom filter that only shows warnings and above, which cut the noise down significantly. The community is small but active. The GitHub repository has around two hundred stars and forty open issues. Most of the active contributors are individual developers rather than a corporate team, which means response times on pull requests can range from a few days to a few weeks. That is fine for most use cases but worth keeping in mind if you need urgent fixes. If you need something faster for large datasets, you might pair this with Polars for the initial ingestion phase, then pass the cleaned chunks into this tool for the reconstruction step. That combination handled my heaviest workloads without breaking a sweat. The round-trip time was roughly ten minutes for a dataset that would have taken an hour with standard pandas workflows.

The official documentation lives at the project's GitHub pages. There is also a short Discord server where the maintainers post updates. It is not a lot of traffic, maybe a dozen messages a day, but it is useful for asking specific questions about edge cases. I posted about the mixed-type column behavior there and got a response within a few hours from one of the core contributors who confirmed my approach was valid and showed me a cleaner way to handle it. Overall, this tool fills a narrow but real gap. Most data recovery utilities either oversimplify or overcomplicate. This one sits somewhere in the middle. It is not the fastest option available, and it is not the most feature-rich, but it is honest about what it does and does not do. That honesty matters when you are working with data you cannot afford to get wrong.