What IDE (PythonWin, Eclipse, etc.) are you using? Maybe there is some setting somewhere in the IDE? I really don't know... Sadly, I'll admit that v10 is still too buggy for my likes, so I'm still doing most of my heavy lifting in 9.3.1 still, so my knowledge of auto complete functionality in v10 is really masked by ignorance.However, here's a story though that may be enlightening. I made a hokey custom python module a long while back (called lmpy.py). It had a bunch of useful little functions in it like sending email, recursive searches, listing fields/field properties of a table, etc. It was basically set up like this:#lmpy.py
def fieldExists(table, fieldName):
"""Returns a list indicating boolean if field exists, if True also the place"""
blah
blah
def doThat(param1,param2,param3)
"""Does this, that, and the other"""
blah
blah
And when placed in the proper folder (one of the folders that sys.path references), the lmpy module works like this:>>> import lmpy
>>> lmpy.fieldExists(myTable, "FIELD1")
[True, 3]
The great thing I found, is without even trying, the thing had auto complete functionality "built in", so for example after I typed "lmpy." I got a pick list of all the functions available in the module, and upon picking one, it would tell you what the method did (that's the """" part).With v10, there is a folder: C:\Program Files\ArcGIS\Desktop10.0\arcpy\arcpy, and it is chock full of .py files that are basically what my module is... A bunch of functions that define/control the Python auto complete functionality. For example, a brief excerpt of arc.py (which references all the ArcInfo Workstation coverage tools):@gptooldoc('CollapseDualLinesToCenterline_arc', None)
def CollapseDualLinesToCenterline(in_cover=None, out_cover=None, maximum_width=None, minimum_width=None):
"""CollapseDualLinesToCenterline_arc(in_cover, out_cover, maximum_width, {minimum_width})
Derives centerlines (single lines) from dual-line features, such as road
casings, based on specified width tolerances.
INPUTS:
in_cover (Coverage):
The coverage containing near parallel dual lines, such as road casings, from
which centerlines are derived.
maximum_width (Double):
Sets the maximum width in coverage units.
minimum_width {Double}:
Sets the minimum width in coverage units. The default is zero.
OUTPUTS:
out_cover (Coverage):
The output coverage containing the derived centerlines. The output coverage name
must be different from the input coverage name."""
try:
retval = convertArcObjectToPythonObject(gp.CollapseDualLinesToCenterline_arc(*gp_fixargs((in_cover, out_cover, maximum_width, minimum_width), True)))
return retval
except Exception, e:
raise e
@gptooldoc('Dissolve_arc', None)
def Dissolve(in_cover=None, out_cover=None, dissolve_item=None, feature_type=None):
"""Dissolve_arc(in_cover, out_cover, dissolve_item, {feature_type})
Creates a new coverage by merging adjacent polygons, lines, or regions that have
the same value for a specified item.
INPUTS:
in_cover (Coverage):
The coverage containing features to be dissolved.
dissolve_item (String):
The item in the in_cover feature attribute table that is used to dissolve
features.
* Dissolve_item���?�An item name will be used to perform the dissolve. The item may
be a redefined item.
* #ALL���?�All items past the cover-ID in the PAT, AAT, or region subclass PAT will
be used as a single dissolve item. If there are no items past the cover-ID, then
the cover-ID will be used.
feature_type {String}:
The feature classes to be preserved in the output coverage:
* POLY���?�Polygons will be dissolved; an AAT will not be created for the output
coverage. This is the default option.
* LINE���?�Nodes will be dissolved; a PAT will not be created for the output
coverage.
* NET���?�Polygons will be dissolved, and both a PAT and AAT will be created for the
output coverage.
* REGION.subclass���?�Region subclass will be dissolved, and all existing attributes
of the input coverage will be maintained in the output coverage.
OUTPUTS:
out_cover (Coverage):
The coverage to be created. The output coverage cannot already exist."""
try:
retval = convertArcObjectToPythonObject(gp.Dissolve_arc(*gp_fixargs((in_cover, out_cover, dissolve_item, feature_type), True)))
return retval
except Exception, e:
raise e
@gptooldoc('Eliminate_arc', None)
def Eliminate(in_cover=None, out_cover=None, info_express=None, polygon_boundary=None, feature_type=None, selection_file=None, polygon_option=None):
"""Eliminate_arc(in_cover, out_cover, info_express;info_express..., {polygon_boundary}, {feature_type}, {selection_file}, {polygon_option})
Merges the selected polygons with neighboring polygons if they have the largest
shared border or the largest area.Eliminate is often used to remove sliver
polygons created during polygon overlay
or buffering. With the LINE option, Eliminate merges selected arcs separated by
pseudo nodes into single arcs.
INPUTS:
in_cover (Coverage):
The coverage whose selected polygons or arcs will be merged into neighboring
features.
info_express (INFO Expression):
An INFO query containing one or more logical expressions to select features from
the input coverage.
* Reselect���?�Reduces the selected set of records with a selection expression to
those that meet its criteria. If no selection expression follows, the selected
set will be empty.
* Aselect���?�Adds unselected records that meet the selection expression criteria to
the currently selected set. If no selection expression follows, the selected set
will contain all features.
* Nselect���?�Reverses the current selection to the unselected set.
polygon_boundary {Boolean}:
Ensures that polygons along the coverage boundary are not altered.
* NO_KEEP_EDGE���?�Allows the elimination of outer polygon boundaries. This is the
default.
* KEEP_EDGE���?�Is only used with the POLYGON option. Any polygon which is a
neighbor of the background polygon will not be eliminated when KEEP_EDGE is
specified.
feature_type {String}:
The feature class(es) to be eliminated in the Output Coverage. This parameter is
only used for polygon coverages.
* POLY���?�Polygon features will be eliminated; an AAT will not be created for the
Output Coverage.
* LINE���?�Line features will be eliminated; a PAT will not be created for the
Output Coverage.
selection_file {File}:
A Selection File is a preexisting file that identifies which features will be
used.
polygon_option {Boolean}:
Specifies which method will be used for eliminating polygons. This parameter is
only used for polygon coverages.
* BORDER���?�Merges a selected polygon with a neighboring unselected polygon by
dropping an Arc. The neighboring polygon is the one with the longest shared
border. This is the default and the way Eliminate worked with the POLY option in
all pre-6.1.1 releases.
* AREA���?�Merges a selected polygon with a neighboring unselected polygon by
dropping an Arc. The neighboring polygon is the one with the largest area.
OUTPUTS:
out_cover (Coverage):
The new coverage with all the selected sliver polygons merged into larger
features. There should be a smaller number of polygons than the Input Coverage
contains."""
try:
retval = convertArcObjectToPythonObject(gp.Eliminate_arc(*gp_fixargs((in_cover, out_cover, info_express, polygon_boundary, feature_type, selection_file, polygon_option), True)))
return retval
except Exception, e:
raise e
