Recent changes to feature-requests

symbol description and other features from python.el

Emin Martinian — Fri, 23 Mar 2007 20:03:26 -0000

Would it be possible to merge some of the features from python.el such as symbol description (C-c C-f) into python-model.el?

Is python-mode.el still being actively developed or is python.el the active version?

Thanks,
-Emin

Hungry delete

Rebecca Breu — Wed, 27 Sep 2006 09:24:47 -0000

I really love the hungry-delete feature of Emacs'
c-mode. It would be great to have hungry-delete for
python-mode as well.

IronPython

Anonymous — Wed, 23 Aug 2006 15:58:53 -0000

Is there any way to add IronPython to the mix? It
already has jpython. I tried to change Jpython ref with
ironpython, but the whole thing just hangs up.
Visual Studio is good IDE, but, I am so used to xemacs,
I would love to have this.

PySharp for Xemcs anyone?

Mark decorator when marking function

Michael Kleehammer — Tue, 28 Mar 2006 14:03:18 -0000

I often mark a function to move it and I need to take
the decorators with it. Perhaps it would make sense
for py-beginning-of-def-or-class to automatically
include decorators.

Spell-check comments

Anonymous — Wed, 08 Feb 2006 21:56:31 -0000

Would be kinda cool if you could spell-check the
comments in your code (oughta mostly be in the
author's primary language) but leave the program
text alone (too many false positives). Any idea
if other prog modes in Emacs do this already?

'cls' deserves pseudo-keyword status, same as 'self'

szplug — Tue, 04 Oct 2005 17:20:57 -0000

It's a quick and easy addition, but, 'cls' should be a
pseudo-keyword too since it is the convention for the
class argument for class methods, like 'self' is the
convention for the instance argument with instance
methods. Eg,

class Foo(object):
def summat(cls, x):
.....
summat = classmethod(summat)

....

Special handling of private names

Anonymous — Wed, 14 Sep 2005 09:32:46 -0000

At least for me, seeing code like

class Foo:

def __private(self):
frob()

def another_method(self)

class Bar:

def __init__(self):
self.foo = Foo()

...

def some_method:
...
self.foo.__private(self.__frobval)

looks ugly (I mean the part in some_method()). If
requested,
it would be more nice if two leading underscores were
not shown
in methods and vars, but they would be colored
differently. This wouldn't
need to be default, but rather taken into use by

(setq py-mangle-private-names t
private-name-color "#0040fc") ;; norwegian
blue :)

edvard@majakari.net

autodetection of python shell

Jonas Kölker — Fri, 10 Jun 2005 12:30:28 -0000

(See also 783259, regarding more flexible python shell
selection.)

I propose that at appropriate times (*), the default
python shell is (re-)determined according to the
sha-bang line.

(*) Suggestions: on file load, on first shell
invocation, on each interactive invocation.

Example of the behaviour I would like:
On loading a file beginning with `#!/usr/bin/env
python2.4', the (default) python shell is set to
`python2.4' (no path information)

On loading a file beginning with
"#!/path/to/my/custom/app", my custom app (with full
path info) is the default shell.

On invoking the shell the first time in a freshly
created file, the sha-bang line is examined and
suggested as a default shell.

(for all cases: if not has sha-bang line: use current
default)

---

I know I'm being a bit vague (sorry); my agenda is
provoking a discussion of the idea (so I'll know what
to implement, diff and submit), not getting a
yes-or-no-p answer.

--Jonas

Determining the current class

ytrewq1 — Thu, 06 Jan 2005 06:32:30 -0000

I'd like some way to easily determine the class that
the Emacs point is in. I looked for a way but didn't
find anything relevant.

For the moment, I've put together something that
attempts to determine the current class and display it
via the echo area. Code follows:

(defun py-show-current-class ()
(interactive)
(save-excursion
(let ((class-name nil))
(if (py-go-up-tree-to-keyword "class")
(setq class-name (py-current-defun))
(setq class-name "None determined"))
(message (format "Current class: %s" class-name)))))

P.S. I thought of working with which-function-mode, but
the mode line seems too crowded already.

Indentation cycling, in the style of emacs haskell-mode

John Fouhy — Thu, 15 Jul 2004 03:59:50 -0000

Currently, <tab> indents to the deepest valid level.
This is not always desirable.

The haskell functional programming language also uses
indentation to mean stuff. The emacs haskell mode
deals with this by having the <tab> key cycle through
the various possible indentations.

I think this would be a really groovy feature :-)

example:

def foo(x, y):
if x > y:
print 'Zow!'
|

The cursor is now at the position indicated by |. What
I'd like is for <tab> to move the cursor back 4 chars,
to the next-innermost valid indentation. A second
<tab> would move the cursor back again, to the
outermost valid indentation. A third <tab> would start
the cycle again, moving the cursor to the innermost level.

This is an improvement which would definitely enhance
my python-programming experience.