Velocity Reviews

Velocity Reviews (http://www.velocityreviews.com/forums/index.php)
-   Python (http://www.velocityreviews.com/forums/f43-python.html)
-   -   import from a string (http://www.velocityreviews.com/forums/t704022-import-from-a-string.html)

iu2 11-03-2009 12:45 PM

import from a string
 
Hi,

Having a file called funcs.py, I would like to read it into a string,
and then import from that string.
That is instead of importing from the fie system, I wonder if it's
possible to eval the text in the string and treat it as a module.

For example

with file('funcs.py') as f: txt = r.read()
string_import(txt, 'funcs') # is string_import possible?

to have now a module called funcs with the functions defined in
funcs.py.

Thanks


Matt McCredie 11-03-2009 05:49 PM

Re: import from a string
 
iu2 <israelu <at> elbit.co.il> writes:

>
> Hi,
>
> Having a file called funcs.py, I would like to read it into a string,
> and then import from that string.
> That is instead of importing from the fie system, I wonder if it's
> possible to eval the text in the string and treat it as a module.
>
> For example
>
> with file('funcs.py') as f: txt = r.read()
> string_import(txt, 'funcs') # is string_import possible?
>
> to have now a module called funcs with the functions defined in
> funcs.py.


You can do something like this:

import types
import sys

mymodule = types.ModuleType("mymodule", "Optional Doc-String")

with file('funcs.py') as f:
txt = f.read()
exec txt in globals(), mymodule.__dict__
sys.modules['mymodule'] = mymodule


Note that you shouldn't exec untrusted code.
You might also look at the __import__ funciton, which can import by python path.
You might also look at the imp module.

Matt


iu2 11-03-2009 08:36 PM

Re: import from a string
 
On Nov 3, 7:49*pm, Matt McCredie <mccre...@gmail.com> wrote:
> iu2 <israelu <at> elbit.co.il> writes:
>
>
>
> > Hi,

>
> > Having a file called funcs.py, I would like to read it into a string,
> > and then import from that string.
> > That is instead of importing from the fie system, I wonder if it's
> > possible to eval the text in the string and treat it as a module.

>
> > For example

>
> > with file('funcs.py') as f: txt = r.read()
> > string_import(txt, 'funcs') *# is string_import possible?

>
> > to have now a module called funcs with the functions defined in
> > funcs.py.

>
> You can do something like this:
>
> import types
> import sys
>
> mymodule = types.ModuleType("mymodule", "Optional Doc-String")
>
> with file('funcs.py') as f:
> * * txt = f.read()
> exec txt in globals(), mymodule.__dict__
> sys.modules['mymodule'] = mymodule
>
> Note that you shouldn't exec untrusted code.
> You might also look at the __import__ funciton, which can import by python path.
> You might also look at the imp module.
>
> Matt


Thanks, it seems simpler than I thought.
I don't fully understand , though, the exec statement, how it causes
the string execute in the context of mymodule.

Gabriel Genellina 11-04-2009 01:10 AM

Re: import from a string
 
En Tue, 03 Nov 2009 17:36:08 -0300, iu2 <israelu@elbit.co.il> escribió:
> On Nov 3, 7:49 pm, Matt McCredie <mccre...@gmail.com> wrote:
>> iu2 <israelu <at> elbit.co.il> writes:
>>
>> > Having a file called funcs.py, I would like to read it into a string,
>> > and then import from that string.
>> > That is instead of importing from the fie system, I wonder if it's
>> > possible to eval the text in the string and treat it as a module.


>> mymodule = types.ModuleType("mymodule", "Optional Doc-String")
>> with file('funcs.py') as f:
>> txt = f.read()
>> exec txt in globals(), mymodule.__dict__
>> sys.modules['mymodule'] = mymodule

>
> Thanks, it seems simpler than I thought.
> I don't fully understand , though, the exec statement, how it causes
> the string execute in the context of mymodule.


Sometimes you don't even require a module, and this is simpler to
understand. Suppose you have a string like this:

txt = """
def foo(x):
print 'x=', x

def bar(x):
return x + x
"""

you may execute it:

py> namespace = {}
py> exec txt in namespace

The resulting namespace contains the foo and bar functions, and you may
call them:

py> namespace.keys()
['__builtins__', 'foo', 'bar']
py> namespace['foo']('hello')
x= hello

exec just executes the string using the given globals dictionary as its
global namespace. Whatever is present in the dictionary is visible in the
executed code as global variables (none in this example). The global names
that the code creates become entries in the dictionary. (foo and bar;
__builtins__ is an implementation detail of CPython). You may supply
separate globals and locals dictionaries.

--
Gabriel Genellina


iu2 11-04-2009 05:45 AM

Re: import from a string
 
On Nov 4, 3:10*am, "Gabriel Genellina" <gagsl-...@yahoo.com.ar> wrote:
> En Tue, 03 Nov 2009 17:36:08 -0300, iu2 <isra...@elbit.co.il> escribió:
>
>
>
>
>
> > On Nov 3, 7:49 pm, Matt McCredie <mccre...@gmail.com> wrote:
> >> iu2 <israelu <at> elbit.co.il> writes:

>
> >> > Having a file called funcs.py, I would like to read it into a string,
> >> > and then import from that string.
> >> > That is instead of importing from the fie system, I wonder if it's
> >> > possible to eval the text in the string and treat it as a module.
> >> mymodule = types.ModuleType("mymodule", "Optional Doc-String")
> >> with file('funcs.py') as f:
> >> * * txt = f.read()
> >> exec txt in globals(), mymodule.__dict__
> >> sys.modules['mymodule'] = mymodule

>
> > Thanks, it seems simpler than I thought.
> > I don't fully understand , though, the exec statement, how it causes
> > the string execute in the context of mymodule.

>
> Sometimes you don't even require a module, and this is simpler to *
> understand. Suppose you have a string like this:
>
> txt = """
> def foo(x):
> * *print 'x=', x
>
> def bar(x):
> * *return x + x
> """
>
> you may execute it:
>
> py> namespace = {}
> py> exec txt in namespace
>
> The resulting namespace contains the foo and bar functions, and you may *
> call them:
>
> py> namespace.keys()
> ['__builtins__', 'foo', 'bar']
> py> namespace['foo']('hello')
> x= hello
>
> exec just executes the string using the given globals dictionary as its *
> global namespace. Whatever is present in the dictionary is visible in the *
> executed code as global variables (none in this example). The global names *
> that the code creates become entries in the dictionary. (foo and bar; *
> __builtins__ is an implementation detail of CPython). You may supply *
> separate globals and locals dictionaries.
>
> --
> Gabriel Genellina- Hide quoted text -
>
> - Show quoted text -


Thanks for the explanation.
What happens if both global and local dictionaries are supplied: where
are the newly created entities created? In the local dict?



Gabriel Genellina 11-04-2009 06:02 AM

Re: import from a string
 
En Wed, 04 Nov 2009 02:45:23 -0300, iu2 <israelu@elbit.co.il> escribió:
> On Nov 4, 3:10 am, "Gabriel Genellina" <gagsl-...@yahoo.com.ar> wrote:


>> txt = """
>> def foo(x):
>> print 'x=', x
>>
>> def bar(x):
>> return x + x
>> """
>>
>> py> namespace = {}
>> py> exec txt in namespace
>> py> namespace.keys()
>> ['__builtins__', 'foo', 'bar']
>> py> namespace['foo']('hello')
>> x= hello


> What happens if both global and local dictionaries are supplied: where
> are the newly created entities created? In the local dict?


The amazing thing about Python is how easy is to experiment in the
interpreter.
Just see it by yourself!

--
Gabriel Genellina


Terry Reedy 11-04-2009 06:51 PM

Re: import from a string
 
Gabriel Genellina wrote:
> En Wed, 04 Nov 2009 02:45:23 -0300, iu2 <israelu@elbit.co.il> escribió:
>> On Nov 4, 3:10 am, "Gabriel Genellina" <gagsl-...@yahoo.com.ar> wrote:

>
>>> txt = """
>>> def foo(x):
>>> print 'x=', x
>>>
>>> def bar(x):
>>> return x + x
>>> """
>>>
>>> py> namespace = {}
>>> py> exec txt in namespace
>>> py> namespace.keys()
>>> ['__builtins__', 'foo', 'bar']
>>> py> namespace['foo']('hello')
>>> x= hello

>
>> What happens if both global and local dictionaries are supplied: where
>> are the newly created entities created? In the local dict?

>
> The amazing thing about Python is how easy is to experiment in the
> interpreter.
> Just see it by yourself!


Hint: they are created in the same namespace they always are (ignoring
nested functions and nonlocal namespaces). But I agree with Gabriel:
just try it. n1,n2={},{}; exec....

Terry Jan Reedy



iu2 11-05-2009 05:53 AM

Re: import from a string
 
On Nov 4, 8:51*pm, Terry Reedy <tjre...@udel.edu> wrote:
> Gabriel Genellina wrote:
> > En Wed, 04 Nov 2009 02:45:23 -0300, iu2 <isra...@elbit.co.il> escribió:
> >> On Nov 4, 3:10 am, "Gabriel Genellina" <gagsl-...@yahoo.com.ar> wrote:

>
> >>> txt = """
> >>> def foo(x):
> >>> * *print 'x=', x

>
> >>> def bar(x):
> >>> * *return x + x
> >>> """

>
> >>> py> namespace = {}
> >>> py> exec txt in namespace
> >>> py> namespace.keys()
> >>> ['__builtins__', 'foo', 'bar']
> >>> py> namespace['foo']('hello')
> >>> x= hello

>
> >> What happens if both global and local dictionaries are supplied: where
> >> are the newly created entities created? In the local dict?

>
> > The amazing thing about Python is how easy is to experiment in the
> > interpreter.
> > Just see it by yourself!

>
> Hint: they are created in the same namespace they always are (ignoring
> nested functions and nonlocal namespaces). But I agree with Gabriel:
> just try it. n1,n2={},{}; exec....
>
> Terry Jan Reedy- Hide quoted text -
>
> - Show quoted text -


n2 :-)


All times are GMT. The time now is 01:57 PM.

Powered by vBulletin®. Copyright ©2000 - 2014, vBulletin Solutions, Inc.
SEO by vBSEO ©2010, Crawlability, Inc.