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

iu2

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

Matt McCredie

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.

iu2

En Tue, 03 Nov 2009 17:36:08 -0300, iu2 <> 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

Gabriel Genellina

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?

iu2

En Wed, 04 Nov 2009 02:45:23 -0300, iu2 <> 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

Gabriel Genellina

Gabriel Genellina wrote:
> En Wed, 04 Nov 2009 02:45:23 -0300, iu2 <> 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

Terry Reedy

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

iu2