[one]

Lrh9,

Ummm I think we have 'cannonized' your stuff, If you get the time to do it,, try and find/create links to your posts of your project including your first proposition and asking Freddie if you could recruit here.
take the links and ask Freddie if he would COPY your info and relevant converse to a single Thread.

"'Chaos' is a state, thus it needs to be started/initiated, manipulated and ended." -J.

It is just hard to follow and IMO staying within the confines of a single thread, when concerning your project, would be a nice thing, from the readers point of view and posterity.

Lookin' good

J.

[lrh9]

Lrh9,

Ummm I think we have 'cannonized' your stuff, If you get the time to do it,, try and find/create links to your posts of your project including your first proposition and asking Freddie if you could recruit here.
take the links and ask Freddie if he would COPY your info and relevant converse to a single Thread.

"'Chaos' is a state, thus it needs to be started/initiated, manipulated and ended." -J.

It is just hard to follow and IMO staying within the confines of a single thread, when concerning your project, would be a nice thing, from the readers point of view and posterity.

Lookin' good

J.

I suppose it would be better to say, "Updates on program, see thread.", than cluttering a discussion. I'll give it some consideration and then contact Freddy with my proposal and coordinate with him.

[Freddy]

And as if my magic it all happened...

[lrh9]

I've decided to implement the modules as abilities scheme. There are a few minor problems, but I'll figure them out.

Code

from uuid import uuid4 as _uuid4

UUID = 0

class DuplicatedModule:

    def __init__(self, module_object):
        self.__dict__ = dict(module_object.__dict__)


class Agent:

    def __init__(self, name = UUID):
        self._uuid = _uuid4()
        if name is UUID:
            name = self._uuid
        self.name = name


    @property
    def uuid(self):
        return self._uuid


    def add_ability(self, key, duplicated_module):
        self.__dict__[key] = duplicated_module

myagent = Agent()

import random

myagent.add_ability('random', DuplicatedModule(random))

print("myagent now how its own copy of random, and altering its random's attributes and methods does not affect the global random.")
print("In the default random, BPF is {0}.".format(myagent.random.BPF))
print("Setting myagent.random.BPF to 1.")
myagent.random.BPF = 1
print("myagent.random.BPF is now {0}.".format(myagent.random.BPF))
print("global random.BPF is still {0}.".format(random.BPF))

The main problem is that the duplicated module doesn't compare as the same to a module object. I can't think of any reason why someone would need to check that the agent's abilities are modules without knowing it, but it's something I want to learn more about.

P.S. I thought some of you might enjoy this comic about the reverse Turing test.

http://xkcd.com/632/

[Freddy]

Hehe, funny 

[one]

Larry,
I need to review what you have here, but I do have a few good ideas. I believe their is room for another assistant type A.I.

Lets start a 'Wave' soon (I'll send invite) and discuss a few things after I catch up w/u

J.

[lrh9]

I've been doing more research into modules, and I discovered how to manually create a module object.

PEP302 is a Python document about how to create a custom import hook. An import hook is a class that has specific functions called when an import statement is encountered in code.

PEP302 describes a basic method for loading a module.

Code

def load_module(self, fullname):
            ispkg, code = self._get_code(fullname)
            mod = sys.modules.setdefault(fullname, imp.new_module(fullname))
            mod.__file__ = "<%s>" % self.__class__.__name__
            mod.__loader__ = self
            if ispkg:
                mod.__path__ = []
            exec code in mod.__dict__
            return mod

I added a similar method to the agent.

Code

def importcopy(self, file, name):
        file_stream = open(file)
        module_code = file_stream.read()
        self.__dict__[name] = imp.new_module(name)
        exec(module_code, self.__dict__[name].__dict__)

However, this isn't the final code. It is only a shim. I've been in the process of creating a fully functioning importer that will be more robust and function similarly to the current Python importer. I only included this to allow some testing if I decide to implement other agent functions. I'm beginning planning for the agent's low level command interface. This low level interface will serve as a way to alter and control the agent using raw Python code.

[lrh9]

The Python standard library has a module named "code" that provides code for emulating the Python interactive interpreter. Now all I need to do is remove the interactive generalization so that other objects can interface and control the agent.

Code

def control(self, local = None):
        if local == None:
            local = locals()
        try:
            code.interact(local = local)
        except SystemExit:
            return

[lrh9]

OK. The module does have a base class for an interpreter. I'll make an interpreter an attribute of the agent, and allow developers and users to define the interface to this interpreter. I might add code for a basic command line and GUI interface by default.

[Freddy]

Good to see you are getting along with this.  I am afraid it all looks like Greek to me as I only ever touched the surface of Python.  But hopefully with these regular reports you will run into someone who you can converse with more on this.

[lrh9]

Thanks. I'd be more than happy to answer anyone's questions though to the best of my ability.

I'm also considering adding a thread of execution to the agent. In computer science terms, an "agent" is typically defined as a software system capable of being proactive and/or responding to the environment. An agent for instance can start itself on the basis of certain conditions, respond to certain conditions, or even suspend its own operation. Autonomy (self-control) is a very import part of "agency". You might think of your anti-virus application as an agent, because it scans incoming files and active processes and acts to remove threats - for the most part without user involvement.

[lrh9]

Created a functional importer in the agent.

Need to polish up code in the meantime.

[lrh9]

Finished up a importing system finally. Unfortunately I've been working on it so long that I've neglected where I want to go with the actual agent software. I need to give that some more reevaluation.

Been trying to get my thoughts together better.

Working on a diagram to help me think about it.

[Bragi]

Finished up a importing system finally.

Getting something hard done, always a nice moment.

[lrh9]

Yep. And I'm keeping it archived and saved at multiple locations too.

Hate to lose it now. Of course, now that I've solved the problem once through I'm fairly confident it wouldn't be too hard for me to get to the solution again.