Velocity Reviews - Computer Hardware Reviews

Velocity Reviews > Newsgroups > Programming > Python > Another form of dynamic import

Reply
Thread Tools

Another form of dynamic import

 
 
Marco Nawijn
Guest
Posts: n/a
 
      03-25-2009
Hello,

In short I would like to know if somebody knows if it is possible to
re-execute a statement that raised an exception? I will explain the
reason by providing a small introduction on why this might be nice in
my case
and some example code.

I am using the python bindings to a *very* large C++ library. About
5000 classes divided over approx. 450 different
packages are exposed through the Python interface. To reduce the
number of import statements that need to be inserted and to limit the
number of wildcard imports it would be very helpful if class names
could be automatically imported from the proper module. There is no
problem in finding out the proper module given a (valid) class name.

As an example, look at the following statement

>> aPoint = gp_Pnt(1.0, 0.0, 0.0) # Oops, this will raise a NameError, since

# gp_Pnt class
is unknown

NameError: name 'gp_Pnt' is not defined

As indicated, this will raise a NameError exception. What I would like
to do is something like the following (pseudo-code):

try:
....
....
aPoint = gp_Pnt(1.0, 0.0, 0.0) [1]

....
....
except NameError, e:

name = e.args[0].split[1]

if isValid(name):
doImport(name)
===> Can I go back to statement [1] from this point?
else:
raise e

There is no problem in catching the exception, finding out which name
is unknown to python and check if this is a valid name for my library.
My question is, is there any possibility of going back to the
statement that raised the error, re-execute the statement and
continue?

Thanks for any thoughts and suggestions.

Marco
 
Reply With Quote
 
 
 
 
Kay Schluehr
Guest
Posts: n/a
 
      03-25-2009
On 25 Mrz., 15:23, Marco Nawijn <(E-Mail Removed)> wrote:
> Hello,
>
> In short I would like to know if somebody knows if it is possible to
> re-execute a statement that raised an exception? I will explain the
> reason by providing a small introduction on why this might be nice in
> my case
> and some example code.
>
> I am using the python bindings to a *very* large C++ library. About
> 5000 classes divided over approx. 450 different
> packages are exposed through the Python interface. To reduce the
> number of import statements that need to be inserted and to limit the
> number of wildcard imports it would be very helpful if class names
> could be automatically imported from the proper module. There is no
> problem in finding out the proper module given a (valid) class name.
>
> As an example, look at the following statement
>
> >> aPoint = gp_Pnt(1.0, 0.0, 0.0) # Oops, this will raise a NameError, since

>
> # gp_Pnt class
> is unknown
>
> NameError: name 'gp_Pnt' is not defined
>
> As indicated, this will raise a NameError exception. What I would like
> to do is something like the following (pseudo-code):
>
> try:
> ....
> ....
> aPoint = gp_Pnt(1.0, 0.0, 0.0) [1]
>
> ....
> ....
> except NameError, e:
>
> name = e.args[0].split[1]
>
> if isValid(name):
> doImport(name)
> ===> Can I go back to statement [1] from this point?
> else:
> raise e
>
> There is no problem in catching the exception, finding out which name
> is unknown to python and check if this is a valid name for my library.
> My question is, is there any possibility of going back to the
> statement that raised the error, re-execute the statement and
> continue?
>
> Thanks for any thoughts and suggestions.
>
> Marco


There is no call/cc continuation in Python when you are asking for
such a thing.

I wonder however why you don't try lazy attribute access? Instead of
making a raw function call like that to gp_Pnt, one can thread all
calls to the C++ system through an object that implements __getattr__
and loads new names incrementally if one is missing.
 
Reply With Quote
 
 
 
 
pruebauno@latinmail.com
Guest
Posts: n/a
 
      03-25-2009
On Mar 25, 10:23*am, Marco Nawijn <(E-Mail Removed)> wrote:
> Hello,
>
> In short I would like to know if somebody knows if it is possible to
> re-execute a statement that raised an exception? I will explain the
> reason by providing a small introduction on why this might be nice in
> my case
> and some example code.
>
> I am using the python bindings to a *very* large C++ library. About
> 5000 classes divided over approx. 450 different
> packages are exposed through the Python interface. To reduce the
> number of import statements that need to be inserted and to limit the
> number of wildcard imports it would be very helpful if class names
> could be automatically imported from the proper module. There is no
> problem in finding out the proper module given a (valid) class name.
>
> As an example, look at the following statement
>
> >> aPoint = gp_Pnt(1.0, 0.0, 0.0) * * # Oops, this will raise a NameError, since

>
> * * * * * * * * * * * * * * * * * * * * * * * * * * * # gp_Pnt class
> is unknown
>
> NameError: name 'gp_Pnt' is not defined
>
> As indicated, this will raise a NameError exception. What I would like
> to do is something like the following (pseudo-code):
>
> try:
> * * ....
> * * ....
> * * aPoint = gp_Pnt(1.0, 0.0, 0.0) * *[1]
>
> * * ....
> * * ....
> except NameError, e:
>
> * * *name = e.args[0].split[1]
>
> * * *if isValid(name):
> * * * * * doImport(name)
> ===> Can I go back to statement [1] from this point?
> * * *else:
> * * * * *raise e
>
> There is no problem in catching the exception, finding out which name
> is unknown to python and check if this is a valid name for my library.
> My question is, is there any possibility of going back to the
> statement that raised the error, re-execute the statement and
> continue?
>
> Thanks for any thoughts and suggestions.
>
> Marco


You can always use a loop:

recover=True
while True:
try:
....
....
aPoint = gp_Pnt(1.0, 0.0, 0.0) [1]
....
....
except NameError, e:
if recover:
recover=False
name = e.args[0].split[1]
if isValid(name):
doImport(name)
else:
raise e
else:
break


 
Reply With Quote
 
Terry Reedy
Guest
Posts: n/a
 
      03-25-2009
Marco Nawijn wrote:

> In short I would like to know if somebody knows if it is possible to
> re-execute a statement that raised an exception?


In short, no.

> As an example, look at the following statement
>
>>> aPoint = gp_Pnt(1.0, 0.0, 0.0) # Oops, this will raise a NameError, since

> # gp_Pnt class
> is unknown
>
> NameError: name 'gp_Pnt' is not defined


Either make sure names are defined before you use them (easy) or provide
alternative code in the except clause.

If you actually have the name written literally in the code, you should
simply import it first, so I presume you have a more complicated use
case where the name to use is dynamically defined in a string. If so,
do something like

aPoint = MyImporter(class_name)(1.0, 0.0, 0.0)

where MyImporter.__new__ imports and returns the class

Terry Jan Reedy

 
Reply With Quote
 
Albert Hopkins
Guest
Posts: n/a
 
      03-25-2009

Also, instead of caching exceptions you can do lazy lookups kinda like
this:

-------------------------------------------------------------------------------------
# a.py

class A:
pass

-------------------------------------------------------------------------------------
# b.py

class B:
pass

-------------------------------------------------------------------------------------
# c.py

class D:
pass

class E:
pass

-------------------------------------------------------------------------------------
# iface.py

class LazyInterface(object):
_attr_dict = dict(A='a', B='b', C='c', D='c')
_attr_cache = dict()
_mod_cache = dict()

def __getattr__(self, name):
if name in self._attr_cache:
return self._attr_cache[name]

elif name in self._attr_dict:
module_name = self._attr_dict[name]
self._mod_cache[module_name] =
self._mod_cache.get(module_name,__import__(module_ name))
self._attr_cache[name] =
getattr(self._mod_cache[module_name], name)
return self._attr_cache[name]
else: raise AttributeError


>>> from iface import LazyInterface
>>> i = LazyInterface()
>>> a = i.A()
>>> a

<a.A instance at 0x7fb034317440>
>>> c = i.C()
>>> c

<c.C instance at 0x7fb034317758>
>>> d = i.D()
>>> d

<c.D instance at 0x7fb0343177a0>

There is probably a cleaner/more robust way of doing the above, but you
get the idea.

 
Reply With Quote
 
Anton Hartl
Guest
Posts: n/a
 
      03-25-2009
On 2009-03-25, Marco Nawijn <(E-Mail Removed)> wrote:
> Hello,
>
> In short I would like to know if somebody knows if it is possible to
> re-execute a statement that raised an exception? I will explain the
> reason by providing a small introduction on why this might be nice in
> my case
> and some example code.
>
> I am using the python bindings to a *very* large C++ library. About
> 5000 classes divided over approx. 450 different
> packages are exposed through the Python interface. To reduce the
> number of import statements that need to be inserted and to limit the
> number of wildcard imports it would be very helpful if class names
> could be automatically imported from the proper module. There is no
> problem in finding out the proper module given a (valid) class name.


Maybe this helps:

http://www.connellybarnes.com/code/autoimp/

Regards,
Anton
 
Reply With Quote
 
 
 
Reply

Thread Tools

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is On
HTML code is Off
Trackbacks are On
Pingbacks are On
Refbacks are Off


Similar Threads
Thread Thread Starter Forum Replies Last Post
Another basic question: How to call and show one Web Form from another Web Form? Rob R. Ainscough ASP .Net Web Controls 3 06-14-2005 03:56 PM
A nested dynamic checkbox inside my dynamic form. pizzy Javascript 5 04-12-2005 02:55 PM
Revised: A form -to- dynamic form -to- dynamic checkboxes pizzy Javascript 7 03-23-2005 10:53 PM
How to have a nested dynamic checkbox inside my dynamic form. pizzy Javascript 0 03-23-2005 03:32 AM
Dynamic Form with a Dynamic Form inside it... pizzy Javascript 4 03-18-2005 05:10 AM



Advertisments