;ELC
;;; Compiled by mockbuild@buildfarm06-new.corp.cloudlinux.com on Fri Oct 11 10:09:29 2024
;;; from file /builddir/build/BUILD/emacs-24.3/lisp/progmodes/python.el
;;; in Emacs version 24.3.1
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.

;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


(byte-code "\300\301!\210\300\302!\210\303\304\305\"\210\306\307\310\311!\312B\"\210\306\313\310\314!\312B\"\210\315\316\317\320\321\322\323\324\325\326&	\207" [require ansi-color comint autoload comint-mode "comint" add-to-list auto-mode-alist purecopy "\\.py\\'" python-mode interpreter-mode-alist "python" custom-declare-group python nil "Python Language's flying circus support for Emacs." :group languages :version "24.3" :link (emacs-commentary-link "python")] 10)
#@27 Keymap for `python-mode'.
(defvar python-mode-map (byte-code "\302 \303\304\305#\210\303\306\307#\210\303\310\311#\210\303\312\313#\210\303\314\315#\210\303\316\317#\210\303\320\321#\210\303\322\323#\210\303\324\325#\210\303\326\327#\210\303\330\331#\210\303\332\333#\210\303\334\335#\210\303\336\337#\210\303\340\341#\210\303\342\343#\210\303\344\345#\210\303\346\347#\210\303\350\351#\210\303\352\353#\210\303\354\355#\210\303\356\357#\210\303\360\361#\210\303\362\363#\210\364\365\366	$\210\367\370!\210\371\372\373\374$\210)\207" [map global-map make-sparse-keymap define-key [remap backward-sentence] python-nav-backward-block [remap forward-sentence] python-nav-forward-block [remap backward-up-list] python-nav-backward-up-list "\n" imenu "" python-indent-dedent-line-backspace [backtab] python-indent-dedent-line "<" python-indent-shift-left ">" python-indent-shift-right ":" python-indent-electric-colon "c" python-skeleton-class "d" python-skeleton-def "f" python-skeleton-for "i" python-skeleton-if "t" python-skeleton-try "w" python-skeleton-while "" run-python "" python-shell-send-string "" python-shell-send-region "\230" python-shell-send-defun "" python-shell-send-buffer "\f" python-shell-send-file "" python-shell-switch-to-shell "" python-check "" python-eldoc-at-point substitute-key-definition complete-symbol completion-at-point (lambda (#1=#:def-tmp-var) (defvar python-menu #1# #2="Python Mode menu")) nil easy-menu-do-define python-menu #2# ("Python" :help "Python-specific Features" ["Shift region left" python-indent-shift-left :active mark-active :help "Shift region left by a single indentation step"] ["Shift region right" python-indent-shift-right :active mark-active :help "Shift region right by a single indentation step"] "-" ["Start of def/class" beginning-of-defun :help "Go to start of outermost definition around point"] ["End of def/class" end-of-defun :help "Go to end of definition around point"] ["Mark def/class" mark-defun :help "Mark outermost definition around point"] ["Jump to def/class" imenu :help "Jump to a class or function definition"] "--" ("Skeletons") "---" ["Start interpreter" run-python :help "Run inferior Python process in a separate buffer"] ["Switch to shell" python-shell-switch-to-shell :help "Switch to running inferior Python process"] ["Eval string" python-shell-send-string :help "Eval string in inferior Python session"] ["Eval buffer" python-shell-send-buffer :help "Eval buffer in inferior Python session"] ["Eval region" python-shell-send-region :help "Eval region in inferior Python session"] ["Eval defun" python-shell-send-defun :help "Eval defun in inferior Python session"] ["Eval file" python-shell-send-file :help "Eval file in inferior Python session"] ["Debugger" pdb :help "Run pdb under GUD"] "----" ["Check file" python-check :help "Check file for errors"] ["Help on symbol" python-eldoc-at-point :help "Get help on symbol at point"] ["Complete symbol" completion-at-point :help "Complete symbol before point"])] 5) (#$ . 1030))
#@162 Return non-nil if point is on TYPE using SYNTAX-PPSS.
TYPE can be `comment', `string' or `paren'.  It returns the start
character address of the specified TYPE.
(defalias 'python-syntax-context #[(type &optional syntax-ppss) "\206\300 \303\n\304\"\203\305	8\205<\306	8\202<\303\n\307\"\203.\305	8?\205<\306	8\202<\303\n\310\"\203;	A@\202<\311)\207" [syntax-ppss ppss type eql comment 4 8 string paren nil] 3 (#$ . 4112)])
#@101 Return the context type using SYNTAX-PPSS.
The type returned can be `comment', `string' or `paren'.
(defalias 'python-syntax-context-type #[(&optional syntax-ppss) "\206\300 \302	8\203\303	8\203\304\202\"\305\202\"	A@\205\"\306)\207" [syntax-ppss ppss 8 4 comment string paren] 2 (#$ . 4554)])
#@56 Return non-nil if point is inside 'comment or 'string.
(defalias 'python-syntax-comment-or-string-p #[nil "\300\301 8\207" [8 syntax-ppss] 2 (#$ . 4865)])
(byte-code "\300\301\302\303#\210\304\305\306\307#\210\310\305\306\311#\210\304\312\313\307#\210\310\312\313\311#\210\304\314\301\307#\210\310\314\301\311#\207" [put python-syntax-comment-or-string-p byte-optimizer byte-compile-inline-expand defalias python-info-ppss-context python-syntax-context nil make-obsolete "24.3" python-info-ppss-context-type python-syntax-context-type python-info-ppss-comment-or-string-p] 4)
(defvar python-font-lock-keywords (byte-code "\300\301\302B\303\304B\305\306B\307\310B\311\312B\313\314B\315\316B\317\320B\257	\207" ["\\_<\\(?:\\(?:a\\(?:nd\\|s\\(?:sert\\)?\\)\\|break\\|c\\(?:lass\\|ontinue\\)\\|de[fl]\\|e\\(?:l\\(?:if\\|se\\)\\|x\\(?:cept\\|ec\\)\\)\\|f\\(?:inally\\|or\\|rom\\)\\|global\\|i\\(?:mport\\|[fns]\\)\\|lambda\\|no\\(?:nlocal\\|t\\)\\|or\\|p\\(?:ass\\|rint\\)\\|r\\(?:aise\\|eturn\\)\\|self\\|try\\|w\\(?:hile\\|ith\\)\\|yield\\)\\)\\_>" "\\_<def[[:space:]]+\\(\\(?:[[:word:]]\\|_\\)+\\)" ((1 font-lock-function-name-face)) "\\_<class[[:space:]]+\\(\\(?:[[:word:]]\\|_\\)+\\)" ((1 font-lock-type-face)) "\\_<\\(?:\\(?:Ellipsis\\|False\\|No\\(?:ne\\|tImplemented\\)\\|True\\|__debug__\\|c\\(?:opyright\\|redits\\)\\|exit\\|license\\|quit\\)\\)\\_>" font-lock-constant-face "^[	 ]*\\(@\\(?:[[:word:]]\\|_\\)+\\(?:\\.\\(?:[[:word:]]\\|_\\)+\\)*\\)" ((1 font-lock-type-face)) "\\_<\\(?:\\(?:A\\(?:\\(?:rithmetic\\|ssertion\\|ttribute\\)Error\\)\\|B\\(?:aseException\\|ufferError\\|ytesWarning\\)\\|DeprecationWarning\\|E\\(?:OFError\\|nvironmentError\\|xception\\)\\|F\\(?:loatingPointError\\|utureWarning\\)\\|GeneratorExit\\|I\\(?:OError\\|mport\\(?:Error\\|Warning\\)\\|nde\\(?:\\(?:ntation\\|x\\)Error\\)\\)\\|Key\\(?:Error\\|boardInterrupt\\)\\|LookupError\\|MemoryError\\|N\\(?:\\(?:ame\\|otImplemented\\)Error\\)\\|O\\(?:\\(?:S\\|verflow\\)Error\\)\\|PendingDeprecationWarning\\|R\\(?:e\\(?:ferenceError\\|sourceWarning\\)\\|untime\\(?:Error\\|Warning\\)\\)\\|S\\(?:t\\(?:andardError\\|opIteration\\)\\|y\\(?:ntax\\(?:Error\\|Warning\\)\\|stemE\\(?:rror\\|xit\\)\\)\\)\\|T\\(?:\\(?:ab\\|ype\\)Error\\)\\|U\\(?:n\\(?:boundLocalError\\|icode\\(?:DecodeError\\|E\\(?:\\(?:ncodeE\\)?rror\\)\\|TranslateError\\|Warning\\)\\)\\|serWarning\\)\\|V\\(?:\\(?:MS\\|alue\\)Error\\)\\|W\\(?:arning\\|indowsError\\)\\|ZeroDivisionError\\)\\)\\_>" font-lock-type-face "\\_<\\(?:\\(?:__\\(?:\\(?:all\\|doc\\|import\\|\\(?:nam\\|packag\\)e\\)__\\)\\|a\\(?:bs\\|ll\\|ny\\|pply\\|scii\\)\\|b\\(?:asestring\\|in\\|ool\\|uffer\\|yte\\(?:array\\|s\\)\\)\\|c\\(?:allable\\|hr\\|lassmethod\\|mp\\|o\\(?:erce\\|mp\\(?:ile\\|lex\\)\\)\\)\\|d\\(?:elattr\\|i\\(?:ct\\|r\\|vmod\\)\\)\\|e\\(?:numerate\\|val\\|xec\\(?:file\\)?\\)\\|f\\(?:il\\(?:e\\|ter\\)\\|\\(?:loa\\|orma\\|rozense\\)t\\)\\|g\\(?:etattr\\|lobals\\)\\|h\\(?:as\\(?:attr\\|h\\)\\|e\\(?:lp\\|x\\)\\)\\|i\\(?:d\\|n\\(?:put\\|t\\(?:ern\\)?\\)\\|s\\(?:instance\\|subclass\\)\\|ter\\)\\|l\\(?:en\\|ist\\|o\\(?:cals\\|ng\\)\\)\\|m\\(?:a[px]\\|emoryview\\|in\\)\\|next\\|o\\(?:bject\\|ct\\|pen\\|rd\\)\\|p\\(?:ow\\|r\\(?:int\\|operty\\)\\)\\|r\\(?:a\\(?:nge\\|w_input\\)\\|e\\(?:duce\\|load\\|pr\\|versed\\)\\|ound\\)\\|s\\(?:et\\(?:attr\\)?\\|lice\\|orted\\|t\\(?:aticmethod\\|r\\)\\|u\\(?:m\\|per\\)\\)\\|t\\(?:\\(?:upl\\|yp\\)e\\)\\|unic\\(?:hr\\|ode\\)\\|vars\\|xrange\\|zip\\)\\)\\_>" font-lock-builtin-face #[(limit) "\302\303	\304#\205-\305\306!\203\303	\304#\204\n\305\306!\204*\307 f\310\232\204*\304\202-\311\312!)\207" [re limit "\\([._[:word:]]+\\)\\(?:\\[[^]]+]\\)?[[:space:]]*\\(?:\\(?:\\*\\*\\|//\\|<<\\|>>\\|[%&*+/|^-]\\)?=\\)" re-search-forward t python-syntax-context paren point-marker 61 set-match-data nil] 4] ((1 font-lock-variable-name-face nil nil)) #[(limit) "\302\303	\304#\2056\305\306 8b\2056\307\310!\203)\303	\304#\203)\305\306 8b\210\202\307\310!\2043\304\2026\311\312!)\207" [re limit "\\([._[:word:]]+\\)[[:space:]]*\\(?:,[[:space:]]*[._[:word:]]+[[:space:]]*\\)*,[[:space:]]*[._[:word:]]+[[:space:]]*\\(?:\\(?:\\*\\*\\|//\\|<<\\|>>\\|[%&*+/|^-]\\)?=\\)" re-search-forward t 3 match-data python-syntax-context paren set-match-data nil] 4] ((1 font-lock-variable-name-face nil nil))] 10))
(defconst python-syntax-propertize-function #[(start end) "b\210`	W\205\302\303	\304#\205\305 \210\202\207" [start end re-search-forward "\\(?:[^\"'\\]\\|\\=\\|\\(?:[^\\]\\|\\=\\)\\\\\\(?:\\\\\\\\\\)*[\"']\\)\\(?:\\\\\\\\\\)*\\(\\(?:\"\"\"\\|'''\\|[\"']\\)\\)" t python-syntax-stringify] 4])
#@209 Count number of quotes around point (max is 3).
QUOTE-CHAR is the quote char to count.  Optional argument POINT is
the point where scan starts (defaults to current point) and LIMIT
is used to limit the scan.
(defalias 'python-syntax-count-quotes #[(quote-char &optional point limit) "\304\211\305W\203$	\203\n\\	W\203$\n\\f=\203$T\211\202)\207" [i limit point quote-char 0 3] 3 (#$ . 9454)])
(put 'python-syntax-count-quotes 'byte-optimizer 'byte-compile-inline-expand)
#@64 Put `syntax-table' property correctly on single/triple quotes.
(defalias 'python-syntax-stringify #[nil "\306\307!G\211[u\210\310 u\210\311	8?\205\312	8`Z`\n\205]`Sf\n\313\211\314W\203Z
\203E\\
W\203Z\\f=\203ZT\211\2022,\n\203n\313U\203n\315\202\232\n\204|\316\211T\317\320$\202\232U\203\215\316\fS\f\317\320$\202\232V\205\232\316\f\317\320$.\207" [num-quotes ppss string-start quote-starting-pos quote-ending-pos limit match-string-no-properties 1 syntax-ppss 4 8 0 3 nil put-text-property syntax-table (15) point quote-char i num-closing-quotes] 6 (#$ . 9944)])
#@32 Syntax table for Python files.
(defvar python-mode-syntax-table (byte-code "\305 \306\307 \310\311\fW\203-\312U\204&\n	H\232\203&\313\314#\210T\211\202
,\313\315\314#\210\313\316\314#\210\313\317\320#\210\313\321\322#\210\313\323\324#\210\313\325\326#\210)\207" [table sst symbol i --dotimes-limit-- make-syntax-table (3) standard-syntax-table 128 0 95 modify-syntax-entry "." 36 37 35 "<" 10 ">" 39 "\"" 96 "$"] 5) (#$ . 10574))
#@92 Dotty syntax table for Python files.
It makes underscores and dots word constituent chars.
(defvar python-dotty-syntax-table (byte-code "\302!\303\304\305	#\210\303\306\305	#\210	)\207" [python-mode-syntax-table table make-syntax-table modify-syntax-entry 46 "w" 95] 4) (#$ . 11033))
(byte-code "\302\303\304\305\306\307\310\311\312\313&	\210\302\314\315\316\310\317\306\307\312\320&	\210\302\321\322\323\310\324\306\307&\210\325\326\303\327#\210\330\327\211\203Q	@\326N\203J\303N\204J\331\303\326N#\210	A\211\2043*\332\326\303\333#\210\325\334\314\327#\210\330\327\211\203\204	@\334N\203}\314N\204}\331\314\334N#\210	A\211\204f*\332\334\314\333#\207" [prop --dolist-tail-- custom-declare-variable python-indent-offset 4 "Default indentation offset for Python." :group python :type integer :safe integerp python-indent-guess-indent-offset t "Non-nil tells Python mode to guess `python-indent-offset' value." boolean booleanp python-indent-trigger-commands '(indent-for-tab-command yas-expand yas/expand) "Commands that might trigger a `python-indent-line' call." (repeat symbol) defvaralias python-indent nil (saved-value saved-variable-comment) put make-obsolete-variable "24.3" python-guess-indent] 11)
#@67 Current indentation level `python-indent-line-function' is using.
(defvar python-indent-current-level 0 (#$ . 12271))
#@68 Levels of indentation available for `python-indent-line-function'.
(defvar python-indent-levels '(0) (#$ . 12395))
#@135 List of words that should be dedented.
These make `python-indent-calculate-indentation' subtract the value of
`python-indent-offset'.
(defvar python-indent-dedenters '("else" "elif" "except" "finally") (#$ . 12517))
#@62 Guess and set `python-indent-offset' for the current buffer.
(defalias 'python-indent-guess-indent-offset #[nil "\212\214~\210eb\210\303\204T\304\305\303\306#\203T\307 \204	\310 b\210\311\312!\210`Sf\313\232\204M\314y\210\315 \203	\316 \203Am\204A\314y\210\2022\311\312!\210`Sf\313\232\203	\317 \211\203
\205`b\210\311 \210\320 \211\203o\321\302!\210	\211\202s\322\323\n\",\207" [block-end indentation python-indent-offset nil re-search-forward "^\\_<\\(?:\\(?:class\\|def\\|e\\(?:l\\(?:if\\|se\\)\\|xcept\\)\\|f\\(?:inally\\|or\\)\\|if\\|try\\|w\\(?:hile\\|ith\\)\\)\\)\\_>" t python-syntax-context-type line-end-position python-util-forward-comment -1 58 1 python-info-block-continuation-line-p python-info-continuation-line-p point-marker current-indentation make-local-variable message "Can't guess python-indent-offset, using defaults: %s"] 5 (#$ . 12739) nil])
#@547 Get information on indentation context.
Context information is returned with a cons with the form:
    (STATUS . START)

Where status can be any of the following symbols:
 * inside-paren: If point in between (), {} or []
 * inside-string: If point is inside a string
 * after-backslash: Previous line ends in a backslash
 * after-beginning-of-block: Point is after beginning of block
 * after-line: Point is after normal line
 * no-indent: Point is at beginning of buffer or other special case
START is the buffer position where the sexp starts.
(defalias 'python-indent-context #[nil "\214~\210\212\303 \210\304 )\305\212\306 b\210o)\203\307\202\241\310\311	\"\211\203(\312\202\241\310\313	\"\211\2035\314\202\241\310\311	\"\206@\310\315	\"?\205L\316 \317\nS!)\211\203U\320\202\241\212\321 \210\322\323!\210`Sf\324\232\205\325\326\305\327#\203w\330 \204e\331 \204e\332\326!\205\333 )\211\203\211\334\202\241\212\321 \210\335\305x\210\336 \210\333 )\211\203\240\337\202\241\307+B\207" [start ppss line-beg-pos beginning-of-line syntax-ppss nil line-beginning-position no-indent python-syntax-context string inside-string paren inside-paren comment line-number-at-pos python-info-line-ends-backslash-p after-backslash back-to-indentation python-util-forward-comment -1 58 re-search-backward "\\_<\\(?:\\(?:class\\|def\\|e\\(?:l\\(?:if\\|se\\)\\|xcept\\)\\|f\\(?:inally\\|or\\)\\|if\\|try\\|w\\(?:hile\\|ith\\)\\)\\)\\_>" t python-syntax-context-type python-info-continuation-line-p looking-at point-marker after-beginning-of-block "[[:space:]]\\|\n" python-nav-beginning-of-statement after-line] 4 (#$ . 13633)])
#@60 Calculate correct indentation offset for the current line.
(defalias 'python-indent-calculate-indentation #[nil "\306 \211@A\214~\210\212\307	\310\"\203\311\202r
\307	\312\"\203)\nb\210\313 \\\202r
\307	\314\"\203K\212\nb\210\313 )\315 \210\316\317\f!!\203F\202G\311Z\202r
\307	\320\"\203Z\nb\210\313 \202r
\307	\321\"\203\361\212\315 \210\316\322!\205\235\323y\210o\204x\324\325!\204k\326 b\210\327\322\330 \331#\203\212\332 \204|\316\322!\203\231\332 \204\231i\202\235\313 \\)\206r
\333 \211\205\263
b\210\334\335\326 \331#\210i)\206r
\336 \211*\205\304*b\210i)\206r
\323y\210\337 b\210\212\323y\205\341\337 \206\333`b\205\341\340 )\203\352\313 \202r
\313 \\\202r
\307	\341\"\205r
\212\342\343\326 \"\210\316\344!\205
\345u\210\324\325!?\205
\nb\210\313 )\206r
\346+\212\nb\210\346u\210\214\330 \326 }\210\347 \210)\316\350!\211+\203=
\313 \\\202>
i),\315 \210\316\344!\203Q
,Z\202m
\212+\205g
\nb\210\315 \210\316\351!\205g
,\\)\206m
,*\206r
\346-\207" [indentation-context context-status context-start python-indent-offset python-indent-dedenters block-continuation-start python-indent-context memql 'no-indent 0 'after-beginning-of-block current-indentation 'after-line back-to-indentation looking-at regexp-opt 'inside-string 'after-backslash "\\." -1 python-syntax-context paren line-end-position re-search-backward line-beginning-position t python-syntax-context-type python-info-block-continuation-line-p re-search-forward "\\_<\\(?:\\(?:class\\|def\\|e\\(?:l\\(?:if\\|se\\)\\|xcept\\)\\|f\\(?:inally\\|or\\)\\|if\\|try\\|w\\(?:hile\\|ith\\)\\)\\)\\_>[[:space:]]*" python-info-assignment-continuation-line-p python-info-beginning-of-backslash python-info-line-ends-backslash-p 'inside-paren skip-syntax-forward " " "[])}]" 1 nil python-util-forward-comment "$" "\\_<\\(?:\\(?:class\\|def\\|e\\(?:l\\(?:if\\|se\\)\\|xcept\\)\\|f\\(?:inally\\|or\\)\\|if\\|try\\|w\\(?:hile\\|ith\\)\\)\\)\\_>" assignment-continuation-start content-starts-in-newline indent] 5 (#$ . 15282)])
#@75 Calculate `python-indent-levels' and reset `python-indent-current-level'.
(defalias 'python-indent-calculate-levels #[nil "\306 \211	\246\nZ	\245\307C\307
W\203*	
T_\fB
T\211\202*\n\307=\2049	_\n\\\fB\f\237\211GS\211	+\207" [indentation python-indent-offset remainder steps python-indent-levels step python-indent-calculate-indentation 0 --dotimes-limit-- python-indent-current-level] 3 (#$ . 17314)])
#@67 Toggle `python-indent-current-level' over `python-indent-levels'.
(defalias 'python-indent-toggle-levels #[nil "S\211\302W\205	GS\211\207" [python-indent-current-level python-indent-levels 0] 3 (#$ . 17743)])
#@887 Internal implementation of `python-indent-line-function'.
Uses the offset calculated in
`python-indent-calculate-indentation' and available levels
indicated by the variable `python-indent-levels' to set the
current indentation.

When the variable `last-command' is equal to one of the symbols
inside `python-indent-trigger-commands' or FORCE-TOGGLE is
non-nil it cycles levels indicated in the variable
`python-indent-levels' by setting the current level in the
variable `python-indent-current-level'.

When the variable `last-command' is not equal to one of the
symbols inside `python-indent-trigger-commands' and FORCE-TOGGLE
is nil it calculates possible indentation levels and saves it in
the variable `python-indent-levels'.  Afterwards it sets the
variable `python-indent-current-level' correctly so offset is
equal to (`nth' `python-indent-current-level'
`python-indent-levels')
(defalias 'python-indent-line #[(&optional force-toggle) "	>\203\f\n=\204\203\f\306\232\204\307 \204!\202!\310 \210\311 \312 \313 \\n\206:\312 
X\205:
Y\f8\211\313 U\204V\314 \210\315 \210j\210
b\210\203^\316 \210,\317 \207" [this-command python-indent-trigger-commands last-command force-toggle python-indent-levels starting-pos (0) python-indent-toggle-levels python-indent-calculate-levels point-marker line-beginning-position current-indentation beginning-of-line delete-horizontal-space back-to-indentation python-info-closing-block-message indent-ending-position follow-indentation-p python-indent-current-level next-indent] 3 (#$ . 17964)])
#@79 `indent-line-function' for Python mode.
See `python-indent-line' for details.
(defalias 'python-indent-line-function #[nil "\300 \207" [python-indent-line] 1 (#$ . 19535)])
#@25 De-indent current line.
(defalias 'python-indent-dedent-line #[nil "\300\301 8?\205 \302 \212\303 \210\302 )X\205 i\304V\205 \305\306!\210\306\207" [8 syntax-ppss point-marker back-to-indentation 0 python-indent-line t] 2 (#$ . 19714) "*"])
#@130 De-indent current line.
Argument ARG is passed to `backward-delete-char-untabify' when
point is  not in between the indentation.
(defalias 'python-indent-dedent-line-backspace #[(arg) "\301 ?\205	\302!\207" [arg python-indent-dedent-line backward-delete-char-untabify] 2 (#$ . 19965) "*p"])
(put 'python-indent-dedent-line-backspace 'delete-selection 'supersede)
#@107 Indent a python region automagically.

Called from a program, START and END specify the region to indent.
(defalias 'python-indent-region #[(start end) "\306\212	b\210\307 \nb\210n\204\310y\210`	W\203\214n\203!l\204\206\306\311y\210\312 \210\313 \310y\210\203\205\314\315!\203{\316\317`S\320 \306f`\306\321\211\322W\203q\f\203]
\\\fW\203q
\\f=\203qT\211\202K,#!\323=\203\205\324 \210\325 \210\326 j\210)\310y\210\202	\306\211\223*\207" [deactivate-mark end start word limit point nil point-marker 1 -1 back-to-indentation current-word python-syntax-context string syntax-after + current-indentation 0 3 (15) beginning-of-line delete-horizontal-space python-indent-calculate-indentation quote-char i] 7 (#$ . 20337)])
#@323 Shift lines contained in region START END by COUNT columns to the left.
COUNT defaults to `python-indent-offset'.  If region isn't
active, the current line is shifted.  The shifted region includes
the lines in which START and END lie.  An error is signaled if
any lines in the region are indented less than COUNT columns.
(defalias 'python-indent-shift-left #[(start end &optional count) "\203\305!\202
	\306V\205=\307\212b\210`\fW\2036\310 W\2030\311\312!\2040\313\314!\210\307y\210\202\315\f[#*\207" [count python-indent-offset deactivate-mark start end prefix-numeric-value 0 nil current-indentation looking-at "[ 	]*$" error "Can't shift all lines enough" indent-rigidly] 4 (#$ . 21099) (byte-code "\203\302 \303 	E\207\304 \305 	E\207" [mark-active current-prefix-arg region-beginning region-end line-beginning-position line-end-position] 3)])
(add-to-list 'debug-ignored-errors "^Can't shift all lines enough")
#@236 Shift lines contained in region START END by COUNT columns to the left.
COUNT defaults to `python-indent-offset'.  If region isn't
active, the current line is shifted.  The shifted region includes
the lines in which START and END lie.
(defalias 'python-indent-shift-right #[(start end &optional count) "\305	\203
\306	!\202\n\307\f	#)\207" [deactivate-mark count python-indent-offset start end nil prefix-numeric-value indent-rigidly] 4 (#$ . 22045) (byte-code "\203\302 \303 	E\207\304 \305 	E\207" [mark-active current-prefix-arg region-beginning region-end line-beginning-position line-end-position] 3)])
#@159 Insert a colon and maybe de-indent the current line.
With numeric ARG, just insert that many colons.  With
\[universal-argument], just insert a single colon.
(defalias 'python-indent-electric-colon #[(arg) "\303\250\204\n\304\202!\210?\205Hl\205H\305 \306Zf\307\232?\205H\310\311 8?\205H\312 \313 \314 \210\n	V\205G\212\315	!\210\314 ?\205F\315\n!)*\207" [arg calculated-indentation indentation self-insert-command 1 point-marker 2 58 8 syntax-ppss current-indentation python-indent-calculate-indentation python-info-closing-block-message indent-line-to] 2 (#$ . 22670) "*P"])
(put 'python-indent-electric-colon 'delete-selection t)
#@251 Adjust closing paren line indentation after a char is added.
This function is intended to be added to the
`post-self-insert-hook.'  If a line renders a paren alone, after
adding a char before it, the line will be re-indented
automatically if needed.
(defalias 'python-indent-post-self-insert-function #[nil "`Sf=\205.n?\205.\302f\303>\205.\212\304 b\210\305\306!\205-\307 \310 	W\205,\311	!))\207" [last-command-event indentation nil (41 93 125) line-beginning-position python-syntax-context paren python-indent-calculate-indentation current-indentation indent-line-to] 2 (#$ . 23324)])
#@130 Regexp matching class or function definition.
The name of the defun should be grouped so it can be retrieved
via `match-string'.
(defvar python-nav-beginning-of-defun-regexp "^[[:space:]]*\\_<\\(?:class\\|def\\)\\_>[[:space:]]+\\([_[:alpha:]][_[:word:]]*\\)" (#$ . 23925))
#@119 Internal implementation of `python-nav-beginning-of-defun'.
With positive ARG search backwards, else search forwards.
(defalias 'python-nav--beginning-of-defun #[(&optional arg) "\203\n\306U\203\f\307\306V\203\310\202\311\312 \211\313 \\\314 \306V\205B\212\315 \2044\316 \204*\315 \203@\313 
\\\206A\306)\306W\203R\315 \203R\307\210	\317\320#\203u\321 \204R\306V\203u\313 \306U\204u\313 Y\204R\315 \205\223\322\f!\322 U?\206\223`\nY\205\223`X\205\223\fV\211\203\243\323\307!\206\247\320\202\247\fb\210\317.\207" [arg re-search-fn line-beg-pos line-content-start pos python-indent-offset 0 1 re-search-backward re-search-forward line-beginning-position current-indentation point-marker python-info-looking-at-beginning-of-defun python-nav-backward-block nil t python-syntax-context-type line-number-at-pos beginning-of-line beg-indentation python-nav-beginning-of-defun-regexp found] 5 (#$ . 24205)])
#@288 Move point to `beginning-of-defun'.
With positive ARG search backwards else search forward.  When ARG
is nil or 0 defaults to 1.  When searching backwards nested
defuns are handled with care depending on current point
position.  Return non-nil if point is moved to
`beginning-of-defun'.
(defalias 'python-nav-beginning-of-defun #[(&optional arg) "\203\n\305U\203\f\306\307\n\310=\203\311 \204B\305V\203#\202%[\305\fW\203A\312!\203:	\204:\313T\211\202)*	)\207" [arg found this-command i --dotimes-limit-- 0 1 nil mark-defun python-info-looking-at-beginning-of-defun python-nav--beginning-of-defun t] 3 (#$ . 25160)])
#@87 Move point to the end of def or class.
Returns nil if point is not in a def or class.
(defalias 'python-nav-end-of-defun #[nil "\302`\303 \204\304\305!\204\304\306!\2059\307 \310 \210\311\305!\210\307 	V\203*m\203\311\306!\210\305y\210`V\2059b*\207" [beg-pos beg-defun-indent nil python-info-looking-at-beginning-of-defun python-nav-beginning-of-defun 1 -1 current-indentation python-nav-end-of-statement python-util-forward-comment] 2 (#$ . 25807) nil])
#@37 Move to start of current statement.
(defalias 'python-nav-beginning-of-statement #[nil "\300 \210o\204\"\212\301y\210\302 )\204\303\304!\204\303\305!\203\"\301y\204\306 \207" [back-to-indentation -1 python-info-line-ends-backslash-p python-syntax-context string paren point-marker] 2 (#$ . 26282) "^"])
#@182 Move to end of current statement.
Optional argument NOEND is internal and makes the logic to not
jump to the end of line when moving forward searching for the end
of the statement.
(defalias 'python-nav-end-of-statement #[(&optional noend) "\306\211\n\204\307 b\203\211m\204\211\310\311!\211\203m	b\210\310\312!\203)\313\314!\202\206``f`\306\315\211\316W\203Z\203G\f\\W\203Z\f\\f
=\203ZT\211\2025,\\b\210\317\320\306\314#\204db\202\206\310\312!\203z\321\322\323\217\202\206\324 \211\203\211b\210\325y\204*\326 \207" [bs-pos string-start noend limit point quote-char nil line-end-position python-syntax-context string paren python-nav-end-of-statement t 0 3 re-search-forward "\\s|" err (byte-code "\300`\301\302#b\207" [scan-lists 1 -1] 4) ((scan-error (byte-code "\3018b\207" [err 3] 2))) python-info-line-ends-backslash-p 1 point-marker i] 4 (#$ . 26600) "^"])
#@93 Move backward to previous statement.
With ARG, repeat.  See `python-nav-forward-statement'.
(defalias 'python-nav-backward-statement #[(&optional arg) "\204\301\302[!\207" [arg 1 python-nav-forward-statement] 2 (#$ . 27512) "^p"])
#@123 Move forward to next statement.
With ARG, repeat.  With negative argument, move ARG times
backward to previous statement.
(defalias 'python-nav-forward-statement #[(&optional arg) "\204\301\302V\203\303 \210\304 \210\305 \210S\211\202\302W\2053\305 \210\304\306!\210\305 \210T\211\202\207" [arg 1 0 python-nav-end-of-statement python-util-forward-comment python-nav-beginning-of-statement -1] 3 (#$ . 27755) "^p"])
#@33 Move to start of current block.
(defalias 'python-nav-beginning-of-block #[nil "`\304\305 \210\306\307!\203\310 \202Qo\204)\305 \210\311 \204#\312 \203)\313y\210\202\314 \nZ\315 \203:\314 V\204.\306\307!\203L\314 U\203L\310 \202P	b\210\316)*\207" [block-regexp starting-pos python-indent-offset block-matching-indent "^[[:space:]]*\\_<\\(?:\\(?:class\\|def\\|e\\(?:l\\(?:if\\|se\\)\\|xcept\\)\\|f\\(?:inally\\|or\\)\\|if\\|try\\|w\\(?:hile\\|ith\\)\\)\\)\\_>" python-nav-beginning-of-statement looking-at "\\_<\\(?:\\(?:class\\|def\\|e\\(?:l\\(?:if\\|se\\)\\|xcept\\)\\|f\\(?:inally\\|or\\)\\|if\\|try\\|w\\(?:hile\\|ith\\)\\)\\)\\_>" point-marker python-info-current-line-comment-p python-info-current-line-empty-p -1 current-indentation python-nav-backward-block nil] 2 (#$ . 28193) "^"])
#@31 Move to end of current block.
(defalias 'python-nav-end-of-block #[nil "\301 \2054\302 \303 \210\304y\203-m\204-\302 V\203#\303 \204\202\305 \204\306 \204\307\310!\210\311 )\207" [block-indentation python-nav-beginning-of-block current-indentation python-nav-end-of-statement 1 python-info-current-line-comment-p python-info-current-line-empty-p python-util-forward-comment -1 point-marker] 2 (#$ . 29008) "^"])
#@93 Move backward to previous block of code.
With ARG, repeat.  See `python-nav-forward-block'.
(defalias 'python-nav-backward-block #[(&optional arg) "\204\301\302[!\207" [arg 1 python-nav-forward-block] 2 (#$ . 29440) "^p"])
#@123 Move forward to next block of code.
With ARG, repeat.  With negative argument, move ARG times
backward to previous block.
(defalias 'python-nav-forward-block #[(&optional arg) "\204\303\304`\305V\203'\306 \210\307\n\310\311#\203 \312 \204S\211\202\305W\203D\313 \210\314\n\310\311#\203=\312 \2040T\211\202(\313 \210\315\316!\204T	b\210\310\202]`	U?\205]\317 *\207" [arg starting-pos block-start-regexp 1 "^[[:space:]]*\\_<\\(?:\\(?:class\\|def\\|e\\(?:l\\(?:if\\|se\\)\\|xcept\\)\\|f\\(?:inally\\|or\\)\\|if\\|try\\|w\\(?:hile\\|ith\\)\\)\\)\\_>" 0 python-nav-end-of-statement re-search-forward nil t python-syntax-context-type python-nav-beginning-of-statement re-search-backward looking-at "\\_<\\(?:\\(?:class\\|def\\|e\\(?:l\\(?:if\\|se\\)\\|xcept\\)\\|f\\(?:inally\\|or\\)\\|if\\|try\\|w\\(?:hile\\|ith\\)\\)\\)\\_>" point-marker] 5 (#$ . 29675) "^p"])
#@89 Safe version of standard `forward-sexp'.
When ARG > 0 move forward, else if ARG is < 0.
(defalias 'python-nav-lisp-forward-sexp-safe #[(&optional arg) "\204\304\305\306V\203\307\202\310\306V\203\311\202\312\305\313\314\217+\207" [arg search-fn paren-regexp forward-sexp-function 1 nil 0 "[])}]" "[([{]" re-search-forward re-search-backward (forward-sexp arg) ((error (byte-code "	\302\303#\205\304\305!\205\202\207" [search-fn paren-regexp nil t python-syntax-context paren] 4)))] 4 (#$ . 30564)])
#@99 Move to forward sexp.
With positive Optional argument DIR direction move forward, else
backwards.
(defalias 'python-nav--forward-sexp #[(&optional dir) "\206\306\211\307U?\205\237
\307V\203\306\211\205 \310\202 \311\312\211\203)\313\202*\314\315 \211\316>\203=\312\317!)\202\236
\320=\204\\	\203M\321\322!\204\\	\204b\323\324`S!!\325=\203b\326!\202\236
\327 \203k\330\202\203\331 \203t\332\202\203\333 \203}\334\202\203\335 \205\203\336\212\326!\210`)0\2120b\210\327 \203\233\330\202\305\331 \203\244\332\202\305\333 \203\255\334\202\305\335 \203\266\336\202\305\337 \203\277\340\202\305\341 \205\305\342)1	\2036
m\204\337\343 \203\337\344!\210\345!\202\235

\330=\203\352\346 \202\235

\334=\203\365\347 \202\235

\350>\203
1\342=\203
0b\210\346 \202\235

\351>\203!
1\340=\203!
0b\210\346 \202\235

\352>\2030
0b\210\347 \202\235
0b\202\235
o\204I
\343 \203I
\344!\210\345!\202\235

\332=\203T
\353 \202\235

\336=\203_
\354 \202\235

\355>\203u
1\340=\203u
0b\210\353 \202\235

\356>\203\213
1\342=\203\213
0b\210\353 \202\235

\357>\203\232
0b\210\354 \202\235
0b++\207" [dir forward-p re-search-fn context-type forward-sexp-function context 1 0 t -1 nil re-search-forward re-search-backward python-syntax-context-type (string comment) forward-sexp paren looking-at "[([{]" syntax-class syntax-after 5 python-nav-lisp-forward-sexp-safe python-info-beginning-of-block-p block-start python-info-end-of-block-p block-end python-info-beginning-of-statement-p statement-start python-info-end-of-statement-p statement-end python-info-statement-starts-block-p starts-block python-info-statement-ends-block-p ends-block python-info-current-line-empty-p python-util-forward-comment python-nav--forward-sexp python-nav-end-of-block python-nav-end-of-statement (statement-end block-end) (statement-end block-end) (statement-end block-end) python-nav-beginning-of-block python-nav-beginning-of-statement (statement-start block-start) (statement-start block-start) (statement-start block-start) next-sexp-pos next-sexp-context] 4 (#$ . 31092)])
#@24 Move to backward sexp.
(defalias 'python-nav--backward-sexp #[nil "\300\301!\207" [python-nav--forward-sexp -1] 2 (#$ . 33205)])
#@119 Move forward across one block of code.
With ARG, do it that many times.  Negative arg -N means
move backward N times.
(defalias 'python-nav-forward-sexp #[(&optional arg) "\204\301\302V\203\303 \210S\211\202\302W\205&\304 \210T\211\202\207" [arg 1 0 python-nav--forward-sexp python-nav--backward-sexp] 3 (#$ . 33341) "^p"])
#@125 Internal implementation of `python-nav-up-list'.
DIR is always 1 or -1 and comes sanitized from
`python-nav-up-list' calls.
(defalias 'python-nav--up-list #[(&optional dir) "\306 \307V\211\310>\206\233\n\311=\203\312\313!)\202\233	\203X\314 \203X\212\315 \205-\316 \f\203D\f\307V\203D\316 \fY\203D\317 \204.\320 *\211\206M``V\205T
b)\202\233	\203a\320 \202\233	\204\224\316 \307V\203\224\321 \203\224\212\316 \317 \203\201\316 \fY\204u)`)`V\205\220b)\202\233	?\205\233\315 *\207" [dir forward-p context forward-sexp-function indentation parent-end-pos python-syntax-context-type 0 (string comment) paren nil up-list python-info-end-of-block-p python-nav-beginning-of-block current-indentation python-nav-backward-block python-nav-end-of-block python-info-beginning-of-block-p prev-block-pos] 4 (#$ . 33689)])
#@223 Move forward out of one level of parentheses (or blocks).
With ARG, do this that many times.
A negative argument means move backward but still to a less deep spot.
This command assumes point is not in a string or comment.
(defalias 'python-nav-up-list #[(&optional arg) "\204\301\302V\203\303\301!\210S\211\202\302W\205(\303\304!\210T\211\202\207" [arg 1 0 python-nav--up-list -1] 3 (#$ . 34543) "^p"])
#@224 Move backward out of one level of parentheses (or blocks).
With ARG, do this that many times.
A negative argument means move backward but still to a less deep spot.
This command assumes point is not in a string or comment.
(defalias 'python-nav-backward-up-list #[(&optional arg) "\204\301\302[!\207" [arg 1 python-nav-up-list] 2 (#$ . 34970) "^p"])
(byte-code "\300\301\302\303\304\305\306\307\310\311&	\210\300\312\313\314\304\305\306\307&\210\300\315\316\317\304\305\306\307\310\311&	\210\300\320\321\322\304\305\306\307&\210\300\323\324\325\304\305\306\307\310\311&	\210\300\326\327\330\304\305\306\307\310\311&	\210\300\331\332\333\304\305\306\307\310\311&	\210\300\334\335\336\304\305\306\307\310\311&	\210\300\337\340\341\304\342\306\307\310\343&	\210\300\344\345\346\304\347\306\307\310\350&	\210\300\351\345\352\304\353\306\307\310\350&	\210\300\354\345\355\304\356\306\307\310\350&	\210\300\357\345\360\304\305\306\307\310\311&	\210\300\361\362\363\304\364\306\307\310\350&	\210\300\365\366\367\304\370\306\307&\207" [custom-declare-variable python-shell-buffer-name "Python" "Default buffer name for Python interpreter." :type string :group python :safe stringp python-shell-interpreter "python" "Default Python interpreter for shell." python-shell-internal-buffer-name "Python Internal" "Default buffer name for the Internal Python interpreter." python-shell-interpreter-args "-i" "Default arguments for the Python interpreter." python-shell-prompt-regexp ">>> " "Regular Expression matching top-level input prompt of python shell.\nIt should not contain a caret (^) at the beginning." python-shell-prompt-block-regexp "[.][.][.] " "Regular Expression matching block input prompt of python shell.\nIt should not contain a caret (^) at the beginning." python-shell-prompt-output-regexp "" "Regular Expression matching output prompt of python shell.\nIt should not contain a caret (^) at the beginning." python-shell-prompt-pdb-regexp "[(<]*[Ii]?[Pp]db[>)]+ " "Regular Expression matching pdb input prompt of python shell.\nIt should not contain a caret (^) at the beginning." python-shell-enable-font-lock t "Should syntax highlighting be enabled in the python shell buffer?\nRestart the python shell after changing this variable for it to take effect." boolean booleanp python-shell-process-environment nil "List of environment variables for Python shell.\nThis variable follows the same rules as `process-environment'\nsince it merges with it before the process creation routines are\ncalled.  When this variable is nil, the Python shell is run with\nthe default `process-environment'." (repeat string) listp python-shell-extra-pythonpaths "List of extra pythonpaths for Python shell.\nThe values of this variable are added to the existing value of\nPYTHONPATH in the `process-environment' variable." (repeat string) python-shell-exec-path "List of path to search for binaries.\nThis variable follows the same rules as `exec-path' since it\nmerges with it before the process creation routines are called.\nWhen this variable is nil, the Python shell is run with the\ndefault `exec-path'." (repeat string) python-shell-virtualenv-path "Path to virtualenv root.\nThis variable, when set to a string, makes the values stored in\n`python-shell-process-environment' and `python-shell-exec-path'\nto be modified properly so shells are started with the specified\nvirtualenv." python-shell-setup-codes '(python-shell-completion-setup-code python-ffap-setup-code python-eldoc-setup-code) "List of code run by `python-shell-send-setup-codes'." (repeat symbol) python-shell-compilation-regexp-alist `((,(rx line-start (1+ (any " 	")) "File \"" (group (1+ (not (any "\"<")))) "\", line " (group (1+ digit))) 1 2) (,(rx " in file " (group (1+ not-newline)) " on line " (group (1+ digit))) 1 2) (,(rx line-start "> " (group (1+ (not (any "(\"<")))) "(" (group (1+ digit)) ")" (1+ (not (any "("))) "()") 1 2)) "`compilation-error-regexp-alist' for inferior Python." (alist string)] 10)
#@275 Calculate the appropriate process name for inferior Python process.
If DEDICATED is t and the variable `buffer-file-name' is non-nil
returns a string with the form
`python-shell-buffer-name'[variable `buffer-file-name'] else
returns the value of `python-shell-buffer-name'.
(defalias 'python-shell-get-process-name #[(dedicated) "\203	\203\303\304\n	#\207\303\305\n\"\207" [dedicated buffer-file-name python-shell-buffer-name format "%s[%s]" "%s"] 5 (#$ . 38970)])
#@249 Calculate the appropriate process name for Internal Python process.
The name is calculated from `python-shell-global-buffer-name' and
a hash of all relevant global shell settings in order to ensure
uniqueness for different types of configurations.
(defalias 'python-shell-internal-get-process-name #[nil "\306\307\310\311 	\n\312\313\f\314#\312\315
\314#\312\315\314#\312\315\314#\206%\314\312\315\314#\260\n!#\207" [python-shell-internal-buffer-name python-shell-prompt-regexp python-shell-prompt-block-regexp python-shell-prompt-output-regexp python-shell-setup-codes python-shell-process-environment format "%s [%s]" md5 python-shell-parse-command mapconcat symbol-value "" identity python-shell-extra-pythonpaths python-shell-exec-path python-shell-virtualenv-path] 17 (#$ . 39447)])
#@67 Calculate the string used to execute the inferior Python process.
(defalias 'python-shell-parse-command #[nil "\304 \305 \306\307\310\n!#*\207" [exec-path process-environment python-shell-interpreter python-shell-interpreter-args python-shell-calculate-process-environment python-shell-calculate-exec-path format "%s %s" executable-find] 4 (#$ . 40252)])
#@69 Calculate process environment given `python-shell-virtualenv-path'.
(defalias 'python-shell-calculate-process-environment #[nil "\306	\307#\n\205\f\310\n!\f\203&\311\312\313\314\315\316\f
#
\317\312!\206#\320$\"\210\204/	\210\202I\311\321\307\"\210\311\322\313\323
\317\322!\206A\320$\"\210\311\324\"\210	*\207" [python-shell-process-environment process-environment python-shell-virtualenv-path virtualenv python-shell-extra-pythonpaths path-separator append nil directory-file-name setenv "PYTHONPATH" format "%s%s%s" mapconcat identity getenv "" "PYTHONHOME" "PATH" "%s/bin%s%s" "VIRTUAL_ENV"] 8 (#$ . 40616)])
#@59 Calculate exec path given `python-shell-virtualenv-path'.
(defalias 'python-shell-calculate-exec-path #[nil "\304	\305#\204\n\202\306\307\310!\"\nB)\207" [python-shell-exec-path exec-path path python-shell-virtualenv-path append nil format "%s/bin" directory-file-name] 4 (#$ . 41247)])
#@103 Hook run after content is put into comint buffer.
OUTPUT is a string with the contents of the buffer.
(defalias 'python-comint-output-filter-function #[(output) "\301!\207" [output ansi-color-filter-apply] 2 (#$ . 41549)])
(defvar python-shell--parent-buffer nil)
#@92 Syntax table for shell output.
It makes parens and quotes be treated as punctuation chars.
(defvar python-shell-output-syntax-table (byte-code "\302!\303\304\305	#\210\303\306\305	#\210\303\307\305	#\210\303\310\305	#\210\303\311\305	#\210\303\312\305	#\210\303\313\305	#\210\303\314\305	#\210	)\207" [python-dotty-syntax-table table make-syntax-table modify-syntax-entry 39 "." 34 40 91 123 41 93 125] 4) (#$ . 41820))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\305\306!\204\302\306\307\310#\210\300\207" [inferior-python-mode-hook variable-documentation put purecopy "Hook run when entering Inferior Python mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp inferior-python-mode-map definition-name inferior-python-mode] 5)
(defvar inferior-python-mode-map (make-sparse-keymap))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\305\306!\204\302\306\307\310#\210\300\207" [inferior-python-mode-map variable-documentation put purecopy "Keymap for `inferior-python-mode'." boundp inferior-python-mode-syntax-table definition-name inferior-python-mode] 5)
(defvar inferior-python-mode-syntax-table (make-syntax-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\207" [inferior-python-mode-syntax-table variable-documentation put purecopy "Syntax table for `inferior-python-mode'." inferior-python-mode-abbrev-table definition-name inferior-python-mode] 5)
(defvar inferior-python-mode-abbrev-table (progn (define-abbrev-table 'inferior-python-mode-abbrev-table nil) inferior-python-mode-abbrev-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\207" [inferior-python-mode-abbrev-table variable-documentation put purecopy "Abbrev table for `inferior-python-mode'." inferior-python-mode derived-mode-parent comint-mode] 5)
#@1054 Major mode for Python inferior process.
Runs a Python interpreter as a subprocess of Emacs, with Python
I/O through an Emacs buffer.  Variables
`python-shell-interpreter' and `python-shell-interpreter-args'
controls which Python interpreter is run.  Variables
`python-shell-prompt-regexp',
`python-shell-prompt-output-regexp',
`python-shell-prompt-block-regexp',
`python-shell-enable-font-lock',
`python-shell-completion-setup-code',
`python-shell-completion-string-code',
`python-shell-completion-module-string-code',
`python-eldoc-setup-code', `python-eldoc-string-code',
`python-ffap-setup-code' and `python-ffap-string-code' can
customize this mode for different Python interpreters.

You can also add additional setup code to be run at
initialization of the interpreter via `python-shell-setup-codes'
variable.

(Type \[describe-mode] in the process buffer for a list of commands.)

In addition to any hooks its parent mode `comint-mode' might have run,
this mode runs the hook `inferior-python-mode-hook', as the final step
during initialization.
(defalias 'inferior-python-mode #[nil "\306\300!\210\307\310 \210\311\312\310\313N\203\314\311\313\310\313N#\210\315!\204'\316\317 \"\210\320\f!\211\2036
\321 =\203<\322\f\323 \"\210)\324<\325\"\204V<==\204V\326<\325=C#\210\327!\210\330\f!\210<=>\203l\331>!\210\332\333?@A$B\334C\306\335!\210\336\335\337\"\210\336\335\340\"\210\306\341!\210D!\342\343\344#\210\336\345\346\347\350$\210\351\306\352!\346\"\210\342\353\354#\210\306\355!\210\306\356!\210\306\357!\210E\203\330\330F!\210\306\360!\210\3610\306\362!\210\363\364B\365B\366\367BE!2\370\371!\210)\372\373!\207" [delay-mode-hooks major-mode mode-name inferior-python-mode-map inferior-python-mode-syntax-table parent make-local-variable t comint-mode inferior-python-mode "Inferior Python" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table abbrev-table-get :parents abbrev-table-put use-local-map set-syntax-table python-util-clone-local-variables format "^\\(?:%s\\|%s\\|%s\\)" (":%s") comint-output-filter-functions add-hook python-comint-output-filter-function python-pdbtrack-comint-output-filter-function compilation-error-regexp-alist define-key [remap complete-symbol] completion-at-point completion-at-point-functions python-shell-completion-complete-at-point nil local add-to-list comint-dynamic-complete-functions "	" python-shell-completion-complete-or-indent python-pdbtrack-buffers-to-kill python-pdbtrack-tracked-buffer python-shell-internal-last-output font-lock-defaults (python-font-lock-keywords nil nil nil nil) syntax-propertize-function eval syntax-propertize-rules ((0 (ignore (put-text-property comint-last-input-start end 'syntax-table python-shell-output-syntax-table) (font-lock-unfontify-region comint-last-input-start end)))) "\\(?:[^\"'\\]\\|\\=\\|\\(?:[^\\]\\|\\=\\)\\\\\\(?:\\\\\\\\\\)*[\"']\\)\\(?:\\\\\\\\\\)*\\(\\(?:\"\"\"\\|'''\\|[\"']\\)\\)" ((0 (ignore (and (not (eq (get-text-property start 'field) 'output)) (python-syntax-stringify))))) compilation-shell-minor-mode 1 run-mode-hooks inferior-python-mode-hook inferior-python-mode-abbrev-table local-abbrev-table python-shell--parent-buffer python-shell-prompt-regexp python-shell-prompt-block-regexp python-shell-prompt-pdb-regexp comint-prompt-regexp mode-line-process python-shell-compilation-regexp-alist python-shell-enable-font-lock python-mode-syntax-table] 6 (#$ . 43715) nil])
#@544 Create a python shell comint buffer.
CMD is the python command to be executed and PROC-NAME is the
process name the comint buffer will get.  After the comint buffer
is created the `inferior-python-mode' is activated.  When
optional argument POP is non-nil the buffer is shown.  When
optional argument INTERNAL is non-nil this process is run on a
buffer with a name that starts with a space, following the Emacs
convention for temporary/internal buffers, and also makes sure
the user is not queried for confirmation when the process is
killed.
(defalias 'python-shell-make-comint #[(cmd proc-name &optional pop internal) "\212\306\204\n\307\202\310	\"\311 \312 \313\n!\204[\314
!\315\316	\n@\317A&p\320!rq\210\321 \210)\322!\210\203P\323\324\"\210\203Z\325\317\"\210,\n,\207" [internal proc-name proc-buffer-name process-environment exec-path cmd format "*%s*" " *%s*" python-shell-calculate-process-environment python-shell-calculate-exec-path comint-check-proc split-string-and-unquote apply make-comint-in-buffer nil get-buffer-process inferior-python-mode accept-process-output pop-to-buffer t set-process-query-on-exit-flag cmdlist buffer python-shell--parent-buffer process pop] 7 (#$ . 47236)])
#@562 Run an inferior Python process.
Input and output via buffer named after
`python-shell-buffer-name'.  If there is a process already
running in that buffer, just switch to it.

With argument, allows you to define CMD so you can edit the
command used to call the interpreter and define DEDICATED, so a
dedicated process for the current buffer is open.  When numeric
prefix arg is other than 0 or 4 do not SHOW.

Runs the hook `inferior-python-mode-hook' (after the
`comint-mode-hook' is run).  (Type \[describe-mode] in the
process buffer for a list of commands.)
(defalias 'run-python #[(cmd &optional dedicated show) "\303\304	!\n#\210	\207" [cmd dedicated show python-shell-make-comint python-shell-get-process-name] 4 (#$ . 48480) (byte-code "\203\301\302\303 \"\304\305!\306!\307UE\207\303 \310\311E\207" [current-prefix-arg read-string "Run Python: " python-shell-parse-command y-or-n-p "Make dedicated process? " prefix-numeric-value 4 nil t] 4)])
#@668 Run an inferior Internal Python process.
Input and output via buffer named after
`python-shell-internal-buffer-name' and what
`python-shell-internal-get-process-name' returns.

This new kind of shell is intended to be used for generic
communication related to defined configurations, the main
difference with global or dedicated shells is that these ones are
attached to a configuration, not a buffer.  This means that can
be used for example to retrieve the sys.path and other stuff,
without messing with user shells.  Note that
`python-shell-enable-font-lock' and `inferior-python-mode-hook'
are set to nil for these shells, so setup codes are not sent at
startup.
(defalias 'run-python-internal #[nil "\302\211\303\304\305 \306 \302\307$!*\207" [inferior-python-mode-hook python-shell-enable-font-lock nil get-buffer-process python-shell-make-comint python-shell-parse-command python-shell-internal-get-process-name t] 6 (#$ . 49444)])
#@63 Get inferior Python process for current buffer and return it.
(defalias 'python-shell-get-process #[nil "\306\307!\310\311\"\306\312!\310\311\n\"\313	!\313!\314\f\203#	\206(
\205(!.\207" [dedicated-proc-name dedicated-proc-buffer-name global-proc-name global-proc-buffer-name dedicated-running global-running python-shell-get-process-name t format "*%s*" nil comint-check-proc get-buffer-process] 3 (#$ . 50391)])
#@76 Get or create an inferior Python process for current buffer and return it.
(defalias 'python-shell-get-or-create-process #[nil "\306\307!\310\311\"\306\312!\310\311\n\"\313	!\313!\314\f\2042
\2042\315\316!\2030\307\2022\307\317\f\203;	\202<!.\207" [dedicated-proc-name dedicated-proc-buffer-name global-proc-name global-proc-buffer-name dedicated-running global-running python-shell-get-process-name t format "*%s*" nil comint-check-proc 16 call-interactively run-python get-buffer-process current-prefix-arg] 3 (#$ . 50824)])
#@157 Current internal shell buffer for the current buffer.
This is really not necessary at all for the code to work but it's
there for compatibility with CEDET.
(defvar python-shell-internal-buffer nil (#$ . 51378))
#@147 Last output captured by the internal shell.
This is really not necessary at all for the code to work but it's
there for compatibility with CEDET.
(defvar python-shell-internal-last-output nil (#$ . 51596))
#@52 Get or create an inferior Internal Python process.
(defalias 'python-shell-internal-get-or-create-process #[nil "\303 \304\305\"\306!\204\307 \210	\310\311\312\"\210\313	!*\207" [proc-name proc-buffer-name python-shell-internal-buffer python-shell-internal-get-process-name format " *%s*" process-live-p run-python-internal sit-for 0.1 t get-buffer-process] 3 (#$ . 51808)])
(byte-code "\302\303\304\305#\210\306\303\304\307#\210\310\311\312\305#\210\313\305\211\2038	@\311N\2031\312N\2041\314\312\311N#\210	A\211\204*\315\311\312\307#\210\310\316\317\305#\210\313\305\211\203k	@\316N\203d\317N\204d\314\317\316N#\210	A\211\204M*\315\316\317\307#\207" [prop --dolist-tail-- defalias python-proc python-shell-internal-get-or-create-process nil make-obsolete "24.3" defvaralias python-buffer python-shell-internal-buffer (saved-value saved-variable-comment) put make-obsolete-variable python-preoutput-result python-shell-internal-last-output] 6)
#@96 Send STRING to inferior Python PROCESS.
When MSG is non-nil messages the first line of STRING.
(defalias 'python-shell-send-string #[(string &optional process msg) "\206\306 \307	\310\311#\203\312\313\n@\"\210\nG\314V\203o\315\f!\203,\315\f!\316P\202-
\317\320!\321 \206: \322\323\324!!!\"\325\216r!q\210	c\210\326 \210)r!q\210\327\330\211\"\330\331%\210,\332 #+\202\206\333	\"\210\334\335	\"\203\202\334\336	\"\205\206\333\310\"*\207" [process string lines msg default-directory temporary-file-directory python-shell-get-or-create-process split-string "\n" t message "Sent: %s..." 1 file-remote-p "/tmp" make-temp-file "py" buffer-file-name get-buffer-create generate-new-buffer-name " *temp file*" ((byte-code "\301!\203\n\302!\210\301\207" [#1=#:temp-buffer buffer-name kill-buffer] 2)) delete-trailing-whitespace write-region nil 0 python-shell-send-file comint-send-string string-match "\n$" "\n[ 	].*\n?$" temp-file-name file-name #1# #2=#:temp-file] 6 (#$ . 52791) "sPython command: "])
(defvar python-shell-output-filter-in-progress nil)
(defvar python-shell-output-filter-buffer nil)
#@295 Filter used in `python-shell-send-string-no-output' to grab output.
STRING is the output received to this point from the process.
This filter saves received output from the process in
`python-shell-output-filter-buffer' and stops receiving it after
detecting a prompt at the end of the buffer.
(defalias 'python-shell-output-filter #[(string) "\306!	P\307\310\311\n\f$	\"\2034\312	\313\211\224OG\313V\2034\307\314P	\"\2034	\313\225\312O\315\207" [string python-shell-output-filter-buffer python-shell-prompt-regexp python-shell-prompt-block-regexp python-shell-prompt-pdb-regexp python-shell-output-filter-in-progress ansi-color-filter-apply string-match format "
?\n\\(?:%s\\|%s\\|%s\\)$" nil 0 "^" "" python-shell-prompt-output-regexp] 6 (#$ . 53928)])
#@119 Send STRING to PROCESS and inhibit output.
When MSG is non-nil messages the first line of STRING.  Return
the output.
(defalias 'python-shell-send-string-no-output #[(string &optional process msg) "\206\304 \305\306\211\307\310\311\217\206r\312!q\210\313 ),\207" [process inhibit-quit python-shell-output-filter-in-progress comint-preoutput-filter-functions python-shell-get-or-create-process (python-shell-output-filter) t nil (byte-code "\306\307	\n#\210\f\203\310\n!\210\202
\306)\207" [inhibit-quit string process msg python-shell-output-filter-in-progress python-shell-output-filter-buffer nil python-shell-send-string accept-process-output] 4) ((quit (byte-code "\301\302\303!\207" [quit-flag t eval (ignore nil)] 2))) process-buffer comint-interrupt-subjob] 4 (#$ . 54705)])
#@112 Send STRING to the Internal Python interpreter.
Returns the output.  See `python-shell-send-string-no-output'.
(defalias 'python-shell-internal-send-string #[(string) "\302\303\304\305#\306 \307#\211\207" [string python-shell-internal-last-output python-shell-send-string-no-output replace-regexp-in-string "_emacs_out +" "" python-shell-internal-get-or-create-process nil] 5 (#$ . 55512)])
(byte-code "\300\301\302\303#\210\304\301\302\305#\210\300\306\302\303#\210\304\306\302\305#\207" [defalias python-send-receive python-shell-internal-send-string nil make-obsolete "24.3" python-send-string] 4)
#@72 Send the region delimited by START and END to inferior Python process.
(defalias 'python-shell-send-region #[(start end) "\303\304!\305	S\306\")\n{P\307\310#\207" [start line-num end python-shell-send-string line-number-at-pos make-string 10 nil t] 4 (#$ . 56121) "r"])
#@147 Send the entire buffer to inferior Python process.
With prefix ARG allow execution of code inside blocks delimited
by "if __name__== '__main__':"
(defalias 'python-shell-send-buffer #[(&optional arg) "\214~\210ed{	\204\302\303\304#\305!*\207" [str arg replace-regexp-in-string "^if[[:space:]]+__name__[[:space:]]+==[[:space:]]+[\"']__main__[\"'][[:space:]]*:" "if __name__ == '__main__ ':" python-shell-send-string] 4 (#$ . 56401) "P"])
#@108 Send the current defun to inferior Python process.
When argument ARG is non-nil do not include decorators.
(defalias 'python-shell-send-defun #[(arg) "\212\301\302\210\303 \204\304\302!\203\305 \306V\204\204)\307y\203&\310\311!\204\302y\210\312 \313 \2043\302\210\312 \")\207" [arg python-shell-send-region 1 python-nav-beginning-of-defun beginning-of-line current-indentation 0 -1 looking-at "^[[:space:]]*@[_[:alpha:]][_[:word:]]*" point-marker python-nav-end-of-defun] 3 (#$ . 56851) "P"])
#@178 Send FILE-NAME to inferior Python PROCESS.
If TEMP-FILE-NAME is passed then that file is used for processing
instead, while internally the shell will continue to use
FILE-NAME.
(defalias 'python-shell-send-file #[(file-name &optional process temp-file-name) "\206\303 	\205\304\305	\306\"\206	!\n\203'\304\305\n\306\"\206#\n!\206(	\211\2041\307\310!\210\311\312\313	\2069\n\n#\"+\207" [process temp-file-name file-name python-shell-get-or-create-process expand-file-name file-remote-p localname error "If FILE-NAME is nil then TEMP-FILE-NAME must be non-nil" python-shell-send-string format "__pyfile = open('''%s''');exec(compile(__pyfile.read(), '''%s''', 'exec'));__pyfile.close()"] 6 (#$ . 57365) "fFile to send: "])
#@43 Switch to inferior Python process buffer.
(defalias 'python-shell-switch-to-shell #[nil "\300\301\302 !\303\"\207" [pop-to-buffer process-buffer python-shell-get-or-create-process t] 3 (#$ . 58108) nil])
#@125 Send all setup code for shell.
This function takes the list of setup code to send from the
`python-shell-setup-codes' list.
(defalias 'python-shell-send-setup-code #[nil "\304p!	\305\211\205&@\211\203\306\307\n\"\210\310\nJ\"\210A\211\204\f\305+\207" [process python-shell-setup-codes code --dolist-tail-- get-buffer-process nil message "Sent %s" python-shell-send-string] 4 (#$ . 58319)])
(byte-code "\300\301\302\"\210\303\304\305\306\307\310\311\312&\210\303\313\314\315\307\310\311\312&\210\303\316\317\320\307\310\311\312&\210\303\321\322\323\307\310\311\312&\207" [add-hook inferior-python-mode-hook python-shell-send-setup-code custom-declare-variable python-shell-completion-setup-code "try:\n    import readline\nexcept ImportError:\n    def __COMPLETER_all_completions(text): []\nelse:\n    import rlcompleter\n    readline.set_completer(rlcompleter.Completer().complete)\n    def __COMPLETER_all_completions(text):\n        import sys\n        completions = []\n        try:\n            i = 0\n            while True:\n                res = readline.get_completer()(text, i)\n                if not res: break\n                i += 1\n                completions.append(res)\n        except NameError:\n            pass\n        return completions" "Code used to setup completion in inferior Python processes." :type string :group python python-shell-completion-string-code "';'.join(__COMPLETER_all_completions('''%s'''))\n" "Python code used to get a string of completions separated by semicolons." python-shell-completion-module-string-code "" "Python code used to get completions separated by semicolons for imports.\n\nFor IPython v0.11, add the following line to\n`python-shell-completion-setup-code':\n\nfrom IPython.core.completerlib import module_completion\n\nand use the following as the value of this variable:\n\n';'.join(module_completion('''%s'''))\n" python-shell-completion-pdb-string-code "';'.join(globals().keys() + locals().keys())" "Python code used to get completions separated by semicolons for [i]pdb."] 8)
#@104 Do completion at point for PROCESS.
LINE is used to detect the context on how to complete given
INPUT.
(defalias 'python-shell-completion-get-completions #[(process line input) "r\306!q\210\307\310	!\311	!\")G\312V\203$\313\314\fP\n\"\203$\315\202P
G\312V\203A\313\314P\n\"\203A\313\316\"\203A\317\202P\313\314P\n\"\203O\320\202P\321\322\315\"\203^\202x\322\317\"\203j
\202x\322\320\"\203w\202x\321 \317=\203\212\323\324\325#\202\214!! \205\272!G\312V\205\272r\306!q\210\326\327 !\"\"\211\"G\330V\205\271\331\"\332\333#*,\207" [process comint-last-prompt-overlay prompt python-shell-completion-pdb-string-code python-shell-prompt-pdb-regexp python-shell-completion-module-string-code process-buffer buffer-substring-no-properties overlay-start overlay-end 0 string-match "^" pdb "^[ 	]*\\(from\\|import\\)[ 	]" import default nil eql replace-regexp-in-string "^[ 	]+" "" python-shell-send-string-no-output format 2 split-string "^'\\|^\"\\|;\\|'$\\|\"$" t python-shell-prompt-regexp line completion-context python-shell-completion-string-code completion-code input completions] 5 (#$ . 60386)])
#@162 Perform completion at point in inferior Python.
Optional argument PROCESS forces completions to be retrieved
using that one instead of current buffer's process.
(defalias 'python-shell-completion-complete-at-point #[(&optional process) "\206\306p!\212\307 p\310\216\311!\210\312 @\313\314
!\315`S!@\235\203U\316
!\210`Sf\317\232\204>`Sf\320\232\203A\321u\210\312 @\fV\204O\322\323!\203\321u\210\202A`.`\324\325\326\327\330 \"#!E*\207" [process #1=#:buffer #2=#:table python-dotty-syntax-table paren-depth syntax-string get-buffer-process syntax-table ((byte-code "rq\210\302	!\210)\302\207" [#1# #2# set-syntax-table] 2)) set-syntax-table syntax-ppss "w_" string-to-syntax syntax-after skip-syntax-backward 41 34 -1 python-syntax-context string completion-table-dynamic apply-partially python-shell-completion-get-completions buffer-substring-no-properties line-beginning-position syntax-list start end] 9 (#$ . 61543)])
#@123 Complete or indent depending on the context.
If content before pointer is all whitespace indent.  If not try
to complete.
(defalias 'python-shell-completion-complete-or-indent #[nil "\300\301\302 \303 {\"\203\304 \207\305 \207" [string-match "^[[:space:]]*$" comint-line-beginning-position point-marker indent-for-tab-command completion-at-point] 4 (#$ . 62504) nil])
(byte-code "\300\301\302\303\304\305\306\307\310\311&	\210\300\312\313\314\304\315\306\307\310\316&	\207" [custom-declare-variable python-pdbtrack-activate t "Non-nil makes python shell enable pdbtracking." :type boolean :group python :safe booleanp python-pdbtrack-stacktrace-info-regexp "^> \\([^\"(<]+\\)(\\([0-9]+\\))\\([?a-zA-Z0-9_<>]+\\)()" "Regular Expression matching stacktrace information.\nUsed to extract the current line and module being inspected." string stringp] 10)
#@146 Variable containing the value of the current tracked buffer.
Never set this variable directly, use
`python-pdbtrack-set-tracked-buffer' instead.
(defvar python-pdbtrack-tracked-buffer nil (#$ . 63364))
#@56 List of buffers to be deleted after tracking finishes.
(defvar python-pdbtrack-buffers-to-kill nil (#$ . 63572))
#@147 Set the buffer for FILE-NAME as the tracked buffer.
Internally it uses the `python-pdbtrack-tracked-buffer' variable.
Returns the tracked buffer.
(defalias 'python-pdbtrack-set-tracked-buffer #[(file-name) "\304!\211\203
	\202\305!\211\235\204\306\303	\"\210	)\207" [file-name file-buffer python-pdbtrack-tracked-buffer python-pdbtrack-buffers-to-kill get-file-buffer find-file-noselect add-to-list] 4 (#$ . 63692)])
#@128 Move overlay arrow to current pdb line in tracked buffer.
Argument OUTPUT is a string with the output from the comint process.
(defalias 'python-pdbtrack-comint-output-filter-function #[(output) "\203\260	\306\230\204\260\307\nd{!\310\311\312!r
q\210\313\216c\210db\210\314\310\315#\2054\316\317\320!!\317\321!+\211 \203\222\f\203\222\322 !!p\"\323!!#\310$r!q\210\324\325!\210\326\324\327!\210\330 eb\210\fSy\210\331 $#\203|\332#$\"\210$\310\223\210)\333!!\210\334\"!\210,\202\257%\203\257r%q\210\310\211\223\210)\335\336&\"\210\310\211%&+	\207" [python-pdbtrack-activate output comint-last-input-end full-output line-number #1=#:temp-buffer "" ansi-color-filter-apply nil generate-new-buffer " *temp*" ((byte-code "\301!\203\n\302!\210\301\207" [#1# buffer-name kill-buffer] 2)) re-search-backward t string-to-number match-string-no-properties 2 1 python-pdbtrack-set-tracked-buffer get-buffer-window make-local-variable overlay-arrow-string "=>" overlay-arrow-position make-marker point-marker set-window-point pop-to-buffer switch-to-buffer-other-window mapc #[(buffer) "\300\301\302\217\207" [nil (kill-buffer buffer) ((error))] 3] python-pdbtrack-stacktrace-info-regexp file-name tracked-buffer shell-buffer tracked-buffer-window tracked-buffer-line-pos python-pdbtrack-tracked-buffer python-pdbtrack-buffers-to-kill] 5 (#$ . 64127)])
#@193 Complete current symbol at point.
For this to work the best as possible you should call
`python-shell-send-buffer' from time to time so context in
inferior python process is updated properly.
(defalias 'python-completion-complete-at-point #[nil "\301 \211\204
\302\303!\202\304!)\207" [process python-shell-get-process error "Completion needs an inferior Python process running" python-shell-completion-complete-at-point] 3 (#$ . 65521)])
(byte-code "\300\301\302\"\210\303\304\305\306\307\310\311\312&\210\303\313\314\315\307\310\311\312&\210\303\316\317\320\307\310\311\312&\210\303\321\322\323\307\310\311\312&\210\303\324\325\326\307\327\311\312\330\331&	\207" [add-to-list debug-ignored-errors "^Completion needs an inferior Python process running." custom-declare-variable python-fill-comment-function 'python-fill-comment "Function to fill comments.\nThis is the function used by `python-fill-paragraph' to\nfill comments." :type symbol :group python python-fill-string-function 'python-fill-string "Function to fill strings.\nThis is the function used by `python-fill-paragraph' to\nfill strings." python-fill-decorator-function 'python-fill-decorator "Function to fill decorators.\nThis is the function used by `python-fill-paragraph' to\nfill decorators." python-fill-paren-function 'python-fill-paren "Function to fill parens.\nThis is the function used by `python-fill-paragraph' to\nfill parens." python-fill-docstring-style 'pep-257 "Style used to fill docstrings.\nThis affects `python-fill-string' behavior with regards to\ntriple quotes positioning.\n\nPossible values are DJANGO, ONETWO, PEP-257, PEP-257-NN,\nSYMMETRIC, and NIL.  A value of NIL won't care about quotes\nposition and will treat docstrings a normal string, any other\nvalue may result in one of the following docstring styles:\n\nDJANGO:\n\n    \"\"\"\n    Process foo, return bar.\n    \"\"\"\n\n    \"\"\"\n    Process foo, return bar.\n\n    If processing fails throw ProcessingError.\n    \"\"\"\n\nONETWO:\n\n    \"\"\"Process foo, return bar.\"\"\"\n\n    \"\"\"\n    Process foo, return bar.\n\n    If processing fails throw ProcessingError.\n\n    \"\"\"\n\nPEP-257:\n\n    \"\"\"Process foo, return bar.\"\"\"\n\n    \"\"\"Process foo, return bar.\n\n    If processing fails throw ProcessingError.\n\n    \"\"\"\n\nPEP-257-NN:\n\n    \"\"\"Process foo, return bar.\"\"\"\n\n    \"\"\"Process foo, return bar.\n\n    If processing fails throw ProcessingError.\n    \"\"\"\n\nSYMMETRIC:\n\n    \"\"\"Process foo, return bar.\"\"\"\n\n    \"\"\"\n    Process foo, return bar.\n\n    If processing fails throw ProcessingError.\n    \"\"\"" (choice (const :tag "Don't format docstrings" nil) (const :tag "Django's coding standards style." django) (const :tag "One newline and start and Two at end style." onetwo) (const :tag "PEP-257 with 2 newlines at end of string." pep-257) (const :tag "PEP-257 with 1 newline at end of string." pep-257-nn) (const :tag "Symmetric style." symmetric)) :safe #[(val) "\301>\207" [val (django onetwo pep-257 pep-257-nn symmetric nil)] 2]] 10)
#@315 `fill-paragraph-function' handling multi-line strings and possibly comments.
If any of the current line is in or at the end of a multi-line string,
fill the string or the paragraph of it that point is in, preserving
the string's indentation.
Optional argument JUSTIFY defines if the paragraph should be justified.
(defalias 'python-fill-paragraph #[(&optional justify) "\212\305\306!\203
	!\202T\212\305\307!\206\310`!\311\232)\203#\n	!\202T\212\312 )f\313\232\2033	!\202T\305\314!\204M\315\316!\204M\212\317\320\321 \"\210\315\316!)\203S\f	!\202T\322)\207" [python-fill-comment-function justify python-fill-string-function python-fill-decorator-function python-fill-paren-function python-syntax-context comment string syntax-after (15) python-nav-beginning-of-statement 64 paren looking-at "[([{]" skip-syntax-forward "^(" line-end-position t] 3 (#$ . 68603) "P"])
#@115 Comment fill function for `python-fill-paragraph'.
JUSTIFY should be used (if applicable) as in `fill-paragraph'.
(defalias 'python-fill-comment #[(&optional justify) "\301!\207" [justify fill-comment-paragraph] 2 (#$ . 69490)])
#@114 String fill function for `python-fill-paragraph'.
JUSTIFY should be used (if applicable) as in `fill-paragraph'.
(defalias 'python-fill-string #[(&optional justify) "\306 \307 \211\310\311!\206\312`!\313\232\205`\n\314\223\210\210*	)\211f\f\314#$\315\211%\316W\203X
\203C#%\\
W\203X#%\\f$=\203X%T\211%\2020%,&\212\f&\\b\210\317\320\314\321#\204odb\210\306 )'\322\323\f'#\315V(\324)\325\"\203\214\326\211B\202\325\324)\327\"\203\237(\205\325\326\330B\202\325\324)\331\"\203\262(\205\325\314\330B\202\325\324)\332\"\203\305(\205\325\314\326B\202\325\324)\333\"\205\325(\205\325\326\211B*\212\334 \210`\fU)+\314,\214\f'}\210\335-!\210)\212+\203I
)\203I
\f&\\b\210`\336\337!\210`|\210*@\203
\340*@!\210\341 \210'dU\204'
'&Z\202)
'b\210`\342\337!\210`|\210*A\203I
'dU\204I
\340*A!\210\341 \210.	\321\207" [marker m #1=#:v #2=#:v str-start-pos limit point-marker make-marker python-syntax-context string syntax-after (15) nil 0 3 re-search-forward "\\s|" t count-matches "\n" eql django 1 onetwo 2 pep-257 pep-257-nn symmetric python-nav-beginning-of-statement fill-paragraph skip-syntax-forward "> " newline indent-according-to-mode skip-syntax-backward point quote-char i num-quotes str-end-pos multi-line-p python-fill-docstring-style delimiters-style docstring-p fill-paragraph-function justify] 5 (#$ . 69727)])
#@117 Decorator fill function for `python-fill-paragraph'.
JUSTIFY should be used (if applicable) as in `fill-paragraph'.
(defalias 'python-fill-decorator #[(&optional justify) "\300\207" [t] 1 (#$ . 71119)])
#@113 Paren fill function for `python-fill-paragraph'.
JUSTIFY should be used (if applicable) as in `fill-paragraph'.
(defalias 'python-fill-paren #[(&optional justify) "\214\304\305!\203\306 Sb\210\202
\307 \304\305!\204$\310\210\304\305!\204$\311\312!\210\304\305!\2032\306 Tb\210\202$\306 }\210\313\314\310eb\210\315!\210+m\204U\316y\210\317 \210\320 b\210\202D)\321\207" [fill-paragraph-function paragraph-separate paragraph-start justify python-syntax-context paren point-marker line-beginning-position nil skip-syntax-backward "^)" "\f\\|[ 	]*$" "," fill-paragraph 1 python-indent-line line-end-position t] 3 (#$ . 71329)])
(byte-code "\302\303\304\305\306\307\310\311\312\313&	\210\314\315\303\304#\210\316\304\211\2039	@\315N\2032\303N\2042\317\303\315N#\210	A\211\204*\320\315\303\321#\207" [prop --dolist-tail-- custom-declare-variable python-skeleton-autoinsert nil "Non-nil means template skeletons will be automagically inserted.\nThis happens when pressing \"if<SPACE>\", for example, to prompt for\nthe if condition." :type boolean :group python :safe booleanp defvaralias python-use-skeletons (saved-value saved-variable-comment) put make-obsolete-variable "24.3"] 11)
#@39 Internal list of available skeletons.
(defvar python-skeleton-available nil (#$ . 72541))
(define-abbrev-table 'python-mode-abbrev-table nil "Abbrev table for Python mode." :case-fixed t :regexp "\\(?:^\\|[^/]\\)\\<\\([[:word:]/]+\\)\\W*" :enable-function #[nil "\301\302 8?\205	\207" [python-skeleton-autoinsert 8 syntax-ppss] 2])
#@158 Define a `python-mode' skeleton using NAME DOC and SKEL.
The skeleton will be bound to python-skeleton-NAME and will
be added to `python-mode-abbrev-table'.
(defalias 'python-skeleton-define '(macro . #[(name doc &rest skel) "\304!\305\306P!\307\310\311\312\313	D\314BBBBB\315\316\317\313	D\320BBE\321	\n\206,\322\323\"BBBF*\207" [name function-name doc skel symbol-name intern "python-skeleton-" progn define-abbrev python-mode-abbrev-table "" quote (:system t) setq python-skeleton-available cons (python-skeleton-available) define-skeleton format "Insert %s statement."] 8 (#$ . 72882)]))
(put 'python-skeleton-define 'lisp-indent-function 2)
#@120 Define a `python-mode' auxiliary skeleton using NAME DOC and SKEL.
The skeleton will be bound to python-skeleton-NAME.
(defalias 'python-define-auxiliary-skeleton '(macro . #[(name doc &optional &rest skel) "\305!\306\307P!\310\311\"\204\312\310\313\"\314BB\315	\f\206&\310\316\"\317\320\321\nD\322BB+BBBBB\207" [name function-name msg skel doc symbol-name intern "python-skeleton--" format "Add '%s' clause? " < "%s:" (n n > _ n) define-skeleton "Auxiliary skeleton for %s statement." nil unless y-or-n-p ((signal 'quit t))] 7 (#$ . 73543)]))
(byte-code "\300\301\302\303#\210\300\304\305\306#\207" [put python-define-auxiliary-skeleton lisp-indent-function 2 python-skeleton--else no-self-insert t] 4)
#@543 Auxiliary skeleton for else statement.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'python-skeleton--else #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new (nil (unless (y-or-n-p "Add 'else' clause? ") (signal 'quit t)) < "else:" n n > _ n)] 4 (#$ . 74268) "*P\nP"])
(put 'python-skeleton--except 'no-self-insert t)
#@545 Auxiliary skeleton for except statement.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'python-skeleton--except #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new (nil (unless (y-or-n-p "Add 'except' clause? ") (signal 'quit t)) < "except:" n n > _ n)] 4 (#$ . 75078) "*P\nP"])
(put 'python-skeleton--finally 'no-self-insert t)
#@546 Auxiliary skeleton for finally statement.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'python-skeleton--finally #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new (nil (unless (y-or-n-p "Add 'finally' clause? ") (signal 'quit t)) < "finally:" n n > _ n)] 4 (#$ . 75897) "*P\nP"])
(byte-code "\302\303\304\305\306\307&\210\305	B\310\305\311\307#\207" [python-mode-abbrev-table python-skeleton-available define-abbrev "if" "" python-skeleton-if :system t put no-self-insert] 7)
#@525 Insert if statement.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'python-skeleton-if #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new ("Condition: " "if " str ":" n _ n ("other condition, %s: " < "elif " str ":" n > _ n nil) '(python-skeleton--else) | ^)] 4 (#$ . 76869) "*P\nP"])
(byte-code "\302\303\304\305\306\307&\210\305	B\310\305\311\307#\207" [python-mode-abbrev-table python-skeleton-available define-abbrev "while" "" python-skeleton-while :system t put no-self-insert] 7)
#@528 Insert while statement.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'python-skeleton-while #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new ("Condition: " "while " str ":" n > _ n '(python-skeleton--else) | ^)] 4 (#$ . 77850) "*P\nP"])
(byte-code "\302\303\304\305\306\307&\210\305	B\310\305\311\307#\207" [python-mode-abbrev-table python-skeleton-available define-abbrev "for" "" python-skeleton-for :system t put no-self-insert] 7)
#@526 Insert for statement.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'python-skeleton-for #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new ("Iteration spec: " "for " str ":" n > _ n '(python-skeleton--else) | ^)] 4 (#$ . 78782) "*P\nP"])
(byte-code "\302\303\304\305\306\307&\210\305	B\310\305\311\307#\207" [python-mode-abbrev-table python-skeleton-available define-abbrev "try" "" python-skeleton-try :system t put no-self-insert] 7)
#@526 Insert try statement.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'python-skeleton-try #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new (nil "try:" n > _ n ("Exception, %s: " < "except " str ":" n > _ n nil) resume: '(python-skeleton--except) '(python-skeleton--else) '(python-skeleton--finally) | ^)] 4 (#$ . 79713) "*P\nP"])
(byte-code "\302\303\304\305\306\307&\210\305	B\310\305\311\307#\207" [python-mode-abbrev-table python-skeleton-available define-abbrev "def" "" python-skeleton-def :system t put no-self-insert] 7)
#@526 Insert def statement.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'python-skeleton-def #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new ("Function name: " "def " str "(" ("Parameter, %s: " (unless (equal 40 (char-before)) ", ") str) "):" n "\"\"\"" - "\"\"\"" n > _ n)] 4 (#$ . 80736) "*P\nP"])
(byte-code "\302\303\304\305\306\307&\210\305	B\310\305\311\307#\207" [python-mode-abbrev-table python-skeleton-available define-abbrev "class" "" python-skeleton-class :system t put no-self-insert] 7)
#@528 Insert class statement.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'python-skeleton-class #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new ("Class name: " "class " str "(" ("Inheritance, %s: " (unless (equal 40 (char-before)) ", ") str) & ")" | -2 ":" n "\"\"\"" - "\"\"\"" n > _ n)] 4 (#$ . 81731) "*P\nP"])
#@43 Add menu items to Python->Skeletons menu.
(defalias 'python-skeleton-add-menu-items #[nil "\305\306\"\307\211\307\211\2052\f@\310\307\311\312\313\314\315\316\317!\320\"AA@\"\321BB\"#\210\fA\211\204\307,\207" [python-skeleton-available items skeletons skeleton --dolist-tail-- sort string< nil easy-menu-add-item ("Python" "Skeletons") apply vector format "Insert %s" split-string symbol-name "-" (t)] 11 (#$ . 82535)])
(byte-code "\300\301\302\303\304\305\306\307&\210\300\310\311\312\304\305\306\307&\207" [custom-declare-variable python-ffap-setup-code "def __FFAP_get_module_path(module):\n    try:\n        import os\n        path = __import__(module).__file__\n        if path[-4:] == '.pyc' and os.path.exists(path[0:-1]):\n            path = path[:-1]\n        return path\n    except:\n        return ''" "Python code to get a module path." :type string :group python python-ffap-string-code "__FFAP_get_module_path('''%s''')\n" "Python code used to get a string with the path of a module."] 8)
#@54 Function for `ffap-alist' to return path for MODULE.
(defalias 'python-ffap-module-path #[(module) "\305=\203\f\306p!\206\307 \211\205%\310\311\n\"	\"\211\205$\312\f\313\314#))\207" [major-mode process python-ffap-string-code module module-file inferior-python-mode get-buffer-process python-shell-get-process python-shell-send-string-no-output format substring-no-properties 1 -1] 5 (#$ . 83558)])
(byte-code "\300\301\302\"\210\303\304\305\306\307\310\311\312&\210\303\313\314\315\307\310\311\312&\207" [eval-after-load "ffap" (progn (push '(python-mode . python-ffap-module-path) ffap-alist) (push '(inferior-python-mode . python-ffap-module-path) ffap-alist)) custom-declare-variable python-check-command "pyflakes" "Command used to check a Python file." :type string :group python python-check-buffer-name "*Python check: %s*" "Buffer name used for check commands."] 8)
#@15 Internal use.
(defvar python-check-custom-command nil (#$ . 84450))
#@150 Check a Python file (default current buffer's file).
Runs COMMAND, a shell command, as if by `compile'.  See
`python-check-command' for the default.
(defalias 'python-check #[(command) "\305\n?\306\"\210\307 \310 \311\306\312#*\207" [command python-check-custom-command compilation-ask-about-save exec-path process-environment save-some-buffers nil python-shell-calculate-process-environment python-shell-calculate-exec-path compilation-start #[(mode-name) "\302	\"\207" [python-check-buffer-name command format] 3]] 4 (#$ . 84525) (list (read-string "Check command: " (or python-check-custom-command (concat python-check-command " " (shell-quote-argument (or (let ((name (buffer-file-name))) (and name (file-name-nondirectory name))) ""))))))])
(byte-code "\300\301\302\303\304\305\306\307&\210\300\310\311\312\304\305\306\307&\207" [custom-declare-variable python-eldoc-setup-code "def __PYDOC_get_help(obj):\n    try:\n        import inspect\n        if hasattr(obj, 'startswith'):\n            obj = eval(obj, globals())\n        doc = inspect.getdoc(obj)\n        if not doc and callable(obj):\n            target = None\n            if inspect.isclass(obj) and hasattr(obj, '__init__'):\n                target = obj.__init__\n                objtype = 'class'\n            else:\n                target = obj\n                objtype = 'def'\n            if target:\n                args = inspect.formatargspec(\n                    *inspect.getargspec(target)\n                )\n                name = obj.__name__\n                doc = '{objtype} {name}{args}'.format(\n                    objtype=objtype, name=name, args=args\n                )\n        else:\n            doc = doc.splitlines()[0]\n    except:\n        doc = ''\n    try:\n        exec('print doc')\n    except SyntaxError:\n        print(doc)" "Python code to setup documentation retrieval." :type string :group python python-eldoc-string-code "__PYDOC_get_help('''%s''')\n" "Python code used to get a string with the documentation of an object."] 8)
#@227 Internal implementation to get documentation at point.
If not FORCE-INPUT is passed then what
`python-info-current-symbol' returns will be used.  If not
FORCE-PROCESS is passed what `python-shell-get-process' returns
is used.
(defalias 'python-eldoc--get-doc-at-point #[(&optional force-input force-process) "\206\305 \211\204\306\307!\202%\n\206\310\311!\211\205$\312\313\f\"	\"))\207" [force-process process force-input input python-eldoc-string-code python-shell-get-process error "Eldoc needs an inferior Python process running" python-info-current-symbol t python-shell-send-string-no-output format] 5 (#$ . 86574)])
#@202 `eldoc-documentation-function' for Python.
For this to work the best as possible you should call
`python-shell-send-buffer' from time to time so context in
inferior python process is updated properly.
(defalias 'python-eldoc-function #[nil "\300 \207" [python-eldoc--get-doc-at-point] 1 (#$ . 87215)])
#@68 Get help on SYMBOL using `help'.
Interactively, prompt for symbol.
(defalias 'python-eldoc-at-point #[(symbol) "\301\302!!\207" [symbol message python-eldoc--get-doc-at-point] 3 (#$ . 87523) (let ((symbol (python-info-current-symbol t)) (enable-recursive-minibuffers t)) (list (read-string (if symbol (format "Describe symbol (default %s): " symbol) "Describe symbol: ") nil nil symbol)))])
(add-to-list 'debug-ignored-errors "^Eldoc needs an inferior Python process running.")
#@53 Python mode's `imenu-prev-index-position-function'.
(defalias 'python-imenu-prev-index-position #[nil "\302\303	\302\304#\211\203\305 \203\205\305 \205\306 )\207" [found python-nav-beginning-of-defun-regexp nil re-search-backward t python-info-looking-at-beginning-of-defun python-info-current-defun] 4 (#$ . 88008)])
#@277 Return name of surrounding function with Python compatible dotty syntax.
Optional argument INCLUDE-TYPE indicates to include the type of the defun.
This function is compatible to be used as
`add-log-current-defun-function' since it returns nil if point is
not inside a defun.
(defalias 'python-info-current-defun #[(&optional include-type) "\214~\210\212\306\210\307\310 `\311\307\211\312\313\215\210
\205*\205$\314\315\"\316\317
\320#P.\207" [type last-indent first-run starting-pos starting-indentation names 1 nil current-indentation t exit (byte-code "\306\307!\203\250\310 \311\216	\203\312 	W\205^\n\2033\212\313b\210\314 \210\315\307!\210\f\316\317
!+\206^\212\312 \\W\203H\202\\\320 \210`\312 Y\203Z\312 T\202[\321\\*W*\203\231\310 \322\216\312 *\203u\203\200\323\307!B\202\231\324\323\321!!\211@\211A@)B)\312 \321U\203\325\326\316\"\210\202\313\207" [save-match-data-internal last-indent first-run starting-pos python-nav-beginning-of-defun-regexp regexp python-nav-beginning-of-defun 1 match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) current-indentation nil python-nav-beginning-of-statement beginning-of-line t looking-at python-nav-end-of-defun 0 ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) match-string-no-properties split-string throw exit inhibit-changing-match-data python-indent-offset min-indent starting-indentation include-type type names match x] 5) format "%s " mapconcat identity "."] 6 (#$ . 88344)])
#@124 Return current symbol using dotty syntax.
With optional argument REPLACE-SELF convert "self" to current
parent defun name.
(defalias 'python-info-current-symbol #[(&optional replace-self) "\306\307 8?\205 \310 p\311\216\312\n!\210\313 \211\205\314\315!!,\211\205K
\204-\f\202K\316 \211\2049\f\202J\317\320\321\322\323\324\325\"!\326#\326P\f#))\207" [#1=#:buffer #2=#:table python-dotty-syntax-table sym name replace-self 8 syntax-ppss syntax-table ((byte-code "rq\210\302	!\210)\302\207" [#1# #2# set-syntax-table] 2)) set-syntax-table symbol-at-point substring-no-properties symbol-name python-info-current-defun replace-regexp-in-string "^\\<self\\>\\." mapconcat identity butlast split-string "\\." "." current-defun] 9 (#$ . 89937)])
#@52 Return non-nil if current statement opens a block.
(defalias 'python-info-statement-starts-block-p #[nil "\212\300 \210\301\302!)\207" [python-nav-beginning-of-statement looking-at "\\_<\\(?:\\(?:class\\|def\\|e\\(?:l\\(?:if\\|se\\)\\|xcept\\)\\|f\\(?:inally\\|or\\)\\|if\\|try\\|w\\(?:hile\\|ith\\)\\)\\)\\_>"] 2 (#$ . 90699)])
#@45 Return non-nil if point is at end of block.
(defalias 'python-info-statement-ends-block-p #[nil "\212\302 )\212\303 )\211\205\205	U*\207" [end-of-statement-pos end-of-block-pos python-nav-end-of-block python-nav-end-of-statement] 3 (#$ . 91034)])
#@55 Return non-nil if point is at beginning of statement.
(defalias 'python-info-beginning-of-statement-p #[nil "`\212\300 \210`)U\207" [python-nav-beginning-of-statement] 2 (#$ . 91295)])
#@49 Return non-nil if point is at end of statement.
(defalias 'python-info-end-of-statement-p #[nil "`\212\300 \210`)U\207" [python-nav-end-of-statement] 2 (#$ . 91486)])
#@51 Return non-nil if point is at beginning of block.
(defalias 'python-info-beginning-of-block-p #[nil "\300 \205\301 \207" [python-info-beginning-of-statement-p python-info-statement-starts-block-p] 1 (#$ . 91659)])
#@45 Return non-nil if point is at end of block.
(defalias 'python-info-end-of-block-p #[nil "\300 \205\301 \207" [python-info-end-of-statement-p python-info-statement-ends-block-p] 1 (#$ . 91881)])
#@56 Return the point of the block the current line closes.
(defalias 'python-info-closing-block #[nil "\212\303 \210\304 )\305 \211\n\235\205~\212\306y\210\305 V\203*o\204*\303 \204*\306y\204\303 \210\305 \232\2048\307\202}	\310\230\203J\304 \311\235\205}\312 \202}	\313\230\203\\\304 \314\235\205}\312 \202}	\315\230\203n\304 \316\235\205}\312 \202}	\317\230\205}\304 \320\235\205}\312 )*\207" [indentation closing-word python-indent-dedenters back-to-indentation current-word current-indentation -1 nil "elif" ("if" "elif") point-marker "else" ("if" "elif" "except" "for" "while") "except" ("try") "finally" ("except" "else")] 3 (#$ . 92083)])
#@177 Message the contents of the block the current line closes.
With optional argument CLOSING-BLOCK-POINT use that instead of
recalculating it calling `python-info-closing-block'.
(defalias 'python-info-closing-block-message #[(&optional closing-block-point) "\206\302 \211\205\214~\210\303\304\212	b\210\305 \210`\306 {)\"))\207" [closing-block-point point python-info-closing-block message "Closes %s" back-to-indentation line-end-position] 5 (#$ . 92755)])
#@114 Return non-nil if current line ends with backslash.
With optional argument LINE-NUMBER, check that line instead.
(defalias 'python-info-line-ends-backslash-p #[(&optional line-number) "\212\214~\210\203\f\301!\210m\204*\302 b\203*\303\304!\203*`Sf\305\232\204*\306y\210\202\f`Sf\305\232\2054\307 *\207" [line-number python-util-goto-line line-end-position python-syntax-context paren 92 1 point-marker] 2 (#$ . 93224)])
#@123 Return the point where the backslashed line start.
Optional argument LINE-NUMBER forces the line number to check against.
(defalias 'python-info-beginning-of-backslash #[(&optional line-number) "\212\214~\210\203\f\301!\210\302 \205(\212\303 b\210\304\305!)\203#\306y\210\202\307 \210\310 *\207" [line-number python-util-goto-line python-info-line-ends-backslash-p line-beginning-position python-syntax-context paren -1 back-to-indentation point-marker] 2 (#$ . 93660)])
#@144 Check if current line is continuation of another.
When current line is continuation of another return the point
where the continued line ends.
(defalias 'python-info-continuation-line-p #[nil "\212\214~\210\303 \210\304 \305 \205\306!\307\232\203$\310\311!\210\312 \202K\313\235\2035\nb\210\310 \210\314 \202K\303 \210\310\311!\210	S\305 \232\205K\315 \205K\312 -\207" [context-type line-start context-start back-to-indentation python-syntax-context-type line-number-at-pos python-syntax-context paren python-util-forward-comment -1 point-marker (string comment) python-info-continuation-line-p python-info-line-ends-backslash-p] 2 (#$ . 94145)])
#@62 Return non-nil if current line is a continuation of a block.
(defalias 'python-info-block-continuation-line-p #[nil "\212\300 \205\301y\210\302 \210\303\304!\205\305 )\207" [python-info-continuation-line-p -1 back-to-indentation looking-at "\\_<\\(?:\\(?:class\\|def\\|e\\(?:l\\(?:if\\|se\\)\\|xcept\\)\\|f\\(?:inally\\|or\\)\\|if\\|try\\|w\\(?:hile\\|ith\\)\\)\\)\\_>" point-marker] 2 (#$ . 94813)])
#@193 Check if current line is a continuation of an assignment.
When current line is continuation of another with an assignment
return the point of the first non-blank character after the
operator.
(defalias 'python-info-assignment-continuation-line-p #[nil "\212\300 \205(\301y\210\302 \210\303\304!?\205(\305\306\307 \310#\205(\311 ?\205(\312\313!\210\314 )\207" [python-info-continuation-line-p -1 back-to-indentation looking-at "\\_<\\(?:\\(?:class\\|def\\|e\\(?:l\\(?:if\\|se\\)\\|xcept\\)\\|f\\(?:inally\\|or\\)\\|if\\|try\\|w\\(?:hile\\|ith\\)\\)\\)\\_>" re-search-forward "[^-%&*+/<->^|~]\\(?:\\(?:\\*\\*\\|//\\|<<\\|>>\\|[%&*+/|^-]\\)?=\\)[^-%&*+/<->^|~]" line-end-position t python-syntax-context-type skip-syntax-forward " " point-marker] 4 (#$ . 95225)])
#@62 Check if point is at `beginning-of-defun' using SYNTAX-PPSS.
(defalias 'python-info-looking-at-beginning-of-defun #[(&optional syntax-ppss) "\302\206\300 !?\205\212\303\304!\210\305	!)\207" [syntax-ppss python-nav-beginning-of-defun-regexp python-syntax-context-type beginning-of-line 1 looking-at] 2 (#$ . 95996)])
#@42 Check if current line is a comment line.
(defalias 'python-info-current-line-comment-p #[nil "\300\301 \302 \\f\206\303\304\"\207" [char-equal line-beginning-position current-indentation 95 35] 3 (#$ . 96323)])
#@54 Check if current line is empty, ignoring whitespace.
(defalias 'python-info-current-line-empty-p #[nil "\212\300\301!\210\302\303!\210\304\301!\305\230)\207" [beginning-of-line 1 looking-at "^[[:space:]]*\\(.*\\)[[:space:]]*$" match-string-no-properties ""] 2 (#$ . 96542)])
#@28 Move point to LINE-NUMBER.
(defalias 'python-util-goto-line #[(line-number) "eb\210Sy\207" [line-number] 1 (#$ . 96823)])
#@121 Clone local variables from FROM-BUFFER.
Optional argument REGEXP selects variables to clone and defaults
to "^python-".
(defalias 'python-util-clone-local-variables #[(from-buffer &optional regexp) "\301\302\303!\"\207" [from-buffer mapc #[(pair) "@9\205\302	\206\f\303\304@!\"\205\305@!AL\207" [pair regexp string-match "^python-" symbol-name make-local-variable] 4] buffer-local-variables] 4 (#$ . 96953)])
#@114 Python mode specific version of `forward-comment'.
Optional argument DIRECTION defines the direction to move to.
(defalias 'python-util-forward-comment #[(&optional direction) "\303\304!\206\305\305W\203\306\202\307\211\203\nb\210\310	!*\207" [direction factor comment-start python-syntax-context comment 0 -99999 99999 forward-comment] 4 (#$ . 97379)])
(byte-code "\300\301N\204\302\300\301\303\304!#\210\305\306!\204\302\306\307\310#\210\300\207" [python-mode-hook variable-documentation put purecopy "Hook run when entering Python mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp python-mode-map definition-name python-mode] 5)
(defvar python-mode-map (make-sparse-keymap))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\305\306!\204\302\306\307\310#\210\300\207" [python-mode-map variable-documentation put purecopy "Keymap for `python-mode'." boundp python-mode-syntax-table definition-name python-mode] 5)
(defvar python-mode-syntax-table (make-syntax-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\207" [python-mode-syntax-table variable-documentation put purecopy "Syntax table for `python-mode'." python-mode-abbrev-table definition-name python-mode] 5)
(defvar python-mode-abbrev-table (progn (define-abbrev-table 'python-mode-abbrev-table nil) python-mode-abbrev-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\207" [python-mode-abbrev-table variable-documentation put purecopy "Abbrev table for `python-mode'." python-mode derived-mode-parent prog-mode] 5)
#@141 Major mode for editing Python files.

\{python-mode-map}
Entry to this mode calls the value of `python-mode-hook'
if that value is non-nil.
(defalias 'python-mode #[nil "\306\300!\210\307\310 \210\311\312\310\313N\203\314\311\313\310\313N#\210\315!\204'\316\317 \"\210\320\f!\211\2036
\321 =\203<\322\f\323 \"\210)\324@\325\"\204V@A=\204V\326@\325AC#\210\327!\210\330\f!\210@A\306\331!\210\332\306\333!\210\334\306\335!\210\336\306\337!\210\340\306\341!\210\307!\306\342!\210\307\"\306\343!\210\344#\306\345!\210\346%\306\347!\210B'\306\350!\210\351(\306\352!\210\353*\306\354!\210\355,\306\356!\210\357.\306\360!\210\3610\306\362!\210\3632\364\365\366\334\367$\210\364\370\371\334\367$\210\306\372!\210\373:\306\374!\210\375<\306\376!\210\373>\364\377\373\334\307$\210\306\201C!\210\201JC\306\201D!\210\201KD\201L\201M\311\201N\334\201O\201P\201QBBBBB\"\210\306\201E!\210\307E\306\201F!\210\201RF\306\201G!\210\201SG\306\201H!\210\201TH\201U \210\306\201V!\210I\203f
\201I \210)\201W\201X!\207" [delay-mode-hooks major-mode mode-name python-mode-map python-mode-syntax-table parent make-local-variable t prog-mode python-mode "Python" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table abbrev-table-get :parents abbrev-table-put use-local-map set-syntax-table tab-width 8 indent-tabs-mode nil comment-start "# " comment-start-skip "#+\\s-*" parse-sexp-lookup-properties parse-sexp-ignore-comments forward-sexp-function python-nav-forward-sexp font-lock-defaults (python-font-lock-keywords nil nil nil nil) syntax-propertize-function indent-line-function python-indent-line-function indent-region-function python-indent-region paragraph-start "\\s-*$" fill-paragraph-function python-fill-paragraph beginning-of-defun-function python-nav-beginning-of-defun end-of-defun-function python-nav-end-of-defun add-hook completion-at-point-functions python-completion-complete-at-point local post-self-insert-hook python-indent-post-self-insert-function imenu-extract-index-name-function python-info-current-defun imenu-prev-index-position-function python-imenu-prev-index-position add-log-current-defun-function which-func-functions python-mode-abbrev-table local-abbrev-table python-syntax-propertize-function skeleton-further-elements eldoc-documentation-function mode-require-final-newline outline-regexp outline-heading-end-regexp outline-level python-indent-guess-indent-offset ((abbrev-mode nil) (< '(backward-delete-char-untabify (min python-indent-offset (current-column)))) (^ '(- (1+ (current-indentation))))) python-eldoc-function add-to-list hs-special-modes-alist "^\\s-*\\(?:def\\|class\\)\\>" "#" #[(arg) "\300 \207" [python-nav-end-of-defun] 1] (nil) "[[:space:]]*\\_<\\(?:\\(?:class\\|def\\|e\\(?:l\\(?:if\\|se\\)\\|xcept\\)\\|f\\(?:inally\\|or\\)\\|if\\|try\\|w\\(?:hile\\|ith\\)\\)\\)\\_>" ":\\s-*\n" #[nil "\301 \245T\207" [python-indent-offset current-indentation] 2 "`outline-level' function for Python mode."] python-skeleton-add-menu-items python-shell-internal-buffer run-mode-hooks python-mode-hook] 9 (#$ . 99034) nil])
(provide 'python)