Mucking with the calling scripts namespace (For a good reason, honest!)

[Doug Rosser]

Thank you for your help Larry. Let me see if I've got this straight:

1. Python doesn't provide an obvious way to modify the __main__
namespace. You can peek at values with "global" but you can't treat it
like a dictionary at runtime.

2. If you need to access objects that won't have names until run-time
(but you incidentally -KNOW- their names and want to reference them in
a bit of code), encapsulate them in a container. This effectively
creates a new not-really namespace, as the objects in the container
become attributes.

Well, all-in-all, I'd really still rather have #1, but I can live with
#2.

da rosser
-- We are the music makers, and we are the dreamers of dreams --

"Larry Bates" <lbates at swamisoft.com> wrote in message news:<rJudnRiTPvRB8JPcRVn-gw at comcast.com>...
> I would suggest following:
> 
> 1) Change the config file into proper format for
> ConfigParser module.
> 
> [server_001]
> hostname=alpha
> os=posix
> 
> [server_002]
> hostname=beta
> os=win
> 
> [client_001]
> hostname=ichi
> os=posix
> 
> [client_002]
> hostname=ni
> os=posix
> 
> This makes it easy to define up to 999 servers and
> 999 clients (just make the counter longer if you
> require more).
> 
> 2) Create classes to hold information/methods that
> will work on each server/client.
> 
> class server:
>     def __init__(self, server_id, name, os):
>         self.id=server_id
>         self.name=name
>         self.os=os
>         return
> 
>     def dosomething(self):
>         #
>         # Insert code here to do something on this
>         # server.
>         #
>         return
> 
> 3) Create class to hold servers/clients (I'll leave
> the one to handle clients to you).
> 
> class servers:
>     def __init__(self, INI):
>         #
>         # Create an index pointer for next method
>         #
>         self.next_index=0
>         #
>         # Create a list to hold server names
>         #
>         self.names=[]
>         serverlist=[x for x in INI.sections if
> INI.sections.beginswith('server')]
>         serverlist.sort()  # If you want to keep them in order
>         #
>         # Loop over each server entry
>         #
>         for server_id in serverlist:
>             name=INI.get(server_id, 'name')
>             os=INI.get(server_id, 'os')
>             self.append(id, name, os)
> 
>         return
> 
>     def append(self, server_id, name, os):
>         #
>         # Create server instance and append to list of servers
>         #
>         self.names.append(server_id)
>         self.__dict__[name]=server(server_id, name, os)
>         return
> 
>     def __iter__(self):
>         return self
> 
>     def next(self):
>         #
>         # Try to get the next route
>         #
>         try: SERVER=self.names[self.next_index]
>         except:
>             self.next_index=0
>             raise StopIteration
>         #
>         # Increment the index pointer for the next call
>         #
>         self.next_index+=1
>         return SERVER
> 
> In your programt do something like:
> 
> import ConfigParser
> 
> INI=ConfigParser.ConfigParser()
> INI.read(inifilepath)
> 
> SERVERS=servers(INI)
> 
> Now you can access
> 
> SERVERS.server_001.name
> SERVERS.server_001.os
> 
> or call methods via
> 
> SERVERS.server_001.dosomething()
> 
> or you can easily loop over them
> 
> for SERVER in SERVERS:
>     SERVER.dosomething()
> 
> or
> 
> print SERVERS.names
> 
> Code not tested, but I hope it helps.
> 
> Larry Bates
> Syscon, Inc.
> 
> 
> 
> "Doug Rosser" <da_rosser at yahoo.com> wrote in message
> news:e08cd05f.0408020727.15ce4356 at posting.google.com...
> > I'm writing a fairly complicated test framework and keeping
> > configuration data inside ini files that are parsed at runtime by the
> > ConfigParser module.
> >
> > For example, there would be a section similar to the following
> >
> > [servers]
> > server1:{'hostname':'alpha','os':'posix'}
> > server2:{'hostname':'beta','os':'win'}
> >
> > [clients]
> > client1:{'hostname':'ichi','os':'posix'}
> > client2:{'hostname':'ni','os':'posix'}
> >
> > As I read the configuration file, I don't actually create instances,
> > but use the data to check "what's out there" to make sure the physical
> > network environment has the bits and pieces required to run a
> > particular test. This is a sort of "go/no-go" resource check.
> >
> > Assuming that everything is correct with the physical network
> > environment, I want my testers to be able to refer to these resources
> > in their python scripts by the names in the ini file, like so:
> >
> > myTest.checkResources() # Read the config file and associate names
> > with real
> >                         # life instances
> >
> > server1.doSomething()   # Note how I have cleverly saved myself from
> > declaring
> >                         # "server1" because the module myTest has
> > inserted
> >                         # it into the right namespace :-)
> >
> > Down to business: How do I write a module that can insert these names
> > into the calling script's namespace at runtime? Is this even possible
> > in Python?
> >
> > da rosser
> > -- We are the music makers, and we are the dreamers of dreams --