diff -ur python-mode-1.0/pycomplete.el python-mode-1.0+/pycomplete.el
--- python-mode-1.0/pycomplete.el	2005-12-02 11:30:11.000000000 -0500
+++ python-mode-1.0+/pycomplete.el	2008-02-01 22:22:01.000000000 -0500
@@ -1,36 +1,45 @@
 ;;; Complete symbols at point using Pymacs.
-
 ;;; See pycomplete.py for the Python side of things and a short description
 ;;; of what to expect.
 
 (require 'pymacs)
 (require 'python-mode)
 
-(pymacs-load "pycomplete")
+(pymacs-load "/home/jj/Projects/pymacs-2.0/extensions.pycomplete")
+
+;;check if prev character is blank-type
+(defun char-before-blank ()
+  (save-excursion
+  (forward-char -1)
+  (looking-at "[\n\t\r]")))
 
 (defun py-complete ()
   (interactive)
-  (let ((pymacs-forget-mutability t)) 
-    (insert (pycomplete-pycomplete (py-symbol-near-point)
-				   (py-find-global-imports)))))
+  (let ((pymacs-forget-mutability t))
+    (if (and
+         (and (eolp) (not (bolp))
+         (not (char-before-blank))))
+      (insert (pycomplete-pycomplete (py-symbol-near-point) (py-find-global-imports)))
+      (indent-for-tab-command))))
 
 (defun py-find-global-imports ()
   (save-excursion
     (let (first-class-or-def imports)
       (goto-char (point-min))
       (setq first-class-or-def
-	    (re-search-forward "^ *\\(def\\|class\\) " nil t))
+        (re-search-forward "^ *\\(def\\|class\\) " nil t))
       (goto-char (point-min))
       (setq imports nil)
       (while (re-search-forward
-	      "^\\(import \\|from \\([A-Za-z_][A-Za-z_0-9]*\\) import \\).*"
-	      nil t)
-	(setq imports (append imports
-			      (list (buffer-substring
-				     (match-beginning 0)
-				     (match-end 0))))))
+          "\\(import \\|from \\([A-Za-z_][A-Za-z_0-9\\.]*\\) import \\).*"
+          nil t)
+    (setq imports (append imports
+                  (list (buffer-substring
+                     (match-beginning 0)
+                     (match-end 0))))))
       imports)))
 
-(define-key py-mode-map "\M-\C-i"  'py-complete)
+(define-key py-mode-map "\M-\C-i" 'py-complete)
+(define-key py-mode-map "\t" 'py-complete)
 
 (provide 'pycomplete)
diff -ur python-mode-1.0/pycomplete.py python-mode-1.0+/pycomplete.py
--- python-mode-1.0/pycomplete.py	2005-12-02 11:30:11.000000000 -0500
+++ python-mode-1.0+/pycomplete.py	2008-02-01 22:22:01.000000000 -0500
@@ -1,4 +1,3 @@
-
 """
 Python dot expression completion using Pymacs.
 
@@ -6,23 +5,25 @@
 
     (require 'pycomplete)
 
-to your .xemacs/init.el file (untried w/ GNU Emacs so far) and have Pymacs
-installed, when you hit M-TAB it will try to complete the dot expression
+to your .xemacs/init.el file (.emacs for GNU Emacs) and have Pymacs
+installed, when you hit TAB it will try to complete the dot expression
 before point.  For example, given this import at the top of the file:
 
     import time
 
-typing "time.cl" then hitting M-TAB should complete "time.clock".
-
-This is unlikely to be done the way Emacs completion ought to be done, but
-it's a start.  Perhaps someone with more Emacs mojo can take this stuff and
-do it right.
+typing "time.cl" then hitting TAB should complete "time.clock".
 
 See pycomplete.el for the Emacs Lisp side of things.
 """
-
 import sys
 import os.path
+import string
+from Pymacs import lisp
+
+
+sys.path.append(".")
+
+ENABLE_GG_FUZZY_GUESS=True
 
 try:
     x = set
@@ -43,8 +44,9 @@
                 exec stmt in globals(), locald
             except TypeError:
                 raise TypeError, "invalid type: %s" % stmt
-
-    dots = s.split(".")
+            except:
+                continue
+    dots = s.split(".")
     if not s or len(dots) == 1:
         keys = set()
         keys.update(locald.keys())
@@ -60,7 +62,7 @@
 
     sym = None
     for i in range(1, len(dots)):
-        s = ".".join(dots[:i])
+        s = ".".join(dots[:i])
         try:
             sym = eval(s, globals(), locald)
         except NameError:
@@ -68,22 +70,98 @@
                 sym = __import__(s, globals(), locald, [])
             except ImportError:
                 return []
-    if sym is not None:
-        s = dots[-1]
+    if sym is not None:
+        s = dots[-1]
         return [k for k in dir(sym) if k.startswith(s)]
 
+def get_keyword_completition(s):
+    # Reserved keywords for Python 2.5
+    keywords=""" and       del       from      not       while
+as        elif      global    or        with
+assert    else      if        pass      yield
+break     except    import    print
+class     exec      in        raise
+continue  finally   is        return
+def       for       lambda    try
+"""
+    kl=keywords.split()
+
+    return [ k+" " for k in kl if k.startswith(s)]
+
+def get_common_fuzzy_completition(s):
+    result=[]
+    # Then we add  some *common* words
+    commonFuzzyWords=""" self. """
+    kl=commonFuzzyWords.split()
+    result=[ k for k in kl if k.startswith(s)]
+    if len(result)==0:
+        dottedparts=s.split(".")
+        if(len(dottedparts)>=2):
+            mx=dottedparts[1]
+            # This is a very tiny list of stuff
+            kl=""" remove( append(  join(""".split()
+            lisp.message("Hyper fuzzy extracted method:"+mx+" List:"+str(kl))
+            result=[ k for k in kl if k.startswith(mx)]
+    return result
+
+
 def pycomplete(s, imports=None):
     completions = get_all_completions(s, imports)
+
+
+    # [GG] Extension1:
+    if ENABLE_GG_FUZZY_GUESS : # and len(completions)==0:
+        #lisp.message("Trying to complete using a fuzzy guess for:"+s)
+        k2=get_keyword_completition(s)
+        k3=get_common_fuzzy_completition(s)
+        # Integrate the fuzzy guess with other completitions
+        for k in k2:
+            completions.append(k)
+        for k in k3:
+            completions.append(k)
+
+    lisp.message("DEBUG completions="+str(completions))
     dots = s.split(".")
-    return os.path.commonprefix([k[len(dots[-1]):] for k in completions])
+    result = os.path.commonprefix([k[len(dots[-1]):] for k in completions])
 
-if __name__ == "__main__":
-    print "<empty> ->", pycomplete("")
+
+    if result == "":
+        if completions:
+            width = lisp.window_width() - 2
+            colum = width / 20
+            white = "                    "
+
+            msg = ""
+
+            counter = 0
+            for completion in completions :
+                if completion.__len__() < 20 :
+                    msg += completion + white[completion.__len__():]
+                    counter += 1
+                else :
+                    msg += completion + white[completion.__len__() - 20:]
+                    counter += 2
+
+                if counter >= colum :
+                    counter = 0
+                    msg += '\n'
+
+        else:
+            msg = "no completions for:"+s
+
+
+        lisp.message(msg)
+    return  result
+
+
+
+def testPycomplete():
+    print " ->", pycomplete("")
     print "sys.get ->", pycomplete("sys.get")
     print "sy ->", pycomplete("sy")
     print "sy (sys in context) ->", pycomplete("sy", imports=["import sys"])
     print "foo. ->", pycomplete("foo.")
-    print "Enc (email * imported) ->",
+    print "Enc (email * imported) ->",
     print pycomplete("Enc", imports=["from email import *"])
     print "E (email * imported) ->",
     print pycomplete("E", imports=["from email import *"])
@@ -91,6 +169,32 @@
     print "Enc ->", pycomplete("Enc")
     print "E ->", pycomplete("E")
 
+
+def test():
+    from Pymacs import lisp,utility
+    log=utility.log
+
+    lisp.switch_to_buffer("*Messages*")
+    log.info("Testing PyComplete extension... (GG)")
+    log.info(" ->" + str(pycomplete("")))
+    log.info("sys.get ->" + str(pycomplete("sys.get")))
+    log.info("sy ->" + str(pycomplete("sy")))
+    log.info("sy (sys in context) ->" + str(pycomplete("sy", imports=["import sys"])))
+    log.info("foo. ->" + str(pycomplete("foo.")))
+    log.info("Enc (email * imported) ->" +
+             str(pycomplete("Enc" , imports=["from email import *"])))
+    log.info("E (email * imported) ->"+ str(pycomplete("E"  ,imports=["from email import *"])))
+
+    log.info("Enc ->" + str(pycomplete("Enc")))
+    log.info("E ->" + str(pycomplete("E")))
+    log.info(" Test finished")
+
+# Publish it:
+interactions = {}
+interactions[test]=''
+
+if __name__ == "__main__":
+    testPycomplete()
 # Local Variables :
 # pymacs-auto-reload : t
 # End :
