Accessing Java variables with illegal Python characters

[ryanmkurtz]

Hopefully this is a question with an answer instead of an issue.

If I am trying to access the Java variable MyClass.foo_$bar from JPype, how to I do that? Including the $ results in SyntaxError: invalid syntax.

[Thrameos]

You use getattr and setattr for variables that are not directly available. public class Test { public int foo_$bar; }

…

--- import jpype jpype.startJVM(classpath=".") Test = jpype.JClass("Test") test = Test() print(getattr(test,"foo_$bar")) print(setattr(test,"foo_$bar", 2)) print(getattr(test,"foo_$bar"))

[ryanmkurtz]

Thanks!

[Thrameos]

Please note that you may use getatter/setattr with the JClass customizer (_jclass_init_) to rename variables to new names. Thus they don’t have to be inaccessible in Python. You can rename it foo_DDbar if you wanted to. Simply choose the root of your tree and apply a customizer routine that will get the map of fields and method and assign them to the correct Python bindings. That is how JPype creates Pythonic classes from uncooperative Java classes.

[ryanmkurtz]

Thanks, i'll give this a try.

[ryanmkurtz]

This mechanism is somewhat working when a Java object is instantiated, but I am unsure how to get it to work with things like:

public interface Constants {
    public static final String FOO_BAR = "blah";
}

If I just do print(Constants.FOO_BAR), the __jclass_init__ method doesn't get called.

[Thrameos]

Interesting. I though that it ran at class initiation. I will take a look.

[Thrameos]

Sorry this got delayed due to cataract surgery. Did you figure it out?

[ryanmkurtz]

No worries, I hope the surgery went well for you.

I never figured this out. I was hoping you could try my little example above to see that __jclas_init__ was not getting called.

[Thrameos]

I had no difficulty with the rename.

import jpype

import jpype
jpype.startJVM(classpath=".")
Test = jpype.JClass("Test")


@jpype.JImplementationFor('Test')
class _Test(object):

    def __jclass_init__(cls):
        setattr(self, '_renamed', cls.__dict__['foo_$bar'])
        print("Updated keys:", cls.__dict__.keys())


test = Test()
print(test._renamed)
test._renamed = 2
print(test._renamed)

Are you sure you don't have a problem with your pattern of applying the customizer?

[Thrameos]

Note you don't need to care about order here.

import jpype
jpype.startJVM(classpath=".")
Test = jpype.JClass("Test")


test = Test()
setattr(test, "foo_$bar", 7)

@jpype.JImplementationFor('Test')
class _Test(object):

    def __jclass_init__(cls):
        setattr(cls, '_renamed', cls.__dict__['foo_$bar'])
        print("Updated keys:", cls.__dict__)


print(test._renamed)
test._renamed = 2
print(test._renamed)

[ryanmkurtz]

In the case that wasn't working for me, I never instantiated an object. I was just working with static class variables:

public interface Constants {
    public static final String FOO_BAR = "blah";
}

Would you expect the __jclass_init__ mechanism to work here?

[ryanmkurtz]

I should add that it works for me with instantiated object member variables, so I think my pattern of applying is working.

[Thrameos]

Okay I see the problem. I did not realize it was a static field. Those are very hard to manipulate as unlike an instance you need to set the value in the static parent without dereferencing. I can try to make a work around in a future version, but for now the best we can do is something indirect.

public class Test {
   public int foo_$bar;
   public static int ack_$no = 42;

   public static void verify()
   {
        System.out.println(ack_$no);
   }
}

With

import jpype
jpype.startJVM(classpath=".")
Test = jpype.JClass("Test")

@jpype.JImplementationFor('Test')
class _Test(object):

    def __jclass_init__(cls):
        setattr(cls, '_renamed', cls.__dict__['foo_$bar'])

Test.verify()
# Horrible magic line here!
Test.__dict__["ack_$no"].__set__(None, 32)
Test.verify()

[Thrameos]

I made a pattern to make this much easy to access.

import jpype
jpype.startJVM(classpath=".")
Test = jpype.JClass("Test")
setattr(Test, ".static", getattr(Test, ".ack_$no"))
Test.verify()
Test.f = 15
Test.static = 5
Test.verify()

[Thrameos]

I am not sure if I want to hold off the current release to add the descriptor manipulator, but you can try It out see if it is a better solution for your long term use case.

[ryanmkurtz]

Will this result in __jclass_init__ getting called in my above example? I would still like to rename the static fields behind the scenes in a way that is transparent to the user.

[ryanmkurtz]

I am not sure if I want to hold off the current release to add the descriptor manipulator, but you can try It out see if it is a better solution for your long term use case.

Yes, please don't hold up the release on account of this.

[Thrameos]

Yes, this command will be callable from the __jclass_init__ so it will trigger when @JImplementationFor appears.

The problem with the current implementation is we can only set members whuch start with underscore. For an instance this is fine as it gets dereferenced on access. But for a static, it sets in the python class, not java side. Effectively you can't set any static field that leads with underscore properly. Total disaster! So I need to change the logic to use a new "descriptor magic" to resolve the it.