jsonext-0.4.2/0000755000175000017500000000000013151042656013100 5ustar marcmarc00000000000000jsonext-0.4.2/PKG-INFO0000644000175000017500000000212313151042656014173 0ustar marcmarc00000000000000Metadata-Version: 1.0 Name: jsonext Version: 0.4.2 Summary: Well-structured helpers to help serializing commonly encountered structures to JSON (like datetime, to_dict(), etc. Home-page: http://github.com/mbr/jsonext Author: Marc Brinkmann Author-email: git@marcbrinkmann.de License: MIT Description: jsonext ======= .. image:: https://travis-ci.org/mbr/jsonext.svg?branch=master :target: https://travis-ci.org/mbr/jsonext jsonext makes it easy to serialize objects outside of the standard Python primitives to JSON:: >>> import jsonext >>> from datetime import datetime >>> jsonext.dumps(datetime.now()) '"2014-03-22T22:17:18.304528+00:00"' >>> jsonext.dumps(i**2 for i in range(10)) '[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]' It uses mixins to the standard encoder to achieve this and is easily reuse- and extensible. Check out the `documentation `_ for details. Platform: UNKNOWN jsonext-0.4.2/jsonext.egg-info/0000755000175000017500000000000013151042656016264 5ustar marcmarc00000000000000jsonext-0.4.2/jsonext.egg-info/PKG-INFO0000644000175000017500000000212313151042656017357 0ustar marcmarc00000000000000Metadata-Version: 1.0 Name: jsonext Version: 0.4.2 Summary: Well-structured helpers to help serializing commonly encountered structures to JSON (like datetime, to_dict(), etc. Home-page: http://github.com/mbr/jsonext Author: Marc Brinkmann Author-email: git@marcbrinkmann.de License: MIT Description: jsonext ======= .. image:: https://travis-ci.org/mbr/jsonext.svg?branch=master :target: https://travis-ci.org/mbr/jsonext jsonext makes it easy to serialize objects outside of the standard Python primitives to JSON:: >>> import jsonext >>> from datetime import datetime >>> jsonext.dumps(datetime.now()) '"2014-03-22T22:17:18.304528+00:00"' >>> jsonext.dumps(i**2 for i in range(10)) '[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]' It uses mixins to the standard encoder to achieve this and is easily reuse- and extensible. Check out the `documentation `_ for details. Platform: UNKNOWN jsonext-0.4.2/jsonext.egg-info/dependency_links.txt0000644000175000017500000000000113151042656022332 0ustar marcmarc00000000000000 jsonext-0.4.2/jsonext.egg-info/top_level.txt0000644000175000017500000000001013151042656021005 0ustar marcmarc00000000000000jsonext jsonext-0.4.2/jsonext.egg-info/requires.txt0000644000175000017500000000001213151042656020655 0ustar marcmarc00000000000000six arrow jsonext-0.4.2/jsonext.egg-info/SOURCES.txt0000644000175000017500000000044513151042656020153 0ustar marcmarc00000000000000LICENSE MANIFEST.in README.rst setup.py docs/Makefile docs/conf.py docs/index.rst jsonext/__init__.py jsonext/mixins.py jsonext/wrappers.py jsonext.egg-info/PKG-INFO jsonext.egg-info/SOURCES.txt jsonext.egg-info/dependency_links.txt jsonext.egg-info/requires.txt jsonext.egg-info/top_level.txtjsonext-0.4.2/LICENSE0000644000175000017500000000204213151042654014101 0ustar marcmarc00000000000000Copyright (c) 2014 Marc Brinkmann 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. jsonext-0.4.2/README.rst0000644000175000017500000000116213151042654014565 0ustar marcmarc00000000000000jsonext ======= .. image:: https://travis-ci.org/mbr/jsonext.svg?branch=master :target: https://travis-ci.org/mbr/jsonext jsonext makes it easy to serialize objects outside of the standard Python primitives to JSON:: >>> import jsonext >>> from datetime import datetime >>> jsonext.dumps(datetime.now()) '"2014-03-22T22:17:18.304528+00:00"' >>> jsonext.dumps(i**2 for i in range(10)) '[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]' It uses mixins to the standard encoder to achieve this and is easily reuse- and extensible. Check out the `documentation `_ for details. jsonext-0.4.2/setup.py0000644000175000017500000000121313151042654014605 0ustar marcmarc00000000000000#!/usr/bin/env python # -*- coding: utf-8 -*- import os from setuptools import setup, find_packages def read(fname): return open(os.path.join(os.path.dirname(__file__), fname)).read() setup( name='jsonext', version='0.4.2', description='Well-structured helpers to help serializing commonly ' 'encountered structures to JSON (like datetime, to_dict(), ' ' etc.', long_description=read('README.rst'), author='Marc Brinkmann', author_email='git@marcbrinkmann.de', url='http://github.com/mbr/jsonext', license='MIT', packages=find_packages(exclude=['tests']), install_requires=['six', 'arrow'], ) jsonext-0.4.2/jsonext/0000755000175000017500000000000013151042656014572 5ustar marcmarc00000000000000jsonext-0.4.2/jsonext/wrappers.py0000644000175000017500000000370013151042654017005 0ustar marcmarc00000000000000import arrow import datetime import re import six class DecoderWrapper(object): def __init__(self, decoder): self._decoder = decoder def _convert_dict(self, v): return {k: self._convert(v) for k, v in six.iteritems(v)} def _convert_list(self, v): return [self._convert(v) for v in iter(v)] def _convert_text(self, v): return v def _convert_integer(self, v): return v def _convert_float(self, v): return v def _convert_bool(self, v): return v def _convert_none(self, v): return v def _convert(self, value): if isinstance(value, dict): return self._convert_dict(value) if isinstance(value, list): return self._convert_list(value) if isinstance(value, six.text_type): return self._convert_text(value) if isinstance(value, six.integer_types): return self._convert_integer(value) if isinstance(value, float): return self._convert_float(value) if isinstance(value, bool): return self._convert_bool(value) if value is None: return self.convert_none(value) assert False, 'unreachable' def decode(self, *args, **kwargs): val = self._decoder.decode(*args, **kwargs) return self._convert(val) def raw_recode(self, *args, **kwargs): val = self._decoder.raw_decode(*args, **kwargs) return self._convert(val) class ISO88601Wrapper(DecoderWrapper): DATE_RE = re.compile(r'^\d{4}-\d{2}-\d{2}$') TIME_RE = re.compile(r'^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}[^\s]*$') def _convert_text(self, v): try: if self.DATE_RE and self.DATE_RE.match(v): return arrow.get(v).date() if self.TIME_RE and self.TIME_RE.match(v): return arrow.get(v).to('utc').naive except arrow.ParserError: return v return v jsonext-0.4.2/jsonext/__init__.py0000644000175000017500000000133013151042654016676 0ustar marcmarc00000000000000"""JSON-rendering helpers. This module provides mixins for the stdlib :class:`json.JSONEncoder` class, adding serialization methods for other object types, such as :class:`~datetime.datetime` objects or iterables. All these are ready to use by using :data:`~jsonext.dumps`. """ import functools import json from .mixins import ( JSONDateTimeMixin, JSONIterableMixin, JSONToDictMixin, JSONStringifyMixin, ) from .wrappers import ISO88601Wrapper class JSONEncoder(JSONDateTimeMixin, JSONIterableMixin, JSONToDictMixin, JSONStringifyMixin, json.JSONEncoder): pass JSONDecoder = ISO88601Wrapper(json.JSONDecoder()) dumps = functools.partial(json.dumps, cls=JSONEncoder) loads = JSONDecoder.decode jsonext-0.4.2/jsonext/mixins.py0000644000175000017500000000543413151042654016457 0ustar marcmarc00000000000000import datetime import arrow class JSONDateTimeMixin(object): """A mixin for JSONEncoders, encoding :class:`datetime.datetime` and :class:`datetime.date` objects by converting them to strings that can be parsed by all modern browsers JS Date() object. All timestamps are converted to UTC before being serialized. Date objects simply use :meth:`~datetime.date.isoformat`. >>> import jsonext >>> from datetime import datetime >>> dt = datetime(2013, 11, 17, 12, 00, 00) # Python 3.3.3 release! >>> jsonext.dumps(dt) '"2013-11-17T12:00:00+00:00"' >>> d = dt.date() >>> d datetime.date(2013, 11, 17) >>> jsonext.dumps(d) '"2013-11-17"' """ def default(self, o): if isinstance(o, datetime.datetime): return arrow.get(o).to('utc').isoformat() if isinstance(o, datetime.date): return o.isoformat() return super(JSONDateTimeMixin, self).default(o) class JSONIterableMixin(object): """A mixin for JSONEncoders, encoding any iterable type by converting it to a list. Especially useful for SQLAlchemy results that look a lot like regular lists or iterators, but will trip up the encoder. Beware of infinite generators. >>> import jsonext >>> gen = (i**2 for i in range(10)) >>> jsonext.dumps(gen) '[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]' """ def default(self, o): try: iterable = iter(o) except TypeError: pass else: return list(iterable) return super(JSONIterableMixin, self).default(o) class JSONToDictMixin(object): """A mixin for JSONEncoders, encoding any object with a to_dict() method by calling that method and encoding the return value. >>> import jsonext >>> class Foo(object): ... def __init__(self, a, b): ... self.a = a ... self.b = b ... def to_dict(self): ... return {'A': self.a, 'B': self.b} ... >>> items = [Foo(1,2), Foo(3,4)] >>> jsonext.dumps(items) '[{"A": 1, "B": 2}, {"A": 3, "B": 4}]' """ def default(self, o): if hasattr(o, 'to_dict'): return o.to_dict() return super(JSONToDictMixin, self).default(o) class JSONStringifyMixin(object): """A mixing for JSONEncoders, encoding any object that has a ``__str__`` method with the return value of said function. >>> import jsonext >>> from decimal import Decimal as D >>> x = D('123.456') >>> jsonext.dumps(x) '"123.456"' >>> from datetime import timedelta >>> t = timedelta(days=5, seconds=12345) >>> jsonext.dumps(t) '"5 days, 3:25:45"' """ def default(self, o): if hasattr(o, '__str__'): return str(o) return super(JSONStringifyMixin, self).default(o) jsonext-0.4.2/docs/0000755000175000017500000000000013151042656014030 5ustar marcmarc00000000000000jsonext-0.4.2/docs/index.rst0000644000175000017500000000515013151042654015670 0ustar marcmarc00000000000000jsonext ======= jsonext is a small library that collects commonly used implementations of JSON-serializers for various objects. A good example are :class:`~datetime.datetime` objects, which are commonly found in web applications. Since JSON does not know these types, they need to be serialized to strings - certainly not an impossible task, but tricky enough to get right when timezones are involved that it's a turn off to reimplement them every time. There are many other libraries on PyPI that somehow deal with this problem or a related one, though many of those are either dead or do a horrible job of wrapping the standard JSON library in funky ways. Encoders and Mixins ------------------- jsonext works with the standard libraries facilities as closely as possible; new encoding methods are added as mixins:: from json import JSONEncoder from jsonenc.mixins import JSONDateTimeMixin, JSONIterableMixin class MyJSONEncoder(JSONDateTimeMixin, JSONIterableMixin, JSONEncoder): pass # ... enc = MyJSONEncoder() enc.encode(data) The example above will encode ``data`` as JSON, using :class:`~jsonext.mixins.JSONDateTimeMixin` to encode any :class:`~datetime.datetime` objects found and any iterables using :class:`~jsonext.mixins.JSONIterableMixin`. All these are just mixins for the stdlib's :class:`~json.JSONEncoder`. Behind the scene these mixins provide a :meth:`~json.JSONEncoder.default` method that will check for types it can encode and either return the result or call the superclasses default method. An example implementation for a custom class ``Foo`` is simple:: class JSONFooMixin(object): def default(self, o): if isinstance(o, Foo): # return anything composed of objects the encoder can handle return ('This is a Foo object as a tuple', Foo.value) return super(JSONFooMixin, self).default(o) Shortcuts --------- Some shortcuts are provided if less customization is needed. The `jsonext.JSONEncoder` is a :class:`~jsonext.mixins.JSONEncoder` with some commonly useful classes mixed in: :class:`~jsonext.mixins.JSONDateTimeMixin`, :class:`~jsonext.mixins.JSONIterableMixin`, :class:`~jsonext.mixins.JSONToDictMixin`, :class:`~jsonext.mixins.JSONStringifyMixin` and :class:`~jsonext.mixins.json.JSONEncoder`. In addition, the :func:`jsonext.dumps` function is the same as :func:`json.dumps`, except is uses :class:`jsonext.JSONEncoder` as the encoder per default. This means that:: import jsonext jsonext.dumps(some_data) will just work. API Reference ------------- The following mixins are provided: .. automodule:: jsonext.mixins :members: jsonext-0.4.2/docs/conf.py0000644000175000017500000002037613151042654015335 0ustar marcmarc00000000000000# -*- coding: utf-8 -*- # # jsonext documentation build configuration file, created by # sphinx-quickstart on Sat Mar 22 21:29:12 2014. # # This file is execfile()d with the current directory set to its # containing dir. # # Note that not all possible configuration values are present in this # autogenerated file. # # All configuration values have a default; values that are commented out # serve to show the default. import sys import os import sphinx_readable_theme # If extensions (or modules to document with autodoc) are in another directory, # add these directories to sys.path here. If the directory is relative to the # documentation root, use os.path.abspath to make it absolute, like shown here. #sys.path.insert(0, os.path.abspath('.')) # -- General configuration ------------------------------------------------ # If your documentation needs a minimal Sphinx version, state it here. #needs_sphinx = '1.0' # Add any Sphinx extension module names here, as strings. They can be # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom # ones. extensions = [ 'sphinx.ext.autodoc', 'sphinx.ext.intersphinx', ] # Add any paths that contain templates here, relative to this directory. templates_path = ['_templates'] # The suffix of source filenames. source_suffix = '.rst' # The encoding of source files. #source_encoding = 'utf-8-sig' # The master toctree document. master_doc = 'index' # General information about the project. project = u'jsonext' copyright = u'2014, Marc Brinkmann' # The version info for the project you're documenting, acts as replacement for # |version| and |release|, also used in various other places throughout the # built documents. # # The short X.Y version. version = '0.4.2' # The full version, including alpha/beta/rc tags. release = '0.4.2' # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. #language = None # There are two options for replacing |today|: either, you set today to some # non-false value, then it is used: #today = '' # Else, today_fmt is used as the format for a strftime call. #today_fmt = '%B %d, %Y' # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. exclude_patterns = ['_build'] # The reST default role (used for this markup: `text`) to use for all # documents. #default_role = None # If true, '()' will be appended to :func: etc. cross-reference text. #add_function_parentheses = True # If true, the current module name will be prepended to all description # unit titles (such as .. function::). #add_module_names = True # If true, sectionauthor and moduleauthor directives will be shown in the # output. They are ignored by default. #show_authors = False # The name of the Pygments (syntax highlighting) style to use. pygments_style = 'sphinx' # A list of ignored prefixes for module index sorting. #modindex_common_prefix = [] # If true, keep warnings as "system message" paragraphs in the built documents. #keep_warnings = False # -- Options for HTML output ---------------------------------------------- # The theme to use for HTML and HTML Help pages. See the documentation for # a list of builtin themes. html_theme = 'readable' # Theme options are theme-specific and customize the look and feel of a theme # further. For a list of options available for each theme, see the # documentation. #html_theme_options = {} # Add any paths that contain custom themes here, relative to this directory. html_theme_path = [sphinx_readable_theme.get_html_theme_path()] # The name for this set of Sphinx documents. If None, it defaults to # " v documentation". #html_title = None # A shorter title for the navigation bar. Default is the same as html_title. #html_short_title = None # The name of an image file (relative to this directory) to place at the top # of the sidebar. #html_logo = None # The name of an image file (within the static path) to use as favicon of the # docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32 # pixels large. #html_favicon = None # 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'] # Add any extra paths that contain custom files (such as robots.txt or # .htaccess) here, relative to this directory. These files are copied # directly to the root of the documentation. #html_extra_path = [] # If not '', a 'Last updated on:' timestamp is inserted at every page bottom, # using the given strftime format. #html_last_updated_fmt = '%b %d, %Y' # If true, SmartyPants will be used to convert quotes and dashes to # typographically correct entities. #html_use_smartypants = True # Custom sidebar templates, maps document names to template names. #html_sidebars = {} # Additional templates that should be rendered to pages, maps page names to # template names. #html_additional_pages = {} # If false, no module index is generated. #html_domain_indices = True # If false, no index is generated. #html_use_index = True # If true, the index is split into individual pages for each letter. #html_split_index = False # If true, links to the reST sources are added to the pages. #html_show_sourcelink = True # If true, "Created using Sphinx" is shown in the HTML footer. Default is True. #html_show_sphinx = True # If true, "(C) Copyright ..." is shown in the HTML footer. Default is True. #html_show_copyright = True # If true, an OpenSearch description file will be output, and all pages will # contain a tag referring to it. The value of this option must be the # base URL from which the finished HTML is served. #html_use_opensearch = '' # This is the file name suffix for HTML files (e.g. ".xhtml"). #html_file_suffix = None # Output file base name for HTML help builder. htmlhelp_basename = 'jsonextdoc' # -- Options for LaTeX output --------------------------------------------- latex_elements = { # The paper size ('letterpaper' or 'a4paper'). #'papersize': 'letterpaper', # The font size ('10pt', '11pt' or '12pt'). #'pointsize': '10pt', # Additional stuff for the LaTeX preamble. #'preamble': '', } # Grouping the document tree into LaTeX files. List of tuples # (source start file, target name, title, # author, documentclass [howto, manual, or own class]). latex_documents = [ ('index', 'jsonext.tex', u'jsonext Documentation', u'Marc Brinkmann', 'manual'), ] # The name of an image file (relative to this directory) to place at the top of # the title page. #latex_logo = None # For "manual" documents, if this is true, then toplevel headings are parts, # not chapters. #latex_use_parts = False # If true, show page references after internal links. #latex_show_pagerefs = False # If true, show URL addresses after external links. #latex_show_urls = False # Documents to append as an appendix to all manuals. #latex_appendices = [] # If false, no module index is generated. #latex_domain_indices = True # -- Options for manual page output --------------------------------------- # One entry per manual page. List of tuples # (source start file, name, description, authors, manual section). man_pages = [('index', 'jsonext', u'jsonext Documentation', [u'Marc Brinkmann'], 1)] # If true, show URL addresses after external links. #man_show_urls = False # -- Options for Texinfo output ------------------------------------------- # Grouping the document tree into Texinfo files. List of tuples # (source start file, target name, title, author, # dir menu entry, description, category) texinfo_documents = [ ('index', 'jsonext', u'jsonext Documentation', u'Marc Brinkmann', 'jsonext', 'One line description of project.', 'Miscellaneous'), ] # Documents to append as an appendix to all manuals. #texinfo_appendices = [] # If false, no module index is generated. #texinfo_domain_indices = True # How to display URL addresses: 'footnote', 'no', or 'inline'. #texinfo_show_urls = 'footnote' # If true, do not generate a @detailmenu in the "Top" node's menu. #texinfo_no_detailmenu = False # Example configuration for intersphinx: refer to the Python standard library. intersphinx_mapping = {'http://docs.python.org/': None} jsonext-0.4.2/docs/Makefile0000644000175000017500000001515613151042654015476 0ustar marcmarc00000000000000# 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/jsonext.qhcp" @echo "To view the help file:" @echo "# assistant -collectionFile $(BUILDDIR)/qthelp/jsonext.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/jsonext" @echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/jsonext" @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." jsonext-0.4.2/MANIFEST.in0000644000175000017500000000007613151042654014637 0ustar marcmarc00000000000000include LICENSE include README.rst recursive-include docs/ * jsonext-0.4.2/setup.cfg0000644000175000017500000000007313151042656014721 0ustar marcmarc00000000000000[egg_info] tag_build = tag_date = 0 tag_svn_revision = 0