← Back
Editing: patched_packages.py
# Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """ Provides patches for some commonly used modules that enable them to work with pyfakefs. """ import sys from importlib import reload try: import pandas as pd try: import pandas.io.parsers as parsers except ImportError: parsers = None except ImportError: pd = None parsers = None try: import xlrd except ImportError: xlrd = None try: import django try: from django.core.files import locks except ImportError: locks = None except ImportError: django = None locks = None # From pandas v 1.2 onwards the python fs functions are used even when the engine # selected is "c". This means that we don't explicitly have to change the engine. patch_pandas = parsers is not None and [ int(v) for v in pd.__version__.split(".")[:2] ] < [ 1, 2, ] def get_modules_to_patch(): modules_to_patch = {} if xlrd is not None: modules_to_patch["xlrd"] = XLRDModule if locks is not None: modules_to_patch["django.core.files.locks"] = FakeLocks return modules_to_patch def get_classes_to_patch(): classes_to_patch = {} if patch_pandas: classes_to_patch["TextFileReader"] = ["pandas.io.parsers"] return classes_to_patch def reload_handler(name): if name in sys.modules: reload(sys.modules[name]) return True def get_cleanup_handlers(): handlers = {} if pd is not None: handlers["pandas.core.arrays.arrow.extension_types"] = ( handle_extension_type_cleanup ) if django is not None: for module_name in django_view_modules(): handlers[module_name] = lambda name=module_name: reload_handler(name) return handlers def get_fake_module_classes(): fake_module_classes = {} if patch_pandas: fake_module_classes["TextFileReader"] = FakeTextFileReader return fake_module_classes if xlrd is not None: class XLRDModule: """Patches the xlrd module, which is used as the default Excel file reader by pandas. Disables using memory mapped files, which are implemented platform-specific on OS level.""" def __init__(self, _): self._xlrd_module = xlrd def open_workbook( self, filename=None, logfile=sys.stdout, verbosity=0, use_mmap=False, file_contents=None, encoding_override=None, formatting_info=False, on_demand=False, ragged_rows=False, ): return self._xlrd_module.open_workbook( filename, logfile, verbosity, False, file_contents, encoding_override, formatting_info, on_demand, ragged_rows, ) def __getattr__(self, name): """Forwards any unfaked calls to the standard xlrd module.""" return getattr(self._xlrd_module, name) if patch_pandas: # we currently need to add fake modules for both the parser module and # the contained text reader - maybe this can be simplified class FakeTextFileReader: fake_parsers = None def __init__(self, filesystem): if self.fake_parsers is None: self.__class__.fake_parsers = ParsersModule(filesystem) def __call__(self, *args, **kwargs): return self.fake_parsers.TextFileReader(*args, **kwargs) def __getattr__(self, name): return getattr(self.fake_parsers.TextFileReader, name) class ParsersModule: def __init__(self, _): self._parsers_module = parsers class TextFileReader(parsers.TextFileReader): def __init__(self, *args, **kwargs): kwargs["engine"] = "python" super().__init__(*args, **kwargs) def __getattr__(self, name): """Forwards any unfaked calls to the standard xlrd module.""" return getattr(self._parsers_module, name) if pd is not None: def handle_extension_type_cleanup(_name): # the module registers two extension types on load # on reload it raises if the extensions have not been unregistered before try: import pyarrow # the code to register these types has been in the module # since it was created (in pandas 1.5) pyarrow.unregister_extension_type("pandas.interval") pyarrow.unregister_extension_type("pandas.period") except ImportError: pass return False if locks is not None: class FakeLocks: """django.core.files.locks uses low level OS functions, fake it.""" _locks_module = locks def __init__(self, _): pass @staticmethod def lock(f, flags): return True @staticmethod def unlock(f): return True def __getattr__(self, name): return getattr(self._locks_module, name) if django is not None: def get_all_view_modules(urlpatterns, modules=None): if modules is None: modules = set() for pattern in urlpatterns: if hasattr(pattern, "url_patterns"): get_all_view_modules(pattern.url_patterns, modules=modules) else: if hasattr(pattern.callback, "cls"): view = pattern.callback.cls elif hasattr(pattern.callback, "view_class"): view = pattern.callback.view_class else: view = pattern.callback modules.add(view.__module__) return modules def django_view_modules(): try: all_urlpatterns = __import__( django.conf.settings.ROOT_URLCONF ).urls.urlpatterns return get_all_view_modules(all_urlpatterns) except Exception: return set()
Save File
Cancel