Module Name Conflicts

Discussion in 'Python' started by torched_smurf@yahoo.com, Aug 19, 2005.

  1. Guest

    I have a java program in a package called 'cmd'. This of course
    conflicts with the builtin python package of the same name. The thing
    is, I need to be able to import from both of these packages in the same
    script. I can import either one first, but any future attempt to import
    from cmd.* will look up the first cmd that was imported, so the second
    package is essentially eclipsed. I've tried fiddling with sys.path and
    sys.packageManager.searchPath, to no avail. To answer the obvious first
    suggestion, no I can't rename the java package to 'Cmd' or anything
    like that. Any ideas?

    -Smurf
     
    , Aug 19, 2005
    #1
    1. Advertising

  2. ncf Guest

    Maybe what you're looking for is __import__()?

    >>> help(__import__)

    Help on built-in function __import__ in module __builtin__:

    __import__(...)
    __import__(name, globals, locals, fromlist) -> module

    Import a module. The globals are only used to determine the
    context;
    they are not modified. The locals are currently unused. The
    fromlist
    should be a list of names to emulate ``from name import ...'', or
    an
    empty list to emulate ``import name''.
    When importing a module from a package, note that __import__('A.B',
    ....)
    returns package A when fromlist is empty, but its submodule B when
    fromlist is not empty.
     
    ncf, Aug 19, 2005
    #2
    1. Advertising

  3. Dan Sommers Guest

    On 18 Aug 2005 16:06:46 -0700,
    wrote:

    > I have a java program in a package called 'cmd'. This of course
    > conflicts with the builtin python package of the same name. The thing
    > is, I need to be able to import from both of these packages in the same
    > script. I can import either one first, but any future attempt to import
    > from cmd.* will look up the first cmd that was imported, so the second
    > package is essentially eclipsed. I've tried fiddling with sys.path and
    > sys.packageManager.searchPath, to no avail. To answer the obvious first
    > suggestion, no I can't rename the java package to 'Cmd' or anything
    > like that. Any ideas?


    Assuming you can fiddle with sys.path at the right times, you can call
    an imported module anything you want:

    fix_sys_path_to_find_java_cmd_first()
    import cmd as java_cmd
    fix_sys_path_to_find_python_cmd_first()
    import cmd as python_cmd

    Obviously, then, 'cmd' does not reference either module; you'd have to
    use java_cmd and python_cmd as appropriate.

    HTH,
    Dan

    --
    Dan Sommers
    <http://www.tombstonezero.net/dan/>
     
    Dan Sommers, Aug 19, 2005
    #3
  4. Robert Kern Guest

    Dan Sommers wrote:

    > Assuming you can fiddle with sys.path at the right times, you can call
    > an imported module anything you want:
    >
    > fix_sys_path_to_find_java_cmd_first()
    > import cmd as java_cmd
    > fix_sys_path_to_find_python_cmd_first()
    > import cmd as python_cmd
    >
    > Obviously, then, 'cmd' does not reference either module; you'd have to
    > use java_cmd and python_cmd as appropriate.


    That doesn't work. The first module is recorded as 'cmd' in sys.modules
    and gets reused on the second import.

    [~]$ mkdir foo1
    [~]$ mkdir foo2
    [~]$ touch foo1/blah.py
    [~]$ touch foo2/blah.py
    [~]$ python
    Python 2.4.1 (#2, Mar 31 2005, 00:05:10)
    [GCC 3.3 20030304 (Apple Computer, Inc. build 1666)] on darwin
    Type "help", "copyright", "credits" or "license" for more information.
    >>> import sys
    >>> sys.path.insert(0,'foo1')
    >>> import blah as blah1
    >>> sys.path.insert(0,'foo2')
    >>> import blah as blah2
    >>> sys.modules['blah']

    <module 'blah' from 'foo1/blah.py'>
    >>> blah2.__file__

    'foo1/blah.py'
    >>>


    --
    Robert Kern


    "In the fields of hell where the grass grows high
    Are the graves of dreams allowed to die."
    -- Richard Harter
     
    Robert Kern, Aug 19, 2005
    #4
  5. Guest

    Robert Kern wrote:
    > Dan Sommers wrote:
    >
    > > Assuming you can fiddle with sys.path at the right times, you can call
    > > an imported module anything you want:
    > >
    > > fix_sys_path_to_find_java_cmd_first()
    > > import cmd as java_cmd
    > > fix_sys_path_to_find_python_cmd_first()
    > > import cmd as python_cmd
    > >
    > > Obviously, then, 'cmd' does not reference either module; you'd have to
    > > use java_cmd and python_cmd as appropriate.

    >
    > That doesn't work. The first module is recorded as 'cmd' in sys.modules
    > and gets reused on the second import.


    Exactly. And clearing sys.modules doesn't fix the problem. Once it's
    imported something from the first cmd package, it can no longer find
    anything in another cmd package; it will always look for it in that
    first package.

    -Smurf
     
    , Aug 19, 2005
    #5
  6. Robert Kern Guest

    wrote:
    > I have a java program in a package called 'cmd'. This of course
    > conflicts with the builtin python package of the same name. The thing
    > is, I need to be able to import from both of these packages in the same
    > script. I can import either one first, but any future attempt to import
    > from cmd.* will look up the first cmd that was imported, so the second
    > package is essentially eclipsed. I've tried fiddling with sys.path and
    > sys.packageManager.searchPath, to no avail. To answer the obvious first
    > suggestion, no I can't rename the java package to 'Cmd' or anything
    > like that. Any ideas?


    Why not copy cmd.py into your package under a different name?


    --
    Robert Kern


    "In the fields of hell where the grass grows high
    Are the graves of dreams allowed to die."
    -- Richard Harter
     
    Robert Kern, Aug 19, 2005
    #6
  7. Guest

    ncf wrote:
    > Maybe what you're looking for is __import__()?
    >
    > >>> help(__import__)

    > Help on built-in function __import__ in module __builtin__:
    >
    > __import__(...)
    > __import__(name, globals, locals, fromlist) -> module
    >
    > Import a module. The globals are only used to determine the
    > context;
    > they are not modified. The locals are currently unused. The
    > fromlist
    > should be a list of names to emulate ``from name import ...'', or
    > an
    > empty list to emulate ``import name''.
    > When importing a module from a package, note that __import__('A.B',
    > ...)
    > returns package A when fromlist is empty, but its submodule B when
    > fromlist is not empty.


    Using this doesn't appear to work any better than regular old import.

    -Smurf
     
    , Aug 19, 2005
    #7
  8. Guest

    Robert Kern wrote:
    > Why not copy cmd.py into your package under a different name?
    >


    It offends my sense of modularity. For the record, I'm trying to use
    pdb, the debugger, which in turn uses cmd. So it would be a matter of
    taking pdb.py and hacking it to import a renamed version of cmd... kind
    of messy and not a very good longterm solution. That's not to say I
    won't resort to it if no better options are forthcoming.

    -Smurf
     
    , Aug 19, 2005
    #8
  9. Peter Hansen Guest

    wrote:
    > Robert Kern wrote:
    >>That doesn't work. The first module is recorded as 'cmd' in sys.modules
    >>and gets reused on the second import.

    >
    > Exactly. And clearing sys.modules doesn't fix the problem. Once it's
    > imported something from the first cmd package, it can no longer find
    > anything in another cmd package; it will always look for it in that
    > first package.


    That part isn't correct. Removing the entry from sys.modules should
    (and has, for me, in the past) worked fine to let a second import reload
    a module, or find a new module after sys.path has been tweaked. Try it
    again.

    -Peter
     
    Peter Hansen, Aug 19, 2005
    #9
  10. ncf Guest

    I'm honestly not too sure how __import__ works, but I know you can
    provide a full path to it. Oh well, that was my best guess. I wish I
    could've been of more help. -Wes
     
    ncf, Aug 19, 2005
    #10
  11. Guest

    ncf wrote:
    > Maybe what you're looking for is __import__()?


    Okay, actually this does work, but only in one direction. That is, I
    can import the python package first, and then the java package, but not
    the other way around.

    --------------------------------------------------------------
    Importing the python cmd first:

    $~> jython
    Jython 2.2a1 on java1.4.2_08 (JIT: null)
    Type "copyright", "credits" or "license" for more information.
    >>> __import__('cmd')

    <module 'cmd' from '~/code/jython-2.2a1/Lib/cmd.py'>
    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ python package
    >>> import sys
    >>> sys.path.insert(0, java_classpath)
    >>> sys.modules.clear()
    >>> __import__('cmd')

    <java package cmd 1>
    ^^^^^^^^^^^^^^^^^^^^ java package

    --------------------------------------------------------------
    Importing the java cmd first:

    $~> jython
    Jython 2.2a1 on java1.4.2_08 (JIT: null)
    Type "copyright", "credits" or "license" for more information.
    >>> import sys
    >>> sys.path.insert(0, java_classpath)
    >>> __import__('cmd')

    <java package cmd 1>
    ^^^^^^^^^^^^^^^^^^^^ java package
    >>> sys.path = sys.path[1:]
    >>> sys.modules.clear()
    >>> __import__('cmd')

    <java package cmd 1>
    ^^^^^^^^^^^^^^^^^^^^ java package, again
    --------------------------------------------------------------

    Very odd.

    -Smurf
     
    , Aug 19, 2005
    #11
  12. Dan Sommers Guest

    On Thu, 18 Aug 2005 16:46:42 -0700,
    Robert Kern <> wrote:

    > Dan Sommers wrote:


    [ something that obviously doesn't work ]

    > That doesn't work. The first module is recorded as 'cmd' in
    > sys.modules and gets reused on the second import.


    Yes, you're right. I apologize.

    Regards,
    Dan

    --
    Dan Sommers
    <http://www.tombstonezero.net/dan/>
     
    Dan Sommers, Aug 19, 2005
    #12
  13. Robert Kern Guest

    wrote:
    > Robert Kern wrote:
    >
    >>Why not copy cmd.py into your package under a different name?

    >
    > It offends my sense of modularity. For the record, I'm trying to use
    > pdb, the debugger, which in turn uses cmd. So it would be a matter of
    > taking pdb.py and hacking it to import a renamed version of cmd... kind
    > of messy and not a very good longterm solution. That's not to say I
    > won't resort to it if no better options are forthcoming.


    A solution more kind to your sensibilities might be to make an auxiliary
    package alongside (rather than inside) yours. No modification to source
    necessary.

    pystdlib/
    __init__.py
    cmd.py
    pdb.py

    Python 2.4.1 (#2, Mar 31 2005, 00:05:10)
    [GCC 3.3 20030304 (Apple Computer, Inc. build 1666)] on darwin
    Type "help", "copyright", "credits" or "license" for more information.
    >>> import pystdlib
    >>> from pystdlib import pdb
    >>> pdb.cmd.__file__

    'pystdlib/cmd.py'
    >>>


    --
    Robert Kern


    "In the fields of hell where the grass grows high
    Are the graves of dreams allowed to die."
    -- Richard Harter
     
    Robert Kern, Aug 19, 2005
    #13
  14. On Thu, 18 Aug 2005 16:46:42 -0700, Robert Kern <> wrote:

    >Dan Sommers wrote:
    >
    >> Assuming you can fiddle with sys.path at the right times, you can call
    >> an imported module anything you want:
    >>
    >> fix_sys_path_to_find_java_cmd_first()
    >> import cmd as java_cmd
    >> fix_sys_path_to_find_python_cmd_first()
    >> import cmd as python_cmd
    >>
    >> Obviously, then, 'cmd' does not reference either module; you'd have to
    >> use java_cmd and python_cmd as appropriate.

    >
    >That doesn't work. The first module is recorded as 'cmd' in sys.modules
    >and gets reused on the second import.
    >
    >[~]$ mkdir foo1
    >[~]$ mkdir foo2
    >[~]$ touch foo1/blah.py
    >[~]$ touch foo2/blah.py
    >[~]$ python
    >Python 2.4.1 (#2, Mar 31 2005, 00:05:10)
    >[GCC 3.3 20030304 (Apple Computer, Inc. build 1666)] on darwin
    >Type "help", "copyright", "credits" or "license" for more information.
    > >>> import sys
    > >>> sys.path.insert(0,'foo1')
    > >>> import blah as blah1
    > >>> sys.path.insert(0,'foo2')
    > >>> import blah as blah2
    > >>> sys.modules['blah']

    ><module 'blah' from 'foo1/blah.py'>
    > >>> blah2.__file__

    >'foo1/blah.py'
    > >>>

    >


    How about (untested)

    import new
    blah1 = new.module('blah')
    execfile('./foo1/blah.py', blah1.__dict__)
    blah2 = new.module('blah')
    execfile('./foo2/blah.py', blah2.__dict__)

    Of course, there is the issue of caching .pyc's and what to put in
    sys.path and sys.modules, but blah1 and blah2 ought to be usable, I think.

    Regards,
    Bengt Richter
     
    Bengt Richter, Aug 19, 2005
    #14
  15. wrote:
    > I have a java program in a package called 'cmd'. This of course
    > conflicts with the builtin python package of the same name. The thing
    > is, I need to be able to import from both of these packages in the same
    > script. I can import either one first, but any future attempt to import
    > from cmd.* will look up the first cmd that was imported, so the second
    > package is essentially eclipsed. I've tried fiddling with sys.path and
    > sys.packageManager.searchPath, to no avail. To answer the obvious first
    > suggestion, no I can't rename the java package to 'Cmd' or anything
    > like that. Any ideas?
    >
    > -Smurf


    Never used it myself, but you can try to use the builtin 'imp' module.

    Python Library Reference
    3.21 imp -- Access the import internals

    This module provides an interface to the mechanisms used to implement
    the import statement. It defines the following constants and functions:

    ....
     
    Rocco Moretti, Aug 19, 2005
    #15
  16. ncf Guest

    Heh, so long as it works. Sorry for the delay, I've been away for a bit
    ;P Hope it's all owrking out
    -Wes
     
    ncf, Aug 21, 2005
    #16
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. Shadow Lynx
    Replies:
    1
    Views:
    3,015
    Christopher Reed
    Feb 4, 2006
  2. plb
    Replies:
    0
    Views:
    400
  3. plb
    Replies:
    0
    Views:
    319
  4. Replies:
    11
    Views:
    457
    Steven Bethard
    Nov 16, 2005
  5. Gelonida N

    resolving module name conflicts.

    Gelonida N, Nov 11, 2011, in forum: Python
    Replies:
    0
    Views:
    177
    Gelonida N
    Nov 11, 2011
Loading...

Share This Page