Stephan Richter <[EMAIL PROTECTED]> writes: 

> I want to make my own name space with the following situation:
> class X:
>     attributes = {'foo': 'bar'}
> x = X()
> Then I want to use it like that:
> <dtml-with x>
>       <dtml-var foo>
> </dtml-with>

I puzzled through a related problem a little, but for (I think) a
different reason.  I have an External Method that takes a significant
amount of time to run, and returns a collection of data. I didn't want
to have to push the names of all the subvariables returned onto the
stack; that pollutes the name space.  What I wanted to do was the

<dtml-let x="MyExternalMethod(arg1, arg2)">
        Variable 1: <dtml-var expr="x.variable1"> <br>
        Variable 2: <dtml-var expr="x.variable2"> <br>

(But, as in your case, I could also have done:

     <dtml-with expr="MyExternalMethod(arg1, arg2)">
            Variable 1: <dtml-var expr="variable1"> <br>
            Variable 2: <dtml-var expr="variable2"> <br>
     </dtml-let> )

To me, this first example seemed like a pretty common and obvious
thing to to.  I didn't need "x" to be persistent, I didn't need or
want acqusition, I just wanted to keep my variables containerized in a
structure.  For this purpose, FunctionTemplate, InstanceDict, and
TemplateDict all seemed either inappropriate, too complex, or too

So, I wrote the simple container class at the end of this message that
contains a grab-bag of methods that can be used for my application as
well as with a variety of others that use <dtml-with> and <dtml-in>.
It essentially provides all that "_.namespace()" does, plus some extra
introspection.  It's concocted from various pieces of Zope and the

Now, philosophical Zope questions:

* To those in the know, is there any problems returning non-persistent

* Next, it there a reason that there's no sanctioned class for this

* Can you return a populated namespace from a DTML Method or a Python Script
using existing mechanisms?

* Why can't you set values in "_.namespace()" in DTML after a
namespace has been created?

* To me, it would make so much more sense to be able create a namespace
with temporary variables (as shown in one of the HowTos) rather than
forcing people to hack them using REQUEST.set().  The namespace
could be used directly as a structure (eg, "ns.x") or as a scope 
(eg, <dtml-with ns> <dtml-var x> </dtml-with> ).  Is there a deep
reason it doesn't exist?

Anyway, here's my "no-guarantee" class.  Notice the magic member
"__allow_access_to_unprotected_subobjects__", which the documentation
(read, code) says can also be set to a list of members that you want
to be publicly accessible and unprotected.  Use this code as a guide;
you can trim it down to get what you want.  An instance of this class
can be used directly as an argument to <dtml-with>; to use with
<dtml-in>, use either the "getItems" or "getMap()" methods.


class StructureInstance:
    """A simple, non-persistent, class-based dictionary
    that's useful for returning arguments to Zope"""

    __allow_access_to_unprotected_subobjects__ = 1

    def __init__(self, dict={}):

    def __getattr__(self, name):
        try: return self.__d[name]
        except KeyError: raise AttributeError, name

    def __getitem__(self, name):
        try: return self.__d[name]
        except KeyError: raise KeyError, name

    def __setitem__(self, name, value):
        self.__d[name] = value

    def update(self, dict):

    def getKeys(self, spec=None):
        if spec is None:
            return self.__d.keys()
        return filter((lambda x, spec=spec: x in spec), self.__d.keys())

    def getValues(self, spec=None):
        if spec is None:        
            return self.__d.values()

        return map(lambda y: y[1],
                      filter((lambda x, spec=spec: x[0] in spec),

    def getItems(self, spec=None):
        if spec is None:
            return self.__d.items()

        return filter((lambda x, spec=spec: x[0] in spec), self.__d.items())

    def getMap(self, spec=None):
        items = self.getItems(spec)
        dict = {}
        for (i, j) in items:
            dict[i] = j
        return dict
    def set(self, **args):

Michael Halle

Zope-Dev maillist  -  [EMAIL PROTECTED]
**  No cross posts or HTML encoding!  **
(Related lists - )

Reply via email to