without blocking the main thread.

    We close inpipe once the end of the source stream is reached.

    """

    def __init__(self, source):

        super(StreamFeeder, self).__init__()

        self.daemon = True

        filelike = False

        self.bytes = bytes()

        if type(source) in (type(''), bytes, bytearray):  # string-like

            self.bytes = bytes(source)

        else:  # can be either file pointer or file-like

                # converting file descriptor (int) stdin into file-like

                source = os.fdopen(source, 'rb', 16384)

            # let's see if source is file-like by now

            filelike = hasattr(source, 'read')

        if not filelike and not self.bytes:

            raise TypeError("StreamFeeder's source object must be a readable "

                            "file-like, a file descriptor, or a string-like.")

        self.source = source

        self.readiface, self.writeiface = os.pipe()

    def run(self):

        t = self.writeiface

        If `value` is None or already a `cls` instance, return it. If `value`

        is a number (or looks like one if you squint just right), assume it's

        a database primary key and let SQLAlchemy sort things out. Otherwise,

        fall back to resolving it using `callback` (if specified); this could

        e.g. be a function that looks up instances by name (though that won't

        work if the name begins with a digit). Otherwise, raise Exception.

        """

        if value is None:

            return None

        if isinstance(value, cls):

            return value

            return cls.get(value)

        if isinstance(value, basestring) and value.isdigit():

            return cls.get(int(value))

        if callback is not None:

            return callback(value)

        raise Exception(

            'given object must be int, long or Instance of %s '

            'got %s, no callback provided' % (cls, type(value))

        )

    @classmethod