homepage

Python defines some BSDish exit codes in the os module:
 EX_CANTCREAT = 73
 EX_CONFIG = 78
 EX_DATAERR = 65
 EX_IOERR = 74
 EX_NOHOST = 68
 EX_NOINPUT = 66
 EX_NOPERM = 77
 EX_NOUSER = 67
 EX_OK = 0
 EX_OSERR = 71
 EX_OSFILE = 72
 EX_PROTOCOL = 76
 EX_SOFTWARE = 70
 EX_TEMPFAIL = 75
 EX_UNAVAILABLE = 69
 EX_USAGE = 64
but these are documented as only available on UNIX and may not be portable across all flavors. 
POSIX [1] and C99 defines EXIT_SUCCESS and EXIT_FAILURE constants. I propose adding those to sys.
Having these constants in sys will make them more discoverable because they will be next to sys.exit().
[1] http://pubs.opengroup.org/onlinepubs/009695399/functions/exit.html 

I am attaching a patch implementing these constants. If this is well-received, I will add documentation.

Where are EXIT_FAILURE and EXIT_SUCCESS defined?
And we should probably call them EX_FAILURE and EX_SUCESS to match what's already there.

> Where are EXIT_FAILURE and EXIT_SUCCESS defined?
In C stdlib:
$ grep EXIT_ /usr/include/stdlib.h
#define	EXIT_FAILURE	1
#define	EXIT_SUCCESS	0
> we should probably call them EX_FAILURE and EX_SUCESS to match what's already there.
No. EX_ macros come from a non-standard sysexits.h header. Python stdlib traditionally does not change the spelling of the constants that
come from C libraries or standards.
Even in the absence of POSIX and C99 standards, I would prefer EXIT_ prefix over EX_ for clarity. "EX" does not clearly mean "exit", it may stand for "exception", "execution", "example" etc.

Sounds good, I have no objections.

Aren't EXIT_SUCCESS and EXIT_FAILURE needed only for support VMS?

I would say, they are there to support *humans*. I am not aware of any human language where "success" is spelled 0. (1 is a failing mark in some schools - so there is a precedent for that. :-)

Those should be in the os module, not in sys. The os module is for interfaces to the operating system, while the sys module is for Python-specific stuff.
As for the point of adding them, I don't find them useful, but I won't oppose it either :-)

> Those should be in the os module, not in sys.
I disagree. The whole point of this proposal is to have platform-independent status codes available next to the sys.exit() function.
We already have over a dozen BSDish exit codes in os that are hardly ever used.

> We already have over a dozen BSDish exit codes in os that are hardly
> ever used.
Then precisely, those new codes should go in the os module as well.

I agree with Antoine -- all the exit codes should be in one place.

> Then precisely, those new codes should go in the os module as well.
What is your logic? Having os.EX_ codes in os does not help as far as sys.exit() is concerned: no-one is using them and they are not available on all platforms. If we add EXIT_FAILURE and EXIT_SUCCESS to os now, we will only create confusion: should I use os.EX_OK or os.EXIT_SUCCESS?
Note that sys.exit() is different from os._exit(). It may not even result in termination of the interpreter. Why should users of sys.exit() be required to import os if they want to indicate a failure?

Well, my favourite answer would be use sys.exit(0) and sys.exit(1), respectively (or raise SystemExit without or with an error message), as everyone is already doing right now. Since I don't really get the usability argument of adding those constants, it's hard for me to buy that they should sit close to sys.exit().

Ethan> all the exit codes should be in one place.
Do you realize that os.EX_* codes are not available on Windows? Having platform-independent EXIT_* codes next to posix-only EX_* codes will send the wrong message about their availability.

Antoine> Since I don't really get the usability argument of adding those constants ..
If I am alone in finding exit(EXIT_FAILURE) clearer than exit(1), I should certainly drop my proposal.

Well it would be clearer if not for the widely established knowledge (amongst most or all programming languages) that zero means success and non-zero means failure. So in this case I find it personally useless.

I'm +0 on adding these. The only reason is that I've seen academic
code written by well-known researchers that used 1 for a successful
exit. :)
I'm not sure about the os module. These are C99 and not OS specific.

Stefan> I've seen academic code written by well-known researchers
Stefan> that used 1 for a successful exit.
Thank you! What I've seen more than once was exit(True) to indicate success where True is not necessarily a literal, but something like
len(results) > 0.

This can be implemented as separate module on PyPI. No need to add these aliases for 0 and 1 to the stdlib.

> This can be implemented as separate module on PyPI.
Sure! Make them even less discoverable!
Let me try to state my motivations for adding these constants:
1. I find exit(EXIT_FAILURE) much clearer than exit(1). 
2. I want people to standardize on status=1 for a generic failure code. I do see exit(-1) used as often as exit(1).
3. I want discourage people from using computed integer results as exit status. For example,
# process files and store errors in a list
sys.exit(len(errors)) # bad - success for multiples of 256 errors
sys.exit(sys.EXIT_SUCCESS if not errors else sys.EXIT_FAILURE) # good

An entire PyPI module for two constants?
Change of heart, I'm okay with them going in sys, but only +0 on adding them.
This SO answer* has an interesting point to make about the nature of return codes and what their values should be; tl;dr - the convention should be between your program and the other program(s) you are trying communicate with.
* http://stackoverflow.com/a/8869000/208880 

> the convention should be between your program and the other program(s) you are trying communicate with.
This may be true in general, but Python stdlib sets the convention in its subprocess.check_call and subprocess.check_output methods. These methods use 0=success convention.

> I want people to standardize on status=1 for a generic failure code.
Why that? Multiple error codes can be used by the same program, depending on the kind of error.
> I want discourage people from using computed integer results as exit status.
Ok, that's the first good argument for this feature. Although I would encourage people raise an exception if they want to signify a failure, rather than simply change the error code.

> 1. I find exit(EXIT_FAILURE) much clearer than exit(1). 
 import sys
 exit(sys.EXIT_FAILURE)
or
 import sys
 sys.exit(sys.EXIT_FAILURE)
don't look too clear to me. On the other hand, these constants may helpful to people who came from C world.
> 3. I want discourage people from using computed integer results as exit status.
Adding a FAQ entry or updating sys.exit() documentation would be more suitable to achieve the aim of this item. I wouldn't add two constants to the stdlib because of a bad programming practice.

why not spell them "sys.exit.FAILURE" and "sys.exit.SUCCESS" ?

>> I want people to standardize on status=1 for a generic failure code.
> Why that? Multiple error codes can be used by the same program, depending on the kind of error.
Antoine, please read what I write carefully before disagreeing. I want "to standardize on status=1 for a **generic** failure code". Cooperating processes can certainly agree on other values for the specific failure modes.
What I really want to avoid is the use of -1 as a generic failure code, because it leads to a rather common error
rc = subprocess.call(..)
if rc < 0:
 raise Error # never reached!

How often you see EXIT_SUCCESS and EXIT_FAILURE in C code besides GNU tools that should support VMS? And even GNU tools usually use multiple error codes for different kinds of errors.
I think that these constants are rather unusual for C programmers.
I'm only -0 on adding these constants, not -1, because I'm sure they will be never used. But this will add a burden on the documentation and will confuse inexperienced users when they unexpectedly encounter with sys.exit(sys.EXIT_FAILURE) instead of sys.exit(1).

> And even GNU tools usually use multiple error codes for different kinds of errors.
And how often do they not give them symbolic names?

Actually, my guess is also that these constants will not be used. Not because they are not helpful, but because they'd only be available in Python 3.5+. Meaning that if you use them, your code won't work with long time supported CPython versions like 3.4 for the next decade or so.

> will confuse inexperienced users when they unexpectedly encounter with sys.exit(sys.EXIT_FAILURE) instead of sys.exit(1).
Are you serious? I've seen senior programmers who thought that status < 0 means failure and status >= 0 means success. Why would anyone who understands English would need to know what the numerical value of EXIT_FAILURE is to understand that status=EXIT_FAILURE means "failure"?
Not to mention that google returns a pageful of relevant links for "EXIT_FAILURE".

> if you use them, your code won't work with long time
> supported CPython versions like 3.4 for the next decade or so.
This would be a generic argument against any new feature. I don't think it is very compelling in this case. For people who develop on a latest version. these constants will pop up in sys.<tab> autocompletion and they will likely use them. If they need to support pre-3.5 versions,
try:
 from sys import exit, EXIT_FAILURE
except ImportError:
 from sys import exit
 EXIT_FAILURE = 1
is not a hard work-around.
You would say, why not just use EXIT_FAILURE = 1 to begin with? To avoid Bob using EXIT_FAILURE = -1, Alice using EX_FAIL = 1 and Karl
giving up and using exit(1) in perpetuity.

FWIW I have wondered in the past why these constants were missing. I would be more likely to use them when checking an exit status than when setting one. I typically do "raise SystemExit()" or "raise SystemExit('Error message')", which implicitly sets the status.
My preference would be to put EXIT_SUCCESS and EXIT_FAILURE in the "os" module, next to the existing EX_ codes. But I guess the "sys" module would also work.

@Serhiy, EXIT_FAILURE is used in Python's C code itself (just once admittedly, and then we use 0 sometimes for success and sometimes for errors, and then 1 for errors... aiee.)
FWIW to the extent that folk want to write posix code in Python, I'm all for helping them, I find the amount of help this will be to be hard to assess. There is some code to adding the constants in documentation and learning surface area.
Right now we don't document all the ways Python can interact with exit codes, and I suspect thats actually a bigger burden than writing the code to generate any given code.

I have personally come across situations where I am calling a Python script from a C program and would like to check the exit codes of the script, and have had to write sys.exit(1) and sys.exit(0) in Python, and compared them to EXIT_SUCCESS/EXIT_FAILURE in C. It would have been easy to introduce a bug where I returned the wrong exit code, so I was hoping they would have been implemented in sys.
It seems like a no-brainer to add these, they reduce magic number use and improve the accessibility of Python to people coming from C. I would love to add these if everyone is OK with it.

Hi Elliot!
> It seems like a no-brainer to add these, they reduce magic number use and improve the accessibility of Python to people coming from C. I would love to add these if everyone is OK with it.
Sound great. But IMO I think that this can be solved doing:
 EXIT_FAILURE = 1
 EXIT_SUCCESS = 0
 sys.exit(EXIT_SUCCES)
And what is the difference between EX_OK and EXIT_SUCCESS? both values are 0. 
BTW, I think this is a good improve and more for C coder. 
I recommend you mmake the PR.

Any reasons the PR still not merged?

> Any reasons the PR still not merged?
There was dissent about whether these constants should be added or not. It doesn't help to merge a PR that is not expected to provide a benefit.