pax_global_header00006660000000000000000000000064127527105510014517gustar00rootroot0000000000000052 comment=eabdce35f55c648630527fd73a09ea85b4753ea2 sphinx_celery-1.3.1/000077500000000000000000000000001275271055100143755ustar00rootroot00000000000000sphinx_celery-1.3.1/.bumpversion.cfg000066400000000000000000000004521275271055100175060ustar00rootroot00000000000000[bumpversion] current_version = 1.3.1 commit = True tag = True parse = (?P\d+)\.(?P\d+)\.(?P\d+)(?P[a-z]+)? serialize = {major}.{minor}.{patch}{releaselevel} {major}.{minor}.{patch} [bumpversion:file:sphinx_celery/__init__.py] [bumpversion:file:README.rst] sphinx_celery-1.3.1/.cookiecutterrc000066400000000000000000000006121275271055100174220ustar00rootroot00000000000000default_context: email: 'ask@celeryproject.org' full_name: 'Ask Solem' github_username: 'celery' project_name: 'sphinx_celery' project_short_description: 'Sphinx Celery Theme and Utilities' project_slug: 'sphinx_celery' version: '1.0.0' year: '2016' sphinx_celery-1.3.1/.coveragerc000066400000000000000000000002351275271055100165160ustar00rootroot00000000000000[run] branch = 1 cover_pylib = 0 include=*sphinx_celery/* omit = sphinx_celery.tests.* [report] omit = */python?.?/* */site-packages/* */pypy/* sphinx_celery-1.3.1/.editorconfig000066400000000000000000000003151275271055100170510ustar00rootroot00000000000000# http://editorconfig.org root = true [*] indent_style = space indent_size = 4 trim_trailing_whitespace = true insert_final_newline = true charset = utf-8 end_of_line = lf [Makefile] indent_style = tab sphinx_celery-1.3.1/.gitignore000066400000000000000000000004161275271055100163660ustar00rootroot00000000000000.DS_Store *.pyc *$py.class *~ .*.sw[pon] dist/ *.egg-info *.egg *.egg/ doc/__build/* build/ .build/ pip-log.txt .directory erl_crash.dump *.db Documentation/ .tox/ .ropeproject/ .project .pydevproject .idea/ .coverage celery/tests/cover/ .ve* cover/ .vagrant/ *.sqlite3 sphinx_celery-1.3.1/.travis.yml000066400000000000000000000006571275271055100165160ustar00rootroot00000000000000language: python sudo: false cache: false python: - '3.5' env: global: PYTHONUNBUFFERED=yes matrix: - TOXENV=2.6 - TOXENV=2.7 - TOXENV=3.3 - TOXENV=3.4 - TOXENV=3.4 - TOXENV=pypy - TOXENV=3.5 - TOXENV=pypy3 install: travis_retry pip install -U tox script: tox -v -- -v after_success: - .tox/$TRAVIS_PYTHON_VERSION/bin/coverage xml - .tox/$TRAVIS_PYTHON_VERSION/bin/codecov -e TOXENV sphinx_celery-1.3.1/AUTHORS000066400000000000000000000001541275271055100154450ustar00rootroot00000000000000The Celery theme was created by Armin Ronacher. Rest of contributors: - Ask Solem sphinx_celery-1.3.1/Changelog000066400000000000000000000021101275271055100162010ustar00rootroot00000000000000Changes ======= .. _version-1.3.1: 1.3.1 ===== :release-date: 2016-08-10 01:40 p.m. PDT - No longer depends on sphinxcontrib-spelling. This library depends on the enchant C library being installed, and are crashing Travis builds. .. _version-1.3.0: 1.3.0 ===== :release-date: 2016-05-27 01:41 p.m. PDT - Removes dependency on non-Python3 compatible sphinxcontrib-cheeseshop The ``:pypi:`` role has been replaced using extlinks, so will still work. .. _version-1.2.0: 1.2.0 ===== :release-date: 2016-04-14 11:22 p.m. PDT - New extlink crossref type: ``:github_username:``. - New extlink crossref type: ``:github_branch:``. - New extlink crossref type: ``:sha:``. - Adds :pypi:`sphinxcontrib-spelling`. To check spelling mistakes run the following command: .. code-block:: console $ sphinx-build -b spelling .. _version-1.1.0: 1.1.0 ===== :release-date: 2016-04-08 04:18 p.m. PDT - New apicheck extension - New configcheck extension .. _version-1.0.0: 1.0.0 ===== :release-date: 2016-04-07 05:19 p.m. PDT :release-by: Ask Solem - Initial release sphinx_celery-1.3.1/LICENSE000066400000000000000000000047011275271055100154040ustar00rootroot00000000000000Copyright (c) 2012-2016 Ask Solem & contributors. All rights reserved. SPHINX_CELERY is licensed under The BSD License (3 Clause, also known as the new BSD license). The license is an OSI approved Open Source license and is GPL-compatible(1). The license text can also be found here: http://www.opensource.org/licenses/BSD-3-Clause License ======= Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of Ask Solem, nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL Ask Solem OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. Documentation License ===================== The documentation portion of SPHINX_CELERY (the rendered contents of the "docs" directory of a software distribution or checkout) is supplied under the "Creative Commons Attribution-ShareAlike 4.0 International" (CC BY-SA 4.0) License as described by http://creativecommons.org/licenses/by-sa/4.0/ Footnotes ========= (1) A GPL-compatible license makes it possible to combine SPHINX_CELERY with other software that is released under the GPL, it does not mean that we're distributing SPHINX_CELERY under the GPL license. The BSD license, unlike the GPL, let you distribute a modified version without making your changes open source. sphinx_celery-1.3.1/MANIFEST.in000066400000000000000000000004571275271055100161410ustar00rootroot00000000000000include README.rst Changelog LICENSE recursive-include extra README *.py recursive-include requirements *.txt recursive-include sphinx_celery *.conf recursive-include sphinx_celery *.css_t recursive-include sphinx_celery *.html recursive-include sphinx_celery *.js recursive-include sphinx_celery *.css sphinx_celery-1.3.1/Makefile000066400000000000000000000070771275271055100160500ustar00rootroot00000000000000PROJ=sphinx_celery PGPIDENT="Celery Security Team" PYTHON=python GIT=git TOX=tox NOSETESTS=nosetests ICONV=iconv FLAKE8=flake8 FLAKEPLUS=flakeplus SPHINX2RST=sphinx2rst SPHINX_DIR=docs/ SPHINX_BUILDDIR="${SPHINX_DIR}/_build" README=README.rst README_SRC="docs/templates/readme.txt" CONTRIBUTING=CONTRIBUTING.rst CONTRIBUTING_SRC="docs/contributing.rst" SPHINX_HTMLDIR="${SPHINX_BUILDDIR}/html" DOCUMENTATION=Documentation FLAKEPLUSTARGET=2.7 all: help help: @echo "docs - Build documentation." @echo "test-all - Run tests for all supported python versions." @echo "distcheck ---------- - Check distribution for problems." @echo " test - Run unittests using current python." @echo " lint ------------ - Check codebase for problems." @echo " apicheck - Check API reference coverage." @echo " configcheck - Check configuration reference coverage." @echo " readmecheck - Check README.rst encoding." @echo " contribcheck - Check CONTRIBUTING.rst encoding" @echo " flakes -------- - Check code for syntax and style errors." @echo " flakecheck - Run flake8 on the source code." @echo " flakepluscheck - Run flakeplus on the source code." @echo "readme - Regenerate README.rst file." @echo "contrib - Regenerate CONTRIBUTING.rst file" @echo "clean-dist --------- - Clean all distribution build artifacts." @echo " clean-git-force - Remove all uncomitted files." @echo " clean ------------ - Non-destructive clean" @echo " clean-pyc - Remove .pyc/__pycache__ files" @echo " clean-docs - Remove documentation build artifacts." @echo " clean-build - Remove setup artifacts." @echo "bump - Bump patch version number." @echo "bump-minor - Bump minor version number." @echo "bump-major - Bump major version number." @echo "release - Make PyPI release." clean: clean-docs clean-pyc clean-build clean-dist: clean clean-git-force bump: bumpversion patch bump-minor: bumpversion minor bump-major: bumpversion major release: python setup.py register sdist bdist_wheel upload --sign --identity="$(PGPIDENT)" Documentation: (cd "$(SPHINX_DIR)"; $(MAKE) html) mv "$(SPHINX_HTMLDIR)" $(DOCUMENTATION) docs: Documentation clean-docs: -rm -rf "$(SPHINX_BUILDDIR)" lint: flakecheck apicheck configcheck readmecheck apicheck: (cd "$(SPHINX_DIR)"; $(MAKE) apicheck) configcheck: (cd "$(SPHINX_DIR)"; $(MAKE) configcheck) flakecheck: $(FLAKE8) --ignore=X999 "$(PROJ)" flakediag: -$(MAKE) flakecheck flakepluscheck: $(FLAKEPLUS) --$(FLAKEPLUSTARGET) "$(PROJ)" flakeplusdiag: -$(MAKE) flakepluscheck flakes: flakediag flakeplusdiag clean-readme: -rm -f $(README) readmecheck: $(ICONV) -f ascii -t ascii $(README) >/dev/null $(README): $(SPHINX2RST) "$(README_SRC)" --ascii > $@ readme: clean-readme $(README) readmecheck clean-contrib: -rm -f "$(CONTRIBUTING)" $(CONTRIBUTING): $(SPHINX2RST) "$(CONTRIBUTING_SRC)" > $@ contrib: clean-contrib $(CONTRIBUTING) clean-pyc: -find . -type f -a \( -name "*.pyc" -o -name "*$$py.class" \) | xargs rm -find . -type d -name "__pycache__" | xargs rm -r removepyc: clean-pyc clean-build: rm -rf build/ dist/ .eggs/ *.egg-info/ .tox/ .coverage cover/ clean-git: $(GIT) clean -xdn clean-git-force: $(GIT) clean -xdf test-all: clean-pyc $(TOX) test: $(PYTHON) setup.py test cov: $(NOSETESTS) -xv --with-coverage --cover-html --cover-branch build: $(PYTHON) setup.py sdist bdist_wheel distcheck: lint test clean dist: readme contrib clean-dist build sphinx_celery-1.3.1/README.rst000066400000000000000000000026321275271055100160670ustar00rootroot00000000000000===================================================================== Celery Sphinx Utilities ===================================================================== :Version: 1.3.1 :Download: http://pypi.python.org/pypi/sphinx_celery/ :Source: http://github.com/celery/sphinx_celery/ :Keywords: Sphinx, documentation, python About ===== This project provides the Celery sphinx theme and common Sphinx utilities. .. _installation: Installation ============ You can install sphinx_celery either via the Python Package Index (PyPI) or from source. To install using `pip`,:: $ pip install -U sphinx_celery To install using `easy_install`,:: $ easy_install -U sphinx_celery .. _installing-from-source: Downloading and installing from source -------------------------------------- Download the latest version of sphinx_celery from http://pypi.python.org/pypi/sphinx_celery/ You can install it by doing the following,:: $ tar xvfz sphinx_celery.0.0.tar.gz $ cd sphinx_celery.0.0 $ python setup.py build # python setup.py install The last command must be executed as a privileged user if you are not currently using a virtualenv. .. _installing-from-git: Using the development version ----------------------------- With pip ~~~~~~~~ You can install the latest snapshot of sphinx_celery using the following pip command:: $ pip install https://github.com/celery/sphinx_celery#egg=sphinx_celery sphinx_celery-1.3.1/appveyor.yml000066400000000000000000000024511275271055100167670ustar00rootroot00000000000000environment: global: # SDK v7.0 MSVC Express 2008's SetEnv.cmd script will fail if the # /E:ON and /V:ON options are not enabled in the batch script intepreter # See: http://stackoverflow.com/a/13751649/163740 WITH_COMPILER: "cmd /E:ON /V:ON /C .\\extra\\appveyor\\run_with_compiler.cmd" matrix: # Pre-installed Python versions, which Appveyor may upgrade to # a later point release. # See: http://www.appveyor.com/docs/installed-software#python - PYTHON: "C:\\Python27" PYTHON_VERSION: "2.7.x" PYTHON_ARCH: "32" - PYTHON: "C:\\Python34" PYTHON_VERSION: "3.4.x" PYTHON_ARCH: "32" - PYTHON: "C:\\Python27-x64" PYTHON_VERSION: "2.7.x" PYTHON_ARCH: "64" WINDOWS_SDK_VERSION: "v7.0" - PYTHON: "C:\\Python34-x64" PYTHON_VERSION: "3.4.x" PYTHON_ARCH: "64" WINDOWS_SDK_VERSION: "v7.1" init: - "ECHO %PYTHON% %PYTHON_VERSION% %PYTHON_ARCH%" install: - "powershell extra\\appveyor\\install.ps1" - "%PYTHON%/Scripts/pip.exe install -U setuptools" build: off test_script: - "%WITH_COMPILER% %PYTHON%/python setup.py test" after_test: - "%WITH_COMPILER% %PYTHON%/python setup.py bdist_wheel" artifacts: - path: dist\* #on_success: # - TODO: upload the content of dist/*.whl to a public wheelhouse sphinx_celery-1.3.1/extra/000077500000000000000000000000001275271055100155205ustar00rootroot00000000000000sphinx_celery-1.3.1/extra/appveyor/000077500000000000000000000000001275271055100173655ustar00rootroot00000000000000sphinx_celery-1.3.1/extra/appveyor/install.ps1000066400000000000000000000053421275271055100214640ustar00rootroot00000000000000# Sample script to install Python and pip under Windows # Authors: Olivier Grisel and Kyle Kastner # License: CC0 1.0 Universal: http://creativecommons.org/publicdomain/zero/1.0/ $BASE_URL = "https://www.python.org/ftp/python/" $GET_PIP_URL = "https://bootstrap.pypa.io/get-pip.py" $GET_PIP_PATH = "C:\get-pip.py" function DownloadPython ($python_version, $platform_suffix) { $webclient = New-Object System.Net.WebClient $filename = "python-" + $python_version + $platform_suffix + ".msi" $url = $BASE_URL + $python_version + "/" + $filename $basedir = $pwd.Path + "\" $filepath = $basedir + $filename if (Test-Path $filename) { Write-Host "Reusing" $filepath return $filepath } # Download and retry up to 5 times in case of network transient errors. Write-Host "Downloading" $filename "from" $url $retry_attempts = 3 for($i=0; $i -lt $retry_attempts; $i++){ try { $webclient.DownloadFile($url, $filepath) break } Catch [Exception]{ Start-Sleep 1 } } Write-Host "File saved at" $filepath return $filepath } function InstallPython ($python_version, $architecture, $python_home) { Write-Host "Installing Python" $python_version "for" $architecture "bit architecture to" $python_home if (Test-Path $python_home) { Write-Host $python_home "already exists, skipping." return $false } if ($architecture -eq "32") { $platform_suffix = "" } else { $platform_suffix = ".amd64" } $filepath = DownloadPython $python_version $platform_suffix Write-Host "Installing" $filepath "to" $python_home $args = "/qn /i $filepath TARGETDIR=$python_home" Write-Host "msiexec.exe" $args Start-Process -FilePath "msiexec.exe" -ArgumentList $args -Wait -Passthru Write-Host "Python $python_version ($architecture) installation complete" return $true } function InstallPip ($python_home) { $pip_path = $python_home + "/Scripts/pip.exe" $python_path = $python_home + "/python.exe" if (-not(Test-Path $pip_path)) { Write-Host "Installing pip..." $webclient = New-Object System.Net.WebClient $webclient.DownloadFile($GET_PIP_URL, $GET_PIP_PATH) Write-Host "Executing:" $python_path $GET_PIP_PATH Start-Process -FilePath "$python_path" -ArgumentList "$GET_PIP_PATH" -Wait -Passthru } else { Write-Host "pip already installed." } } function InstallPackage ($python_home, $pkg) { $pip_path = $python_home + "/Scripts/pip.exe" & $pip_path install $pkg } function main () { InstallPython $env:PYTHON_VERSION $env:PYTHON_ARCH $env:PYTHON InstallPip $env:PYTHON InstallPackage $env:PYTHON wheel } main sphinx_celery-1.3.1/extra/appveyor/run_with_compiler.cmd000066400000000000000000000034621275271055100236100ustar00rootroot00000000000000:: To build extensions for 64 bit Python 3, we need to configure environment :: variables to use the MSVC 2010 C++ compilers from GRMSDKX_EN_DVD.iso of: :: MS Windows SDK for Windows 7 and .NET Framework 4 (SDK v7.1) :: :: To build extensions for 64 bit Python 2, we need to configure environment :: variables to use the MSVC 2008 C++ compilers from GRMSDKX_EN_DVD.iso of: :: MS Windows SDK for Windows 7 and .NET Framework 3.5 (SDK v7.0) :: :: 32 bit builds do not require specific environment configurations. :: :: Note: this script needs to be run with the /E:ON and /V:ON flags for the :: cmd interpreter, at least for (SDK v7.0) :: :: More details at: :: https://github.com/cython/cython/wiki/64BitCythonExtensionsOnWindows :: http://stackoverflow.com/a/13751649/163740 :: :: Author: Olivier Grisel :: License: CC0 1.0 Universal: http://creativecommons.org/publicdomain/zero/1.0/ @ECHO OFF SET COMMAND_TO_RUN=%* SET WIN_SDK_ROOT=C:\Program Files\Microsoft SDKs\Windows SET MAJOR_PYTHON_VERSION="%PYTHON_VERSION:~0,1%" IF %MAJOR_PYTHON_VERSION% == "2" ( SET WINDOWS_SDK_VERSION="v7.0" ) ELSE IF %MAJOR_PYTHON_VERSION% == "3" ( SET WINDOWS_SDK_VERSION="v7.1" ) ELSE ( ECHO Unsupported Python version: "%MAJOR_PYTHON_VERSION%" EXIT 1 ) IF "%PYTHON_ARCH%"=="64" ( ECHO Configuring Windows SDK %WINDOWS_SDK_VERSION% for Python %MAJOR_PYTHON_VERSION% on a 64 bit architecture SET DISTUTILS_USE_SDK=1 SET MSSdk=1 "%WIN_SDK_ROOT%\%WINDOWS_SDK_VERSION%\Setup\WindowsSdkVer.exe" -q -version:%WINDOWS_SDK_VERSION% "%WIN_SDK_ROOT%\%WINDOWS_SDK_VERSION%\Bin\SetEnv.cmd" /x64 /release ECHO Executing: %COMMAND_TO_RUN% call %COMMAND_TO_RUN% || EXIT 1 ) ELSE ( ECHO Using default MSVC build environment for 32 bit architecture ECHO Executing: %COMMAND_TO_RUN% call %COMMAND_TO_RUN% || EXIT 1 ) sphinx_celery-1.3.1/extra/release/000077500000000000000000000000001275271055100171405ustar00rootroot00000000000000sphinx_celery-1.3.1/extra/release/removepyc.sh000077500000000000000000000001401275271055100215030ustar00rootroot00000000000000#!/bin/bash (cd "${1:-.}"; find . -name "*.pyc" | xargs rm -- 2>/dev/null) || echo "ok" sphinx_celery-1.3.1/requirements/000077500000000000000000000000001275271055100171205ustar00rootroot00000000000000sphinx_celery-1.3.1/requirements/default.txt000066400000000000000000000000141275271055100213000ustar00rootroot00000000000000Sphinx>=1.4 sphinx_celery-1.3.1/requirements/pkgutils.txt000066400000000000000000000001251275271055100215210ustar00rootroot00000000000000setuptools>=20.6.7 wheel>=0.29.0 flake8>=2.5.4 flakeplus>=1.1 tox>=2.3.1 bumpversion sphinx_celery-1.3.1/requirements/test.txt000066400000000000000000000000141275271055100206330ustar00rootroot00000000000000case>=1.0.3 sphinx_celery-1.3.1/setup.cfg000066400000000000000000000000771275271055100162220ustar00rootroot00000000000000[nosetests] where = sphinx_celery/tests [wheel] universal = 1 sphinx_celery-1.3.1/setup.py000066400000000000000000000063061275271055100161140ustar00rootroot00000000000000#!/usr/bin/env python # -*- coding: utf-8 -*- from setuptools import setup, find_packages import os import re import sys import codecs NAME = 'sphinx_celery' extra = {} # -*- Classifiers -*- classes = """ Development Status :: 5 - Production/Stable Programming Language :: Python Programming Language :: Python :: 2 Programming Language :: Python :: 2.7 Programming Language :: Python :: 2.6 Programming Language :: Python :: 3 Programming Language :: Python :: 3.3 Programming Language :: Python :: 3.4 Programming Language :: Python :: 3.5 License :: OSI Approved :: BSD License Intended Audience :: Developers Operating System :: OS Independent """ classifiers = [s.strip() for s in classes.split('\n') if s] # -*- Distribution Meta -*- re_meta = re.compile(r'__(\w+?)__\s*=\s*(.*)') re_doc = re.compile(r'^"""(.+?)"""') def add_default(m): attr_name, attr_value = m.groups() return ((attr_name, attr_value.strip("\"'")),) def add_doc(m): return (('doc', m.groups()[0]),) pats = {re_meta: add_default, re_doc: add_doc} here = os.path.abspath(os.path.dirname(__file__)) with open(os.path.join(here, 'sphinx_celery', '__init__.py')) as meta_fh: meta = {} for line in meta_fh: if line.strip() == '# -eof meta-': break for pattern, handler in pats.items(): m = pattern.match(line.strip()) if m: meta.update(handler(m)) # -*- Installation Requires -*- py_version = sys.version_info is_jython = sys.platform.startswith('java') is_pypy = hasattr(sys, 'pypy_version_info') def strip_comments(l): return l.split('#', 1)[0].strip() def _pip_requirement(req): if req.startswith('-r '): _, path = req.split() return reqs(*path.split('/')) return [req] def _reqs(*f): return [ _pip_requirement(r) for r in ( strip_comments(l) for l in open( os.path.join(os.getcwd(), 'requirements', *f)).readlines() ) if r] def reqs(*f): return [req for subreq in _reqs(*f) for req in subreq] # -*- Long Description -*- if os.path.exists('README.rst'): long_description = codecs.open('README.rst', 'r', 'utf-8').read() else: long_description = 'See http://pypi.python.org/pypi/sphinx_celery/' # -*- Entry Points -*- # # -*- %%% -*- setup( name=NAME, version=meta['version'], description=meta['doc'], author=meta['author'], author_email=meta['contact'], url=meta['homepage'], platforms=['any'], license='BSD', packages=find_packages(exclude=['ez_setup', 'tests', 'tests.*']), package_data={ 'sphinx_celery': [ 'theme.conf', ], os.path.join('sphinx_celery', 'static'): [ 'celery.css_t', ], os.path.join('sphinx_celery', 'templates'): [ 'page.html', ], }, include_package_data=True, zip_safe=False, install_requires=reqs('default.txt'), tests_require=reqs('test.txt'), test_suite='nose.collector', classifiers=classifiers, entry_points={ 'sphinx_themes': [ 'path = sphinx_celery:get_html_theme_path', ], }, long_description=long_description, **extra) sphinx_celery-1.3.1/sphinx_celery/000077500000000000000000000000001275271055100172515ustar00rootroot00000000000000sphinx_celery-1.3.1/sphinx_celery/__init__.py000066400000000000000000000020141275271055100213570ustar00rootroot00000000000000"""Sphinx Celery Theme.""" from __future__ import absolute_import, unicode_literals import os import re from collections import namedtuple __version__ = '1.3.1' __author__ = 'Ask Solem' __contact__ = 'ask@celeryproject.org' __homepage__ = 'http://github.com/celery/sphinx_celery' __docformat__ = 'restructuredtext' # -eof meta- __all__ = ['get_html_templates_path', 'get_html_theme_path'] version_info_t = namedtuple('version_info_t', ( 'major', 'minor', 'micro', 'releaselevel', 'serial', )) # bumpversion can only search for {current_version} # so we have to parse the version here. _temp = re.match( r'(\d+)\.(\d+).(\d+)(.+)?', __version__).groups() VERSION = version_info = version_info_t( int(_temp[0]), int(_temp[1]), int(_temp[2]), _temp[3] or '', '') del(_temp) del(re) def get_html_theme_path(): return os.path.abspath(os.path.dirname(os.path.dirname(__file__))) def get_html_templates_path(): return os.path.join( os.path.abspath(os.path.dirname((__file__))), 'templates', ) sphinx_celery-1.3.1/sphinx_celery/apicheck.py000066400000000000000000000137321275271055100214000ustar00rootroot00000000000000""" Sphinx Autodoc coverage checker. ================================ This builder extension makes sure all modules in the documented package is represented in the autodoc API reference. Usage ----- .. code-block:: console $ sphinx-build -b apicheck -d _build/doctrees . _build/apicheck Configuration ------------- apicheck_ignore_modules ~~~~~~~~~~~~~~~~~~~~~~~ List of modules to ignore, either as module names or regexes. Example: .. code-block:: python apicheck_ignore_modules = [ 'django.utils.functional', r'django.db.*', ] Test packages are ignored by default, even if this setting is defined. apicheck_package ~~~~~~~~~~~~~~~~ The package to verify, can be the fully-qualified name of a module or an actual module. Example: .. code-block:: python apicheck_package = 'django' Default is the value of the ``project`` configuration key in all lowercase. apicheck_domains ~~~~~~~~~~~~~~~~ List of domains to check. Default is ``['py']`` and Python is the only domain currently supported. """ from __future__ import absolute_import, unicode_literals import importlib import os from collections import defaultdict from six import string_types from sphinx.ext import autodoc from sphinx.util.console import bold, darkgreen, green, red from .builders import BaseBuilder from .utils import bytes_if_py2 DEFAULT_IGNORE = [r'.*?\.tests.*'] TITLEHEADER = '=' SUBHEADER = '-' ERR = 'ERROR' ERR_MISSING = '{error}: In index but module does not exist: {module}' ERR_UNDOCUMENTED = 'Undocumented Autodoc Modules' OK_STATUS = 'OK: All modules documented :o)' NOK_STATUS = """ {title} {undocumented}\ """ DOMAIN_FORMAT = """\ {domain} {modules} """ MODULE_FORMAT = '- {module}' class ModuleDocumenter(autodoc.ModuleDocumenter): missing_modules = set() def import_object(self): if not super(ModuleDocumenter, self).import_object(): self.missing_modules.add(self.modname) return False return True def title(s, spacing=2, sep=TITLEHEADER): return '\n'.join([ sep * (len(s) + spacing), '{0}{1}{0}'.format(' ' * (spacing // 2), red(s)), sep * (len(s) + spacing), ]) def header(s, sep=SUBHEADER): return '\n'.join([bold(s), sep * len(s)]) def find_python_modules(package): if isinstance(package, string_types): package = importlib.import_module(package) name, path = package.__name__, package.__file__ current_dist_depth = len(name.split('.')) - 1 current_dist = os.path.join(os.path.dirname(path), *([os.pardir] * current_dist_depth)) abs = os.path.abspath(current_dist) dist_name = os.path.basename(abs) for dirpath, dirnames, filenames in os.walk(abs): package = (dist_name + dirpath[len(abs):]).replace('/', '.') if '__init__.py' in filenames: yield package for filename in filenames: if filename.endswith('.py') and filename != '__init__.py': yield '.'.join([package, filename])[:-3] class APICheckBuilder(BaseBuilder): name = 'apicheck' pickle_filename = 'apicheck.pickle' find_modules = { 'py': find_python_modules, } def init(self): self.ignore_patterns = self.compile_regexes( self.config.apicheck_ignore_modules + DEFAULT_IGNORE, ) self.check_domains = self.config.apicheck_domains self.check_package = ( self.config.apicheck_package or self.config.project.lower()) self.undocumented = defaultdict(list) self.all_modules = defaultdict(set) def is_ignored_module(self, module): return any(regex.match(module) for regex in self.ignore_patterns) def write(self, *ignored): for domain in self.check_domains: self.build_coverage(domain) self.check_missing() if not self.app.statuscode: self.write_coverage(self.check_domains) def build_coverage(self, domain): self.all_modules[domain].update(self.find_modules[domain]( self.check_package, )) self.undocumented[domain].extend(self.find_undocumented( domain, self.env.domaindata[domain]['modules'], )) def find_undocumented(self, domain, documented): return ( mod for mod in self.all_modules[domain] if mod not in documented and not self.is_ignored_module(mod) ) def write_coverage(self, domains): status = any(self.undocumented.values()) if status: self.app.statuscode = 2 print(self.format_undocumented_domains(domains)) else: print(green(OK_STATUS)) def check_missing(self): for mod in ModuleDocumenter.missing_modules: self.app.statuscode = 3 print(ERR_MISSING.format( error=red(ERR), module=bold(mod), )) def format_undocumented_domains(self, domains): return NOK_STATUS.format( title=title(ERR_UNDOCUMENTED), undocumented='\n'.join( self.format_undocumented_domain(domain) for domain in domains ), ) def format_undocumented_domain(self, domain): return DOMAIN_FORMAT.format(domain=header(domain), modules='\n'.join( self.format_undocumented_module(module) for module in self.undocumented[domain] )) def format_undocumented_module(self, module): return MODULE_FORMAT.format(module=darkgreen(module)) def as_dict(self): return { 'undocumented': dict(self.undocumented), } def setup(app): app.add_builder(APICheckBuilder) app.add_config_value( bytes_if_py2('apicheck_ignore_modules'), [], False) app.add_config_value( bytes_if_py2('apicheck_domains'), ['py'], False) app.add_config_value( bytes_if_py2('apicheck_package'), None, False) reg = autodoc.AutoDirective._registry reg[ModuleDocumenter.objtype] = ModuleDocumenter sphinx_celery-1.3.1/sphinx_celery/autodocargspec.py000066400000000000000000000010021275271055100226170ustar00rootroot00000000000000from __future__ import absolute_import, unicode_literals from sphinx.ext import autodoc as _autodoc from sphinx.util import inspect def wrapped_getargspec(fun, *args, **kwargs): while 1: try: wrapped = fun.__wrapped__ if wrapped is fun: break fun = wrapped except AttributeError: break return inspect.getargspec(fun, *args, **kwargs) _autodoc.getargspec = wrapped_getargspec def setup(app): app.require_sphinx('1.0') sphinx_celery-1.3.1/sphinx_celery/builders.py000066400000000000000000000016571275271055100214450ustar00rootroot00000000000000from __future__ import absolute_import, unicode_literals import os import pickle import re from sphinx.builders import Builder ERR_INVALID_REGEX = 'Invalid regex {0!r} in apicheck_ignore_modules: {1!r}' class BaseBuilder(Builder): def get_outdated_docs(self): return '{0} overview'.format(self.name) def finish(self): picklepath = os.path.join(self.outdir, self.pickle_filename) with open(picklepath, mode='wb') as fh: pickle.dump(self.as_dict(), fh) def compile_regex(self, regex): if not regex.startswith('^'): regex = '^{0}'.format(regex) if not regex.endswith('$'): regex = '{0}$'.format(regex) try: return re.compile(regex) except Exception as exc: self.warn(ERR_INVALID_REGEX.format(regex, exc)) def compile_regexes(self, regexes): return [self.compile_regex(regex) for regex in regexes] sphinx_celery-1.3.1/sphinx_celery/conf.py000066400000000000000000000247771275271055100205710ustar00rootroot00000000000000# -*- coding: utf-8 -*- from __future__ import absolute_import, unicode_literals import os import sys from . import get_html_templates_path PY3 = sys.version_info[0] >= 3 LINKCODE_URL = 'https://github.com/{proj}/tree/{branch}/{filename}.py' GITHUB_BRANCH = 'master' EXTENSIONS = [ 'sphinx.ext.autodoc', 'sphinx.ext.intersphinx', 'sphinx.ext.todo', 'sphinx.ext.coverage', 'sphinx.ext.imgmath', 'sphinx.ext.ifconfig', 'sphinx.ext.viewcode', 'sphinx.ext.extlinks', 'sphinx_celery.autodocargspec', 'sphinx_celery.github_issues', 'sphinx_celery.signal_crossref', 'sphinx_celery.setting_crossref', 'sphinx_celery.apicheck', 'sphinx_celery.configcheck', ] INTERSPHINX_MAPPING = { 'python': ('http://docs.python.org/dev/', None), 'sphinx': ('http://www.sphinx-doc.org/en/stable/', None), 'kombu': ('http://kombu.readthedocs.io/en/master/', None), 'celery': ('http://docs.celeryproject.org/en/master', None), 'djcelery': ('http://django-celery.readthedocs.io/en/latest/', None), 'cyme': ('http://cyme.readthedocs.io/en/latest/', None), 'amqp': ('http://amqp.readthedocs.io/en/latest/', None), 'vine': ('http://vine.readthedocs.io/en/latest/', None), 'flower': ('http://flower.readthedocs.io/en/latest/', None), 'redis': ('http://redis-py.readthedocs.io/en/latest/', None), 'django': ('http://django.readthedocs.io/en/latest/', None), 'boto': ('http://boto.readthedocs.io/en/latest/', None), 'sqlalchemy': ('http://sqlalchemy.readthedocs.io/en/latest', None), 'kazoo': ('http://kazoo.readthedocs.io/en/latest/', None), 'msgpack': ('http://pythonhosted.org/msgpack-python/', None), 'riak': ('http://basho.github.io/riak-python-client/', None), 'pylibmc': ('http://sendapatch.se/projects/pylibmc/', None), 'eventlet': ('http://eventlet.net/doc/', None), 'gevent': ('http://gevent.org/', None), 'pyOpenSSL': ('http://pyopenssl.readthedocs.io/en/stable/', None), 'nose': ('http://nose.readthedocs.io/en/latest', None), 'tox': ('http://tox.readthedocs.io/en/latest', None), } string_types = (str,) if PY3 else (basestring,) def add_paths(config_file, path_additions): this = os.path.dirname(os.path.abspath(config_file)) sys.path.insert(0, os.path.join(this, os.pardir)) for path in path_additions: sys.path.append(os.path.join(this, path)) def configure_django(django_settings, **config): if django_settings: os.environ['DJANGO_SETTINGS_MODULE'] = django_settings else: from django.conf import settings # noqa if not settings.configured: settings.configure(**config) try: from django import setup as django_setup except ImportError: pass else: django_setup() def import_package(package): if isinstance(package, string_types): return __import__(package) return package def prepare_intersphinx_mapping(project, mapping, include, exclude, **extra): if include: mapping = dict((k, v) for k, v in mapping.items() if k in include) if exclude: mapping = dict((k, v) for k, v in mapping.items() if k not in exclude) mapping = dict(mapping, **extra) # Remove project itself from intersphinx mapping.pop(project.lower(), None) return mapping def create_linkcode_resolver(linkcode_url, github_project, github_branch): def linkcode_resolve(domain, info): if domain != 'py' or not info['module']: return filename = info['module'].replace('.', '/') return linkcode_url.format( proj=github_project, branch=github_branch, filename=filename, ) return linkcode_resolve def build_config( package, config_file, project, author=None, author_name=None, github_project=None, webdomain=None, canonical_url=None, canonical_stable_url=None, canonical_dev_url=None, django_settings=None, configure_django_settings={}, copyright=None, publisher=None, description='', path_additions=['_ext'], version_dev=None, version_stable=None, extensions=EXTENSIONS, extra_extensions=[], linkcode_url=LINKCODE_URL, github_branch=GITHUB_BRANCH, master_doc='index', html_logo=None, html_prepend_sidebars=[], templates_path=None, latex_logo=None, intersphinx_mapping=INTERSPHINX_MAPPING, extra_intersphinx_mapping={}, include_intersphinx=frozenset(), exclude_intersphinx=frozenset(), spelling_lang='en_US', spelling_show_suggestions=True, extlinks=None, **kwargs): add_paths(config_file, path_additions) if configure_django_settings or django_settings: configure_django(django_settings, **configure_django_settings or {}) package = import_package(package) description = description or package.__doc__ author = author or package.__author__ author_name = author_name or author extlinks = extlinks or {} extlinks.setdefault('sha', ( 'https://github.com/{0}/commit/%s'.format(github_project), 'GitHub SHA@', )) extlinks.setdefault('github_branch', ( 'https://github.com/{0}/tree/%s'.format(github_project), 'GitHub branch', )) extlinks.setdefault('github_user', ( 'https://github.com/%s/', '@', )) extlinks.setdefault('pypi', ( 'https://pypi.python.org/pypi/%s/', '', )) if not canonical_dev_url: canonical_dev_url = '/'.join([ canonical_url.rstrip('/'), 'en', 'master', ]) if not canonical_stable_url: canonical_stable_url = '/'.join([ canonical_url.rstrip('/'), 'en', 'latest', ]) if templates_path is None: templates_path = ['_templates'] if version_dev: templates_path.append(get_html_templates_path()) version = '.'.join(map(str, package.VERSION[0:2])) extensions = extensions + extra_extensions if os.environ.get('SPELLCHECK'): extensions.append('sphinxcontrib.spelling') conf = dict( extensions=extensions + extra_extensions, project=project, github_project=github_project, html_show_sphinx=False, # Add any paths that contain templates here, # relative to this directory. templates_path=templates_path, # The suffix of source filenames. source_suffix='.rst', # The master toctree document. master_doc=master_doc, copyright='{0}, {1}'.format(copyright, author), # The short X.Y version. version=version, # The full version, including alpha/beta/rc tags. release=package.__version__, exclude_patterns=['_build', 'Thumbs.db', '.DS_Store'], # If true, '()' will be appended to :func: etc. cross-reference text. add_function_parentheses=True, linkcode_resolve=create_linkcode_resolver( linkcode_url, github_project, github_branch, ), intersphinx_mapping=prepare_intersphinx_mapping( project, intersphinx_mapping, include_intersphinx, exclude_intersphinx, **extra_intersphinx_mapping ), # The name of the Pygments (syntax highlighting) style to use. pygments_style='colorful', # Add any paths that contain custom static files # (such as style sheets) here, relative to this directory. # They are copied after the builtin static files, so a file named # "default.css" will overwrite the builtin "default.css". html_static_path=['_static'], html_use_smartypants=True, add_module_names=True, highlight_language='python3', # If true, `todo` and `todoList` produce output, # else they produce nothing. todo_include_todos=True, # If false, no module index is generated. html_use_modindex=True, # If false, no index is generated. html_use_index=True, html_logo=html_logo, html_context={ 'version_dev': version_dev or version, 'version_stable': version_stable or version, 'canonical_stable_url': canonical_stable_url, 'canonical_dev_url': canonical_dev_url, }, man_pages=[ (master_doc, project.lower(), u'{0} Documentation'.format(project), [author_name], 1) ], # Grouping the document tree into Texinfo files. List of tuples # (source start file, target name, title, author, # dir menu entry, description, category) texinfo_documents=[ (master_doc, project, u'{0} Documentation'.format(project), author_name, project, description, 'Miscellaneous'), ], latex_logo=latex_logo or html_logo, latex_documents=[ ('index', '{0}.tex'.format(project), '{0} Documentation'.format(project), author, 'manual'), ], html_theme='sphinx_celery', html_sidebars={ 'index': list(html_prepend_sidebars) + [ 'sourcelink.html', 'searchbox.html', ], '**': list(html_prepend_sidebars) + [ 'relations.html', 'sourcelink.html', 'searchbox.html', ], }, # Bibliographic Dublin Core info. epub_title='Celery Manual, Version {0}'.format(version), epub_author=author_name, epub_publisher=publisher or author_name, epub_copyright=copyright, # The language of the text. It defaults to the language option # or en if the language is not set. epub_language='en', # The scheme of the identifier. Typical schemes are ISBN or URL. epub_scheme='ISBN', # The unique identifier of the text. This can be a ISBN number # or the project homepage. epub_identifier=webdomain, # A unique identification for the text. epub_uid='{0} Manual, Version {0}'.format(project, version), # A list of files that should not be packed into the epub file. epub_exclude_files=['search.html'], # The depth of the table of contents in toc.ncx. epub_tocdepth=3, # -- spelling spelling_lang=spelling_lang, spelling_show_suggestions=spelling_show_suggestions, # -- extlinks extlinks=extlinks, ) return dict(conf, **kwargs) sphinx_celery-1.3.1/sphinx_celery/configcheck.py000066400000000000000000000065751275271055100221030ustar00rootroot00000000000000""" Sphinx Configuration Reference Checker ====================================== This builder extension makes sure all settings in the documented package are represented in the configuration reference ( meaning they all have ``.. setting::`` directives). Usage ----- .. code-block:: console $ sphinx-build -b configcheck -d _build/doctrees . _build/configcheck Configuration ------------- configcheck_ignore_settings ~~~~~~~~~~~~~~~~~~~~~~~~~~~ List of settings to ignore, either as setting names or regexes. Example: .. code-block:: python configcheck_ignore_settings = [ 'USE_TZ', r'.*SECRET.*', ] configcheck_project_settings ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ A function returning a set of all setting names. Example: .. code-block:: python def configcheck_project_settings(): from django import conf return set(conf._all_settings) configcheck_should_ignore ~~~~~~~~~~~~~~~~~~~~~~~~~ Optional function that can be used in addition to ``configcheck_ignore_settings`` to ignore setting names programmatically. Example: .. code-block:: python def configcheck_should_ignore(setting): from django import conf return conf.is_deprecated(setting) """ from __future__ import absolute_import, unicode_literals from six import iterkeys as keys from sphinx.util.console import bold, green, red from .builders import BaseBuilder from .utils import bytes_if_py2 ERR = 'ERROR' ERR_MISSING_DOC = '{error}: Setting not documented: {name}' OK_STATUS = 'OK: All settings documented :o)' class ConfigCheckBuilder(BaseBuilder): name = 'configcheck' pickle_filename = 'configcheck.pickle' def init(self): self.ignore_patterns = self.compile_regexes( self.config.configcheck_ignore_settings, ) self.should_ignore = ( self.config.configcheck_should_ignore or (lambda s: False)) self.project_settings = self.config.configcheck_project_settings self.undocumented = set() def is_ignored_setting(self, setting): return self.should_ignore(setting) or any( regex.match(setting) for regex in self.ignore_patterns) def write(self, *ignored): self.check_missing() def documented_settings(self): return { name for reftype, name in keys( self.app.env.domaindata['std']['objects']) if reftype == 'setting' } def check_missing(self): all_settings = self.project_settings() documented_settings = self.documented_settings() self.undocumented.update( setting for setting in all_settings ^ documented_settings if not self.is_ignored_setting(setting) ) for setting in self.undocumented: self.app.statuscode = 2 print(ERR_MISSING_DOC.format( error=red(ERR), name=bold(setting), )) if not self.app.statuscode: print(green(OK_STATUS)) def as_dict(self): return { 'undocumented': self.undocumented, } def setup(app): app.add_builder(ConfigCheckBuilder) app.add_config_value( bytes_if_py2('configcheck_ignore_settings'), [], False) app.add_config_value( bytes_if_py2('configcheck_project_settings'), None, False) app.add_config_value( bytes_if_py2('configcheck_should_ignore'), None, False) sphinx_celery-1.3.1/sphinx_celery/github_issues.py000066400000000000000000000067351275271055100225130ustar00rootroot00000000000000"""Stolen from sphinxcontrib-issuetracker. Had to modify this as the original will make one Github API request per issue, which is not at all needed if we just want to link to issues. """ from __future__ import absolute_import, unicode_literals import re import sys from collections import namedtuple from docutils import nodes from docutils.transforms import Transform from sphinx.roles import XRefRole from sphinx.addnodes import pending_xref URL = 'https://github.com/{project}/issues/{issue_id}' Issue = namedtuple('Issue', ('id', 'title', 'url')) if sys.version_info[0] == 3: str_t = text_t = str else: str_t = basestring text_t = unicode class IssueRole(XRefRole): innernodeclass = nodes.inline class Issues(Transform): default_priority = 999 def apply(self): config = self.document.settings.env.config github_project = config.github_project issue_pattern = config.github_issue_pattern if isinstance(issue_pattern, str_t): issue_pattern = re.compile(issue_pattern) for node in self.document.traverse(nodes.Text): parent = node.parent if isinstance(parent, (nodes.literal, nodes.FixedTextElement)): continue text = text_t(node) new_nodes = [] last_issue_ref_end = 0 for match in issue_pattern.finditer(text): head = text[last_issue_ref_end:match.start()] if head: new_nodes.append(nodes.Text(head)) last_issue_ref_end = match.end() issuetext = match.group(0) issue_id = match.group(1) refnode = pending_xref() refnode['reftarget'] = issue_id refnode['reftype'] = 'issue' refnode['github_project'] = github_project reftitle = issuetext refnode.append(nodes.inline( issuetext, reftitle, classes=['xref', 'issue'])) new_nodes.append(refnode) if not new_nodes: continue tail = text[last_issue_ref_end:] if tail: new_nodes.append(nodes.Text(tail)) parent.replace(node, new_nodes) def make_issue_reference(issue, content_node): reference = nodes.reference() reference['refuri'] = issue.url if issue.title: reference['reftitle'] = issue.title reference.append(content_node) return reference def resolve_issue_reference(app, env, node, contnode): if node['reftype'] != 'issue': return issue_id = node['reftarget'] project = node['github_project'] issue = Issue(issue_id, None, URL.format(project=project, issue_id=issue_id)) conttext = text_t(contnode[0]) formatted_conttext = nodes.Text(conttext.format(issue=issue)) formatted_contnode = nodes.inline(conttext, formatted_conttext, classes=contnode['classes']) return make_issue_reference(issue, formatted_contnode) def init_transformer(app): app.add_transform(Issues) def setup(app): app.require_sphinx('1.0') app.add_role('issue', IssueRole()) app.add_config_value('github_project', None, 'env') app.add_config_value('github_issue_pattern', re.compile(r'[Ii]ssue #(\d+)'), 'env') app.connect(str('builder-inited'), init_transformer) app.connect(str('missing-reference'), resolve_issue_reference) sphinx_celery-1.3.1/sphinx_celery/setting_crossref.py000066400000000000000000000004371275271055100232120ustar00rootroot00000000000000from __future__ import absolute_import, unicode_literals from .utils import bytes_if_py2 def setup(app): app.add_crossref_type( directivename=bytes_if_py2('setting'), rolename=bytes_if_py2('setting'), indextemplate=bytes_if_py2('pair: %s; setting'), ) sphinx_celery-1.3.1/sphinx_celery/signal_crossref.py000066400000000000000000000004341275271055100230070ustar00rootroot00000000000000from __future__ import absolute_import, unicode_literals from .utils import bytes_if_py2 def setup(app): app.add_crossref_type( directivename=bytes_if_py2('signal'), rolename=bytes_if_py2('signal'), indextemplate=bytes_if_py2('pair: %s; signal'), ) sphinx_celery-1.3.1/sphinx_celery/static/000077500000000000000000000000001275271055100205405ustar00rootroot00000000000000sphinx_celery-1.3.1/sphinx_celery/static/celery.css_t000066400000000000000000000150341275271055100230630ustar00rootroot00000000000000/* * celery.css_t * ~~~~~~~~~~~~ * * :copyright: Copyright 2010 by Armin Ronacher. * :license: BSD, see LICENSE for details. */ {% set page_width = 940 %} {% set sidebar_width = 220 %} {% set body_font_stack = 'Optima, Segoe, "Segoe UI", Candara, Calibri, Arial, sans-serif' %} {% set headline_font_stack = 'Futura, "Trebuchet MS", Arial, sans-serif' %} {% set code_font_stack = "'Consolas', 'Menlo', 'Deja Vu Sans Mono', 'Bitstream Vera Sans Mono', monospace" %} @import url("basic.css"); /* -- page layout ----------------------------------------------------------- */ body { font-family: {{ body_font_stack }}; font-size: 17px; background-color: white; color: #000; margin: 30px 0 0 0; padding: 0; } div.document { width: {{ page_width }}px; margin: 0 auto; } div.deck { font-size: 18px; } p.developmentversion { color: red; } div.related { width: {{ page_width - 20 }}px; padding: 5px 10px; background: #F2FCEE; margin: 15px auto 15px auto; } div.documentwrapper { float: left; width: 100%; } div.bodywrapper { margin: 0 0 0 {{ sidebar_width }}px; } div.sphinxsidebar { width: {{ sidebar_width }}px; } hr { border: 1px solid #B1B4B6; } div.body { background-color: #ffffff; color: #3E4349; padding: 0 30px 0 30px; } img.celerylogo { padding: 0 0 10px 10px; float: right; } div.footer { width: {{ page_width - 15 }}px; margin: 10px auto 30px auto; padding-right: 15px; font-size: 14px; color: #888; text-align: right; } div.footer a { color: #888; } div.sphinxsidebar a { color: #444; text-decoration: none; border-bottom: 1px dashed #DCF0D5; } div.sphinxsidebar a:hover { border-bottom: 1px solid #999; } div.sphinxsidebar { font-size: 14px; line-height: 1.5; } div.sphinxsidebarwrapper { padding: 7px 10px; } div.sphinxsidebarwrapper p.logo { padding: 0 0 20px 0; margin: 0; } div.sphinxsidebar h3, div.sphinxsidebar h4 { font-family: {{ headline_font_stack }}; color: #444; font-size: 24px; font-weight: normal; margin: 0 0 5px 0; padding: 0; } div.sphinxsidebar h4 { font-size: 20px; } div.sphinxsidebar h3 a { color: #444; } div.sphinxsidebar p.logo a, div.sphinxsidebar h3 a, div.sphinxsidebar p.logo a:hover, div.sphinxsidebar h3 a:hover { border: none; } div.sphinxsidebar p { color: #555; margin: 10px 0; } div.sphinxsidebar ul { margin: 10px 0; padding: 0; color: #000; } div.sphinxsidebar input { border: 1px solid #ccc; font-family: {{ body_font_stack }}; font-size: 1em; } /* -- body styles ----------------------------------------------------------- */ a { color: #348613; text-decoration: underline; } a:hover { color: #59B833; text-decoration: underline; } div.body h1, div.body h2, div.body h3, div.body h4, div.body h5, div.body h6 { font-family: {{ headline_font_stack }}; font-weight: normal; margin: 30px 0px 10px 0px; padding: 0; } div.body h1 { margin-top: 0; padding-top: 0; font-size: 200%; } div.body h2 { font-size: 180%; } div.body h3 { font-size: 150%; } div.body h4 { font-size: 130%; } div.body h5 { font-size: 100%; } div.body h6 { font-size: 100%; } div.body h1 a.toc-backref, div.body h2 a.toc-backref, div.body h3 a.toc-backref, div.body h4 a.toc-backref, div.body h5 a.toc-backref, div.body h6 a.toc-backref { color: inherit!important; text-decoration: none; } a.headerlink { color: #ddd; padding: 0 4px; text-decoration: none; } a.headerlink:hover { color: #444; background: #eaeaea; } div.body p, div.body dd, div.body li { line-height: 1.4em; } div.admonition { background: #fafafa; margin: 20px -30px; padding: 10px 30px; border-top: 1px solid #ccc; border-bottom: 1px solid #ccc; } div.admonition p.admonition-title { font-family: {{ headline_font_stack }}; font-weight: normal; font-size: 24px; margin: 0 0 10px 0; padding: 0; line-height: 1; } div.admonition p.last { margin-bottom: 0; } div.highlight{ background-color: white; } dt:target, .highlight { background: #FAF3E8; } div.note { background-color: #eee; border: 1px solid #ccc; } div.seealso { background-color: #ffc; border: 1px solid #ff6; } div.topic { background-color: #eee; } div.warning { background-color: #ffe4e4; border: 1px solid #f66; } p.admonition-title { display: inline; } p.admonition-title:after { content: ":"; } pre, tt { font-family: {{ code_font_stack }}; font-size: 0.9em; } img.screenshot { } tt.descname, tt.descclassname { font-size: 0.95em; } tt.descname { padding-right: 0.08em; } img.screenshot { -moz-box-shadow: 2px 2px 4px #eee; -webkit-box-shadow: 2px 2px 4px #eee; box-shadow: 2px 2px 4px #eee; } table.docutils { border: 1px solid #888; -moz-box-shadow: 2px 2px 4px #eee; -webkit-box-shadow: 2px 2px 4px #eee; box-shadow: 2px 2px 4px #eee; } table.docutils td, table.docutils th { border: 1px solid #888; padding: 0.25em 0.7em; } table.field-list, table.footnote { border: none; -moz-box-shadow: none; -webkit-box-shadow: none; box-shadow: none; } table.footnote { margin: 15px 0; width: 100%; border: 1px solid #eee; background: #fdfdfd; font-size: 0.9em; } table.footnote + table.footnote { margin-top: -15px; border-top: none; } table.field-list th { padding: 0 0.8em 0 0; } table.field-list td { padding: 0; } table.footnote td.label { width: 0px; padding: 0.3em 0 0.3em 0.5em; } table.footnote td { padding: 0.3em 0.5em; } dl { margin: 0; padding: 0; } dl dd { margin-left: 30px; } blockquote { margin: 0 0 0 30px; padding: 0; } ul { margin: 10px 0 10px 30px; padding: 0; } pre { background: #F0FFEB; padding: 7px 10px; margin: 15px 0; border: 1px solid #C7ECB8; border-radius: 2px; -moz-border-radius: 2px; -webkit-border-radius: 2px; line-height: 1.3em; } tt { background: #F0FFEB; color: #222; /* padding: 1px 2px; */ } tt.xref, a tt { background: #F0FFEB; border-bottom: 1px solid white; } a.reference { text-decoration: none; border-bottom: 1px dashed #DCF0D5; } a.reference:hover { border-bottom: 1px solid #6D4100; } a.footnote-reference { text-decoration: none; font-size: 0.7em; vertical-align: top; border-bottom: 1px dashed #DCF0D5; } a.footnote-reference:hover { border-bottom: 1px solid #6D4100; } a:hover tt { background: #EEE; } sphinx_celery-1.3.1/sphinx_celery/templates/000077500000000000000000000000001275271055100212475ustar00rootroot00000000000000sphinx_celery-1.3.1/sphinx_celery/templates/page.html000066400000000000000000000013201275271055100230450ustar00rootroot00000000000000{% extends "layout.html" %} {% block body %}
{% if version >= version_dev %}

This document is for {{ project }}'s development version, which can be significantly different from previous releases. Get the stable docs here: {{ version_stable }}.

{% else %}

This document describes the current stable version of {{project}} ({{ version }}). For development docs, go here.

{% endif %}
{{ body }} {% endblock %} sphinx_celery-1.3.1/sphinx_celery/tests/000077500000000000000000000000001275271055100204135ustar00rootroot00000000000000sphinx_celery-1.3.1/sphinx_celery/tests/__init__.py000066400000000000000000000000001275271055100225120ustar00rootroot00000000000000sphinx_celery-1.3.1/sphinx_celery/theme.conf000066400000000000000000000000731275271055100212220ustar00rootroot00000000000000[theme] inherit = basic stylesheet = celery.css [options] sphinx_celery-1.3.1/sphinx_celery/utils.py000066400000000000000000000004441275271055100207650ustar00rootroot00000000000000from __future__ import absolute_import, unicode_literals import sys __all__ = ['bytes_if_py2'] if sys.version_info[0] >= 3: def bytes_if_py2(s): return s else: def bytes_if_py2(s): # noqa if isinstance(s, unicode): return s.encode() return s sphinx_celery-1.3.1/tox.ini000066400000000000000000000015371275271055100157160ustar00rootroot00000000000000[tox] envlist = 2.6,2.7,pypy,3.3,3.4,3.5,pypy3,flake8,flakeplus [testenv] deps= -r{toxinidir}/requirements/test.txt sitepackages = False recreate = False commands = {toxinidir}/extra/release/removepyc.sh {toxinidir} nosetests -xsv --with-coverage \ --cover-inclusive --cover-erase [] basepython = 2.6: python2.6 2.7: python2.7 3.3: python3.3 3.4: python3.4 3.5: python3.5 pypy: pypy pypy3: pypy3 [testenv:docs] deps = -r{toxinidir}/requirements/docs.txt commands = sphinx-build -W -b linkcheck -d {envtmpdir}/doctrees docs docs/_build/linkcheck [testenv:flake8] deps = -r{toxinidir}/requirements/pkgutils.txt commands = flake8 --ignore=X999 {toxinidir}/sphinx_celery [testenv:flakeplus] deps = -r{toxinidir}/requirements/pkgutils.txt commands = flakeplus --2.7 {toxinidir}/spinx_celery