Re: Custom JAR using standalone Jython 2.7.2 doesn't obey JYTHONPATH

Hello Alan.

It seems up to date, and makes the point quite well that configuration 
comes via the registry (by design), since it simply never mentions 
environment variables. I should have said that the registry could be 
used to set python.path, and (I think) provides a further default during 
initialisation for those properties not yet set.

I think the statement about relative paths in python.cachedir is out of 
date, since recent changes, now I look closely, but the rest looks good.

That's not what confuses me about initialisation. A lot goes on inside 
initialize() whose purpose is obscure.

Jeff Allen
On 29/03/2020 22:13, Alan Kennedy wrote:
> Is this documentation out of date?
>
> https://www.jython.org/registry.html
>
> I always found it accurate in the past.
>
> Alan.
>
>
> On Sun, Mar 29, 2020, 8:43 PM Jeff Allen <[email protected] 
> <mailto:[email protected]>> wrote:
>
>     I find initialisation difficult to follow too, although I have
>     single-stepped it a hundred times. It may help to see where the
>     environment is picked up now in the main program:
>
>     https://github.com/jythontools/jython/blob/f77cc106afc4b0b61426ae4212c1e38d20ec942d/src/org/python/util/jython.java#L498
>
>     and this simply involves getting things from the variables and
>     setting them in the Java properties that get passed into
>     initialisation:
>
>     https://github.com/jythontools/jython/blob/f77cc106afc4b0b61426ae4212c1e38d20ec942d/src/org/python/util/jython.java#L709
>
>     These are just the system properties in this case, although the
>     initialisation is designed to allow them to come from elsewhere.
>     (This is where I get lost, but the simple case is simple enough.)
>
>     The manifest in the standalone JAR makes org.python.util.jython
>     the main class, so it runs when you run the JAR with java -jar,
>     therefore it picks up JYTHONPATH in the places I've linked, to be
>     the default value of python.path. Or you could (I think) have
>     given -Dpython.path=... to java instead.
>
>     Sorry this change was a surprise. Of course, there are no major
>     releases to come (no 2.8, I mean).
>
>     Jeff
>
>     Jeff Allen
>
>     On 29/03/2020 10:06, Pekka Klärck wrote:
>>     Hi,
>>
>>     I understand the idea to isolate the JAR from the environment, but I'm
>>     still a bit surprised that this was changed in a minor release and
>>     that when I use `java -jar jython-standalone-2.7.2.jar` JYTHONPATH is
>>     actually obeyed. Anyway, this isn't a big problem for us as we can
>>     explicitly handle JYTHONPATH ourselves. My current solution is doing
>>     that on Python side and calling the function that does it as part of
>>     creating the runner on Java side. You can see it here if you are
>>     interested:
>>     https://github.com/robotframework/robotframework/commit/cce18967c8b27a14239112b74b66e57e4584f3b0
>>
>>     I also looked at configuring `python.path` via `PythonInterpreter`. If
>>     I understood it correctly, I should call
>>     `PythonInterpreter.initialize` before creating a `PythonInterpreter`
>>     instance and the `initialize` method needs also arguments in addition
>>     to properties. Due to how our code is structured and arguments are
>>     passed nowadays, that looked rather complicated. If there's some
>>     easier way to set `pytohn.path` perhaps it could work. That said, I'm
>>     fine with the above solution that seems to work fine in our tests.
>>
>>     Thanks again for Jython 2.7.2 everyone involved!
>>
>>     Cheers,
>>          .peke
>>
>>     la 28. maalisk. 2020 klo 13.48 Jeff Allen ([email protected]  <mailto:[email protected]>) kirjoitti:
>>>     I think this is because you are no longer running the interpreter via the jython.main() programme. Try setting in the Java System property python.path, what you might have put in JYTHONPATH.
>>>
>>>     If you are initialising Jython with your own properties object(s) it should go in the earliest consulted, I suspect.
>>>
>>>     Rationale
>>>
>>>     The design intent in Jython is that it use the registry (Java properties) as the means of configuring the interpreter. (Well, it seems to have been that from early on: I'm inferring a principle from the implementation.) Java promotes a platform-independent world where the Java interpreter can be launched any number of ways, and there isn't necessarily a shell environment in the way Unix and C have led us to expect. System properties, however, are a Java feature so it must always be possible to set them.
>>>
>>>     The main program, that you might invoke from the console (even if it is via the java command rather than the launcher), sits as a bridge between console world and Java world, and so I think it is only there that environment variables should be consulted, rather than in a scattered way. (This was mostly true already, but maybe not for JYTHONPATH.) Implementation of the -E option (ignore environment variables), and of trying to be more faithful to CPython in our main program, is behind making this absolute.
>>>
>>>     Jeff
>>>
>>>     On 27/03/2020 21:59, Pekka Klärck wrote:
>>>
>>>     Hi,
>>>
>>>     In the Robot Framework project
>>>     (https://github.com/robotframework/robotframework) one of our
>>>     distributions is a standalone JAR that is built on top of standalone
>>>     Jython. We've earlier used Jython 2.7.0, but there have been lot of
>>>     fixes since that and we are now planning to switch to Jython 2.7.2. I
>>>     have already changed our build scripts and have been running all our
>>>     acceptance tests using the new JAR.
>>>
>>>     Things have worked pretty well with the new JAR otherwise, but it
>>>     seems it doesn't obey JYTHONPATH set externally before execution.
>>>     Executing Python code can see the environment variable, but Python
>>>     modules in directories listed in it cannot be imported. I just tested
>>>     that if I build a JAR from same sources with Jython 2.7.0, JYTHONPATH
>>>     works as expected.
>>>
>>>     The strange thing is that when I tested with the standalone Jython
>>>     2.7.2 alone, it did handle JYTHONPATH just fine. This got me thinking
>>>     that perhaps we are somehow embedding Jython wrong. Are there some
>>>     know changes related to embedding Jython using PythonInterpreter?
>>>     Should we perhaps configure it somehow to get JYTHONPATH processed
>>>     correctly? The code currently just initialized PythonInterpreter
>>>     without any arguments and then calls `interpreter.exec(code)`. You can
>>>     find the full code here:
>>>     https://github.com/robotframework/robotframework/blob/master/src/java/org/robotframework/RobotRunner.java
>>>
>>>     One workaround for us is processing JYTHONPATH in our code and I
>>>     already tested that it works. If that turns out to be the only
>>>     solution, I just need to find a way to do that only when using the JAR
>>>     distribution.
>>>
>>>     Cheers,
>>>          .peke
>     _______________________________________________
>     Jython-dev mailing list
>     [email protected]
>     <mailto:[email protected]>
>     https://lists.sourceforge.net/lists/listinfo/jython-dev
>

_______________________________________________
Jython-dev mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/jython-dev