pax_global_header00006660000000000000000000000064140556673520014527gustar00rootroot0000000000000052 comment=7cdf1e9840119d92595f93b0695ba0cdaf850b18 ipdb-0.13.9/000077500000000000000000000000001405566735200125375ustar00rootroot00000000000000ipdb-0.13.9/.gitignore000066400000000000000000000002231405566735200145240ustar00rootroot00000000000000bin lib include # Python *.pyc /__pycache__/ # setuptools / distribute /*.egg-info/ /*.egg/ /build/ /dist/ # tox .tox # pip pip-selfcheck.json ipdb-0.13.9/.travis.yml000066400000000000000000000010151405566735200146450ustar00rootroot00000000000000arch: - amd64 - ppc64le language: python python: - "2.7" - "3.4" - "3.5" - "3.6" - "3.7" - "3.8" - "3.8-dev" - "nightly" - "pypy" matrix: exclude: - python: "pypy" arch: ppc64le before_install: # Update pip and setuptools to the latest. - pip install --upgrade pip setuptools - pip install codecov install: # Install ipdb, which will install the right IPython version for the current python. - pip install -e . script: - coverage run setup.py test - codecov sudo: false ipdb-0.13.9/AUTHORS000066400000000000000000000003541405566735200136110ustar00rootroot00000000000000aldrik andreagrandi bmw dimasad emulbreh felixonmars gnebehay gotcha IxDay JamshedVesuna kynan lebedov marciomazza mauritsvanrees msabramo nikolas omergertel pgularski pjdelport Psycojoker sas23 steinnes Wilfred WouterVH zvodd d1618033 ipdb-0.13.9/COPYING.txt000066400000000000000000000027241405566735200144150ustar00rootroot00000000000000Copyright (c) 2007-2019 ipdb development team All rights reserved. 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 the ipdb Development Team 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 THE COPYRIGHT OWNER 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. ipdb-0.13.9/HISTORY.txt000066400000000000000000000142721405566735200144470ustar00rootroot00000000000000Changelog ========= 0.13.9 (2021-06-02) ------------------- - Fix again when `pyproject.toml` does not contain `tool` section. [markab108] 0.13.8 (2021-05-26) ------------------- - Fix when `pyproject.toml` does not contain `tool` section. [anjos] - Add the convenience function ``iex()``. [alanbernstein] 0.13.7 (2021-03-16) ------------------- - Do not instantiate IPython on import [adamchainz] 0.13.6 (2021-03-08) ------------------- - Fix broken parsing of pyproject.toml [alexandrebarbaruiva] 0.13.5 (2021-03-02) ------------------- - Add support for pyproject.toml as configuration file [alexandrebarbaruiva] - For users using python 3.4, install 6.0.0 <= IPython < 7.0.0, for users using python 3.5, install 7.0.0 <= IPython < 7.10.0, for users using python 3.6, install 7.10.0 <= IPython < 7.17.0, for users using python>3.6, install IPython >= 7.17.0. [d1618033] 0.13.4 (2020-10-01) ------------------- - Add '-m' option [mrmino] 0.13.3 (2020-06-23) ------------------- - Allow runcall, runeval to also use set context value [meowser] - Add condition argument to set_trace [alexandrebarbaruiva] 0.13.2 (2020-03-03) ------------------- - Remove leftover debug code [gotcha] 0.13.1 (2020-02-28) ------------------- - Fix when no configuration file [gotcha] 0.13.0 (2020-02-28) ------------------- - Add option to set context via environment variable or configuration file [alexandrebarbaruiva] 0.12.3 (2019-12-03) ------------------- - Fix version in usage [gotcha] 0.12.2 (2019-07-30) ------------------- - Avoid emitting term-title bytes [steinnes] 0.12.1 (2019-07-26) ------------------- - Fix --help [native-api] 0.12 (2019-03-20) ----------------- - Drop support for Python 3.3.x [bmw] - Stop deprecation warnings from being raised when IPython >= 5.1 is used. Support for IPython < 5.1 has been dropped. [bmw] 0.11 (2018-02-15) ----------------- - Simplify loading IPython and getting information from it. Drop support for python 2.6 Drop support for IPython < 5.0.0 [takluyver] 0.10.3 (2017-04-22) ------------------- - For users using python 2.6, do not install IPython >= 2.0.0. And for users using python 2.7, do not install IPython >= 6.0.0. [vphilippon] - Drop support for python 3.2. [vphilippon] - Command line usage consistent with pdb - Add argument commands [zvodd] 0.10.2 (2017-01-25) ------------------- - Ask IPython which debugger class to use. Closes https://github.com/gotcha/ipdb/issues/105 [gnebehay, JBKahn] - ipdb.set_trace() does not ignore context arg anymore. Closes https://github.com/gotcha/ipdb/issues/93. [gnebehay, Garrett-R] 0.10.1 (2016-06-14) ------------------- - Support IPython 5.0. [ngoldbaum] 0.10.0 (2016-04-29) ------------------- - Stop trying to magically guess when stdout needs to be captured. Like needed by `nose`. Rather, provide a set of function that can be called explicitely when needed. [gotcha] - drop support of IPython before 0.10.2 0.9.4 (2016-04-29) ------------------ - Fix Restart error when using `python -m ipdb` Closes https://github.com/gotcha/ipdb/issues/93. [gotcha] 0.9.3 (2016-04-15) ------------------ - Don't require users to pass a traceback to post_mortem. [Wilfred] 0.9.2 (2016-04-15) ------------------ - Closes https://github.com/gotcha/ipdb/issues/93. [gotcha] 0.9.1 (2016-04-12) ------------------ - Reset ``sys.modules['__main__']`` to original value. Closes https://github.com/gotcha/ipdb/issues/85 [gotcha] - Fix support of IPython versions 0.x [asivokon] 0.9.0 (2016-02-22) ------------------ - Switch to revised BSD license (with approval of all contributors). Closes https://github.com/gotcha/ipdb/issues/68 [lebedov, gotcha] 0.8.3 (2016-02-17) ------------------ - Don't pass sys.argv to IPython for configuration. [emulbreh] 0.8.2 (2016-02-15) ------------------ - Fix lexical comparison for version numbers. [sas23] - Allow configuring how many lines of code context are displayed by `set_trace` [JamshedVesuna] - If an instance of IPython is already running its configuration will be loaded. [IxDay] 0.8.1 (2015-06-03) ------------------ - Make Nose support less invasive. Closes https://github.com/gotcha/ipdb/issues/52 Closes https://github.com/gotcha/ipdb/issues/31 [blink1073, gotcha] - Fix for post_mortem in context manager. Closes https://github.com/gotcha/ipdb/issues/20 [omergertel] 0.8 (2013-09-19) ---------------- - More Python 3 compatibility; implies dropping Python 2.5 support. Closes https://github.com/gotcha/ipdb/issues/37 [gotcha] 0.7.1 (2013-09-19) ------------------ - IPython 1.0 compatibility. Closes https://github.com/gotcha/ipdb/issues/44 [pgularski] - Index into version_info in setup.py for Python 2.6 compatibility. [kynan] - Add Travis CI configuration. [kynan] 0.7 (2012-07-06) ---------------- - Add ``launch_ipdb_on_exception`` context manager. Implies dropping Python 2.4 support. [Psycojoker] - Wrap sys.excepthook only once. [marciomazza] - Add GPL file and refer in headers. [stan3] - Python 3 support. [Piet Delport] - Basic tests. [msabramo] - Added the functions ``runcall``, ``runeval`` and ``run``. [dimasad] 0.6.1 (2011-10-17) ------------------ - State dependency on IPython later or equal to 0.10. [gotcha] 0.6 (2011-09-01) ---------------- - Add setuptools ``console_scripts`` entry point. [akrito, gotcha] - Nose support. Closes https://github.com/gotcha/ipdb/issues/8 [akaihola, gotcha] 0.5 (2011-08-05) ---------------- - IPython 0.11 support. [lebedov] 0.4 (2011-06-13) ---------------- - When used from IPython, use its colors. Closes https://github.com/gotcha/ipdb/issues/1 [gotcha] - Fixed errors when exiting with "q". [gotcha] - Allow use of ``python -m ipdb mymodule.py``. Python 2.7 only. Closes https://github.com/gotcha/ipdb/issues/3 [gotcha] - Fixed post_mortem when the traceback is None. [maurits] 0.3 (2011-01-16) ---------------- - Add ``post_mortem()`` for ``Products.PDBDebugMode`` support. [Jean Jordaan] - Moved to github.com. 0.2 (2010-10-20) ---------------- - Added ``pm()``. [Paulo Benedict Ang] 0.1 (2010-04-26) ---------------- - First "non dev" release. ipdb-0.13.9/MANIFEST.in000066400000000000000000000001451405566735200142750ustar00rootroot00000000000000include README.rst include manual_test.py include *.txt include AUTHORS recursive-include tests *.py ipdb-0.13.9/README.rst000066400000000000000000000117531405566735200142350ustar00rootroot00000000000000IPython `pdb` ============= .. image:: https://travis-ci.org/gotcha/ipdb.png?branch=master :target: https://travis-ci.org/gotcha/ipdb .. image:: https://codecov.io/gh/gotcha/ipdb/branch/master/graphs/badge.svg?style=flat :target: https://codecov.io/gh/gotcha/ipdb?branch=master Use --- ipdb exports functions to access the IPython_ debugger, which features tab completion, syntax highlighting, better tracebacks, better introspection with the same interface as the `pdb` module. Example usage: .. code-block:: python import ipdb ipdb.set_trace() ipdb.set_trace(context=5) # will show five lines of code # instead of the default three lines # or you can set it via IPDB_CONTEXT_SIZE env variable # or setup.cfg file ipdb.pm() ipdb.run('x[0] = 3') result = ipdb.runcall(function, arg0, arg1, kwarg='foo') result = ipdb.runeval('f(1,2) - 3') Arguments for `set_trace` +++++++++++++++++++++++++ The `set_trace` function accepts `context` which will show as many lines of code as defined, and `cond`, which accepts boolean values (such as `abc == 17`) and will start ipdb's interface whenever `cond` equals to `True`. Using configuration file ++++++++++++++++++++++++ It's possible to set up context using a `.ipdb` file on your home folder, `setup.cfg` or `pyproject.toml` on your project folder. You can also set your file location via env var `$IPDB_CONFIG`. Your environment variable has priority over the home configuration file, which in turn has priority over the setup config file. Currently, only context setting is available. A valid setup.cfg is as follows :: [ipdb] context=5 A valid .ipdb is as follows :: context=5 A valid pyproject.toml is as follows :: [tool.ipdb] context=5 The post-mortem function, ``ipdb.pm()``, is equivalent to the magic function ``%debug``. .. _IPython: http://ipython.org If you install ``ipdb`` with a tool which supports ``setuptools`` entry points, an ``ipdb`` script is made for you. You can use it to debug your python 2 scripts like :: $ bin/ipdb mymodule.py And for python 3 :: $ bin/ipdb3 mymodule.py Alternatively with Python 2.7 only, you can also use :: $ python -m ipdb mymodule.py You can also enclose code with the ``with`` statement to launch ipdb if an exception is raised: .. code-block:: python from ipdb import launch_ipdb_on_exception with launch_ipdb_on_exception(): [...] .. warning:: Context managers were introduced in Python 2.5. Adding a context manager implies dropping Python 2.4 support. Use ``ipdb==0.6`` with 2.4. Or you can use ``iex`` as a function decorator to launch ipdb if an exception is raised: .. code-block:: python from ipdb import iex @iex def main(): [...] .. warning:: Using ``from future import print_function`` for Python 3 compat implies dropping Python 2.5 support. Use ``ipdb<=0.8`` with 2.5. Issues with ``stdout`` ---------------------- Some tools, like ``nose`` fiddle with ``stdout``. Until ``ipdb==0.9.4``, we tried to guess when we should also fiddle with ``stdout`` to support those tools. However, all strategies tried until 0.9.4 have proven brittle. If you use ``nose`` or another tool that fiddles with ``stdout``, you should explicitly ask for ``stdout`` fiddling by using ``ipdb`` like this .. code-block:: python import ipdb ipdb.sset_trace() ipdb.spm() from ipdb import slaunch_ipdb_on_exception with slaunch_ipdb_on_exception(): [...] Development ----------- ``ipdb`` source code and tracker are at https://github.com/gotcha/ipdb. Pull requests should take care of updating the changelog ``HISTORY.txt``. Under the unreleased section, add your changes and your username. Manual testing ++++++++++++++ To test your changes, make use of ``manual_test.py``. Create a virtual environment, install IPython and run ``python manual_test.py`` and check if your changes are in effect. If possible, create automated tests for better behaviour control. Automated testing +++++++++++++++++ To run automated tests locally, create a virtual environment, install `coverage` and run `coverage run setup.py test`. Third-party support ------------------- Products.PDBDebugMode +++++++++++++++++++++ Zope2 Products.PDBDebugMode_ uses ``ipdb``, if available, in place of ``pdb``. .. _Products.PDBDebugMode: http://pypi.python.org/pypi/Products.PDBDebugMode iw.debug ++++++++ iw.debug_ allows you to trigger an ``ipdb`` debugger on any published object of a Zope2 application. .. _iw.debug: http://pypi.python.org/pypi/iw.debug ipdbplugin ++++++++++ ipdbplugin_ is a nose_ test runner plugin that also uses the IPython debugger instead of ``pdb``. (It does not depend on ``ipdb`` anymore). .. _ipdbplugin: http://pypi.python.org/pypi/ipdbplugin .. _nose: http://readthedocs.org/docs/nose ipdb-0.13.9/ipdb/000077500000000000000000000000001405566735200134555ustar00rootroot00000000000000ipdb-0.13.9/ipdb/__init__.py000066400000000000000000000007731405566735200155750ustar00rootroot00000000000000# Copyright (c) 2007-2016 Godefroid Chapelle and ipdb development team # # This file is part of ipdb. # Redistributable under the revised BSD license # https://opensource.org/licenses/BSD-3-Clause from ipdb.__main__ import set_trace, post_mortem, pm, run, iex # noqa from ipdb.__main__ import runcall, runeval, launch_ipdb_on_exception # noqa from ipdb.stdout import sset_trace, spost_mortem, spm # noqa from ipdb.stdout import slaunch_ipdb_on_exception # noqa ipdb-0.13.9/ipdb/__main__.py000066400000000000000000000234211405566735200155510ustar00rootroot00000000000000# Copyright (c) 2011-2016 Godefroid Chapelle and ipdb development team # # This file is part of ipdb. # Redistributable under the revised BSD license # https://opensource.org/licenses/BSD-3-Clause from __future__ import print_function import os import sys from decorator import contextmanager __version__ = '0.13.9' from IPython import get_ipython from IPython.core.debugger import BdbQuit_excepthook from IPython.terminal.ipapp import TerminalIPythonApp from IPython.terminal.embed import InteractiveShellEmbed try: import configparser except: import ConfigParser as configparser def _get_debugger_cls(): shell = get_ipython() if shell is None: # Not inside IPython # Build a terminal app in order to force ipython to load the # configuration ipapp = TerminalIPythonApp() # Avoid output (banner, prints) ipapp.interact = False ipapp.initialize(["--no-term-title"]) shell = ipapp.shell else: # Running inside IPython # Detect if embed shell or not and display a message if isinstance(shell, InteractiveShellEmbed): sys.stderr.write( "\nYou are currently into an embedded ipython shell,\n" "the configuration will not be loaded.\n\n" ) # Let IPython decide about which debugger class to use # This is especially important for tools that fiddle with stdout return shell.debugger_cls def _init_pdb(context=None, commands=[]): if context is None: context = os.getenv("IPDB_CONTEXT_SIZE", get_context_from_config()) debugger_cls = _get_debugger_cls() try: p = debugger_cls(context=context) except TypeError: p = debugger_cls() p.rcLines.extend(commands) return p def wrap_sys_excepthook(): # make sure we wrap it only once or we would end up with a cycle # BdbQuit_excepthook.excepthook_ori == BdbQuit_excepthook if sys.excepthook != BdbQuit_excepthook: BdbQuit_excepthook.excepthook_ori = sys.excepthook sys.excepthook = BdbQuit_excepthook def set_trace(frame=None, context=None, cond=True): if not cond: return wrap_sys_excepthook() if frame is None: frame = sys._getframe().f_back p = _init_pdb(context).set_trace(frame) if p and hasattr(p, 'shell'): p.shell.restore_sys_module_state() def get_context_from_config(): try: parser = get_config() return parser.getint("ipdb", "context") except (configparser.NoSectionError, configparser.NoOptionError): return 3 except ValueError: value = parser.get("ipdb", "context") raise ValueError( "In %s, context value [%s] cannot be converted into an integer." % (parser.filepath, value) ) class ConfigFile(object): """ Filehandle wrapper that adds a "[ipdb]" section to the start of a config file so that users don't actually have to manually add a [ipdb] section. Works with configparser versions from both Python 2 and 3 """ def __init__(self, filepath): self.first = True with open(filepath) as f: self.lines = f.readlines() # Python 2.7 (Older dot versions) def readline(self): try: return self.__next__() except StopIteration: return '' # Python 2.7 (Newer dot versions) def next(self): return self.__next__() # Python 3 def __iter__(self): return self def __next__(self): if self.first: self.first = False return "[ipdb]\n" if self.lines: return self.lines.pop(0) raise StopIteration def get_config(): """ Get ipdb config file settings. All available config files are read. If settings are in multiple configs, the last value encountered wins. Values specified on the command-line take precedence over all config file settings. Returns: A ConfigParser object. """ parser = configparser.ConfigParser() filepaths = [] # Low priority goes first in the list for cfg_file in ("setup.cfg", ".ipdb", "pyproject.toml"): cwd_filepath = os.path.join(os.getcwd(), cfg_file) if os.path.isfile(cwd_filepath): filepaths.append(cwd_filepath) # Medium priority (whenever user wants to set a specific path to config file) home = os.getenv("HOME") if home: default_filepath = os.path.join(home, ".ipdb") if os.path.isfile(default_filepath): filepaths.append(default_filepath) # High priority (default files) env_filepath = os.getenv("IPDB_CONFIG") if env_filepath and os.path.isfile(env_filepath): filepaths.append(env_filepath) if filepaths: # Python 3 has parser.read_file(iterator) while Python2 has # parser.readfp(obj_with_readline) try: read_func = parser.read_file except AttributeError: read_func = parser.readfp for filepath in filepaths: parser.filepath = filepath # Users are expected to put an [ipdb] section # only if they use setup.cfg if filepath.endswith('setup.cfg'): with open(filepath) as f: parser.remove_section("ipdb") read_func(f) # To use on pyproject.toml, put [tool.ipdb] section elif filepath.endswith('pyproject.toml'): import toml toml_file = toml.load(filepath) if "tool" in toml_file and "ipdb" in toml_file["tool"]: if not parser.has_section("ipdb"): parser.add_section("ipdb") for key, value in toml_file["tool"]["ipdb"].items(): parser.set("ipdb", key, str(value)) else: read_func(ConfigFile(filepath)) return parser def post_mortem(tb=None): wrap_sys_excepthook() p = _init_pdb() p.reset() if tb is None: # sys.exc_info() returns (type, value, traceback) if an exception is # being handled, otherwise it returns None tb = sys.exc_info()[2] if tb: p.interaction(None, tb) def pm(): post_mortem(sys.last_traceback) def run(statement, globals=None, locals=None): _init_pdb().run(statement, globals, locals) def runcall(*args, **kwargs): return _init_pdb().runcall(*args, **kwargs) def runeval(expression, globals=None, locals=None): return _init_pdb().runeval(expression, globals, locals) @contextmanager def launch_ipdb_on_exception(): try: yield except Exception: e, m, tb = sys.exc_info() print(m.__repr__(), file=sys.stderr) post_mortem(tb) finally: pass # iex is a concise alias iex = launch_ipdb_on_exception() _usage = """\ usage: python -m ipdb [-m] [-c command] ... pyfile [arg] ... Debug the Python program given by pyfile. Initial commands are read from .pdbrc files in your home directory and in the current directory, if they exist. Commands supplied with -c are executed after commands from .pdbrc files. To let the script run until an exception occurs, use "-c continue". To let the script run up to a given line X in the debugged file, use "-c 'until X'" Option -m is available only in Python 3.7 and later. ipdb version %s.""" % __version__ def main(): import traceback import sys import getopt try: from pdb import Restart except ImportError: class Restart(Exception): pass if sys.version_info >= (3, 7): opts, args = getopt.getopt(sys.argv[1:], 'mhc:', ['help', 'command=']) else: opts, args = getopt.getopt(sys.argv[1:], 'hc:', ['help', 'command=']) commands = [] run_as_module = False for opt, optarg in opts: if opt in ['-h', '--help']: print(_usage) sys.exit() elif opt in ['-c', '--command']: commands.append(optarg) elif opt in ['-m']: run_as_module = True if not args: print(_usage) sys.exit(2) mainpyfile = args[0] # Get script filename if not run_as_module and not os.path.exists(mainpyfile): print('Error:', mainpyfile, 'does not exist') sys.exit(1) sys.argv = args # Hide "pdb.py" from argument list # Replace pdb's dir with script's dir in front of module search path. if not run_as_module: sys.path[0] = os.path.dirname(mainpyfile) # Note on saving/restoring sys.argv: it's a good idea when sys.argv was # modified by the script being debugged. It's a bad idea when it was # changed by the user from the command line. There is a "restart" command # which allows explicit specification of command line arguments. pdb = _init_pdb(commands=commands) while 1: try: if run_as_module: pdb._runmodule(mainpyfile) else: pdb._runscript(mainpyfile) if pdb._user_requested_quit: break print("The program finished and will be restarted") except Restart: print("Restarting", mainpyfile, "with arguments:") print("\t" + " ".join(sys.argv[1:])) except SystemExit: # In most cases SystemExit does not warrant a post-mortem session. print("The program exited via sys.exit(). Exit status: ", end='') print(sys.exc_info()[1]) except: traceback.print_exc() print("Uncaught exception. Entering post mortem debugging") print("Running 'cont' or 'step' will restart the program") t = sys.exc_info()[2] pdb.interaction(None, t) print("Post mortem debugger finished. The " + mainpyfile + " will be restarted") if __name__ == '__main__': main() ipdb-0.13.9/ipdb/stdout.py000066400000000000000000000014451405566735200153550ustar00rootroot00000000000000from __future__ import print_function import sys from contextlib import contextmanager from IPython.utils import io from .__main__ import set_trace from .__main__ import post_mortem def update_stdout(): # setup stdout to ensure output is available with nose io.stdout = sys.stdout = sys.__stdout__ def sset_trace(frame=None, context=3): update_stdout() if frame is None: frame = sys._getframe().f_back set_trace(frame, context) def spost_mortem(tb=None): update_stdout() post_mortem(tb) def spm(): spost_mortem(sys.last_traceback) @contextmanager def slaunch_ipdb_on_exception(): try: yield except Exception: e, m, tb = sys.exc_info() print(m.__repr__(), file=sys.stderr) spost_mortem(tb) finally: pass ipdb-0.13.9/manual_test.py000066400000000000000000000010011405566735200154150ustar00rootroot00000000000000# Copyright (c) 2011-2016 Godefroid Chapelle and ipdb development team # # This file is part of ipdb. # Redistributable under the revised BSD license # https://opensource.org/licenses/BSD-3-Clause def output(arg): print("MANUAL: arg=%s" % arg) def main(): for abc in range(10): import ipdb; ipdb.set_trace() output(abc) # code to test with nose import unittest class IpdbUsageTests(unittest.TestCase): def testMain(self): main() if __name__ == "__main__": main() ipdb-0.13.9/setup.cfg000066400000000000000000000001631405566735200143600ustar00rootroot00000000000000[check-manifest] ignore = tox.ini .travis.yml [zest.releaser] python-file-with-version = ipdb/__main__.py ipdb-0.13.9/setup.py000066400000000000000000000051411405566735200142520ustar00rootroot00000000000000# Copyright (c) 2007-2016 Godefroid Chapelle and ipdb development team # # This file is part of ipdb. # Redistributable under the revised BSD license # https://opensource.org/licenses/BSD-3-Clause from setuptools import setup, find_packages from sys import version_info import re import io version = re.search( r'__version__\s*=\s*[\'"]([^\'"]*)[\'"]', # It excludes inline comment too io.open('ipdb/__main__.py', encoding='utf_8_sig').read() ).group(1) long_description = (open('README.rst').read() + '\n\n' + open('HISTORY.txt').read()) if version_info[0] == 2: console_script = 'ipdb' else: console_script = 'ipdb%d' % version_info.major setup(name='ipdb', version=version, description="IPython-enabled pdb", long_description=long_description, classifiers=[ 'Programming Language :: Python :: 2.7', 'Programming Language :: Python :: 3', 'Programming Language :: Python :: 3.4', 'Programming Language :: Python :: 3.5', 'Programming Language :: Python :: 3.6', 'Programming Language :: Python :: 3.7', 'Programming Language :: Python :: 3.8', 'Operating System :: MacOS :: MacOS X', 'Operating System :: POSIX :: Linux', 'Operating System :: Microsoft :: Windows', 'Topic :: Software Development :: Debuggers', 'License :: OSI Approved :: BSD License', ], keywords='pdb ipython', author='Godefroid Chapelle', author_email='gotcha@bubblenet.be', url='https://github.com/gotcha/ipdb', license='BSD', packages=find_packages(exclude=['ez_setup', 'examples', 'tests']), include_package_data=True, zip_safe=True, test_suite='tests', python_requires=">=2.7", install_requires=[ 'setuptools', ], extras_require={ ':python_version == "2.7"': ['ipython >= 5.1.0, < 6.0.0', 'toml >= 0.10.2', 'decorator < 5.0.0'], # No support for python 3.0, 3.1, 3.2. # FTR, `decorator` is also a dependency of Ipython. ':python_version == "3.4"': ['ipython >= 6.0.0, < 7.0.0', 'toml >= 0.10.2', 'decorator < 5.0.0'], ':python_version == "3.5"': ['ipython >= 7.0.0, < 7.10.0', 'toml >= 0.10.2', 'decorator'], ':python_version == "3.6"': ['ipython >= 7.10.0, < 7.17.0', 'toml >= 0.10.2', 'decorator'], ':python_version > "3.6"': ['ipython >= 7.17.0', 'toml >= 0.10.2', 'decorator'], }, tests_require=[ 'mock; python_version<"3"' ], entry_points={ 'console_scripts': ['%s = ipdb.__main__:main' % console_script] } ) ipdb-0.13.9/tests/000077500000000000000000000000001405566735200137015ustar00rootroot00000000000000ipdb-0.13.9/tests/__init__.py000066400000000000000000000000001405566735200160000ustar00rootroot00000000000000ipdb-0.13.9/tests/test_config.py000066400000000000000000000305431405566735200165640ustar00rootroot00000000000000# Copyright (c) 2012-2016 Marc Abramowitz and ipdb development team # # This file is part of ipdb. # Redistributable under the revised BSD license # https://opensource.org/licenses/BSD-3-Clause try: import configparser except: import ConfigParser as configparser import unittest import os import tempfile import shutil from ipdb.__main__ import get_config class ModifiedEnvironment(object): """ I am a context manager that sets up environment variables for a test case. """ def __init__(self, **kwargs): self.prev = {} self.excur = kwargs for k in kwargs: self.prev[k] = os.getenv(k) def __enter__(self): self.update_environment(self.excur) def __exit__(self, type, value, traceback): self.update_environment(self.prev) def update_environment(self, d): for k in d: if d[k] is None: if k in os.environ: del os.environ[k] else: os.environ[k] = d[k] class ConfigTest(unittest.TestCase): """ All variations of config file parsing works as expected. """ def _write_file(self, path, lines): f = open(path, "w") f.writelines([x + "\n" for x in lines]) f.close() def setUp(self): """ Create all temporary config files for testing """ self.tmpd = tempfile.mkdtemp() self.addCleanup(shutil.rmtree, self.tmpd) # Set CWD to known empty directory so we don't pick up some other .ipdb # file from the CWD tests are actually run from. save_cwd = os.getcwd() self.addCleanup(os.chdir, save_cwd) cwd_dir = os.path.join(self.tmpd, "cwd") os.mkdir(cwd_dir) os.chdir(cwd_dir) # This represents the $HOME config file, and doubles for the current # working directory config file if we set CWD to self.tmpd self.default_filename = os.path.join(self.tmpd, ".ipdb") self.default_context = 10 self._write_file( self.default_filename, [ "# this is a test config file for ipdb", "context = {}".format(str(self.default_context)), ], ) self.env_filename = os.path.join(self.tmpd, "ipdb.env") self.env_context = 20 self._write_file( self.env_filename, [ "# this is a test config file for ipdb", "context = {}".format(str(self.env_context)), ], ) self.setup_filename = os.path.join(cwd_dir, "setup.cfg") self.setup_context = 25 self._write_file( self.setup_filename, [ "[ipdb]", "context = {}".format(str(self.setup_context)), ], ) self.pyproject_filename = os.path.join(cwd_dir, "pyproject.toml") self.pyproject_context = 30 self._write_file( self.pyproject_filename, [ "[tool.ipdb]", "context = {}".format(str(self.pyproject_context)), ], ) def test_noenv_nodef_nosetup_pyproject(self): """ Setup: $IPDB_CONFIG unset, $HOME/.ipdb does not exist, setup.cfg does not exist, pyproject.toml exists Result: load pyproject.toml """ os.unlink(self.env_filename) os.unlink(self.default_filename) os.remove(self.setup_filename) with ModifiedEnvironment(IPDB_CONFIG=None, HOME=self.tmpd): cfg = get_config() self.assertEqual(["ipdb"], cfg.sections()) self.assertEqual(self.pyproject_context, cfg.getint("ipdb", "context")) self.assertRaises(configparser.NoOptionError, cfg.get, "ipdb", "version") def test_env_nodef_setup_pyproject(self): """ Setup: $IPDB_CONFIG is set, $HOME/.ipdb does not exist, setup.cfg exists, pyproject.toml exists Result: load $IPDB_CONFIG """ os.unlink(self.default_filename) with ModifiedEnvironment(IPDB_CONFIG=self.env_filename, HOME=self.tmpd): cfg = get_config() self.assertEqual(["ipdb"], cfg.sections()) self.assertEqual(self.env_context, cfg.getint("ipdb", "context")) self.assertRaises(configparser.NoOptionError, cfg.get, "ipdb", "version") def test_env_def_setup_pyproject(self): """ Setup: $IPDB_CONFIG is set, $HOME/.ipdb exists, setup.cfg exists, pyproject.toml exists Result: load $IPDB_CONFIG """ with ModifiedEnvironment(IPDB_CONFIG=self.env_filename, HOME=self.tmpd): cfg = get_config() self.assertEqual(["ipdb"], cfg.sections()) self.assertEqual(self.env_context, cfg.getint("ipdb", "context")) self.assertRaises(configparser.NoOptionError, cfg.get, "ipdb", "version") def test_noenv_nodef_setup_pyproject(self): """ Setup: $IPDB_CONFIG unset, $HOME/.ipdb does not exist, setup.cfg exists, pyproject.toml exists Result: load pyproject.toml """ os.unlink(self.env_filename) os.unlink(self.default_filename) with ModifiedEnvironment(IPDB_CONFIG=None, HOME=self.tmpd): cfg = get_config() self.assertEqual(["ipdb"], cfg.sections()) self.assertEqual(self.pyproject_context, cfg.getint("ipdb", "context")) self.assertRaises(configparser.NoOptionError, cfg.get, "ipdb", "version") def test_noenv_def_setup_pyproject(self): """ Setup: $IPDB_CONFIG unset, $HOME/.ipdb exists, setup.cfg exists, pyproject.toml exists Result: load .ipdb """ os.unlink(self.env_filename) with ModifiedEnvironment(IPDB_CONFIG=None, HOME=self.tmpd): cfg = get_config() self.assertEqual(["ipdb"], cfg.sections()) self.assertEqual(self.default_context, cfg.getint("ipdb", "context")) self.assertRaises(configparser.NoOptionError, cfg.get, "ipdb", "version") def test_env_nodef_nosetup(self): """ Setup: $IPDB_CONFIG is set, $HOME/.ipdb does not exist, setup.cfg does not exist, pyproject.toml does not exist Result: load $IPDB_CONFIG """ os.unlink(self.default_filename) os.unlink(self.pyproject_filename) os.remove(self.setup_filename) with ModifiedEnvironment(IPDB_CONFIG=self.env_filename, HOME=self.tmpd): cfg = get_config() self.assertEqual(["ipdb"], cfg.sections()) self.assertEqual(self.env_context, cfg.getint("ipdb", "context")) self.assertRaises(configparser.NoOptionError, cfg.getboolean, "ipdb", "version") def test_noenv_def_nosetup(self): """ Setup: $IPDB_CONFIG unset, $HOME/.ipdb exists, setup.cfg does not exist, pyproject.toml does not exist Result: load $HOME/.ipdb """ os.unlink(self.env_filename) os.unlink(self.pyproject_filename) os.remove(self.setup_filename) with ModifiedEnvironment(IPDB_CONFIG=None, HOME=self.tmpd): cfg = get_config() self.assertEqual(["ipdb"], cfg.sections()) self.assertEqual(self.default_context, cfg.getint("ipdb", "context")) self.assertRaises(configparser.NoOptionError, cfg.get, "ipdb", "version") def test_noenv_nodef_nosetup(self): """ Setup: $IPDB_CONFIG unset, $HOME/.ipdb does not exist, setup.cfg does not exist, pyproject.toml does not exist Result: load nothing """ os.unlink(self.env_filename) os.unlink(self.default_filename) os.unlink(self.pyproject_filename) os.remove(self.setup_filename) with ModifiedEnvironment(IPDB_CONFIG=None, HOME=self.tmpd): cfg = get_config() self.assertEqual([], cfg.sections()) def test_env_cwd(self): """ Setup: $IPDB_CONFIG is set, .ipdb in local dir, setup.cfg does not exist, pyproject.toml does not exist Result: load .ipdb """ os.chdir(self.tmpd) # setUp is already set to restore us to our pre-testing cwd os.unlink(self.pyproject_filename) os.remove(self.setup_filename) with ModifiedEnvironment(IPDB_CONFIG=self.env_filename, HOME=self.tmpd): cfg = get_config() self.assertEqual(["ipdb"], cfg.sections()) self.assertEqual(self.env_context, cfg.getint("ipdb", "context")) self.assertRaises(configparser.NoOptionError, cfg.get, "ipdb", "version") def test_env_def_nosetup(self): """ Setup: $IPDB_CONFIG is set, $HOME/.ipdb exists, setup.cfg does not exist, pyproject.toml does not exist Result: load $IPDB_CONFIG """ os.unlink(self.pyproject_filename) os.remove(self.setup_filename) with ModifiedEnvironment(IPDB_CONFIG=self.env_filename, HOME=self.tmpd): cfg = get_config() self.assertEqual(["ipdb"], cfg.sections()) self.assertEqual(self.env_context, cfg.getint("ipdb", "context")) self.assertRaises(configparser.NoOptionError, cfg.get, "ipdb", "version") def test_noenv_def_setup(self): """ Setup: $IPDB_CONFIG unset, $HOME/.ipdb exists, setup.cfg exists, pyproject.toml does not exist Result: load $HOME/.ipdb """ os.unlink(self.env_filename) os.unlink(self.pyproject_filename) with ModifiedEnvironment(IPDB_CONFIG=None, HOME=self.tmpd): cfg = get_config() self.assertEqual(["ipdb"], cfg.sections()) self.assertEqual(self.default_context, cfg.getint("ipdb", "context")) self.assertRaises(configparser.NoOptionError, cfg.getboolean, "ipdb", "version") def test_noenv_nodef_setup(self): """ Setup: $IPDB_CONFIG unset, $HOME/.ipdb does not exist, setup.cfg exists, pyproject.toml does not exist Result: load setup """ os.unlink(self.env_filename) os.unlink(self.default_filename) os.unlink(self.pyproject_filename) with ModifiedEnvironment(IPDB_CONFIG=None, HOME=self.tmpd): cfg = get_config() self.assertEqual(["ipdb"], cfg.sections()) self.assertEqual(self.setup_context, cfg.getint("ipdb", "context")) self.assertRaises(configparser.NoOptionError, cfg.get, "ipdb", "version") def test_env_def_setup(self): """ Setup: $IPDB_CONFIG is set, $HOME/.ipdb exists, setup.cfg exists, pyproject.toml does not exist Result: load $IPDB_CONFIG """ os.unlink(self.pyproject_filename) with ModifiedEnvironment(IPDB_CONFIG=self.env_filename, HOME=self.tmpd): cfg = get_config() self.assertEqual(["ipdb"], cfg.sections()) self.assertEqual(self.env_context, cfg.getint("ipdb", "context")) self.assertRaises(configparser.NoOptionError, cfg.get, "ipdb", "version") def test_env_nodef_setup(self): """ Setup: $IPDB_CONFIG is set, $HOME/.ipdb does not exist, setup.cfg exists, pyproject.toml does not exist Result: load $IPDB_CONFIG """ os.unlink(self.default_filename) os.unlink(self.pyproject_filename) with ModifiedEnvironment(IPDB_CONFIG=self.env_filename, HOME=self.tmpd): cfg = get_config() self.assertEqual(["ipdb"], cfg.sections()) self.assertEqual(self.env_context, cfg.getint("ipdb", "context")) self.assertRaises(configparser.NoOptionError, cfg.getboolean, "ipdb", "version") def test_noenv_def_setup(self): """ Setup: $IPDB_CONFIG unset, $HOME/.ipdb exists, setup.cfg exists, pyproject.toml does not exist Result: load $HOME/.ipdb """ os.unlink(self.env_filename) os.unlink(self.pyproject_filename) with ModifiedEnvironment(IPDB_CONFIG=None, HOME=self.tmpd): cfg = get_config() self.assertEqual(["ipdb"], cfg.sections()) self.assertEqual(self.default_context, cfg.getint("ipdb", "context")) self.assertRaises(configparser.NoOptionError, cfg.get, "ipdb", "version") ipdb-0.13.9/tests/test_import.py000066400000000000000000000011231405566735200166210ustar00rootroot00000000000000# Copyright (c) 2012-2016 Marc Abramowitz and ipdb development team # # This file is part of ipdb. # Redistributable under the revised BSD license # https://opensource.org/licenses/BSD-3-Clause import unittest class ImportTest(unittest.TestCase): def test_import(self): from ipdb import set_trace, post_mortem, pm, iex, run, runcall, runeval set_trace # please pyflakes post_mortem # please pyflakes pm # please pyflakes iex # please pyflakes run # please pyflakes runcall # please pyflakes runeval # please pyflakes ipdb-0.13.9/tests/test_opts.py000066400000000000000000000033541405566735200163040ustar00rootroot00000000000000# Copyright (c) 2012-2016 Marc Abramowitz and ipdb development team # # This file is part of ipdb. # Redistributable under the revised BSD license # https://opensource.org/licenses/BSD-3-Clause import unittest try: from unittest.mock import patch except ImportError: from mock import patch from getopt import GetoptError from ipdb.__main__ import main @patch('ipdb.__main__._get_debugger_cls') class OptsTest(unittest.TestCase): def set_argv(self, *argv): argv_patch = patch('ipdb.__main__.sys.argv', argv) argv_patch.start() self.addCleanup(argv_patch.stop) @patch('ipdb.__main__.sys.version_info', (3, 7)) def test_debug_module_script(self, get_debugger_cls): module_name = 'my_buggy_module' self.set_argv('ipdb', '-m', module_name) main() debugger = get_debugger_cls.return_value.return_value debugger._runmodule.assert_called_once_with(module_name) @patch('ipdb.__main__.os.path.exists') def test_debug_script(self, exists, get_debugger_cls): script_name = 'my_buggy_script' self.set_argv('ipdb', script_name) main() debugger = get_debugger_cls.return_value.return_value debugger._runscript.assert_called_once_with(script_name) def test_option_m_fallback_on_py36(self, get_debugger_cls): self.set_argv('ipdb', '-m', 'my.module') with patch('ipdb.__main__.sys.version_info', (3, 6)): with self.assertRaises(GetoptError): main() with patch('ipdb.__main__.sys.version_info', (3, 7)): self.set_argv('ipdb', '-m', 'my.module') try: main() except GetoptError: self.fail("GetoptError raised unexpectedly.") ipdb-0.13.9/tox.ini000066400000000000000000000004771405566735200140620ustar00rootroot00000000000000# Tox (http://tox.testrun.org/) is a tool for running tests # in multiple virtualenvs. This configuration file will run the # test suite on all supported python versions. To use it, "pip install tox" # and then run "tox" from this directory. [tox] envlist = py26, py27, pypy [testenv] commands = python setup.py test