Question

I might need to do multiple reads over a big code-base, and with different tools.
I then thought that is a real waste to read on disk so many times while the text won’t change, so I wrote the following.

class Module(object):
    def __init__(self, module_path):
        self.module_path = module_path
        self._text = None
        self._ast = None

    @property
    def text(self):
        if not self._text:
            self._text = open(self.module_path).read()
        return self._text

    @property
    def ast(self):
        s = self.text  # which is actually discarded
        if not self._ast:
            self._ast = parse(self.text)

        return self._ast


class ContentDirectory(object):
    def __init__(self):
        self.content = {}

    def __getitem__(self, module_path):
        if module_path not in self.content:
            self.content[module_path] = Module(module_path)

        return self.content[module_path]

But now it comes the problem, because I would like to avoid changing the rest of the code, while being able to use this new trick.

The only way I see would be to patch the “open” builtin function everywhere it might be used, for example.

from myotherlib import __builtins__ as other_builtins
other_builtins.open = my_dummy_open  # which uses this cache

But it does not really seem like a wise idea.
Should I just give up and only try if the performance is really too bad maybe?

Answer 1

you can use mmap module: http://docs.python.org/library/mmap.html