pax_global_header00006660000000000000000000000064133004367120014511gustar00rootroot0000000000000052 comment=b41a50350dc1749487ede01ebb17999abd51f107 nplusone-1.0.0/000077500000000000000000000000001330043671200133525ustar00rootroot00000000000000nplusone-1.0.0/.gitignore000066400000000000000000000006131330043671200153420ustar00rootroot00000000000000*.py[cod] # C extensions *.so # Packages *.egg *.egg-info dist build eggs parts bin var sdist develop-eggs .installed.cfg lib lib64 # Installer logs pip-log.txt # Unit test / coverage reports .coverage .tox nosetests.xml # Translations *.mo # Mr Developer .mr.developer.cfg .project .pydevproject # Complexity output/*.html output/*/index.html # Sphinx docs/_build README.html _sandbox nplusone-1.0.0/.travis.yml000066400000000000000000000030501330043671200154610ustar00rootroot00000000000000language: python sudo: false python: - "2.7" - "3.6" env: global: - PYTHONPATH=tests/testapp matrix: - DJANGO_VERSION=">=1.8,<1.9" - DJANGO_VERSION=">=1.9,<1.10" - DJANGO_VERSION=">=1.10,<1.11" - DJANGO_VERSION=">=1.11,<2.0" - DJANGO_VERSION=">=2.0,<2.1" matrix: exclude: - python: "2.7" env: DJANGO_VERSION=">=2.0,<2.1" install: - travis_retry pip install codecov - travis_retry pip install -U -r dev-requirements.txt - travis_retry pip install -U "django$DJANGO_VERSION" - travis_retry pip install -U . script: - flake8 . - pytest after_success: codecov jobs: include: - stage: PyPI release if: tag IS present env: [] install: true script: echo 'Releasing to PyPI...' after_success: true deploy: provider: pypi user: jm.carp password: secure: P3woJdZse2/7bYeln/e3W6HEJvJ0cAqqkYwwlnfset3CuDF3+2UE4uJ2mJqtKKcfoJiIFv7wOOaEtvYI5M5p5Y4LOE9ArVpz9kDJw5eqd28jMGJJ3E5V25y29hKw40uUBq9vjrL6tFR2kPqEf1RmRKwuCbkj7nNwDkHm6oAbgph9uZ14BHtWGMpfj0qHRaH16I8lHJ0GBZfX9cd51Rp8UxcOBCI4mASwWWeuqgwTl9SYuKWitgdwiga4epBJ4w8wgWEDaQvRqIaW7vKsndC/RvXF7Oi9xLL1spPbYtCYr5LVL3v3QvCBO8L0KIj0m7cCmBo9G8vzNT5GZwl+x+MbCgU5eU7sxojdX3LVO3b2yoCpGcxnKGCXZP2JB2oKZ1Fn61SNdO3BmJBsmsMJScRMxV9T0uPTWwxVa+/RVzHxulHlJTxWHUrjjYpd7tn5l6Kise676Nx54fc7JDDoHOYKI44Ztb8UpeJzJYTm2sDYOrFdHptv8lDLumqptpiDkqmsfOS+u7OsLWAUj+eRXGV3OSRs3ezMtKcD3l290mqrY3ibJfxpJZn0djoat+L1On2T3seI3AhSuCiu4QAOxvPAEUBBXO0uU+WMHk5lY4ZLBFRTaqpOc8Nv4oPOSLim4WGZsB1IYIhQ9fexk/Xl3oo+JilSh3BBwYCoZS8x/NKNpNQ= on: tags: true distributions: sdist bdist_wheel nplusone-1.0.0/AUTHORS.rst000066400000000000000000000001161330043671200152270ustar00rootroot00000000000000******* Authors ******* - Joshua Carp `@jmcarp `_ nplusone-1.0.0/HISTORY.rst000066400000000000000000000045211330043671200152470ustar00rootroot00000000000000********* Changelog ********* 1.0.0 (2018-05-20) ================== * Support Peewee 3.0. * Add `Profiler` context manager for use without HTTP requests. * Allow model whitelist with fnmatch patterns. * Add generic wsgi middleware. 0.9.0 (2017-12-02) ================== * Support Django 2.0. 0.8.2 (2017-11-27) ================== * Support standard flask extension initialization. Thanks @dcramer! 0.8.1 (2017-08-13) ================== * Support new Django middleware interface. Thanks @noisecapella! 0.8.0 (2017-04-10) ================== * Support Django 1.11. 0.7.3 (2016-10-23) ================== * Handle varying _populate_full signatures across SQLAlchemy versions. Thanks @mrluanma! * Update Django test versions. 0.7.2 (2016-06-13) ================== * Ignore lazy loads on records singly and multiply loaded in same request. * Handle Django `process_response` when `process_request` not called. 0.7.1 (2016-06-03) ================== * Fix field name on Django `prefetch_related`. * Handle iteration over empty results in Django templates. * Fix model and field introspection on Django many-to-many lookups. * Ignore lazy loads from `get` and `one`. 0.7.0 (2016-04-18) ================== * Refactor eager-load checking. * Fix false positive on empty queries using eager loads. * Handle eager load checks on nested relationships. * Backwards-incompatible: Drop support for Django 1.7. 0.6.1 (2016-01-08) ================== * Handle SQLAlchemy properties and columns with different names. 0.6.0 (2016-01-02) ================== * Add whitelist options. 0.5.0 (2015-12-27) ================== * Support Django 1.9. * Ignore lazy loads on singly-loaded records. Thanks @twidi! 0.4.0 (2015-11-17) ================== * Support Django 1.9 beta. 0.3.0 (2015-11-15) ================== * Optionally raise errors on potentially unnecessary queries. 0.2.1 (2015-11-09) ================== * Fix bug on iterating over Django one-to-many relationships. Thanks @orgkhnargh! 0.2.0 (2015-07-07) ================== * Detect unused eager loads in SQLAlchemy and Django. * Handle concurrent requests in Django and Flask-SQLAlchemy. * Handle false-positive lazy loads on prefetching in Django. * Fix field names on unnamed reverse relations in Django. * Update documentation. 0.1.0 (2015-06-29) ================== * First release. * Support for SQLAlchemy, Peewee, and the Django ORM. nplusone-1.0.0/LICENSE000066400000000000000000000020331330043671200143550ustar00rootroot00000000000000Copyright 2016 Joshua Carp Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. nplusone-1.0.0/MANIFEST.in000066400000000000000000000000261330043671200151060ustar00rootroot00000000000000include *.rst LICENSE nplusone-1.0.0/README.rst000066400000000000000000000143661330043671200150530ustar00rootroot00000000000000======== nplusone ======== .. image:: https://img.shields.io/pypi/v/nplusone.svg :target: http://badge.fury.io/py/nplusone :alt: Latest version .. image:: https://img.shields.io/travis/jmcarp/nplusone/master.svg :target: https://travis-ci.org/jmcarp/nplusone :alt: Travis-CI .. image:: https://img.shields.io/codecov/c/github/jmcarp/nplusone/master.svg :target: https://codecov.io/github/jmcarp/nplusone :alt: Code coverage nplusone is a library for detecting the n+1 queries problem in Python ORMs, including SQLAlchemy, Peewee, and the Django ORM. The Problem =========== Many object-relational mapping (ORM) libraries default to lazy loading for relationships. This pattern can be efficient when related rows are rarely accessed, but quickly becomes inefficient as relationships are accessed more frequently. In these cases, loading related rows eagerly using a ``JOIN`` can be vastly more performant. Unfortunately, understanding when to use lazy versus eager loading can be challenging: you might not notice the problem until your app has slowed to a crawl. ``nplusone`` is an ORM profiling tool to help diagnose and improve poor performance caused by inappropriate lazy loading. ``nplusone`` monitors applications using Django or SQLAlchemy and sends notifications when potentially expensive lazy loads are emitted. It can identify the offending relationship attribute and specific lines of code behind the problem, and recommend fixes for better performance. ``nplusone`` also detects inappropriate eager loading for Flask-SQLAlchemy and the Django ORM, emitting a warning when related data are eagerly loaded but never accessed within the current request. Installation ============ :: pip install -U nplusone nplusone supports Python >= 2.7 or >= 3.3. Usage ===== Note: ``nplusone`` should only be used for development and should not be deployed to production environments. Django ****** Note: ``nplusone`` supports Django >= 1.8. Add ``nplusone`` to ``INSTALLED_APPS``: :: INSTALLED_APPS = ( ... 'nplusone.ext.django', ) Add ``NPlusOneMiddleware``: :: MIDDLEWARE = ( 'nplusone.ext.django.NPlusOneMiddleware', ... ) Optionally configure logging settings: :: NPLUSONE_LOGGER = logging.getLogger('nplusone') NPLUSONE_LOG_LEVEL = logging.WARN Configure logging handlers: :: LOGGING = { 'version': 1, 'handlers': { 'console': { 'class': 'logging.StreamHandler', }, }, 'loggers': { 'nplusone': { 'handlers': ['console'], 'level': 'WARN', }, }, } When your app loads data lazily, ``nplusone`` will emit a log message: :: Potential n+1 query detected on `.` Consider using `select_related `_ or `prefetch_related `_ in this case. When your app eagerly loads related data without accessing it, ``nplusone`` will log a warning: :: Potential unnecessary eager load detected on `.` Flask-SQLAlchemy **************** Wrap application with ``NPlusOne``: :: from flask import Flask from nplusone.ext.flask_sqlalchemy import NPlusOne app = Flask(__name__) NPlusOne(app) Optionally configure logging settings: :: app = Flask(__name__) app.config['NPLUSONE_LOGGER'] = logging.getLogger('app.nplusone') app.config['NPLUSONE_LOG_LEVEL'] = logging.ERROR NPlusOne(app) When your app loads data lazily, ``nplusone`` will emit a log message: :: Potential n+1 query detected on `.` Consider using ``subqueryload`` or ``joinedload`` in this case; see SQLAlchemy's guide to `relationship loading `_ for complete documentation. When your app eagerly loads related data without accessing it, ``nplusone`` will log a warning: :: Potential unnecessary eager load detected on `.` WSGI **** For other frameworks that follow the WSGI specification, wrap your application with `NPlusOneMiddleware`. You must also import the relevant ``nplusone`` extension for your ORM: :: import bottle from nplusone.ext.wsgi import NPlusOneMiddleware import nplusone.ext.sqlalchemy app = NPlusOneMiddleware(bottle.app()) Generic ******* The integrations above are coupled to the request-response cycle. To use ``nplusone`` outside the context of an HTTP request, use the ``Profiler`` context manager: You must also import the relevant ``nplusone`` extension for your ORM: :: from nplusone.core import profiler import nplusone.ext.sqlalchemy with profiler.Profiler(): ... Customizing notifications ************************* By default, ``nplusone`` logs all potentially unnecessary queries using a logger named "nplusone". When the `NPLUSONE_RAISE` configuration option is set, ``nplusone`` will also raise an ``NPlusOneError``. This can be used to force all automated tests involving unnecessary queries to fail. :: # Django config NPLUSONE_RAISE = True # Flask config app.config['NPLUSONE_RAISE'] = True The exception type can also be specified, if desired, using the ``NPLUSONE_ERROR`` option. Ignoring notifications ********************** To ignore notifications from ``nplusone`` globally, configure the whitelist using the `NPLUSONE_WHITELIST` option: :: # Django config NPLUSONE_WHITELIST = [ {'label': 'n_plus_one', 'model': 'myapp.MyModel'} ] # Flask-SQLAlchemy config app.config['NPLUSONE_WHITELIST'] = [ {'label': 'unused_eager_load', 'model': 'MyModel', 'field': 'my_field'} ] You can whitelist models by exact name or by `fnmatch `_ patterns: :: # Django config NPLUSONE_WHITELIST = [ {'model': 'myapp.*'} ] To suppress notifications locally, use the ``ignore`` context manager: :: from nplusone.core import signals with signals.ignore(signals.lazy_load): # lazy-load rows # ... License ======= MIT licensed. See the bundled `LICENSE `_ file for more details. nplusone-1.0.0/dev-requirements.txt000066400000000000000000000003571330043671200174170ustar00rootroot00000000000000# Build tasks invoke>=0.13.0 # Testing mock pytest WebTest pytest-cov pytest-django pytest-pythonpath django-webtest tox>=1.5.0 flake8 # ORMs # TODO: Restore after dropping py27 support # Django SQLAlchemy Flask-SQLAlchemy peewee>=3.0.0 nplusone-1.0.0/docs/000077500000000000000000000000001330043671200143025ustar00rootroot00000000000000nplusone-1.0.0/docs/Makefile000066400000000000000000000151721330043671200157500ustar00rootroot00000000000000# Makefile for Sphinx documentation # # You can set these variables from the command line. SPHINXOPTS = SPHINXBUILD = sphinx-build PAPER = BUILDDIR = _build # User-friendly check for sphinx-build ifeq ($(shell which $(SPHINXBUILD) >/dev/null 2>&1; echo $$?), 1) $(error The '$(SPHINXBUILD)' command was not found. Make sure you have Sphinx installed, then set the SPHINXBUILD environment variable to point to the full path of the '$(SPHINXBUILD)' executable. Alternatively you can add the directory with the executable to your PATH. If you don't have Sphinx installed, grab it from http://sphinx-doc.org/) endif # Internal variables. PAPEROPT_a4 = -D latex_paper_size=a4 PAPEROPT_letter = -D latex_paper_size=letter ALLSPHINXOPTS = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) . # the i18n builder cannot share the environment and doctrees with the others I18NSPHINXOPTS = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) . .PHONY: help clean html dirhtml singlehtml pickle json htmlhelp qthelp devhelp epub latex latexpdf text man changes linkcheck doctest gettext help: @echo "Please use \`make ' where is one of" @echo " html to make standalone HTML files" @echo " dirhtml to make HTML files named index.html in directories" @echo " singlehtml to make a single large HTML file" @echo " pickle to make pickle files" @echo " json to make JSON files" @echo " htmlhelp to make HTML files and a HTML help project" @echo " qthelp to make HTML files and a qthelp project" @echo " devhelp to make HTML files and a Devhelp project" @echo " epub to make an epub" @echo " latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter" @echo " latexpdf to make LaTeX files and run them through pdflatex" @echo " latexpdfja to make LaTeX files and run them through platex/dvipdfmx" @echo " text to make text files" @echo " man to make manual pages" @echo " texinfo to make Texinfo files" @echo " info to make Texinfo files and run them through makeinfo" @echo " gettext to make PO message catalogs" @echo " changes to make an overview of all changed/added/deprecated items" @echo " xml to make Docutils-native XML files" @echo " pseudoxml to make pseudoxml-XML files for display purposes" @echo " linkcheck to check all external links for integrity" @echo " doctest to run all doctests embedded in the documentation (if enabled)" clean: rm -rf $(BUILDDIR)/* html: $(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html @echo @echo "Build finished. The HTML pages are in $(BUILDDIR)/html." dirhtml: $(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml @echo @echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml." singlehtml: $(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml @echo @echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml." pickle: $(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle @echo @echo "Build finished; now you can process the pickle files." json: $(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json @echo @echo "Build finished; now you can process the JSON files." htmlhelp: $(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp @echo @echo "Build finished; now you can run HTML Help Workshop with the" \ ".hhp project file in $(BUILDDIR)/htmlhelp." qthelp: $(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp @echo @echo "Build finished; now you can run "qcollectiongenerator" with the" \ ".qhcp project file in $(BUILDDIR)/qthelp, like this:" @echo "# qcollectiongenerator $(BUILDDIR)/qthelp/complexity.qhcp" @echo "To view the help file:" @echo "# assistant -collectionFile $(BUILDDIR)/qthelp/complexity.qhc" devhelp: $(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp @echo @echo "Build finished." @echo "To view the help file:" @echo "# mkdir -p $$HOME/.local/share/devhelp/complexity" @echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/complexity" @echo "# devhelp" epub: $(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub @echo @echo "Build finished. The epub file is in $(BUILDDIR)/epub." latex: $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex @echo @echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex." @echo "Run \`make' in that directory to run these through (pdf)latex" \ "(use \`make latexpdf' here to do that automatically)." latexpdf: $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex @echo "Running LaTeX files through pdflatex..." $(MAKE) -C $(BUILDDIR)/latex all-pdf @echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex." latexpdfja: $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex @echo "Running LaTeX files through platex and dvipdfmx..." $(MAKE) -C $(BUILDDIR)/latex all-pdf-ja @echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex." text: $(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text @echo @echo "Build finished. The text files are in $(BUILDDIR)/text." man: $(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man @echo @echo "Build finished. The manual pages are in $(BUILDDIR)/man." texinfo: $(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo @echo @echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo." @echo "Run \`make' in that directory to run these through makeinfo" \ "(use \`make info' here to do that automatically)." info: $(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo @echo "Running Texinfo files through makeinfo..." make -C $(BUILDDIR)/texinfo info @echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo." gettext: $(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale @echo @echo "Build finished. The message catalogs are in $(BUILDDIR)/locale." changes: $(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes @echo @echo "The overview file is in $(BUILDDIR)/changes." linkcheck: $(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck @echo @echo "Link check complete; look for any errors in the above output " \ "or in $(BUILDDIR)/linkcheck/output.txt." doctest: $(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest @echo "Testing of doctests in the sources finished, look at the " \ "results in $(BUILDDIR)/doctest/output.txt." xml: $(SPHINXBUILD) -b xml $(ALLSPHINXOPTS) $(BUILDDIR)/xml @echo @echo "Build finished. The XML files are in $(BUILDDIR)/xml." pseudoxml: $(SPHINXBUILD) -b pseudoxml $(ALLSPHINXOPTS) $(BUILDDIR)/pseudoxml @echo @echo "Build finished. The pseudo-XML files are in $(BUILDDIR)/pseudoxml." nplusone-1.0.0/docs/api_reference.rst000066400000000000000000000000571330043671200176250ustar00rootroot00000000000000.. _api: API Reference ============= TODO nplusone-1.0.0/docs/authors.rst000066400000000000000000000000341330043671200165160ustar00rootroot00000000000000.. include:: ../AUTHORS.rst nplusone-1.0.0/docs/changelog.rst000066400000000000000000000000541330043671200167620ustar00rootroot00000000000000.. _changelog: .. include:: ../HISTORY.rst nplusone-1.0.0/docs/conf.py000077500000000000000000000016551330043671200156130ustar00rootroot00000000000000# -*- coding: utf-8 -*- from __future__ import unicode_literals import datetime as dt import os import sys sys.path.insert(0, os.path.abspath('..')) import nplusone # noqa extensions = [ 'sphinx.ext.autodoc', 'sphinx.ext.intersphinx', 'sphinx.ext.viewcode', ] primary_domain = 'py' default_role = 'py:obj' intersphinx_mapping = { 'python': ('http://python.readthedocs.org/en/latest/', None), } source_suffix = '.rst' master_doc = 'index' project = 'nplusone' copyright = 'Joshua Carp {0:%Y}'.format( dt.datetime.utcnow() ) version = release = nplusone.__version__ exclude_patterns = ['_build'] # THEME # on_rtd is whether we are on readthedocs.org on_rtd = os.environ.get('READTHEDOCS', None) == 'True' if not on_rtd: # only import and set the theme if we're building docs locally import sphinx_rtd_theme html_theme = 'sphinx_rtd_theme' html_theme_path = [sphinx_rtd_theme.get_html_theme_path()] nplusone-1.0.0/docs/index.rst000066400000000000000000000006061330043671200161450ustar00rootroot00000000000000nplusone: Detecting the n+1 queries problem in Python ========================================================= Release v\ |version|. (:ref:`Changelog `) Detecting the n+1 queries problem in Python Guide ----- .. toctree:: :maxdepth: 2 install quickstart api_reference Project info ------------ .. toctree:: :maxdepth: 1 changelog authors license nplusone-1.0.0/docs/install.rst000066400000000000000000000011321330043671200164770ustar00rootroot00000000000000.. _install: Installation ============ From the PyPI ------------- :: $ pip install -U nplusone From Source ----------- nplusone is actively developed on Github_. You can clone the public repo: :: git clone https://github.com/jmcarp/nplusone.git Or download one of the following: * tarball_ * zipball_ Once you have the source, you can install it into your site-packages with :: $ python setup.py install .. _Github: https://github.com/jmcarp/nplusone .. _tarball: https://github.com/jmcarp/nplusone/tarball/master .. _zipball: https://github.com/jmcarp/nplusone/zipball/master nplusone-1.0.0/docs/license.rst000066400000000000000000000000711330043671200164540ustar00rootroot00000000000000******* License ******* .. literalinclude:: ../LICENSE nplusone-1.0.0/docs/make.bat000066400000000000000000000145031330043671200157120ustar00rootroot00000000000000@ECHO OFF REM Command file for Sphinx documentation if "%SPHINXBUILD%" == "" ( set SPHINXBUILD=sphinx-build ) set BUILDDIR=_build set ALLSPHINXOPTS=-d %BUILDDIR%/doctrees %SPHINXOPTS% . set I18NSPHINXOPTS=%SPHINXOPTS% . if NOT "%PAPER%" == "" ( set ALLSPHINXOPTS=-D latex_paper_size=%PAPER% %ALLSPHINXOPTS% set I18NSPHINXOPTS=-D latex_paper_size=%PAPER% %I18NSPHINXOPTS% ) if "%1" == "" goto help if "%1" == "help" ( :help echo.Please use `make ^` where ^ is one of echo. html to make standalone HTML files echo. dirhtml to make HTML files named index.html in directories echo. singlehtml to make a single large HTML file echo. pickle to make pickle files echo. json to make JSON files echo. htmlhelp to make HTML files and a HTML help project echo. qthelp to make HTML files and a qthelp project echo. devhelp to make HTML files and a Devhelp project echo. epub to make an epub echo. latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter echo. text to make text files echo. man to make manual pages echo. texinfo to make Texinfo files echo. gettext to make PO message catalogs echo. changes to make an overview over all changed/added/deprecated items echo. xml to make Docutils-native XML files echo. pseudoxml to make pseudoxml-XML files for display purposes echo. linkcheck to check all external links for integrity echo. doctest to run all doctests embedded in the documentation if enabled goto end ) if "%1" == "clean" ( for /d %%i in (%BUILDDIR%\*) do rmdir /q /s %%i del /q /s %BUILDDIR%\* goto end ) %SPHINXBUILD% 2> nul if errorlevel 9009 ( echo. echo.The 'sphinx-build' command was not found. Make sure you have Sphinx echo.installed, then set the SPHINXBUILD environment variable to point echo.to the full path of the 'sphinx-build' executable. Alternatively you echo.may add the Sphinx directory to PATH. echo. echo.If you don't have Sphinx installed, grab it from echo.http://sphinx-doc.org/ exit /b 1 ) if "%1" == "html" ( %SPHINXBUILD% -b html %ALLSPHINXOPTS% %BUILDDIR%/html if errorlevel 1 exit /b 1 echo. echo.Build finished. The HTML pages are in %BUILDDIR%/html. goto end ) if "%1" == "dirhtml" ( %SPHINXBUILD% -b dirhtml %ALLSPHINXOPTS% %BUILDDIR%/dirhtml if errorlevel 1 exit /b 1 echo. echo.Build finished. The HTML pages are in %BUILDDIR%/dirhtml. goto end ) if "%1" == "singlehtml" ( %SPHINXBUILD% -b singlehtml %ALLSPHINXOPTS% %BUILDDIR%/singlehtml if errorlevel 1 exit /b 1 echo. echo.Build finished. The HTML pages are in %BUILDDIR%/singlehtml. goto end ) if "%1" == "pickle" ( %SPHINXBUILD% -b pickle %ALLSPHINXOPTS% %BUILDDIR%/pickle if errorlevel 1 exit /b 1 echo. echo.Build finished; now you can process the pickle files. goto end ) if "%1" == "json" ( %SPHINXBUILD% -b json %ALLSPHINXOPTS% %BUILDDIR%/json if errorlevel 1 exit /b 1 echo. echo.Build finished; now you can process the JSON files. goto end ) if "%1" == "htmlhelp" ( %SPHINXBUILD% -b htmlhelp %ALLSPHINXOPTS% %BUILDDIR%/htmlhelp if errorlevel 1 exit /b 1 echo. echo.Build finished; now you can run HTML Help Workshop with the ^ .hhp project file in %BUILDDIR%/htmlhelp. goto end ) if "%1" == "qthelp" ( %SPHINXBUILD% -b qthelp %ALLSPHINXOPTS% %BUILDDIR%/qthelp if errorlevel 1 exit /b 1 echo. echo.Build finished; now you can run "qcollectiongenerator" with the ^ .qhcp project file in %BUILDDIR%/qthelp, like this: echo.^> qcollectiongenerator %BUILDDIR%\qthelp\complexity.qhcp echo.To view the help file: echo.^> assistant -collectionFile %BUILDDIR%\qthelp\complexity.ghc goto end ) if "%1" == "devhelp" ( %SPHINXBUILD% -b devhelp %ALLSPHINXOPTS% %BUILDDIR%/devhelp if errorlevel 1 exit /b 1 echo. echo.Build finished. goto end ) if "%1" == "epub" ( %SPHINXBUILD% -b epub %ALLSPHINXOPTS% %BUILDDIR%/epub if errorlevel 1 exit /b 1 echo. echo.Build finished. The epub file is in %BUILDDIR%/epub. goto end ) if "%1" == "latex" ( %SPHINXBUILD% -b latex %ALLSPHINXOPTS% %BUILDDIR%/latex if errorlevel 1 exit /b 1 echo. echo.Build finished; the LaTeX files are in %BUILDDIR%/latex. goto end ) if "%1" == "latexpdf" ( %SPHINXBUILD% -b latex %ALLSPHINXOPTS% %BUILDDIR%/latex cd %BUILDDIR%/latex make all-pdf cd %BUILDDIR%/.. echo. echo.Build finished; the PDF files are in %BUILDDIR%/latex. goto end ) if "%1" == "latexpdfja" ( %SPHINXBUILD% -b latex %ALLSPHINXOPTS% %BUILDDIR%/latex cd %BUILDDIR%/latex make all-pdf-ja cd %BUILDDIR%/.. echo. echo.Build finished; the PDF files are in %BUILDDIR%/latex. goto end ) if "%1" == "text" ( %SPHINXBUILD% -b text %ALLSPHINXOPTS% %BUILDDIR%/text if errorlevel 1 exit /b 1 echo. echo.Build finished. The text files are in %BUILDDIR%/text. goto end ) if "%1" == "man" ( %SPHINXBUILD% -b man %ALLSPHINXOPTS% %BUILDDIR%/man if errorlevel 1 exit /b 1 echo. echo.Build finished. The manual pages are in %BUILDDIR%/man. goto end ) if "%1" == "texinfo" ( %SPHINXBUILD% -b texinfo %ALLSPHINXOPTS% %BUILDDIR%/texinfo if errorlevel 1 exit /b 1 echo. echo.Build finished. The Texinfo files are in %BUILDDIR%/texinfo. goto end ) if "%1" == "gettext" ( %SPHINXBUILD% -b gettext %I18NSPHINXOPTS% %BUILDDIR%/locale if errorlevel 1 exit /b 1 echo. echo.Build finished. The message catalogs are in %BUILDDIR%/locale. goto end ) if "%1" == "changes" ( %SPHINXBUILD% -b changes %ALLSPHINXOPTS% %BUILDDIR%/changes if errorlevel 1 exit /b 1 echo. echo.The overview file is in %BUILDDIR%/changes. goto end ) if "%1" == "linkcheck" ( %SPHINXBUILD% -b linkcheck %ALLSPHINXOPTS% %BUILDDIR%/linkcheck if errorlevel 1 exit /b 1 echo. echo.Link check complete; look for any errors in the above output ^ or in %BUILDDIR%/linkcheck/output.txt. goto end ) if "%1" == "doctest" ( %SPHINXBUILD% -b doctest %ALLSPHINXOPTS% %BUILDDIR%/doctest if errorlevel 1 exit /b 1 echo. echo.Testing of doctests in the sources finished, look at the ^ results in %BUILDDIR%/doctest/output.txt. goto end ) if "%1" == "xml" ( %SPHINXBUILD% -b xml %ALLSPHINXOPTS% %BUILDDIR%/xml if errorlevel 1 exit /b 1 echo. echo.Build finished. The XML files are in %BUILDDIR%/xml. goto end ) if "%1" == "pseudoxml" ( %SPHINXBUILD% -b pseudoxml %ALLSPHINXOPTS% %BUILDDIR%/pseudoxml if errorlevel 1 exit /b 1 echo. echo.Build finished. The pseudo-XML files are in %BUILDDIR%/pseudoxml. goto end ) :end nplusone-1.0.0/docs/quickstart.rst000066400000000000000000000000551330043671200172260ustar00rootroot00000000000000.. _quickstart: Quickstart ========== TODO nplusone-1.0.0/docs/requirements.txt000066400000000000000000000000301330043671200175570ustar00rootroot00000000000000sphinx sphinx-rtd-theme nplusone-1.0.0/nplusone/000077500000000000000000000000001330043671200152155ustar00rootroot00000000000000nplusone-1.0.0/nplusone/__init__.py000066400000000000000000000000261330043671200173240ustar00rootroot00000000000000__version__ = '1.0.0' nplusone-1.0.0/nplusone/core/000077500000000000000000000000001330043671200161455ustar00rootroot00000000000000nplusone-1.0.0/nplusone/core/__init__.py000066400000000000000000000000001330043671200202440ustar00rootroot00000000000000nplusone-1.0.0/nplusone/core/exceptions.py000066400000000000000000000001021330043671200206710ustar00rootroot00000000000000# -*- coding: utf-8 -*- class NPlusOneError(Exception): pass nplusone-1.0.0/nplusone/core/listeners.py000066400000000000000000000113341330043671200205310ustar00rootroot00000000000000# -*- coding: utf-8 -*- import six import fnmatch from collections import defaultdict from nplusone.core import signals class Rule(object): def __init__(self, label=None, model=None, field=None): self.label = label self.model = model self.field = field def compare(self, label, model, field): return ( (self.label or self.model or self.field) and (self.label is None or self.label == label) and (self.model is None or self.match_model(model)) and (self.field is None or self.field == field) ) def match_model(self, model): return ( self.model is model or ( isinstance(self.model, six.string_types) and fnmatch.fnmatch(model.__name__, self.model) ) ) class Message(object): label = '' formatter = '' def __init__(self, model, field): self.model = model self.field = field @property def message(self): return self.formatter.format( label=self.label, model=self.model.__name__, field=self.field, ) def match(self, rules): return any( rule.compare(self.label, self.model, self.field) for rule in rules ) class LazyLoadMessage(Message): label = 'n_plus_one' formatter = 'Potential n+1 query detected on `{model}.{field}`' class EagerLoadMessage(Message): label = 'unused_eager_load' formatter = 'Potential unnecessary eager load detected on `{model}.{field}`' class Listener(object): def __init__(self, parent): self.parent = parent def setup(self): pass # pragma: no cover def teardown(self): pass # pragma: no cover class LazyListener(Listener): def setup(self): self.loaded, self.ignore = set(), set() signals.load.connect(self.handle_load, sender=signals.get_worker()) signals.ignore_load.connect(self.handle_ignore, sender=signals.get_worker()) signals.lazy_load.connect(self.handle_lazy, sender=signals.get_worker()) def handle_load(self, caller, args=None, kwargs=None, context=None, ret=None, parser=None): instances = parser(args, kwargs, context, ret) self.loaded.update(instances) def handle_ignore(self, caller, args=None, kwargs=None, context=None, ret=None, parser=None): instances = parser(args, kwargs, context, ret) self.ignore.update(instances) def handle_lazy(self, caller, args=None, kwargs=None, context=None, ret=None, parser=None): model, instance, field = parser(args, kwargs, context) if instance in self.loaded and instance not in self.ignore: message = LazyLoadMessage(model, field) self.parent.notify(message) class EagerListener(Listener): def setup(self): signals.eager_load.connect(self.handle_eager, sender=signals.get_worker()) self.tracker = EagerTracker() self.touched = [] def teardown(self): self.log_eager() def handle_eager(self, caller, args=None, kwargs=None, context=None, ret=None, parser=None): self.tracker.track(*parser(args, kwargs, context)) signals.touch.connect(self.handle_touch, sender=signals.get_worker()) def handle_touch(self, caller, args=None, kwargs=None, context=None, ret=None, parser=None): self.touched.append(parser(args, kwargs, context)) def log_eager(self): self.tracker.prune([each for each in self.touched if each]) for model, field in self.tracker.unused: message = EagerLoadMessage(model, field) self.parent.notify(message) class EagerTracker(object): """Data structure for tracking eager-loaded and subsequently touched related rows. Eager-loaded rows are stored in a dict mapping associations to nested dicts mapping query keys to instances. """ def __init__(self): self.data = defaultdict(lambda: defaultdict(set)) def track(self, model, field, instances, key): self.data[(model, field)][key].update(instances) def prune(self, touched): for model, field, touch_instances in touched: group = self.data[(model, field)] for key, fetch_instances in list(group.items()): if touch_instances and fetch_instances.intersection(touch_instances): group.pop(key, None) @property def unused(self): return [ (model, field) for (model, field), group in self.data.items() if group ] listeners = { 'lazy_load': LazyListener, 'eager_load': EagerListener, } nplusone-1.0.0/nplusone/core/notifiers.py000066400000000000000000000024601330043671200205230ustar00rootroot00000000000000# -*- coding: utf-8 -*- import logging from nplusone.core import exceptions class Notifier(object): CONFIG_KEY = None ENABLED_DEFAULT = False @classmethod def is_enabled(cls, config): return ( config.get(cls.CONFIG_KEY) or ( cls.CONFIG_KEY not in config and cls.ENABLED_DEFAULT ) ) def __init__(self, config): self.config = config # pragma: no cover def notify(self, model, field): pass # pragma: no cover class LogNotifier(Notifier): CONFIG_KEY = 'NPLUSONE_LOG' ENABLED_DEFAULT = True def __init__(self, config): self.logger = config.get('NPLUSONE_LOGGER', logging.getLogger('nplusone')) self.level = config.get('NPLUSONE_LOG_LEVEL', logging.DEBUG) def notify(self, message): self.logger.log(self.level, message.message) class ErrorNotifier(Notifier): CONFIG_KEY = 'NPLUSONE_RAISE' ENABLED_DEFAULT = False def __init__(self, config): self.error = config.get('NPLUSONE_ERROR', exceptions.NPlusOneError) def notify(self, message): raise self.error(message.message) def init(config): return [ notifier(config) for notifier in (LogNotifier, ErrorNotifier) if notifier.is_enabled(config) ] nplusone-1.0.0/nplusone/core/profiler.py000066400000000000000000000014201330043671200203360ustar00rootroot00000000000000# -*- coding: utf-8 -*- import six from nplusone.core import listeners from nplusone.core import exceptions class Profiler(object): def __init__(self, whitelist=None): self.whitelist = [ listeners.Rule(**item) for item in (whitelist or []) ] def __enter__(self): self.listeners = {} for name, listener_type in six.iteritems(listeners.listeners): self.listeners[name] = listener_type(self) self.listeners[name].setup() def __exit__(self, *exc): for name in six.iterkeys(listeners.listeners): self.listeners.pop(name).teardown() def notify(self, message): if not message.match(self.whitelist): raise exceptions.NPlusOneError(message.message) nplusone-1.0.0/nplusone/core/signals.py000066400000000000000000000022421330043671200201570ustar00rootroot00000000000000# -*- coding: utf-8 -*- import functools import contextlib import blinker load = blinker.Signal() ignore_load = blinker.Signal() lazy_load = blinker.Signal() eager_load = blinker.Signal() touch = blinker.Signal() def get_worker(*args, **kwargs): return blinker.ANY def signalify(signal, func, parser=None, **context): @functools.wraps(func) def wrapped(*args, **kwargs): ret = func(*args, **kwargs) signal.send( get_worker(), args=args, kwargs=kwargs, ret=ret, context=context, parser=parser, ) return ret return wrapped def designalify(signal, func): @functools.wraps(func) def wrapped(*args, **kwargs): with ignore(signal): return func(*args, **kwargs) return wrapped @contextlib.contextmanager def ignore(signal, sender=None): sender = sender or get_worker() receivers = list(signal.receivers_for(sender)) for receiver in receivers: signal.disconnect(receiver, sender=sender) try: yield finally: for receiver in receivers: signal.connect(receiver, sender=sender) nplusone-1.0.0/nplusone/core/stack.py000066400000000000000000000005541330043671200176300ustar00rootroot00000000000000# -*- coding: utf-8 -*- import inspect PATTERNS = ['site-packages', 'py.test', 'nplusone'] def get_caller(patterns=None): frames = inspect.stack() patterns = patterns or PATTERNS return next( ( each for each in frames if each[4] and not any(pattern in each[1] for pattern in patterns) ), None, ) nplusone-1.0.0/nplusone/ext/000077500000000000000000000000001330043671200160155ustar00rootroot00000000000000nplusone-1.0.0/nplusone/ext/__init__.py000066400000000000000000000000001330043671200201140ustar00rootroot00000000000000nplusone-1.0.0/nplusone/ext/django/000077500000000000000000000000001330043671200172575ustar00rootroot00000000000000nplusone-1.0.0/nplusone/ext/django/__init__.py000066400000000000000000000002021330043671200213620ustar00rootroot00000000000000# -*- coding: utf-8 -*- from . import patch # noqa from .middleware import NPlusOneMiddleware __all__ = ['NPlusOneMiddleware'] nplusone-1.0.0/nplusone/ext/django/middleware.py000066400000000000000000000034741330043671200217560ustar00rootroot00000000000000# -*- coding: utf-8 -*- import fnmatch import weakref import six from django.conf import settings try: from django.utils.deprecation import MiddlewareMixin except ImportError: MiddlewareMixin = object from nplusone.core import listeners from nplusone.core import notifiers class DjangoRule(listeners.Rule): def match_model(self, model): return ( self.model is model or ( isinstance(self.model, six.string_types) and fnmatch.fnmatch( '{0}.{1}'.format(model._meta.app_label, model.__name__), self.model, ) ) ) class NPlusOneMiddleware(MiddlewareMixin): def __init__(self, *args, **kwargs): super(NPlusOneMiddleware, self).__init__(*args, **kwargs) self.listeners = weakref.WeakKeyDictionary() def load_config(self): self.notifiers = notifiers.init(vars(settings._wrapped)) self.whitelist = [ DjangoRule(**item) for item in getattr(settings, 'NPLUSONE_WHITELIST', []) ] def process_request(self, request): self.load_config() self.listeners[request] = self.listeners.get(request, {}) for name, listener_type in six.iteritems(listeners.listeners): self.listeners[request][name] = listener_type(self) self.listeners[request][name].setup() def process_response(self, request, response): for name, listener_type in six.iteritems(listeners.listeners): listener = self.listeners.get(request, {}).pop(name, None) if listener: listener.teardown() return response def notify(self, message): if not message.match(self.whitelist): for notifier in self.notifiers: notifier.notify(message) nplusone-1.0.0/nplusone/ext/django/patch.py000066400000000000000000000254401330043671200207350ustar00rootroot00000000000000# -*- coding: utf-8 -*- import copy import inspect import functools import importlib import threading import django from django.db.models import query from django.db.models import Model from nplusone.core import signals if django.VERSION >= (1, 9): # pragma: no cover from django.db.models.fields.related_descriptors import ( ReverseOneToOneDescriptor, ForwardManyToOneDescriptor, create_reverse_many_to_one_manager, create_forward_many_to_many_manager, ) else: # pragma: no cover from django.db.models.fields.related import ( SingleRelatedObjectDescriptor as ReverseOneToOneDescriptor, ReverseSingleRelatedObjectDescriptor as ForwardManyToOneDescriptor, create_foreign_related_manager as create_reverse_many_to_one_manager, create_many_related_manager as create_forward_many_to_many_manager, ) def get_worker(): return str(threading.current_thread().ident) def setup_state(): signals.get_worker = get_worker setup_state() def to_key(instance): model = type(instance) return ':'.join([model.__name__, format(instance.pk)]) def patch(original, patched): module = importlib.import_module(original.__module__) setattr(module, original.__name__, patched) def signalify_queryset(func, parser=None, **context): @functools.wraps(func) def wrapped(*args, **kwargs): queryset = func(*args, **kwargs) ctx = copy.copy(context) ctx['args'] = context.get('args', args) ctx['kwargs'] = context.get('kwargs', kwargs) queryset._clone = signalify_queryset(queryset._clone, parser=parser, **ctx) queryset._fetch_all = signalify_fetch_all(queryset, parser=parser, **ctx) queryset._context = ctx return queryset return wrapped def signalify_fetch_all(queryset, parser=None, **context): """Signal lazy load when `QuerySet._fetch_all` fetches rows. Note: patch `_fetch_all` instead of `iterator` since, as of Django 1.11, the former is used for all fetches while the latter is not. """ func = queryset._fetch_all @functools.wraps(func) def wrapped(*args, **kwargs): if queryset._result_cache is None: signals.lazy_load.send( get_worker(), args=args, kwargs=kwargs, ret=None, context=context, parser=parser, ) return func(*args, **kwargs) return wrapped def get_related_name(model): return '{0}_set'.format(model._meta.model_name) def parse_field(field): return ( ( field.related_model # Django >= 1.8 if hasattr(field, 'related_model') else field.related_field.model # Django <= 1.8 ), ( field.remote_field.name # Django >= 1.8 if hasattr(field, 'remote_field') else field.rel.related_name # Django <= 1.8 ) or get_related_name(field.related_model), ) def parse_reverse_field(field): return field.model, field.name def parse_related(context): if 'rel' in context: # pragma: no cover rel = context['rel'] return parse_related_parts(rel.model, rel.related_name, rel.related_model) else: # pragma: no cover field = context['rel_field'] model = field.related_field.model related_name = field.rel.related_name related_model = context['rel_model'] return parse_related_parts(model, related_name, related_model) def parse_related_parts(model, related_name, related_model): return ( model, related_name or get_related_name(related_model), ) def parse_reverse_one_to_one_queryset(args, kwargs, context): descriptor = context['args'][0] field = descriptor.related.field model, name = parse_field(field) instance = context['kwargs']['instance'] return model, to_key(instance), name def parse_forward_many_to_one_queryset(args, kwargs, context): descriptor = context['args'][0] instance = context['kwargs']['instance'] return descriptor.field.model, to_key(instance), descriptor.field.name def parse_many_related_queryset(args, kwargs, context): rel = context['rel'] manager = context['args'][0] model = manager.instance.__class__ related_model = ( manager.target_field.related_model # Django >= 1.8 if hasattr(manager.target_field, 'related_model') else manager.target_field.related_field.model # Django <= 1.8 ) field = manager.prefetch_cache_name if rel.related_name else None return ( model, to_key(manager.instance), field or get_related_name(related_model), ) def parse_foreign_related_queryset(args, kwargs, context): model, name = parse_related(context) descriptor = context['args'][0] return model, to_key(descriptor.instance), name query.prefetch_one_level = signals.designalify( signals.lazy_load, query.prefetch_one_level, ) def parse_get(args, kwargs, context, ret): return [to_key(ret)] if isinstance(ret, Model) else [] # Ignore records loaded during `get` query.QuerySet.get = signals.signalify( signals.ignore_load, query.QuerySet.get, parser=parse_get, ) ReverseOneToOneDescriptor.get_queryset = signalify_queryset( ReverseOneToOneDescriptor.get_queryset, parser=parse_reverse_one_to_one_queryset, ) ForwardManyToOneDescriptor.get_queryset = signalify_queryset( ForwardManyToOneDescriptor.get_queryset, parser=parse_forward_many_to_one_queryset, ) def _create_forward_many_to_many_manager(*args, **kwargs): context = inspect.getcallargs(create_forward_many_to_many_manager, *args, **kwargs) manager = create_forward_many_to_many_manager(*args, **kwargs) manager.get_queryset = signalify_queryset( manager.get_queryset, parser=parse_many_related_queryset, **context ) return manager patch(create_forward_many_to_many_manager, _create_forward_many_to_many_manager) def _create_reverse_many_to_one_manager(*args, **kwargs): context = inspect.getcallargs(create_reverse_many_to_one_manager, *args, **kwargs) manager = create_reverse_many_to_one_manager(*args, **kwargs) manager.get_queryset = signalify_queryset( manager.get_queryset, parser=parse_foreign_related_queryset, **context ) return manager patch(create_reverse_many_to_one_manager, _create_reverse_many_to_one_manager) def parse_forward_many_to_one_get(args, kwargs, context): descriptor, instance, _ = args if instance is None: return None field, model = parse_reverse_field(descriptor.field) return field, model, [to_key(instance)] ForwardManyToOneDescriptor.__get__ = signals.signalify( signals.touch, ForwardManyToOneDescriptor.__get__, parser=parse_forward_many_to_one_get, ) def parse_reverse_one_to_one_get(args, kwargs, context): descriptor, instance = args[:2] if instance is None: return None model, field = parse_field(descriptor.related.field) return model, field, [to_key(instance)] ReverseOneToOneDescriptor.__get__ = signals.signalify( signals.touch, ReverseOneToOneDescriptor.__get__, parser=parse_reverse_one_to_one_get, ) def parse_fetch_all(args, kwargs, context): self = args[0] if hasattr(self, '_context'): manager = self._context['args'][0] instance = manager.instance # Handle iteration over many-to-many relationship if manager.__class__.__name__ == 'ManyRelatedManager': return ( instance.__class__, parse_manager_field(manager, self._context['rel']), [to_key(instance)], ) # Handle iteration over one-to-many relationship else: model, field = parse_related(self._context) return model, field, [to_key(instance)] def parse_manager_field(manager, rel): if manager.reverse: return rel.related_name or get_related_name(rel.related_model) return rel.field.name or get_related_name(rel.model) def parse_load(args, kwargs, context, ret): return [ to_key(row) for row in ret if isinstance(row, Model) ] def is_single(low, high): return high is not None and high - low == 1 # On queryset fetch, emit `touch` if results have been prefetched; emit `load` # if the query requests more than one record, else `ignore_load`. Note: we patch # `_fetch_all` rather than `__iter__` to handle iteration over empty querysets # in Django templates, which does not call `__iter__`. original_fetch_all = query.QuerySet._fetch_all def fetch_all(self): if self._prefetch_done: signals.touch.send( get_worker(), args=(self, ), parser=parse_fetch_all, ) original_fetch_all(self) signal = ( signals.ignore_load if is_single(self.query.low_mark, self.query.high_mark) else signals.load ) signal.send( get_worker(), args=(self, ), ret=self._result_cache, parser=parse_load, ) query.QuerySet._fetch_all = fetch_all original_related_populator_init = query.RelatedPopulator.__init__ def related_populator_init(self, *args, **kwargs): original_related_populator_init(self, *args, **kwargs) self.__nplusone__ = { 'args': args, 'kwargs': kwargs, } query.RelatedPopulator.__init__ = related_populator_init def parse_eager_select(args, kwargs, context): populator = args[0] instance = args[2] meta = populator.__nplusone__ klass_info, select, _ = meta['args'] field = klass_info['field'] model, name = ( parse_field(field) if instance._meta.model != field.model else parse_reverse_field(field) ) return model, name, [to_key(instance)], id(select) # Emit `eager_load` on populating from `select_related` query.RelatedPopulator.populate = signals.signalify( signals.eager_load, query.RelatedPopulator.populate, parser=parse_eager_select, ) def parse_eager_join(args, kwargs, context): instances, descriptor, fetcher, level = args model = instances[0].__class__ field, _ = fetcher.get_current_to_attr(level) keys = [to_key(instance) for instance in instances] return model, field, keys, id(instances) # Emit `eager_load` on populating from `prefetch_related` query.prefetch_one_level = signals.signalify( signals.eager_load, query.prefetch_one_level, parser=parse_eager_join, ) # Emit `touch` on indexing into prefetched `QuerySet` instances original_getitem_queryset = query.QuerySet.__getitem__ def getitem_queryset(self, index): if self._prefetch_done: signals.touch.send( get_worker(), args=(self, ), parser=parse_fetch_all, ) return original_getitem_queryset(self, index) query.QuerySet.__getitem__ = getitem_queryset nplusone-1.0.0/nplusone/ext/flask_sqlalchemy.py000066400000000000000000000031601330043671200217110ustar00rootroot00000000000000# -*- coding: utf-8 -*- import six from flask import g from flask import request from nplusone.core import signals from nplusone.core import listeners from nplusone.core import notifiers import nplusone.ext.sqlalchemy # noqa def get_worker(): try: return request._get_current_object() except RuntimeError: return None def setup_state(): signals.get_worker = get_worker setup_state() class NPlusOne(object): def __init__(self, app=None): self.app = app if app is not None: self.init_app(app) def load_config(self, app): self.notifiers = notifiers.init(app.config) self.whitelist = [ listeners.Rule(**item) for item in app.config.get('NPLUSONE_WHITELIST', []) ] def init_app(self, app): @app.before_request def connect(): self.load_config(app) g.listeners = getattr(g, 'listeners', {}) for name, listener_type in six.iteritems(listeners.listeners): g.listeners[name] = listener_type(self) g.listeners[name].setup() @app.after_request def disconnect(response): for name in six.iterkeys(listeners.listeners): listener = g.listeners.pop(name, None) if listener: listener.teardown() return response def notify(self, message): if not message.match(self.whitelist): for notifier in self.notifiers: notifier.notify(message) def ignore(self, signal): return signals.ignore(getattr(signals, signal)) nplusone-1.0.0/nplusone/ext/peewee.py000066400000000000000000000065021330043671200176440ustar00rootroot00000000000000# -*- coding: utf-8 -*- from __future__ import absolute_import from peewee import BaseQuery from peewee import SelectQuery from peewee import ForeignKeyAccessor from peewee import BackrefAccessor from peewee import ManyToManyQuery from peewee import BaseModelSelect from peewee import database_required from nplusone.core import signals def parse_get_object(args, kwargs, context): accessor, instance = args return accessor.field.model, to_key(instance), accessor.field.name def parse_reverse_get(args, kwargs, context): accessor, instance = args return accessor.field.rel_model, to_key(instance), accessor.field.backref def get_rel_instance(self, instance): value = instance.__data__.get(self.name) if value is not None or self.name in instance.__rel__: if self.name not in instance.__rel__: signals.lazy_load.send( signals.get_worker(), args=(self, instance), parser=parse_get_object, ) obj = self.rel_model.get(self.field.rel_field == value) instance.__rel__[self.name] = obj return instance.__rel__[self.name] elif not self.field.null: raise self.rel_model.DoesNotExist return value ForeignKeyAccessor.get_rel_instance = get_rel_instance def backref_get(self, instance, instance_type=None): if instance is not None: dest = self.field.rel_field.name query = (self.rel_model .select() .where(self.field == getattr(instance, dest))) # Mark query with context so that we can emit a `lazyload` signal # if evaluated during `BaseQuery.execute` query._context = { 'args': (self, instance), 'kwargs': {'instance_type', instance_type}, } return query return self # pragma: no cover; pasted from peewee BackrefAccessor.__get__ = backref_get def to_key(instance): model = type(instance) return ':'.join([model.__name__, format(instance.get_id())]) def parse_load(args, kwargs, context, ret): return [to_key(row) for row in ret] def is_single(offset, limit): return limit is not None and limit - (offset or 0) == 1 original_model_select_iter = BaseModelSelect.__iter__ def model_select_iter(self): if isinstance(self, ManyToManyQuery): signals.lazy_load.send( signals.get_worker(), args=(self._accessor, self._instance), parser=parse_get_object, ) return original_model_select_iter(self) BaseModelSelect.__iter__ = model_select_iter original_query_execute = BaseQuery.execute def query_execute(self, database): ret = original_query_execute(self, database) if hasattr(self, '_context'): # Query has been marked as lazy during backref lookup signals.lazy_load.send( signals.get_worker(), args=self._context['args'], kwargs=self._context['kwargs'], parser=parse_reverse_get, ) if not isinstance(self, SelectQuery): return ret signal = ( signals.ignore_load if is_single(self._offset, self._limit) else signals.load ) signal.send( signals.get_worker(), args=(self, ), ret=list(ret), parser=parse_load, ) return ret BaseQuery.execute = database_required(query_execute) nplusone-1.0.0/nplusone/ext/sqlalchemy.py000066400000000000000000000063131330043671200205340ustar00rootroot00000000000000# -*- coding: utf-8 -*- from __future__ import absolute_import import inspect import itertools from sqlalchemy.orm import query from sqlalchemy.orm import loading from sqlalchemy.orm import attributes from sqlalchemy.orm import strategies from nplusone.core import signals def to_key(instance): model = type(instance) return ':'.join( [model.__name__] + [ format(instance.__dict__.get(key.key)) # Avoid recursion on __get__ for key in get_primary_keys(model) ] ) def get_primary_keys(model): mapper = model.__mapper__ return [ mapper.get_property_by_column(column) for column in mapper.primary_key ] def parse_load(args, kwargs, context, ret): return [ to_key(row) for row in ret if hasattr(row, '__table__') ] def parse_lazy_load(args, kwargs, context): loader, state, _ = args return state.object.__class__, to_key(state.object), loader.parent_property.key def parse_attribute_get(args, kwargs, context): attr, instance = args[:2] if instance is None: return None return attr.class_, attr.key, [to_key(instance)] strategies.LazyLoader._load_for_state = signals.signalify( signals.lazy_load, strategies.LazyLoader._load_for_state, parser=parse_lazy_load, ) def parse_populate(args, kwargs, context): query_context = args[0] state = args[2] instance = state.object return instance.__class__, context['key'], [to_key(instance)], id(query_context) # Emit `eager_load` on populating from `joinedload` or `subqueryload` original_populate_full = loading._populate_full def _populate_full(*args, **kwargs): ret = original_populate_full(*args, **kwargs) context = inspect.getcallargs(original_populate_full, *args, **kwargs) for key, _ in context['populators'].get('eager', []): if context['dict_'].get(key): signals.eager_load.send( signals.get_worker(), args=args, kwargs=kwargs, context={'key': key}, parser=parse_populate, ) return ret loading._populate_full = _populate_full attributes.InstrumentedAttribute.__get__ = signals.signalify( signals.touch, attributes.InstrumentedAttribute.__get__, parser=parse_attribute_get, ) def is_single(offset, limit): return limit is not None and limit - (offset or 0) == 1 original_query_iter = query.Query.__iter__ def query_iter(self): ret, clone = itertools.tee(original_query_iter(self)) signal = ( signals.ignore_load if is_single(self._offset, self._limit) else signals.load ) signal.send( signals.get_worker(), args=(self, ), ret=list(clone), parser=parse_load, ) return ret query.Query.__iter__ = query_iter def parse_get(args, kwargs, context, ret): return [to_key(ret)] if hasattr(ret, '__table__') else [] # Ignore records loaded during `one` for method in ['one_or_none', 'one']: try: original = getattr(query.Query, method) except AttributeError: continue decorated = signals.signalify(signals.ignore_load, original, parse_get) setattr(query.Query, method, decorated) nplusone-1.0.0/nplusone/ext/wsgi.py000066400000000000000000000005511330043671200173410ustar00rootroot00000000000000# -*- coding: utf-8 -*- from nplusone.core import profiler class NPlusOneMiddleware(object): def __init__(self, app, whitelist=None): self.app = app self.whitelist = whitelist def __call__(self, environ, start_response): with profiler.Profiler(whitelist=self.whitelist): return self.app(environ, start_response) nplusone-1.0.0/pytest.ini000066400000000000000000000002651330043671200154060ustar00rootroot00000000000000[pytest] python_files = test*.py django_find_project = false python_paths = tests/testapp addopts=--cov nplusone --cov-report term-missing DJANGO_SETTINGS_MODULE = testapp.settings nplusone-1.0.0/setup.cfg000066400000000000000000000010601330043671200151700ustar00rootroot00000000000000[wheel] # This flag says that the code is written to work on both Python 2 and Python # 3. If at all possible, it is good practice to do this. If you cannot, you # will need to generate wheels for each Python version that you support. universal=1 # E127: continuation line over-indented for visual indent # E128: continuation line under-indented for visual indent # E265: block comment should start with # # E301: expected 1 blank line, found 1 # E302: expected 2 blank lines, found 0 [flake8] ignore = E127,E128,E265,E301,E302,E305,E306 max-line-length = 90 nplusone-1.0.0/setup.py000077500000000000000000000034431330043671200150730ustar00rootroot00000000000000# -*- coding: utf-8 -*- import re from setuptools import setup from setuptools import find_packages REQUIRES = [ 'six>=1.9.0', 'blinker>=1.3', ] def find_version(fname): """Attempts to find the version number in the file names fname. Raises RuntimeError if not found. """ version = '' with open(fname, 'r') as fp: reg = re.compile(r'__version__ = [\'"]([^\'"]*)[\'"]') for line in fp: m = reg.match(line) if m: version = m.group(1) break if not version: raise RuntimeError('Cannot find version information') return version def read(fname): with open(fname) as fp: content = fp.read() return content setup( name='nplusone', version=find_version('nplusone/__init__.py'), description='Detecting the n+1 queries problem in Python', long_description=read('README.rst'), author='Joshua Carp', author_email='jm.carp@gmail.com', url='https://github.com/jmcarp/nplusone', packages=find_packages(exclude=('test*', )), package_dir={'nplusone': 'nplusone'}, include_package_data=True, install_requires=REQUIRES, license=read('LICENSE'), zip_safe=False, keywords='nplusone', classifiers=[ 'Development Status :: 2 - Pre-Alpha', 'Intended Audience :: Developers', 'License :: OSI Approved :: MIT License', 'Natural Language :: English', 'Programming Language :: Python :: 2', 'Programming Language :: Python :: 2.7', 'Programming Language :: Python :: 3', 'Programming Language :: Python :: 3.3', 'Programming Language :: Python :: 3.4', 'Programming Language :: Python :: 3.5', 'Programming Language :: Python :: 3.6', ], test_suite='tests' ) nplusone-1.0.0/tasks.py000066400000000000000000000031341330043671200150520ustar00rootroot00000000000000# -*- coding: utf-8 -*- import os import sys import webbrowser from invoke import task docs_dir = 'docs' build_dir = os.path.join(docs_dir, '_build') @task def test(ctx): import pytest errcode = pytest.main(['tests']) sys.exit(errcode) @task def watch(ctx): """Run tests when a file changes. Requires pytest-xdist.""" import pytest errcode = pytest.main(['-f']) sys.exit(errcode) @task def clean(ctx): ctx.run('rm -rf build') ctx.run('rm -rf dist') ctx.run('rm -rf nplusone.egg-info') clean_docs(ctx) print('Cleaned up.') @task def clean_docs(ctx): ctx.run('rm -rf {0}'.format(build_dir)) @task def browse_docs(ctx): path = os.path.join(build_dir, 'index.html') webbrowser.open_new_tab(path) @task def docs(ctx, clean=False, browse=False, watch=False): """Build the docs.""" if clean: clean_docs(ctx) ctx.run('sphinx-build {0} {1}'.format(docs_dir, build_dir), pty=True) if browse: browse_docs(ctx) if watch: watch_docs(ctx) @task def watch_docs(ctx): """Run build the docs when a file changes.""" try: import sphinx_autobuild # noqa except ImportError: print('ERROR: watch task requires the sphinx_autobuild package.') print('Install it with:') print(' pip install sphinx-autobuild') sys.exit(1) docs(ctx) ctx.run('sphinx-autobuild {} {}'.format(docs_dir, build_dir), pty=True) @task def readme(ctx, browse=False): ctx.run('rst2html.py README.rst > README.html', pty=True) if browse: webbrowser.open_new_tab('README.html') nplusone-1.0.0/tests/000077500000000000000000000000001330043671200145145ustar00rootroot00000000000000nplusone-1.0.0/tests/__init__.py000066400000000000000000000000001330043671200166130ustar00rootroot00000000000000nplusone-1.0.0/tests/conftest.py000066400000000000000000000016301330043671200167130ustar00rootroot00000000000000import mock import pytest import collections from nplusone.core import stack from nplusone.core import signals from nplusone.core import listeners Call = collections.namedtuple('Call', ['objects', 'frame']) PATTERNS = [ 'site-packages', 'py.test', 'nplusone/core', 'nplusone/ext', 'nplusone/tests/conftest', ] @pytest.fixture def calls(): calls = [] def subscriber(sender, args=None, kwargs=None, context=None, ret=None, parser=None): calls.append( Call( parser(args, kwargs, context), stack.get_caller(patterns=PATTERNS) ) ) signals.lazy_load.connect(subscriber, sender=signals.get_worker()) yield calls @pytest.fixture def lazy_listener(): mock_parent = mock.Mock() listener = listeners.LazyListener(mock_parent) listener.setup() try: yield listener finally: listener.teardown() nplusone-1.0.0/tests/test_flask_sqlalchemy.py000066400000000000000000000170371330043671200214570ustar00rootroot00000000000000# -*- coding: utf-8 -*- import mock import flask import pytest import webtest import sqlalchemy as sa from flask_sqlalchemy import SQLAlchemy from nplusone.core import exceptions from nplusone.ext.flask_sqlalchemy import NPlusOne from nplusone.ext.flask_sqlalchemy import setup_state from tests import utils @pytest.fixture(scope='module', autouse=True) def setup(): setup_state() @pytest.fixture def db(): return SQLAlchemy() @pytest.fixture def models(db): return utils.make_models(db.Model) @pytest.fixture() def objects(db, app, models): hobby = models.Hobby() address = models.Address() user = models.User(addresses=[address], hobbies=[hobby]) db.session.add(user) db.session.commit() db.session.close() @pytest.fixture def logger(): return mock.Mock() @pytest.fixture def app(db, models, logger): app = flask.Flask(__name__) app.config['TESTING'] = True app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///:memory:' app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False app.config['NPLUSONE_LOGGER'] = logger db.init_app(app) with app.app_context(): db.create_all() yield app @pytest.fixture def wrapper(app): return NPlusOne(app) @pytest.fixture def routes(app, models, wrapper): @app.route('/many_to_one/') def many_to_one(): users = models.User.query.all() return str(users[0].addresses) @app.route('/many_to_one_one/') def many_to_one_one(): user = models.User.query.filter_by(id=1).one() return str(user.addresses) @app.route('/many_to_one_first/') def many_to_one_first(): user = models.User.query.first() return str(user.addresses) @app.route('/many_to_one_ignore/') def many_to_one_ignore(): with wrapper.ignore('lazy_load'): users = models.User.query.all() return str(users[0].addresses) @app.route('/many_to_many/') def many_to_many(): users = models.User.query.all() return str(users[0].hobbies) @app.route('/many_to_many_impossible/') def many_to_many_impossible(): user = models.User.query.first() users = models.User.query.all() # noqa return str(user.hobbies) @app.route('/many_to_many_impossible_one/') def many_to_many_impossible_one(): user = models.User.query.one() users = models.User.query.all() # noqa return str(user.hobbies) @app.route('/eager_join/') def eager_join(): users = models.User.query.options(sa.orm.subqueryload('hobbies')).all() return str(users[0].hobbies if users else None) @app.route('/eager_subquery/') def eager_subquery(): users = models.User.query.options(sa.orm.subqueryload('hobbies')).all() # Touch class-level descriptor to exercise `None` instance checks print(models.User.hobbies) return str(users[0].hobbies if users else None) @app.route('/eager_join_unused/') def eager_join_unused(): users = models.User.query.options(sa.orm.joinedload('hobbies')).all() return str(users[0]) @app.route('/eager_subquery_unused/') def eager_subquery_unused(): users = models.User.query.options(sa.orm.subqueryload('hobbies')).all() return str(users[0]) @app.route('/eager_nested/') def eager_nested(): hobbies = models.Hobby.query.options( sa.orm.joinedload(models.Hobby.users).joinedload( models.User.addresses, ) ).all() return str(hobbies[0].users[0].addresses) @app.route('/eager_nested_unused/') def eager_nested_unused(): hobbies = models.Hobby.query.options( sa.orm.joinedload(models.Hobby.users).joinedload( models.User.addresses, ) ).all() return str(hobbies[0]) @pytest.fixture def client(app, routes, wrapper): return webtest.TestApp(app) class TestNPlusOne: def test_many_to_one(self, objects, client, logger): client.get('/many_to_one/') assert len(logger.log.call_args_list) == 1 args = logger.log.call_args[0] assert 'User.addresses' in args[1] def test_many_to_one_one(self, objects, client, logger): client.get('/many_to_one_one/') assert not logger.log.called def test_many_to_one_first(self, objects, client, logger): client.get('/many_to_one_first/') assert not logger.log.called def test_many_to_one_ignore(self, objects, client, logger): client.get('/many_to_one_ignore/') assert not logger.log.called def test_many_to_many(self, objects, client, logger): client.get('/many_to_many/') assert len(logger.log.call_args_list) == 1 args = logger.log.call_args[0] assert 'User.hobbies' in args[1] def test_many_to_many_impossible(self, objects, client, logger): client.get('/many_to_many_impossible/') assert not logger.log.called def test_many_to_many_impossible_one(self, objects, client, logger): client.get('/many_to_many_impossible_one/') assert not logger.log.called def test_eager_join(self, objects, client, logger): client.get('/eager_join/') assert not logger.log.called def test_eager_subquery(self, objects, client, logger): client.get('/eager_subquery/') assert not logger.log.called def test_eager_join_empty(self, models, objects, client, logger): models.User.query.delete() client.get('/eager_join/') assert not logger.log.called def test_eager_subquery_empty(self, models, objects, client, logger): models.User.query.delete() client.get('/eager_subquery/') assert not logger.log.called def test_eager_join_unused(self, objects, client, logger): client.get('/eager_join_unused/') assert len(logger.log.call_args_list) == 1 args = logger.log.call_args[0] assert 'User.hobbies' in args[1] def test_eager_subquery_unused(self, objects, client, logger): client.get('/eager_subquery_unused/') assert len(logger.log.call_args_list) == 1 args = logger.log.call_args[0] assert 'User.hobbies' in args[1] def test_eager_nested_unused(self, app, wrapper, objects, client, logger): client.get('/eager_nested/') assert not logger.log.called def test_eager_nested(self, app, wrapper, objects, client, logger): client.get('/eager_nested_unused/') assert len(logger.log.call_args_list) == 2 calls = [call[0] for call in logger.log.call_args_list] assert any('Hobby.users' in call[1] for call in calls) assert any('User.addresses' in call[1] for call in calls) def test_many_to_many_raise(self, app, wrapper, objects, client, logger): app.config['NPLUSONE_RAISE'] = True with pytest.raises(exceptions.NPlusOneError): client.get('/many_to_many/') def test_many_to_many_whitelist(self, app, wrapper, objects, client, logger): app.config['NPLUSONE_WHITELIST'] = [{'model': 'User'}] client.get('/many_to_many/') assert not logger.log.called def test_many_to_many_whitelist_wildcard(self, app, wrapper, objects, client, logger): app.config['NPLUSONE_WHITELIST'] = [{'model': 'U*r'}] client.get('/many_to_many/') assert not logger.log.called def test_many_to_many_whitelist_decoy(self, app, wrapper, objects, client, logger): app.config['NPLUSONE_WHITELIST'] = [{'model': 'Hobby'}] client.get('/many_to_many/') assert logger.log.called nplusone-1.0.0/tests/test_flask_sqlalchemy_wsgi.py000066400000000000000000000036031330043671200225020ustar00rootroot00000000000000# -*- coding: utf-8 -*- import threading import flask import pytest import webtest from flask_sqlalchemy import SQLAlchemy from nplusone.core import signals from nplusone.core import exceptions from nplusone.ext.wsgi import NPlusOneMiddleware import nplusone.ext.sqlalchemy # noqa from tests import utils def get_worker(): return str(threading.current_thread().ident) @pytest.fixture(scope='module', autouse=True) def setup(): signals.get_worker = get_worker @pytest.fixture def db(): return SQLAlchemy() @pytest.fixture def models(db): return utils.make_models(db.Model) @pytest.fixture() def objects(db, app, models): hobby = models.Hobby() address = models.Address() user = models.User(addresses=[address], hobbies=[hobby]) db.session.add(user) db.session.commit() db.session.close() @pytest.fixture def app(db, models): app = flask.Flask(__name__) app.config['TESTING'] = True app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///:memory:' app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False db.init_app(app) with app.app_context(): db.create_all() yield app @pytest.fixture def routes(app, models, wrapper): @app.route('/many_to_one/') def many_to_one(): users = models.User.query.all() return str(users[0].addresses) @app.route('/many_to_one_one/') def many_to_one_one(): user = models.User.query.filter_by(id=1).one() return str(user.addresses) @pytest.fixture def wrapper(app): return NPlusOneMiddleware(app) @pytest.fixture def client(routes, wrapper): return webtest.TestApp(wrapper) class TestNPlusOneMiddleware: def test_many_to_one(self, objects, client): with pytest.raises(exceptions.NPlusOneError): client.get('/many_to_one/') def test_many_to_one_one(self, objects, client): client.get('/many_to_one_one/') nplusone-1.0.0/tests/test_peewee.py000066400000000000000000000077541330043671200174140ustar00rootroot00000000000000# -*- coding: utf-8 -*- import pytest import peewee as pw from nplusone.core import signals import nplusone.ext.peewee # noqa from tests.utils import Bunch @pytest.fixture def db(): return pw.SqliteDatabase(':memory:') @pytest.fixture def Base(db): class Base(pw.Model): class Meta: database = db return Base @pytest.fixture def models(Base): class Hobby(Base): pass class User(Base): hobbies = pw.ManyToManyField(Hobby, backref='users') class Address(Base): user = pw.ForeignKeyField(User, backref='addresses') return Bunch( Hobby=Hobby, User=User, Address=Address, ) @pytest.fixture def session(db, models): db.create_tables( [ models.User, models.Address, models.Hobby, models.User.hobbies.get_through_model() ], safe=True, ) with db.atomic() as transaction: yield transaction @pytest.fixture() def objects(models, session): user = models.User.create(id=1) hobby = models.Hobby.create(id=1) hobby.users.add(user) address = models.Address.create(id=1, user=user) return Bunch( user=user, hobby=hobby, address=address, ) class TestManyToOne: def test_many_to_one(self, models, session, objects, calls, lazy_listener): users = models.User.select() list(users[0].addresses) assert len(calls) == 1 call = calls[0] assert call.objects == (models.User, 'User:1', 'addresses') assert 'users[0].addresses' in ''.join(call.frame[4]) assert lazy_listener.parent.notify def test_many_to_one_get(self, models, session, objects, calls, lazy_listener): user = models.User.get() list(user.addresses) assert len(calls) == 1 call = calls[0] assert call.objects == (models.User, 'User:1', 'addresses') assert 'user.addresses' in ''.join(call.frame[4]) assert not lazy_listener.parent.notify.called def test_many_to_one_prefetch(self, models, session, objects, calls, lazy_listener): users = pw.prefetch( models.User.select(), models.Address.select(), ) list(users[0].addresses) assert len(calls) == 0 def test_many_to_one_ignore(self, models, session, objects, calls): user = models.User.select().first() with signals.ignore(signals.lazy_load): user.addresses assert len(calls) == 0 def test_many_to_one_reverse(self, models, session, objects, calls): address = models.Address.select().first() address.user assert len(calls) == 1 call = calls[0] assert call.objects == (models.Address, 'Address:1', 'user') assert 'address.user' in ''.join(call.frame[4]) def test_many_to_one_reverse_join(self, models, session, objects, calls): address = models.Address.select( models.Address, models.User, ).join( models.User ).first() address.user assert len(calls) == 0 def test_many_to_one_reverse_prefetch(self, models, session, objects, calls): addresses = pw.prefetch( models.Address.select(), models.User.select(), ) addresses[0].user assert len(calls) == 0 class TestManyToMany: def test_many_to_many(self, models, session, objects, calls): users = models.User.select() list(users[0].hobbies) assert len(calls) == 1 call = calls[0] assert call.objects == (models.User, 'User:1', 'hobbies') assert 'users[0].hobbies' in ''.join(call.frame[4]) def test_many_to_many_reverse(self, models, session, objects, calls): hobby = models.Hobby.select().first() list(hobby.users) assert len(calls) == 1 call = calls[0] assert call.objects == (models.Hobby, 'Hobby:1', 'users') assert 'hobby.users' in ''.join(call.frame[4]) nplusone-1.0.0/tests/test_sqlalchemy.py000066400000000000000000000111251330043671200202670ustar00rootroot00000000000000# -*- coding: utf-8 -*- import pytest import sqlalchemy as sa from sqlalchemy.ext.declarative import declarative_base from nplusone.core import signals from nplusone.core import profiler from nplusone.core import exceptions import nplusone.ext.sqlalchemy # noqa from tests import utils Base = declarative_base() models = utils.make_models(Base) @pytest.fixture() def session(): engine = sa.create_engine('sqlite:///:memory:') Session = sa.orm.sessionmaker(bind=engine) Base.metadata.create_all(bind=engine) return Session() @pytest.fixture() def objects(session): hobby = models.Hobby() address = models.Address() user = models.User(addresses=[address], hobbies=[hobby]) session.add(user) session.commit() session.close() class TestManyToOne: def test_many_to_one(self, session, objects, calls): users = session.query(models.User).all() users[0].addresses assert len(calls) == 1 call = calls[0] assert call.objects == (models.User, 'User:1', 'addresses') assert 'users[0].addresses' in ''.join(call.frame[4]) def test_many_to_one_ignore(self, session, objects, calls): users = session.query(models.User).all() with signals.ignore(signals.lazy_load): users[0].addresses assert len(calls) == 0 def test_many_to_one_subquery(self, session, objects, calls): users = session.query( models.User ).options( sa.orm.subqueryload('addresses') ).all() users[0].addresses assert len(calls) == 0 def test_many_to_one_joined(self, session, objects, calls): users = session.query(models.User).options(sa.orm.joinedload('addresses')).all() users[0].addresses assert len(calls) == 0 def test_many_to_one_reverse(self, session, objects, calls): addresses = session.query(models.Address).all() addresses[0].user assert len(calls) == 1 call = calls[0] assert call.objects == (models.Address, 'Address:1', 'user') assert 'addresses[0].user' in ''.join(call.frame[4]) def test_many_to_one_reverse_subquery(self, session, objects, calls): addresses = session.query( models.Address ).options( sa.orm.subqueryload('user') ).all() addresses[0].user assert len(calls) == 0 def test_many_to_one_reverse_joined(self, session, objects, calls): address = session.query(models.Address).options(sa.orm.joinedload('user')).first() address.user assert len(calls) == 0 class TestManyToMany: def test_many_to_many(self, session, objects, calls): users = session.query(models.User).all() users[0].hobbies assert len(calls) == 1 call = calls[0] assert call.objects == (models.User, 'User:1', 'hobbies') assert 'users[0].hobbies' in ''.join(call.frame[4]) def test_many_to_many_subquery(self, session, objects, calls): user = session.query(models.User).options(sa.orm.subqueryload('hobbies')).first() user.hobbies assert len(calls) == 0 def test_many_to_many_joined(self, session, objects, calls): user = session.query(models.User).options(sa.orm.joinedload('hobbies')).first() user.hobbies assert len(calls) == 0 def test_many_to_many_reverse(self, session, objects, calls): hobbies = session.query(models.Hobby).all() hobbies[0].users assert len(calls) == 1 call = calls[0] assert call.objects == (models.Hobby, 'Hobby:1', 'users') assert 'hobbies[0].users' in ''.join(call.frame[4]) def test_many_to_many_reverse_subquery(self, session, objects, calls): hobby = session.query(models.Hobby).options(sa.orm.subqueryload('users')).first() hobby.users assert len(calls) == 0 def test_many_to_many_reverse_joined(self, session, objects, calls): hobby = session.query(models.Hobby).options(sa.orm.joinedload('users')).first() hobby.users assert len(calls) == 0 def test_non_orm_query(session, objects, lazy_listener): session.query(models.Address.id).all() class TestProfile: def test_profile(self, session, objects): with profiler.Profiler(): users = session.query(models.User).all() with pytest.raises(exceptions.NPlusOneError): users[0].addresses def test_profile_whitelist(self, session, objects): with profiler.Profiler(whitelist=[{'model': 'User'}]): users = session.query(models.User).all() users[0].addresses nplusone-1.0.0/tests/testapp/000077500000000000000000000000001330043671200161745ustar00rootroot00000000000000nplusone-1.0.0/tests/testapp/manage.py000077500000000000000000000003721330043671200200030ustar00rootroot00000000000000#!/usr/bin/env python import os import sys if __name__ == "__main__": os.environ.setdefault("DJANGO_SETTINGS_MODULE", "testapp.settings") from django.core.management import execute_from_command_line execute_from_command_line(sys.argv) nplusone-1.0.0/tests/testapp/testapp/000077500000000000000000000000001330043671200176545ustar00rootroot00000000000000nplusone-1.0.0/tests/testapp/testapp/__init__.py000066400000000000000000000000001330043671200217530ustar00rootroot00000000000000nplusone-1.0.0/tests/testapp/testapp/models.py000066400000000000000000000011361330043671200215120ustar00rootroot00000000000000# -*- coding: utf-8 -*- from django.db import models class User(models.Model): hobbies = models.ManyToManyField('Hobby', related_name='users') class Pet(models.Model): user = models.ForeignKey('User', on_delete=models.CASCADE) class Allergy(models.Model): pets = models.ManyToManyField('Pet') class Occupation(models.Model): user = models.OneToOneField( 'User', on_delete=models.CASCADE, related_name='occupation') class Address(models.Model): user = models.ForeignKey('User', on_delete=models.CASCADE, related_name='addresses') class Hobby(models.Model): pass nplusone-1.0.0/tests/testapp/testapp/settings.py000066400000000000000000000053761330043671200221010ustar00rootroot00000000000000""" Django settings for testapp project. Generated by 'django-admin startproject' using Django 1.8.2. For more information on this file, see https://docs.djangoproject.com/en/1.8/topics/settings/ For the full list of settings and their values, see https://docs.djangoproject.com/en/1.8/ref/settings/ """ # Build paths inside the project like this: os.path.join(BASE_DIR, ...) import os import logging import django BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) # Quick-start development settings - unsuitable for production # See https://docs.djangoproject.com/en/1.8/howto/deployment/checklist/ # SECURITY WARNING: keep the secret key used in production secret! SECRET_KEY = 'u@6l6_hkvxkmnr-th^t6+0i&6$zknq-3p+tix181$5kb36(+0d' # SECURITY WARNING: don't run with debug turned on in production! DEBUG = True ALLOWED_HOSTS = [] # Application definition INSTALLED_APPS = ( 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', 'nplusone.ext.django', 'testapp', ) _middleware_classes = ( 'django.contrib.sessions.middleware.SessionMiddleware', 'django.middleware.common.CommonMiddleware', 'django.middleware.csrf.CsrfViewMiddleware', 'django.contrib.auth.middleware.AuthenticationMiddleware', 'django.contrib.messages.middleware.MessageMiddleware', 'django.middleware.clickjacking.XFrameOptionsMiddleware', 'nplusone.ext.django.NPlusOneMiddleware', ) if django.VERSION >= (1, 10): MIDDLEWARE = _middleware_classes else: MIDDLEWARE_CLASSES = _middleware_classes ROOT_URLCONF = 'testapp.urls' TEMPLATES = [ { 'BACKEND': 'django.template.backends.django.DjangoTemplates', 'DIRS': [], 'APP_DIRS': True, 'OPTIONS': { 'context_processors': [ 'django.template.context_processors.debug', 'django.template.context_processors.request', 'django.contrib.auth.context_processors.auth', 'django.contrib.messages.context_processors.messages', ], }, }, ] WSGI_APPLICATION = 'testapp.wsgi.application' # Database # https://docs.djangoproject.com/en/1.8/ref/settings/#databases DATABASES = { 'default': { 'ENGINE': 'django.db.backends.sqlite3', 'NAME': ':memory:', } } # Internationalization # https://docs.djangoproject.com/en/1.8/topics/i18n/ LANGUAGE_CODE = 'en-us' TIME_ZONE = 'UTC' USE_I18N = True USE_L10N = True USE_TZ = True # Static files (CSS, JavaScript, Images) # https://docs.djangoproject.com/en/1.8/howto/static-files/ STATIC_URL = '/static/' NPLUSONE_LOGGER = logging.getLogger('nplusone') NPLUSONE_LOG_LEVEL = logging.DEBUG nplusone-1.0.0/tests/testapp/testapp/tests.py000066400000000000000000000245371330043671200214030ustar00rootroot00000000000000# -*- coding: utf-8 -*- from __future__ import absolute_import import mock import pytest from django.conf import settings from django.http.request import HttpRequest from django.http.response import HttpResponse from nplusone.ext.django.patch import setup_state from nplusone.ext.django.middleware import NPlusOneMiddleware from . import models @pytest.fixture(scope='module', autouse=True) def setup(): setup_state() @pytest.fixture def objects(): user = models.User.objects.create() user2 = models.User.objects.create() pet = models.Pet.objects.create(user=user) pet2 = models.Pet.objects.create(user=user2) allergy = models.Allergy.objects.create() allergy.pets.add(pet) occupation = models.Occupation.objects.create(user=user) address = models.Address.objects.create(user=user) hobby = models.Hobby.objects.create() user.hobbies.add(hobby) return locals() @pytest.mark.django_db class TestOneToOne: def test_one_to_one(self, objects, calls): occupation = models.Occupation.objects.first() occupation.user assert len(calls) == 1 call = calls[0] assert call.objects == (models.Occupation, 'Occupation:1', 'user') assert 'occupation.user' in ''.join(call.frame[4]) def test_one_to_one_select(self, objects, calls): occupation = models.Occupation.objects.select_related('user').first() occupation.user assert len(calls) == 0 def test_one_to_one_prefetch(self, objects, calls): occupation = models.Occupation.objects.prefetch_related('user').first() occupation.user assert len(calls) == 0 def test_one_to_one_reverse(self, objects, calls): user = models.User.objects.first() user.occupation assert len(calls) == 1 call = calls[0] assert call.objects == (models.User, 'User:1', 'occupation') assert 'user.occupation' in ''.join(call.frame[4]) @pytest.mark.django_db class TestManyToOne: def test_many_to_one(self, objects, calls): address = models.Address.objects.first() address.user assert len(calls) == 1 call = calls[0] assert call.objects == (models.Address, 'Address:1', 'user') assert 'address.user' in ''.join(call.frame[4]) def test_many_to_one_select(self, objects, calls): address = list(models.Address.objects.select_related('user').all()) address[0].user assert len(calls) == 0 def test_many_to_one_prefetch(self, objects, calls): address = list(models.Address.objects.prefetch_related('user').all()) address[0].user assert len(calls) == 0 def test_many_to_one_reverse(self, objects, calls): user = models.User.objects.first() user.addresses.first() assert len(calls) == 1 call = calls[0] assert call.objects == (models.User, 'User:1', 'addresses') assert 'user.addresses' in ''.join(call.frame[4]) def test_many_to_one_reverse_no_related_name(self, objects, calls): user = models.User.objects.first() user.pet_set.first() assert len(calls) == 1 call = calls[0] assert call.objects == (models.User, 'User:1', 'pet_set') assert 'user.pet_set' in ''.join(call.frame[4]) @pytest.mark.django_db class TestManyToMany: def test_many_to_many(self, objects, calls): users = models.User.objects.all() list(users[0].hobbies.all()) assert len(calls) == 1 call = calls[0] assert call.objects == (models.User, 'User:1', 'hobbies') assert 'users[0].hobbies' in ''.join(call.frame[4]) def test_many_to_many_prefetch(self, objects, calls): users = models.User.objects.all().prefetch_related('hobbies') list(users[0].hobbies.all()) assert len(calls) == 0 def test_many_to_many_reverse(self, objects, calls): hobbies = models.Hobby.objects.all() list(hobbies[0].users.all()) assert len(calls) == 1 call = calls[0] assert call.objects == (models.Hobby, 'Hobby:1', 'users') assert 'hobbies[0].users' in ''.join(call.frame[4]) def test_many_to_many_reverse_prefetch(self, objects, calls): hobbies = models.Hobby.objects.all().prefetch_related('users') list(hobbies[0].users.all()) assert len(calls) == 0 @pytest.fixture def logger(monkeypatch): mock_logger = mock.Mock() monkeypatch.setattr(settings, 'NPLUSONE_LOGGER', mock_logger) return mock_logger @pytest.mark.django_db class TestIntegration: def test_one_to_one(self, objects, client, logger): client.get('/one_to_one/') assert len(logger.log.call_args_list) == 1 args = logger.log.call_args[0] assert 'Occupation.user' in args[1] def test_one_to_one_first(self, objects, client, logger): client.get('/one_to_one_first/') assert not logger.log.called def test_one_to_many(self, objects, client, logger): client.get('/one_to_many/') assert not logger.log.called def test_many_to_many(self, objects, client, logger): client.get('/many_to_many/') assert len(logger.log.call_args_list) == 1 args = logger.log.call_args[0] assert 'User.hobbies' in args[1] def test_many_to_many_get(self, objects, client, logger): client.get('/many_to_many_get/') assert len(logger.log.call_args_list) == 0 def test_many_to_many_reverse_no_related_name(self, objects, calls): pet = models.Pet.objects.first() pet.allergy_set.first() assert len(calls) == 1 call = calls[0] assert call.objects == (models.Pet, 'Pet:1', 'allergy_set') assert 'pet.allergy_set' in ''.join(call.frame[4]) def test_prefetch_one_to_one(self, objects, client, logger): client.get('/prefetch_one_to_one/') assert not logger.log.called def test_prefetch_one_to_one_unused(self, objects, client, logger): client.get('/prefetch_one_to_one_unused/') assert len(logger.log.call_args_list) == 1 args = logger.log.call_args[0] assert 'User.occupation' in args[1] def test_prefetch_many_to_many(self, objects, client, logger): client.get('/prefetch_many_to_many/') assert not logger.log.called def test_many_to_many_impossible(self, objects, client, logger): client.get('/many_to_many_impossible/') assert not logger.log.called def test_many_to_many_impossible_one(self, objects, client, logger): client.get('/many_to_many_impossible_one/') assert not logger.log.called def test_prefetch_many_to_many_render(self, objects, client, logger): client.get('/prefetch_many_to_many_render/') assert not logger.log.called def test_prefetch_many_to_many_empty(self, objects, client, logger): models.User.objects.all().delete() client.get('/prefetch_many_to_many/') assert not logger.log.called def test_prefetch_many_to_many_render_empty(self, objects, client, logger): models.User.objects.all().delete() client.get('/prefetch_many_to_many_render/') assert not logger.log.called def test_prefetch_many_to_many_unused(self, objects, client, logger): client.get('/prefetch_many_to_many_unused/') assert len(logger.log.call_args_list) == 1 args = logger.log.call_args[0] assert 'User.hobbies' in args[1] def test_prefetch_many_to_many_single(self, objects, client, logger): client.get('/prefetch_many_to_many_single/') assert not logger.log.called def test_prefetch_many_to_many_no_related_name(self, objects, client, logger): client.get('/prefetch_many_to_many_no_related/') assert not logger.log.called def test_select_one_to_one(self, objects, client, logger): client.get('/select_one_to_one/') assert not logger.log.called def test_select_one_to_one_unused(self, objects, client, logger): client.get('/select_one_to_one_unused/') assert len(logger.log.call_args_list) == 1 args = logger.log.call_args[0] assert 'User.occupation' in args[1] def test_select_many_to_one(self, objects, client, logger): client.get('/select_many_to_one/') assert not logger.log.called def test_select_many_to_one_empty(self, objects, client, logger): models.Pet.objects.all().delete() client.get('/select_many_to_one/') assert not logger.log.called def test_select_many_to_one_unused(self, objects, client, logger): client.get('/select_many_to_one_unused/') assert len(logger.log.call_args_list) == 1 args = logger.log.call_args[0] assert 'Pet.user' in args[1] def test_prefetch_nested(self, objects, client, logger): client.get('/prefetch_nested/') assert not logger.log.called def test_prefetch_nested_unused(self, objects, client, logger): client.get('/prefetch_nested_unused/') assert len(logger.log.call_args_list) == 2 calls = [call[0] for call in logger.log.call_args_list] assert any('Pet.user' in call[1] for call in calls) assert any('User.occupation' in call[1] for call in calls) def test_select_nested(self, objects, client, logger): client.get('/select_nested/') assert not logger.log.called def test_select_nested_unused(self, objects, client, logger): client.get('/select_nested_unused/') assert len(logger.log.call_args_list) == 2 calls = [call[0] for call in logger.log.call_args_list] assert any('Pet.user' in call[1] for call in calls) assert any('User.occupation' in call[1] for call in calls) def test_many_to_many_whitelist(self, objects, client, logger): settings.NPLUSONE_WHITELIST = [{'model': 'testapp.User'}] client.get('/many_to_many/') assert not logger.log.called def test_many_to_many_whitelist_wildcard(self, objects, client, logger): settings.NPLUSONE_WHITELIST = [{'model': 'testapp.*'}] client.get('/many_to_many/') assert not logger.log.called @pytest.mark.django_db def test_values(objects, lazy_listener): list(models.User.objects.values('id')) def test_middleware_no_process_request(): middleware = NPlusOneMiddleware() req, resp = HttpRequest(), HttpResponse() processed = middleware.process_response(req, resp) assert processed is resp nplusone-1.0.0/tests/testapp/testapp/urls.py000066400000000000000000000027651330043671200212250ustar00rootroot00000000000000from django.conf.urls import url from . import views urlpatterns = [ url(r'^one_to_one/$', views.one_to_one), url(r'^one_to_one_first/$', views.one_to_one_first), url(r'^one_to_many/$', views.one_to_many), url(r'^many_to_many/$', views.many_to_many), url(r'^many_to_many_get/$', views.many_to_many_get), url(r'^prefetch_one_to_one/$', views.prefetch_one_to_one), url(r'^prefetch_one_to_one_unused/$', views.prefetch_one_to_one_unused), url(r'^prefetch_many_to_many/$', views.prefetch_many_to_many), url(r'^many_to_many_impossible/$', views.many_to_many_impossible), url(r'^many_to_many_impossible_one/$', views.many_to_many_impossible_one), url(r'^prefetch_many_to_many_render/$', views.prefetch_many_to_many_render), url(r'^prefetch_many_to_many_unused/$', views.prefetch_many_to_many_unused), url(r'^prefetch_many_to_many_single/$', views.prefetch_many_to_many_single), url(r'^prefetch_many_to_many_no_related/$', views.prefetch_many_to_many_no_related), url(r'^select_one_to_one/$', views.select_one_to_one), url(r'^select_one_to_one_unused/$', views.select_one_to_one_unused), url(r'^select_many_to_one/$', views.select_many_to_one), url(r'^select_many_to_one_unused/$', views.select_many_to_one_unused), url(r'^prefetch_nested/$', views.prefetch_nested), url(r'^prefetch_nested_unused/$', views.prefetch_nested_unused), url(r'^select_nested/$', views.select_nested), url(r'^select_nested_unused/$', views.select_nested_unused), ] nplusone-1.0.0/tests/testapp/testapp/views.py000066400000000000000000000073131330043671200213670ustar00rootroot00000000000000# -*- coding: utf-8 -*- from django.http import HttpResponse from django.template import Template, Context from . import models def one_to_one(request): occupations = list(models.Occupation.objects.all()) return HttpResponse(occupations[0].user.id) def one_to_one_first(request): occupation = models.Occupation.objects.first() return HttpResponse(occupation.user.id) def one_to_many(request): users = models.User.objects.all().prefetch_related('addresses') return HttpResponse(users[0].addresses.all()) def many_to_many(request): users = list(models.User.objects.all()) return HttpResponse(users[0].hobbies.all()) def many_to_many_get(request): user = models.User.objects.get(pk=1) return HttpResponse(user.hobbies.all()) def prefetch_one_to_one(request): users = models.User.objects.all().select_related('occupation') return HttpResponse(users[0].occupation) def prefetch_one_to_one_unused(request): users = models.User.objects.all().prefetch_related('occupation') return HttpResponse(users[0]) def prefetch_many_to_many(request): users = list(models.User.objects.all().prefetch_related('hobbies')) # Touch class-level descriptors to exercise `None` instance checks print(models.Occupation.user) print(models.User.occupation) return HttpResponse(list(user.hobbies.all()) for user in users) def many_to_many_impossible(request): user = models.User.objects.first() users = list(models.User.objects.all()) # noqa return HttpResponse(user.hobbies.all()) def many_to_many_impossible_one(request): user = models.User.objects.get(pk=1) users = list(models.User.objects.all()) # noqa return HttpResponse(user.hobbies.all()) def prefetch_many_to_many_render(request): users = models.User.objects.all().prefetch_related('hobbies') template = ''' {% for user in users %} {% for hobby in user.hobbies.all %} {{ hobby.id }} {% endfor %} {% endfor %} ''' resp = Template(template).render(Context({'users': users})) return HttpResponse(resp) def prefetch_many_to_many_unused(request): users = models.User.objects.all().prefetch_related('hobbies') return HttpResponse(users[0]) def prefetch_many_to_many_single(request): hobbies = models.Hobby.objects.all().prefetch_related('users') return HttpResponse(hobbies[0].users.all()[0]) def prefetch_many_to_many_no_related(request): pets = models.Pet.objects.all().prefetch_related('allergy_set') return HttpResponse(pets[0].allergy_set.all()[0]) def select_one_to_one(request): users = models.User.objects.all().select_related('occupation') return HttpResponse(users[0].occupation) def select_one_to_one_unused(request): users = models.User.objects.all().select_related('occupation') return HttpResponse(users[0]) def select_many_to_one(request): pets = list(models.Pet.objects.all().select_related('user')) return HttpResponse(pets[0].user if pets else None) def select_many_to_one_unused(request): pets = list(models.Pet.objects.all().select_related('user')) return HttpResponse(pets[0]) def prefetch_nested(request): pets = list(models.Pet.objects.all().prefetch_related('user__occupation')) return HttpResponse(pets[0].user.occupation) def prefetch_nested_unused(request): pets = list(models.Pet.objects.all().prefetch_related('user__occupation')) return HttpResponse(pets[0]) def select_nested(request): pets = list(models.Pet.objects.all().select_related('user__occupation')) return HttpResponse(pets[0].user.occupation) def select_nested_unused(request): pets = list(models.Pet.objects.all().select_related('user__occupation')) return HttpResponse(pets[0]) nplusone-1.0.0/tests/utils.py000066400000000000000000000020151330043671200162240ustar00rootroot00000000000000# -*- coding: utf-8 -*- import sqlalchemy as sa class Bunch(object): def __init__(self, **kwargs): self.__dict__.update(kwargs) def make_models(Base): users_hobbies = sa.Table('users_hobbies', Base.metadata, sa.Column('user_id', sa.Integer, sa.ForeignKey('user.user_id')), sa.Column('hobby_id', sa.Integer, sa.ForeignKey('hobby.id')), ) class User(Base): __tablename__ = 'user' id = sa.Column('user_id', sa.Integer, primary_key=True) addresses = sa.orm.relationship('Address', backref='user') hobbies = sa.orm.relationship('Hobby', secondary=users_hobbies, backref='users') class Address(Base): __tablename__ = 'address' id = sa.Column(sa.Integer, primary_key=True) user_id = sa.Column(sa.Integer, sa.ForeignKey('user.user_id')) class Hobby(Base): __tablename__ = 'hobby' id = sa.Column(sa.Integer, primary_key=True) return Bunch( User=User, Address=Address, Hobby=Hobby, ) nplusone-1.0.0/tox.ini000066400000000000000000000010041330043671200146600ustar00rootroot00000000000000[tox] envlist={py27,py33,py34,py35,py36}-{django18,django19,django110,django111,django20} [testenv] deps= ; Testing mock pytest WebTest pytest-cov pytest-django pytest-pythonpath django-webtest flake8 ; ORMs SQLAlchemy Flask-SQLAlchemy peewee ; Django versions django18: django>=1.8,<1.9 django19: django>=1.9,<1.10 django110: django>=1.10,<1.11 django111: django>=1.11,<2.0 django20: django>=2.0,<2.1 commands= flake8 . py.test