As per the docs

first do f.flush(), and then do os.fsync(f.fileno()), to ensure that all internal buffers associated with f are written to disk.

Here is an example,

import os

with open("filename", "w") as f:
    while True:  # infinite program
        f.write("the text")
        f.flush()
        os.fsync(f.fileno())

For writing the internal buffer to the file you can use the files flush function. However, this should generally be handled by your operating system which has a default buffer size. You can use something like this to open your file if you want to specify your own buffer size:

f = open('file.txt', 'w', buffering=bufsize)

Please also see the following question: How often does Python flush to file

Alternatively to flushing the buffer you could also try to use rolling files, i.e. open a new file if the size of your currently opened file exceeds a certain size. This is generally good practice if you intend to write a lot of data.

Looks like it writes the output to some buffer

That's correct. You can disable this with flush=True, so:

while True:
  print('tick', flush=True)
  time.sleep(5)

doWrite isn't there for you to call. It is part of the interface between the transport and the reactor. It is not part of the interface between the transport and the protocol.

FileDescriptor does not buffer writes until a certain number of bytes have been written. It only buffers writes (at most) until the reactor gets a chance to run again. Twisted is a cooperative multi-tasking system. Only one thing happens at a time. If the one thing that's happening is your application code running then the reactor isn't taking care of its job (like writing bytes to file descriptors). Each thing has to wait for the other to finish before it can start.

Whatever led you to the conclusion that there's a size-based write buffer was a mistake. Whatever problem you're trying to solve, the solution doesn't look like this.

An example usage:

>>> s = 'Hello world'
>>> t = buffer(s, 6, 5)
>>> t
<read-only buffer for 0x10064a4b0, size 5, offset 6 at 0x100634ab0>
>>> print t
world

The buffer in this case is a sub-string, starting at position 6 with length 5, and it doesn't take extra storage space - it references a slice of the string.

This isn't very useful for short strings like this, but it can be necessary when using large amounts of data. This example uses a mutable bytearray:

>>> s = bytearray(1000000)   # a million zeroed bytes
>>> t = buffer(s, 1)         # slice cuts off the first byte
>>> s[1] = 5                 # set the second element in s
>>> t[0]                     # which is now also the first element in t!
'\x05'

This can be very helpful if you want to have more than one view on the data and don't want to (or can't) hold multiple copies in memory.

Note that buffer has been replaced by the better named memoryview in Python 3, though you can use either in Python 2.7.

Note also that you can't implement a buffer interface for your own objects without delving into the C API, i.e. you can't do it in pure Python.

To actually answer the question if you really want to use BufferedWriter.

import io

buffer_size = <number of bytes>

# Open the file unbuffered because we don't want to buffer twice.
with open("myfile.bin", "wb+", 0) as raw_file:
  with io.BufferedWriter(raw_file, buffer_size) as buffered_file:
    buffered_file.write(b"<your data>")

This works for binary files, if you want to do this but with text you need TextIOWrapper.

import io

buffer_size = <number of bytes>

# Open the file unbuffered because we don't want to buffer twice.
with open("myfile.txt", "wb+", 0) as raw_file:
  with io.BufferedWriter(raw_file, buffer_size) as buffered_file:
    # Again, turn off buffering because we're handling that.
    with io.TextIOWrapper(buffered_file, write_through=True) as buffered_text_file:
      buffered_text_file.write("<your data>")

Nested with statements can be written like

with (
  context_manager1 as foo,
  context_manager2 as bar,
  ...
):
  ...

to avoid the deep nesting but if you don't know the shorthand it can look confusing.