How can I open a .NET FileStream object from a Python file handle?

Question

I need to open a writable file handle in Python and then hand off the file descriptor to a function in a .NET assembly (accessed via pythonnet's clr module.

Getting from the Python file object to the win32 HANDLE* is fairly straightforward, as shown in this question:

import clr
from Microsoft.Win32.SafeHandles import SafeFileHandle
from System.IO import FileStream, FileAccess

pyf=open("c:/temp/testing123.txt","w")
fileno=pyf.fileno()
print fileno               # 6
handle = msvcrt.get_osfhandle(fileno)
print handle               # 1832L

According to MSDN, it should now be possible to construct a standard FileStream object from either a straight IntPtr (the handle) or from a SafeFileHandle wrapper.

FileStream(IntPtr, FileAccess)
FileStream(SafeFileHandle, FileAccess)

The problem is... how can I convince the clr module to cast handle as an IntPtr?

I've tried various versions of the following, but they all give me errors:

FileStream(IntPtr(handle), True)
FileStream(IntPtr(Int64(handle), True)
FileStream(IntPtr(Int32(handle), True)
SafeFileHandle(IntPtr(handle), True)
...

=> TypeError ("value cannot be converted to System.IntPtr")

Any suggestions for how to get this darn file handle into C#?

@denfromufa, for various reasons the CLR API is superior for this project. The answer you linked to explains how to get managed handles from C++ into C#, but doesn't help me with the Python case, unfortunately. — Dan Lenski, Jul 21 '15 at 18:16

score 2 · Answer 1 · answered Apr 04 '16 at 02:32

probably a bit too late for this answer, but would something like this have worked?

from contextlib import contextmanager
import ctypes
import io
import os, sys
import tempfile

libc = ctypes.CDLL(None)
c_stdout = ctypes.c_void_p.in_dll(libc, 'stdout')

@contextmanager
def stdout_redirector(stream):
    # The original fd stdout points to. Usually 1 on POSIX systems.
    original_stdout_fd = sys.stdout.fileno()

    def _redirect_stdout(to_fd):
        """Redirect stdout to the given file descriptor."""
        # Flush the C-level buffer stdout
        libc.fflush(c_stdout)
        # Flush and close sys.stdout - also closes the file descriptor (fd)
        sys.stdout.close()
        # Make original_stdout_fd point to the same file as to_fd
        os.dup2(to_fd, original_stdout_fd)
        # Create a new sys.stdout that points to the redirected fd
        sys.stdout = io.TextIOWrapper(os.fdopen(original_stdout_fd, 'wb'))

    # Save a copy of the original stdout fd in saved_stdout_fd
    saved_stdout_fd = os.dup(original_stdout_fd)
    try:
        # Create a temporary file and redirect stdout to it
        tfile = tempfile.TemporaryFile(mode='w+b')
        _redirect_stdout(tfile.fileno())
        # Yield to caller, then redirect stdout back to the saved fd
        yield
        _redirect_stdout(saved_stdout_fd)
        # Copy contents of temporary file to the given stream
        tfile.flush()
        tfile.seek(0, io.SEEK_SET)
        stream.write(tfile.read())
    finally:
        tfile.close()
        os.close(saved_stdout_fd)

Yeah, that's a plausible option too, although trying to modify the `stdin`/`stdout` filehandles can be really fiddly under Windows. I think that casting the Windows C API filehandle to a C# filehandle is still more straightforward. In any case, you are now the guy in charge of the code that actually uses this :-). Is it causing problems? — Dan Lenski, May 06 '16 at 07:16
I think the best answer is, not yet... Latest release of `pythonnet` has compatibility issues and was trying to find an Standard Lib alternate. — Victor Uriarte, May 12 '16 at 17:14

score 1 · Accepted Answer · answered Jul 21 '15 at 22:52

Got an answer thanks to the good folks on the pythonnet mailing list.

The key is to use the Overloads constructor to force-cast the win32 HANDLE to IntPtr type.

Here's a complete working example:

import tempfile, msvcrt
import clr, msvcrt
from System.IO import FileStream, FileAccess
from System import IntPtr

with tempfile.NamedTemporaryFile(suffix='.txt', delete=False) as pyf:
    fileno=pyf.fileno()
    print "fileno", fileno
    handle = msvcrt.get_osfhandle(fileno)
    print "HANDLE", handle

    pyf.write("Python\n")
    pyf.flush()

    cs_handle = IntPtr.Overloads[long](handle)
    cs_fs = FileStream(cs_handle, FileAccess.Write)
    cs_fs.Write("CLR\n", 0, 4)
    cs_fs.Flush()

print "file should contain a line from Python and a line from CLR: ", pyf.name

How can I open a .NET FileStream object from a Python file handle?

2 Answers2

Linked