Here's a link to the ActiveState Recipes site that says how you can read a single character in Windows, Linux and OSX:

    getch()-like unbuffered character reading from stdin on both Windows and Unix

class _Getch:
    """Gets a single character from standard input.  Does not echo to the
screen."""
    def __init__(self):
        try:
            self.impl = _GetchWindows()
        except ImportError:
            self.impl = _GetchUnix()

    def __call__(self): return self.impl()


class _GetchUnix:
    def __init__(self):
        import tty, sys

    def __call__(self):
        import sys, tty, termios
        fd = sys.stdin.fileno()
        old_settings = termios.tcgetattr(fd)
        try:
            tty.setraw(sys.stdin.fileno())
            ch = sys.stdin.read(1)
        finally:
            termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
        return ch


class _GetchWindows:
    def __init__(self):
        import msvcrt

    def __call__(self):
        import msvcrt
        return msvcrt.getch()


getch = _Getch()

I really don't like that you detect which version of _GetchX to use via an ImportError - that isn't obvious to me at all. I also don't like that you keep importing things locally. I think you can solve this like so:

import platform
system = platform.system()    
import sys

if system == "Windows":
    import msvcrt

    class _Getch:
        """Gets a single character from standard input."""

        def __call__(self):
            return msvcrt.getch()

else:
    import tty, termios

    class _Getch: 
        """Gets a single character from standard input."""

        def __call__(self):
            fd = sys.stdin.fileno()
            old_settings = termios.tcgetattr(fd)
            try:
                tty.setraw(sys.stdin.fileno())
                ch = sys.stdin.read(1)
            finally:
                termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
            return ch

If that level of repetition is also upsetting, move the if inside of the __call__ implementation, but that seems like too much. You could try this instead:

class _Getch:
    """Gets a single character from standard input."""

if system == "Windows":
    import msvcrt

    def _call(self):
        return msvcrt.getch()

else:
    import tty, termios

    def _call(self):
       fd = sys.stdin.fileno()
       old_settings = termios.tcgetattr(fd)
       try:
           tty.setraw(sys.stdin.fileno())
           ch = sys.stdin.read(1)
       finally:
           termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
           return ch

_Getch.__call__ = _call

More generally, however, I don't understand why this is a class. Just make it a function.

if system == "Windows":
    import msvcrt

    def getch():
        return msvcrt.getch()

else:
    import tty, termios

    def getch():
       fd = sys.stdin.fileno()
       old_settings = termios.tcgetattr(fd)
       try:
           tty.setraw(sys.stdin.fileno())
           ch = sys.stdin.read(1)
       finally:
           termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
           return ch

Why is this a lambda?

parsenum = (lambda num:
        (sys.maxsize if 0 > num else num))

Just make a normal function, for readability if nothing else.

def parsenum(num):
    return sys.maxsize if 0 > num else num

General thoughts on the rest of your code:

Why are you explicitly calling __call__()? Just call it normally (or just use the function, as above). You also have a lot of magic numbers, which to someone who is not immediately familiar with their ASCII codes (I have literally never been able to remember any ASCII code off the top of my head) isn't helpful - prefer named constants here. Instead of ox == 27 or ox == 127 just do ox in [27, 127] (and replace that with some constant). You shouldn't need to explicitly turn chars into a list, unless you expect that it is some bizarre iterable type that doesn't implement __getitem__.

You mentioned in the comments that you assign the result of sys.stdout.write(i) because it will append the result to the output otherwise. I had no idea that happens, and it seems pretty odd, but it looks like a code smell to anyone (like myself) who doesn't know that it happens. You could put a comment everywhere you do that, but that is annoying and you might forget if you add it in the future. I'd write a simple helper method

def write_to_stdout(i):
    # Have to assign or it will append the result to the output
    _ = sys.stdout.write(i)
    sys.stdout.flush()

until and until_not are basically identical - they could be condensed to this:

def _until_condition(chars, condition, count) -> str:
    y = []
    count = parsenum(count)
    while len(y) <= count:
        i = read_single_keypress()
        write_to_stdout(i)
        if condition(i, chars):
            break
        y = nbsp(i, y)
    return "".join(y)

def until(chars, count=-1) -> str:
    """get chars of stdin until any of chars is read,
    or until count chars have been read, whichever comes first"""

    return _until_condition(chars, lambda i, chars: i in chars, count)

def until_not(chars, count=-1) -> str:
    """read stdin until any of chars stop being read,
    or until count chars have been read; whichever comes first"""

    return _until_condition(chars, lambda i, chars: i not in chars, count)

This is because your terminal is in cooked mode. You can use e.g. tty.setcbreak or curses.cbreak to disable the line buffering. This is a Unix thing, not particularly Python specific.

Example:

import sys, tty
tty.setcbreak(sys.stdin.fileno())

Note that this has other effects such as disabling echo and will persist when your program exits. Typically a higher level interface such as a curses context manager is used to handle key parsing (arrow keys, for instance, send escape sequences) and cleanup.

The primary command line tool outside of Python for this is stty.

Problem is probably due to flushing of stdin since the \n lingers on.

as an alternative, use raw_input

while True:
    c = raw_input('please enter a character: ')
    print 'you entered', c

For the flushing part, see this

Use the fileinput module:

import fileinput

for line in fileinput.input():
    pass

fileinput will loop through all the lines in the input specified as file names given in command-line arguments, or the standard input if no arguments are provided.

Note: line will contain a trailing newline; to remove it use line.rstrip().

It's simpler:

for line in sys.stdin:
    chrCounter += len(line)

The file-like object sys.stdin is automatically iterated over line by line; if you call .readline() on it, you only read the first line (and iterate over that character-by-character); if you call read(), then you'll read the entire input into a single string and iterate over that character-by.character.