On 8 déc, 11:45, Steven D'Aprano <steve
+comp.lang.pyt...@pearwood.info> wrote:
> On Tue, 07 Dec 2010 07:52:06 -0800, gst wrote:
> > Hi,
>
> > But in my IDE I want the completion to also work from within the lower
> > level module when it's refering to the object passed from the upper
> > level:
>
> "The completion"? What do you mean?
Hi,
I mean the autocompletion feature of my IDE :
when I type "object." then on the "." it shows me possible members/
methods of the 'object'. depending on what my IDE can guess about the
object possible type(s) ; in the worst case it can't guess nothing
about it and that's my point below..
> > Well, I'm sure I'm not very clear in my terms (and probably a bit long
> > in the sentence) so here it is in code:
>
> I'm afraid I have to agree with your, your description is not clear to me.
I hope I'm now ;)
> Unfortunately, neither is your code, because I don't understand *why* you
> do the things you do.
damn. ok let's go..
> > file module1.py:
>
> > from subpackage.module2 import class2
>
> Is it relevant that class2 comes from another module?
yes. hmmm or maybe not completely.. I think it only highly depends on
what the IDE can guess on an object type used inside some methods
depending on the files hierarchy..
> Would your concept work if class1 and class2 were defined in the same file?
I guess yes also.
> > class class1(object):
>
> > def __new__(cls, _self=None, *args, **kwargs):
> > if _self: ## we've been passed an instance already
> > initialyzed
> > ## so directly return it instead of creating a
> > new object.
> > return _self
> > return object.__new__(cls)
>
> Depending on your application, this may be an unsafe assumption. If the
> caller says class1("spam"), your class will return "spam". This may or
> may not be what you want.
I'm always passing the good object type when I do this.
> > def __init__(self, _self=None, *args, **kwargs):
> > if _self: ## we've been passed an instance already
> > initialyzed
> > ## so directly returns
> > ## assert(self is _self) ?
> > return
> > self.object2 = class2(object1=self, "blip", "blop") # others
> > init
>
> Okay, this seems like a fairly straightforward case of adding an
> attribute to your instance that includes a reference to itself. No big
> deal... there's nothing wrong with this, although you are creating a
> reference cycle, which is somewhat of a (mild) code-smell.
that is a worry effectively. (hmm when you say it's a case of adding
an attribute that includes a ref to itself it's not really that (or i
badly understand) : it's adding an attribute to a lower level class
instance that contains a ref to an upper level class instance (which
also contains a ref to the lower level class' instance and that's the
cycle (and that's a bit my worry))
> > file module2.py:
>
> > class class2(object):
>
> > def __init__(self, object1, *args, **kwargs):
>
> > from ..module1 import class1
>
> Now you have a circular import, and that's a pretty major code smell.
> That's dangerous. Try to avoid it. Perhaps the easiest way to avoid it is
> to place class1 and class2 in the same module, and stop writing Java :)
damn if this looks like Java it's really not my will ; I've not made
Java anymore for probably 10 years !
I'll try by putting class1 and class2 in same module (or at same
directory level first) and see if that can do it..
>
> > self.object1 = class1(_self=object1) ## instead of:
> > self.object1 = object1
>
> > ## others functions and/or init..
> > ## where now I've completion working on self.object1 : ## if I
> > add(or remove) fields/methods in module1 (and save) then ## I have
> > them available(or disappeared) in the completion when
> > executed from this submodule.
> > ## This ofcourse permits to save me of remembering all of the
> > class1 attributes/methods when I'm working with self.object1 from within
> > one of class2 methods.
>
> I'm afraid I don't understand what you mean here in these comments. What
> do you mean, "save me of (from?) remembering all the class1 attributes/
> methods..." -- how does it save you from knowing the methods? Whether you
> write this:
>
> instance = class1()
> instance.method()
>
> or this:
>
> instance = class1()
> another_instance = class2(instance)
> another_instance.object1.method()
>
> you still need to know the name "method".
>
> It seems to me that this scheme is unnecessarily complex, convoluted and
> confusing, for very little gain. Perhaps you could try explaining what
> you hope to accomplish, giving examples?
Effectively I recognise that this seems like a bit silly/odd .. but as
it's working I wanted some advises so ;)
As I told I try to have some kind of "ultimate" autocompletion, always
working for this kind of case (I know exactly that a certain member of
a certain class' instance will always have the same type but my IDE
doesn't seem to guess/know it.. ; I guess the best answer would be :
bad IDE, change IDE but I'm guessing that others IDE can't do a lot
better in this case.
Anyway many thanks for your reply ; I'll do some further tests with
your comments already..
regards,
greg.
nb: so this "hack" is only relevant during dev ; once the project
would be finished the "hack" could be removed (i.e : in class2 init I
would directly do : self.object1 = object1)
--
http://mail.python.org/mailman/listinfo/python-list
