+ Reply to Thread
Results 1 to 9 of 9

Thread: Anyone using the new Python Toolboxes at 10.1?

  1. #1
    Kevin Gooss
    Join Date
    May 2010
    Posts
    179
    Points
    15
    Answers Provided
    0


    0

    Default Anyone using the new Python Toolboxes at 10.1?

    Just wondering if anyone has used the new Python toolboxes at 10.1?
    The .pyt
    I am experimenting with one and could use some tips.
    fyi, if you want to edit that pyt file in your favorite python editor you may have to go into the options of your editor and set it up to explicitly recognize pyt files. Mine (Wing, pyScripter) did not do that by default and there was no coloring or intellisense until i modified the program under options to read that pyt.

    I want to use pyt because at 10.0 we had such a hassle with deploying script tools and toolboxes because you always need arcatalog to setup the dang params. And they seem to get out of whack on their own over time.

    I'm hoping these python-based toolboxes don't work like that.
    One drawback is that you only get the one pyt file - so if you want to cram 20 custom tools in there you are looking at a huge file.

  2. #2
    David Wynne
    Join Date
    Oct 2009
    Posts
    97
    Points
    42
    Answers Provided
    3


    1

    Default Re: Anyone using the new Python Toolboxes at 10.1?

    Hi Kevin,
    If you have a few minutes, perhaps check out the training seminar on Python toolboxes that we did last week: it will walk through some of these questions you have:
    http://training.esri.com/gateway/ind...&courseID=2523

    If you're looking for additional samples just to see, check out http://esriurl.com/pyt1, http://esriurl.com/pyt2, http://esriurl.com/pyt3

    -Dave

  3. #3
    Kevin Gooss
    Join Date
    May 2010
    Posts
    179
    Points
    15
    Answers Provided
    0


    0

    Default Re: Anyone using the new Python Toolboxes at 10.1?

    Thanks for those tips. I will look into the seminar and samples.
    My greatest concern now is that these examples are designed with one tool in one toolbox.
    I have over 30 tools that i would like to present as services for my applications.

    Running each one of those in ArcMap and publishing the results as a service is just not an option.
    It is too much work.
    I know the code works because i have been using the tools at 10.0
    I just want a painless way to expose many py scripts as services.

  4. #4
    Luke Pinner
    Join Date
    May 2010
    Posts
    317
    Points
    284
    Answers Provided
    32


    1

    Default Re: Anyone using the new Python Toolboxes at 10.1?

    I'm still using 10.0 so can't actually test this, but have you tried using the standard python package structure?

    Something like:

    Code:
    #  \--SomeDir
    #     |  toolbox.pyt
    #     \--toolpackage
    #        |  __init__.py
    #        |  script_a.py
    #        |  script_b.py
    
    
    #----------------------------
    #The .pyt file
    #----------------------------
    
    import arcpy
    from toolpackage.script_a import Tool1
    from toolpackage.script_a import Tool2
    from toolpackage.script_b import Tool3
    
    class Toolbox(object):
        def __init__(self):
            """Define the toolbox (the name of the toolbox is the name of the
            .pyt file)."""
            self.label = "MultiTool_Toolbox"
            self.alias = "Toolbox with Multiple Tools"
    
            # List of tool classes associated with this toolbox
            self.tools = [Tool1, Tool2, Tool3]
    Last edited by lpinner; 09-05-2012 at 04:55 PM.

  5. #5
    Kevin Gooss
    Join Date
    May 2010
    Posts
    179
    Points
    15
    Answers Provided
    0


    0

    Default Re: Anyone using the new Python Toolboxes at 10.1?

    I think i get what you are saying.
    In my master pyt python toolbox file i just have the definitions of the tools and the params for each.
    Each tool has an execute method and in that method i will just place a link to the actual py script file that i already have from pre-10.1 days. I think that will work, but i may have to add a path to the environ variable so python knows where to look for my scripts.

    Hopefully this will let me keep my 10.0 py scripts intact and i can better manage the params using the 10.1 pyt structure.

    One thing about 10.1 - we are spending alot of time figuring out where ags puts things during a publish and then trying to rig things to work better than that.

    thanks for the tip.

  6. #6
    Luke Pinner
    Join Date
    May 2010
    Posts
    317
    Points
    284
    Answers Provided
    32


    1

    Default Re: Anyone using the new Python Toolboxes at 10.1?

    If you didn't want to modify your existing script tools to convert them to classes, then you could do that (calling your scripts from the execute method of each Tool class). I was thinking more of just converting the scripts to classes though, especially if you're writing stubs for those classes anyway.

    How you could do it depends on how you've written your scripts. If your existing 10.0 scripts are basic scripts where all the code is in the top-level scope, then in the execute method of the new Tool class you could use the subprocess module to call python and pass it the path to the 10.0 script. If your 10.0 scripts are organised into functions, you might be able to do something like:

    Code:
    #----------------
    # 10.0 script tool
    # script_10_0.py
    #----------------
    import arcpy
    def do_some_stuff(arg1,arg2):
        print arg1,arg2
    
    if __name__ == '__main__':
        arg1=arcpy.GetParameterAsText(0)
        arg2=arcpy.GetParameterAsText(1)
        do_some_stuff(arg1,arg2)
    
    #----------------------
    # 10.1 Python Toolbox
    #----------------------
    import arcpy
    import script_10_0 #import the old 10.0 script tool so you can call its functions.
    
    class Toolbox(object):
        def __init__(self):
            """Define the toolbox (the name of the toolbox is the name of the
            .pyt file)."""
            self.label = "10_0_Tool_Toolbox"
            self.alias = "Toolbox with 10.0 Tools"
    
            # List of tool classes associated with this toolbox
            self.tools = [Tool1]
    
    class Tool1(object):
        #...
        def execute(self, parameters, messages):
            arg1=parameters[0].valueAsText
            arg2=parameters[1].valueAsText
            script_10_0.do_some_stuff(arg1,arg2)
    Last edited by lpinner; 09-06-2012 at 05:28 PM.

  7. #7
    Kevin Gooss
    Join Date
    May 2010
    Posts
    179
    Points
    15
    Answers Provided
    0


    0

    Default Re: Anyone using the new Python Toolboxes at 10.1?

    that is pretty much what i did. For each individual py script i had i changed the signature and made a main def.
    then in the pyt i import each of those, then call the script by name.main.
    i like this because each of my scripts was pulling in a params json file. now i can pull that params file into the pyt once and dish it off to each side script.

    All that remains is for me to find a way around esri wanting me to run each script in arcmap and publish the results.
    if i could find a way to just publish the pyt once then throw the extra scripts in there and have them recognized that would be the bomb

  8. #8
    Luke Pinner
    Join Date
    May 2010
    Posts
    317
    Points
    284
    Answers Provided
    32


    0

    Default Re: Anyone using the new Python Toolboxes at 10.1?

    Quote Originally Posted by KG22 View Post
    if i could find a way to just publish the pyt once then throw the extra scripts in there and have them recognized that would be the bomb
    Something like the following might work:
    Code:
    #  \--SomeDir
    #     |  toolbox.pyt
    #     |  some_script.py
    #     |  another_script.py
    #     |  ...
    #     |  last_script.py
    #
    # Each *.py contains a class called Tool that's just a stub for your "main" def.
    
    #----------------------------
    #The .pyt file (all Tools are dynamically imported not hardcoded)
    #----------------------------
    
    import arcpy
    import os,sys,glob
    
    class Toolbox(object):
        def __init__(self):
            """Define the toolbox (the name of the toolbox is the name of the .pyt file)."""
            self.label = "MultiTool_Toolbox"
            self.alias = "Toolbox with Multiple Dynamically Imported Tools"
    
            # Dynamic list of tool classes associated with this toolbox
            path=os.path.dirname(__file__)
            self.tools=[]
            for py in glob.glob(os.path.join(path,'*.py')):
                if not __file__ in py:
                    module=os.path.basename(py)[:-3]
                    #Note: "Tool" class must have same 
                    #name as the script "Tool" classes
                    self.tools.append(__import__(module).Tool)
    
    #----------------------------
    #The .py script files
    #----------------------------
    
    #"Tool" class can be called anything but must be 
    # the same in each script and in the calling toolbox
    
    class Tool(object):
    
        # tool/parameter setup methods etc...
    
        def execute(self,*args,**kwargs):
            main(*args,**kwargs)
    
    def main(*args,**kwargs):
        #do stuff
        return
    
    if __name__=='__main__':
        #Run script
        main(sys.argv[1:])
    Last edited by lpinner; 09-07-2012 at 03:52 PM.

  9. #9
    Kevin Gooss
    Join Date
    May 2010
    Posts
    179
    Points
    15
    Answers Provided
    0


    0

    Default Re: Anyone using the new Python Toolboxes at 10.1?

    Still not where i want to be on this one unfortunately.
    I can get all the py and pyt files in order but that still doesn't get me around having to use ArcMap to create the sd file.
    And when that sd file gets published all of the sudden there are lots of new files and folders and my code is being modified by esri hand-holding.

    When i publish the sd esri's convoluted directory structure makes this:

    -GPServiceName.GPServer
    -extracted
    .GPServiceName.sd

    then in the extracted folder we have:
    -esriinfo
    -v101
    .manifest.xml
    .serviceconfiguration.json
    tilingservice.xml

    under esriinfo we have more:
    -metadata
    -thumbnail
    .iteminfo.xml

    thumbnail is just an image, the metadata folder has a file named metadata.xml

    under v101 we have:
    afoldernamedafterwhereyouputyourscripts
    GPServiceName.tbx
    GPServiceName.rlt

    the tbx and rlt are binary
    under the folder that esri creates based on your script folder you have:
    all of your py files, pyc versions for each, a param text file that i was using and esri dragged in, along with any 'helper' py files
    the pyt file for your original python toolbox
    a pyt.xml for the toolbox
    a Tool.pyt.xml for the toolbox
    pyt.xml files for each Tool in the toolbox

    Python toolboxes provide the opportunity to take advantage of your Python skills and create tools entirely and easily out of Python
    perhaps. but getting them published is a different story.

    Say i want to add a Tool to my currently published GPService? Not fun at all. I have to open my pyt, edit it, open it in ArcMap, run EVERY OTHER TOOL including my new tool and then publish?

    Certainly i'm missing some very important in this workflow.

    At ArcGIS 9.0, the script tool framework was first introduced and is geared towards creating Python-based tools for new users, but it is an inefficient process for more experienced users. In the script tool framework:
    You define parameters through the wizard
    You create validation code that lives in the toolbox
    Plus you create and maintain the source script separately
    All of these parts are segregated and more difficult to manage collectively.
    That workflow is starting to look a lot better in hindsight.

+ Reply to Thread

Posting Permissions

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts