def test_module_in_zipped(): with zip_file_in_sys_path(): import moduleinzipped scan(moduleinzipped) assert fixtures.calls == 1
def test_package_in_zipped(): with zip_file_in_sys_path(): import packageinzipped scan(packageinzipped) assert fixtures.calls == 1
def test_ignore_module_absolute(): from .fixtures import ignore_module_absolute scan(ignore_module_absolute, ignore=['importscan.tests.fixtures.ignore_module_absolute.module']) assert fixtures.calls == 0
def test_scenario(): importscan.scan(scenario) dectate.commit(app.Root, app.Generic, app.Document) c = Client(app.Root()) response = c.get('/document') assert response.body == b'Document root' response = c.get('/foo') assert response.body == b'Generic root' response = c.get('/document/a') assert response.body == b'Document model a' response = c.get('/foo/a') assert response.body == b'Generic model a' response = c.get('/') assert response.json == [ 'http://localhost/foo/a', 'http://localhost/document/b' ] response = c.get('/foo/a/link') assert response.body == b'http://localhost/document/c' response = c.get('/document/a/link') assert response.body == b'http://localhost/foo/d'
def test_attributeerror_not_handle_error(): from .fixtures import attributeerror_not_handle_error # skip import errors but not attribute errors def handle_error(name, e): if not isinstance(e, ImportError): raise e with raises(AttributeError): scan(attributeerror_not_handle_error, handle_error=handle_error)
def init_database(registry): import importscan import reha.sql database = reha.sql.Database.from_url( url="sqlite:///example.db" ) importscan.scan(reha.sql) database.instanciate() return database
def register_external_implementations_in(*modules): warnings.warn( message="register_external_implementations_in is deprecated," " please use importscan.scan", category=DeprecationWarning, stacklevel=2, ) import importscan for module in modules: importscan.scan(module)
def test_importerror_handle_error(): from .fixtures import importerror_handle_error # skip import errors def handle_error(name, e): if not isinstance(e, ImportError): raise e scan(importerror_handle_error, handle_error=handle_error) assert fixtures.calls == 1
def application(request, user_interface, authentication, session_middleware, database_with_contents): contents = Registry() contents.register('user', User) contents.register('document', Document) contents.register('file', File) importscan.scan(uvcreha) app = Application(secret=b"secret", database=database_with_contents, authentication=authentication, ui=user_interface, contents=contents) yield (app, WebApp(session_middleware(app)))
def call_builder_init(cls, kb_app, sphinx_app: Sphinx): """ On builder init event, commit registry and do callbacks """ # Find and commit docs project plugins conf_dir = sphinx_app.confdir plugins_dir = sphinx_app.config.kaybee_settings.plugins_dir full_plugins_dir = os.path.join(conf_dir, plugins_dir) if os.path.exists(full_plugins_dir): sys.path.insert(0, conf_dir) plugin_package = importlib.import_module(plugins_dir) importscan.scan(plugin_package) else: logger.info(f'## Kaybee: No plugin dir at {plugins_dir}') dectate.commit(kb_app) for callback in cls.get_callbacks(kb_app, SphinxEvent.BI): callback(kb_app, sphinx_app)
def scan(package=None, ignore=None, handle_error=None): """Scan package for configuration actions (decorators). It scans by recursively importing the package and any modules in it, including any sub-packages. Register any found directives with their app classes. :param package: The Python module or package to scan. Optional; if left empty case the calling package is scanned. :param ignore: A list of packages to ignore. Optional. Defaults to ``['.test', '.tests']``. See :func:`importscan.scan` for details. :param handle_error: Optional error handling function. See :func:`importscan.scan` for details. """ if package is None: package = caller_package() if ignore is None: ignore = ['.test', '.tests'] importscan.scan(package, ignore, handle_error)
def test_rescan(): importscan.scan(basic) dectate.commit(basic.app) importscan.scan(basic) class Sub(basic.app): pass @Sub.view(model=basic.Model, name='extra') def extra(self, request): return "extra" dectate.commit(Sub) c = Client(Sub()) response = c.get('/1/extra') assert response.body == b'extra' response = c.get('/1') assert response.body == b'The view for model: 1'
def scan(package=None, ignore=None, handle_error=None): """Scan package for configuration actions (decorators). It scans by recursively importing the package and any modules in it, including any sub-packages. Register any found directives with their app classes. It also makes a list of :class:`App` subclasses that can be commited using :func:`autocommit`. :param package: The Python module or package to scan. Optional; if left empty case the calling package is scanned. :param ignore: A list of packages to ignore. Optional. Defaults to ``['.test', '.tests']``. See :func:`importscan.scan` for details. :param handle_error: Optional error handling function. See :func:`importscan.scan` for details. """ if package is None: package = caller_package() if ignore is None: ignore = ['.test', '.tests'] importscan.scan(package, ignore, handle_error)
def read(self): return self.visible_widget.read() def fill(self, value): return self.visible_widget.fill(value) def fill(self, fill_data): values = deflatten_dict(fill_data) was_change = False self.before_fill(values) for key, value in values.items(): widget = self.fields(key) if value is None: self.logger.debug('Skipping fill of %r because value was None', key) continue try: if widget.fill(value): was_change = True except NotImplementedError: continue self.after_fill(was_change) return was_change from cfme.services.service_catalogs import ui, ssui # NOQA last for import cycles importscan.scan(ui) importscan.scan(ssui)
def test_ignore_subpackage_function(): from .fixtures import ignore_subpackage_function scan(ignore_subpackage_function, ignore=re.compile('sub$').search) assert fixtures.calls == 0
def test_ignore_module_relative(): from .fixtures import ignore_module scan(ignore_module, ignore=['.module']) assert fixtures.calls == 0
def test_ignore_module_function(): from .fixtures import ignore_module_function scan(ignore_module_function, ignore=re.compile('module$').search) assert fixtures.calls == 0
def test_module(): from .fixtures import module scan(module) assert fixtures.calls == 1
def test_empty_subpackage(): from .fixtures import empty_subpackage scan(empty_subpackage) assert fixtures.calls == 1
def autoscan(ignore=None): """Automatically load Morepath configuration from packages. Morepath configuration consists of decorator calls on :class:`App` instances, i.e. ``@App.view()`` and ``@App.path()``. This function tries to load needed Morepath configuration from all packages automatically. This only works if: - The package is made available using a ``setup.py`` file. - The package or a dependency of the package includes ``morepath`` in the ``install_requires`` list of the ``setup.py`` file. - The ``setup.py`` name is the same as the name of the distributed package or module. For example: if the module inside the package is named ``myapp`` the package must be named ``myapp`` as well (not ``my-app`` or ``MyApp``). If the ``setup.py`` name differs from the package name, it's possible to specify the module morepath should scan using entry points:: setup(name='some-package', ... install_requires=[ 'setuptools', 'morepath' ], entry_points={ 'morepath': [ 'scan = somepackage', ] }) This function simply recursively imports everything in those packages, except for test directories. In addition to calling this function you can also import modules that use Morepath directives manually, and you can use :func:`scan` to automatically import everything in a single package. Typically called immediately after startup just before the application starts serving using WSGI. ``autoscan`` always ignores ``.test`` and ``.tests`` sub-packages -- these are assumed never to contain useful Morepath configuration and are not scanned. ``autoscan`` can fail with an ``ImportError`` when it tries to scan code that imports an optional dependency that is not installed. This happens most commonly in test code, which often rely on test-only dependencies such as ``pytest`` or ``nose``. If those tests are in a ``.test`` or ``.tests`` sub-package they are automatically ignored, however. If you have a special package with such expected import errors, you can exclude them from ``autoscan`` using the ``ignore`` argument, for instance using ``['special_package']``. You then can use :func:`scan` for that package, with a custom ``ignore`` argument that excludes the modules that generate import errors. See also :func:`scan`. :param ignore: ignore to ignore some modules during scanning. Optional. If ommitted, ignore ``.test`` and ``.tests`` packages by default. See :func:`importscan.scan` for more details. """ if ignore is None: ignore = [] ignore.extend(['.test', '.tests']) for package in morepath_packages(): importscan.scan(package, ignore)
def test_attributeerror(): from .fixtures import attributeerror with raises(AttributeError): scan(attributeerror)
"""Generic Objects class to context switch between REST and Automate. Read/Update/Delete functionality. """ update = sentaku.ContextualMethod() delete = sentaku.ContextualMethod() add_tag = sentaku.ContextualMethod() remove_tag = sentaku.ContextualMethod() get_tags = sentaku.ContextualMethod() exists = sentaku.ContextualProperty() name = attr.ib() definition = attr.ib() # generic object definition attributes = attr.ib(default=None) # e.g. {'address': 'Test Address'} associations = attr.ib(default=None) # e.g. {'services': [myservice1, myservice2]} rest_response = attr.ib(default=None, init=False) my_service = attr.ib(default=None) # my_service object with instance assignment @attr.s class GenericObjectInstanceCollection(BaseCollection, sentaku.modeling.ElementMixin): ENTITY = GenericObjectInstance create = sentaku.ContextualMethod() from . import rest, ui # NOQA last for import cycles importscan.scan(rest) importscan.scan(ui)
# from iqe.test_framework.helpers import find_application # # return find_application(context) @property def application(self): return self @property def collections(self): from mta.base.modeling import EntityCollections return EntityCollections.for_application(self) # @contextmanager # def copy_using(self, *, user): # """ # returns a teporary application with changes applied # # :param user: a user credential record to use instead of the default/original one # """ # with _application_construction_allowed(): # app = Application(config=self.config, user=user) # yield app # app.web_ui.browser_manager.close() from mta import base # noqa importscan.scan(base)
uvcreha.contents.registry.register('file', contents.File) uvcreha.contents.registry.register('document', contents.Document) uvcreha.contents.registry.register('preferences', contents.Preferences) #from database.arango import init_database from database.sql import init_database import reha.sql database = init_database(reha.sql.mappers) # Load essentials importscan.scan(uvcreha.browser) importscan.scan(uvcreha.api) ### Middlewares # Session session_environ = "uvcreha.session" session = uvcreha.plugins.session_middleware( pathlib.Path("var/sessions"), secret='secret', cookie_name="uvcreha.cookie" ) session_getter = reiter.auth.components.session_from_environ( session_environ
@attr.s class GenericObjectDefinition(BaseEntity, Updateable, sentaku.modeling.ElementMixin): """Generic Objects Definition class to context switch between UI and REST. Read/Update/Delete functionality. """ update = sentaku.ContextualMethod() delete = sentaku.ContextualMethod() exists = sentaku.ContextualProperty() name = attr.ib() description = attr.ib() attributes = attr.ib(default=None) # e.g. {'address': 'string'} associations = attr.ib(default=None) # e.g. {'services': 'Service'} methods = attr.ib(default=None) # e.g. ['method1', 'method2'] rest_response = attr.ib(default=None, init=False) @attr.s class GenericObjectDefinitionCollection(BaseCollection, sentaku.modeling.ElementMixin): ENTITY = GenericObjectDefinition create = sentaku.ContextualMethod() from . import rest # NOQA last for import cycles importscan.scan(rest)
def test_importerror(): from .fixtures import importerror with raises(ImportError): scan(importerror)
def test_subpackage(): from .fixtures import subpackage scan(subpackage) assert fixtures.calls == 1
def test_scanned_some_error(): with pytest.raises(ZeroDivisionError): importscan.scan(pkg)
def test_package(): from .fixtures import package scan(package) assert fixtures.calls == 1
def scan_onegov(): import importscan import onegov importscan.scan(onegov, ignore=['.test', '.tests'])
def test_ignore_subpackage_relative(): from .fixtures import ignore_subpackage scan(ignore_subpackage, ignore=['.sub']) assert fixtures.calls == 0
raise ItemNotFound("Visible widget is not found") def read(self): return self.visible_widget.read() def fill(self, value): return self.visible_widget.fill(value) def fill(self, fill_data): values = deflatten_dict(fill_data) was_change = False self.before_fill(values) for key, value in values.items(): widget = self.fields(key) if value is None: self.logger.debug('Skipping fill of %r because value was None', key) continue try: if widget.fill(value): was_change = True except NotImplementedError: continue self.after_fill(was_change) return was_change from . import ui, ssui # NOQA last for import cycles importscan.scan(ui) importscan.scan(ssui)
JSON dumps settings_dict to pass as raw hash data to rest_api session Raises: AssertionError: On an http result >=400 (RequestsResponse.ok) """ # Calling the _session patch method because the core patch will wrap settings_dict in a list result = self.appliance.rest_api._session.patch( url=self._api_settings_url, data=json.dumps(settings_dict)) assert result.ok @attr.s class RegionCollection(BaseCollection, sentaku.modeling.ElementMixin): # all = sentaku.ContextualMethod() ENTITY = Region def all(self): self.appliance.rest_api.collections.regions.reload() region_collection = self.appliance.rest_api.collections.regions regions = [ self.instantiate(region.region) for region in region_collection ] return regions from . import ui, ssui, rest # NOQA last for import cycles importscan.scan(ui) importscan.scan(ssui) importscan.scan(rest)
from __future__ import print_function import importscan to_check = 'cfme artifactor fixtures markers utils' if __name__ == '__main__': for name in to_check.split(): base = __import__(name) def handle_error(name, error): print(name, error) importscan.scan(base, handle_error=handle_error)