Console Functions: How is the namespace determined?

Okay, this may take some brain damage to explain.

Right now I am registering a callback using the function:
Con::addCommand

This is being done through a python interface. I am storing a callback to a Python object in this structure:
static HashTable<Namespace::Entry*,void*> scriptCallbackLookup;

As you can see the Namespace::Entry is used to keep track of the python object which I cast to void *. The reason I cast it is because I intend to support more than just Python callbacks in the future.

So, the problem is coming from this:

SomeNamespace::somefunction();

If I register a function like the above it works fine and it does not matter if the namespace actually exists yet. This allows me to define namespace functions before the objects I use it with exist. So what is the issue? The issue is calling the above function without an object puts me at a dead end. I get the call to my callback function, but when I want to lookup the function in the namespace the only information available to me is the function name, not the name space. Normally you would attach an object and call it like this:

someobject.somefunction();
or
SomeNamespace::somefunction(someobject);

Either way if the object has the somefunction defined against its namespace it will work. However, if no namespace is defined shouldn't the console treat it as a function and return "SomeNamespace::somefunction"? Somewhere it is chopping off the SomeNamespace:: portion even if called explicitly. This makes it impossible to determine the namespace the function is supposed to be called against unless you provide an object.

I am guessing conceptually I am thinking about this wrong so I came up with some questions to try and reframe my thoughts:
1. Is there ever a time when you would call the function explicitly (SomeNamespace::somefunction) without an object?
2. Where in the code (I have searched everywhere I can think of) does it actually separate the namespace value from the function value?
3. Should I just require a minimum of 1 object/parameter and if I don't get an object, or an object with the proper namespace then just error out? I just not sure what is the standard for Torque functions. I would like to stay consistent.

I know there is a way to determine namespace, but it involves inserting code into the compiledeval.cc code. Not a good solution in my opinion.

Edit:
Interestingly enough I made it so the first parameter can be checked against being a simobject. If it is I get the namespace for that simobject and call the function associated with that namespace. However, it will not be the explicitly defined namespace:

new ScriptObject(TestNS1){
   className = TestNSA;
};
new ScriptObject(TestNS2){
   className = TestNSB;
};
function TestNSA::somefunction(){
   echo("TestNSA::somefunction");
}
function TestNSB::somefunction(){
   echo("TestNSB::somefunction");
}
// If you call this you get what you expect
TestNS1.somefunction();
TestNS2.somefunction();
// This will call the namespace of the object
// The actual function called will be TestNSB::somefunction
TestNSA::somefunction(TestNS2);

As you can see it could be confusing when using the first parameter as the object. So maybe I should not allow it for my callbacks. If I run this example in TS it does call TestNSA::somefunction like it should because it explicitly calls the function. However, I cannot duplicate this as my callback cannot assume which method called it, and the data provided to the function when calling it with the explicit prefix of the namespace does not keep the namespace information in tact when invoking the callback.

Hmmm, I wonder if I can do a stack trace in this case to determine which command was actually called. That would give me the namespace prefix if any.

Edit (again):
Ahh, darn it. Backtrace will work for console functions defined in script, but does not seem to work inside a C++ callback. That really sucks. I get absolutely no data back in my callback even though the function would technically still not have returned. I wonder if I have to tell it to update the current stack state or something?