Fuckit.py – The Python error steamroller

[irl_zebra]

From the test suite:

def test_context_manager(): with fuckit: pass

    assert 'P' != 'NP' # proof is left as an excercise for the reader

[ndr]

From the implementation:

     try:
         [...]
     except IOError:
         # Worst-case scenario we can only catch errors at a granularity
         # of the whole function.
         [...]
     else:
         # If we have access to the source, we can silence errors on a
         # per-expression basis, which is "better".
         [...]

and then:

    def __exit__(self, exc_type, exc_value, traceback):
        # Returning True prevents the error from propagating. Don't silence
        # KeyboardInterrupt or SystemExit. We aren't monsters.

Brilliant.

[ninetax]

I've been searching for something similar I saw years ago. It was a python library that would remove "heretical" code or something like that. Any error would be "eradicated".

It was funny! There was a religious or medieval theme or something. I can never find it...

[pit]

Vigil, the eternal morally vigilant programming language:

https://github.com/munificent/vigil

[doki_pen]

Works as advertised. I just added it to my project and now all tests are 100% passing! Even 1 == 0!

[3pt14159]

Well to be fair...

http://lmgtfy.com/?q=zero+factorial

[ocdtrekkie]

"This module is like violence: if it doesn't work, you just need more of it."

How could anyone not love this tool?

[kelvin0]

It's the Serious Sam of Python programming ... moar bullets

[bsg75]

s/module/XML/ is another favorite

[avian]

In my previous life I was maintaining some backend services. One of the most common reasons for a service dying was a typo in a name in some rarely visited code path. I was tempted to write a similar module that would be a little bit smarter: when some identifier (variable, method, etc.) was not found, instead of raising an exception, try to find a similarly named thing and use that instead. I never did find a good way of implementing that.

[HCIdivision17]

I think you might like something like TheFuck? EDIT: This bash commandline completion has been updated to by default wait for the user to verify the replacement command is what they wanted; this pretty much turns this from a terminal Russian Roulette into a kinda handy autosuggestion!

https://github.com/nvbn/thefuck

(Previous discussion: https://news.ycombinator.com/item?id=9396116 )

[insertnickname]

That's probably for the best.

[kelvin0]

How about better testing and path coverage of your code? I hope that was also explored as a way to stabilize your codebase? Otherwise your suggestion does come offa bit as 'cowboy-ish' to say the least ...

[dgcoffman]

Ruby has a language feature for this and it's pure 100% poison.

http://rubylearning.com/satishtalim/ruby_method_missing.html

[kevinschumacher]

Looks to be inspired by fuckit.js:

https://github.com/mattdiamond/fuckitjs

So if you want the same thing but for JS give the above a shot.

[collyw]

JS doesn't really need an extra library for that, does it?

[jefurii]

There's also this for your text conversion needs.

http://bazaar.launchpad.net/~leonardr/beautifulsoup/bs4/view...

[mcfunley]

Visual Basic has/had this and not as a joke. It was called "On Error Resume Next."

[ljk]

previous discussion - https://news.ycombinator.com/item?id=6858855

[wyldfire]

There's debate in that thread whether this project is satire or not. I must admit it looks remarkably like satire, especially the test suite.

That said, I have met some developers who would find this as an advantage and might actually try to put it into use. Generally these are folks who prefer the default soldier-on-in-the-face-of-errors behavior from sh and perl.

[hyperion2010]

Ah, this leads to some of my favourite python bugs. Silent failures because you are catching and ignoring an error in some higher calling function where the error type that was once designed to deal with a single case is now overly broad. I've almost given up using try/catch for KeyErrors as a result.

[pekk]

Python uses try/except, not try/catch. The only reason to catch KeyError is to detect missing keys, so if you are trying to do that, only wrap your dict access rather than wrapping large blocks of code where anything could happen. If you are writing code to ignore errors, that is a bug in your own code, not a python bug.

[pikeymick]

The license model is great.

[ronjouch]

Yup. The WTFPL is an actual, (semi)-recognized license used in other projects: https://en.wikipedia.org/wiki/WTFPL

[teh_klev]

From last time around:

https://news.ycombinator.com/item?id=6858855

[dacox]

The tests are gold

[r3bl]

I'm definitely going to use this thing!

[jMyles]

> legitimate tool

You and I have different definitions.

[Khao]

But this tool is not meant to be used. You should never have to write "import someReallyOffensiveModuleName" because those are jokes not meant to be used at work.

[ocdtrekkie]

At work you should probably never be using a tool that just ignores errors. Errors are there for a reason, and you should have a very good reason for ignoring them.

[collyw]

The purpose of this obviously went right over your head.