diff --git a/.github/workflows/codespell.yml b/.github/workflows/codespell.yml new file mode 100644 index 0000000..3138964 --- /dev/null +++ b/.github/workflows/codespell.yml @@ -0,0 +1,9 @@ +name: codespell +on: [pull_request, push] +jobs: + codespell: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v3 + - run: pip install codespell + - run: codespell --count # --ignore-words-list="" --skip="*.css,*.js,*.lock,*.po" diff --git a/.gitignore b/.gitignore index 231d027..8b69ca2 100644 --- a/.gitignore +++ b/.gitignore @@ -27,3 +27,7 @@ gh-pages/ pkg/ test/dest tmp/* +scraps/ + +# IDE droppings +.idea/ diff --git a/_data/navbar.yml b/_data/navbar.yml index ff0a5d9..a48ad54 100644 --- a/_data/navbar.yml +++ b/_data/navbar.yml @@ -24,15 +24,19 @@ navbar: - title: Development subItems: - title: Bug tracker - url: https://bugs.jython.org/ + url: https://github.com/jython/jython/issues/ - title: Github - url: https://github.com/jythontools/jython - - title: Mercurial - url: https://hg.python.org/jython/ + url: https://github.com/jython/jython/ + - title: Legacy + url: legacy-dev - title: Mailing List url: https://sourceforge.net/p/jython/mailman/ - title: Developer Guide url: https://jython-devguide.readthedocs.io/en/latest/ + - title: Jython 3 Features (MVP) + url: jython-3-mvp + - title: Jython 3 Roadmap + url: jython-3-roadmap - title: Website source url: https://github.com/jython/jython.github.io/ - title: Links diff --git a/_layouts/default.html b/_layouts/default.html index 830a986..20f35b2 100644 --- a/_layouts/default.html +++ b/_layouts/default.html @@ -16,7 +16,7 @@
- View on Github + View on Github diff --git a/download.md b/download.md index a43772e..b6c9184 100644 --- a/download.md +++ b/download.md @@ -1,25 +1,35 @@ --- title: Downloads --- + ## Current Version -The current version of Jython is 2.7.2 +The current version of Jython is 2.7.3. It can be downloaded here: -- [Jython Installer](https://repo1.maven.org/maven2/org/python/jython-installer/2.7.2/jython-installer-2.7.2.jar) - Use this to install Jython. - ([metadata](https://search.maven.org/artifact/org.python/jython-installer/2.7.2/jar)) -- [Jython Standalone](https://repo1.maven.org/maven2/org/python/jython-standalone/2.7.2/jython-standalone-2.7.2.jar) - Use this to run Jython without installing or to embed Jython in a Java application. - ([metadata](https://search.maven.org/artifact/org.python/jython-standalone/2.7.2/jar)) -- You may cite Jython 2.7.2 as a - [dependency in your Maven or Gradle build](https://search.maven.org/artifact/org.python/jython-slim/2.7.2/jar). +- [Jython Installer](https://repo1.maven.org/maven2/org/python/jython-installer/2.7.3/jython-installer-2.7.3.jar): + Use this to install Jython. + ([metadata](https://search.maven.org/artifact/org.python/jython-installer/2.7.3/jar)) +- [Jython Standalone](https://repo1.maven.org/maven2/org/python/jython-standalone/2.7.3/jython-standalone-2.7.3.jar): + Use this to run Jython without installing or to embed Jython in a Java application. + ([metadata](https://search.maven.org/artifact/org.python/jython-standalone/2.7.3/jar)) +- You may cite Jython 2.7.3 as a + [dependency in your Maven or Gradle build](https://search.maven.org/artifact/org.python/jython-slim/2.7.3/jar). For information on installing see [Installation](installation). This version is supported on Java 8 (minimum) and 11. + +## Current Release Candidate or Beta +There is no current release candidate or beta. +A build from the repository will identify as Jython 2.7.4a1-something. + + ## Previous Versions Previous versions of Jython are available from: - [Jython Installer](https://search.maven.org/artifact/org.python/jython-installer) - [Jython Standalone](https://search.maven.org/artifact/org.python/jython-standalone) + ## OpenPGP Public Keys Release files for supported releases are signed by the following: @@ -28,9 +38,8 @@ Release files for supported releases are signed by the following: You can validate these keys, using the installer as an example: - ```bash -gpg --keyserver hkp://pool.sks-keyservers.net --recv-keys [key id] +gpg --keyserver hkps://keyserver.ubuntu.com --recv-keys [key id] gpg --verify jython-installer-[x.y.z].jar.asc \ jython-installer-[x.y.z].jar @@ -38,6 +47,9 @@ gpg --verify jython-installer-[x.y.z].jar.asc \ GPG will report `Good signature from [release owner]`. -GPG may also report a warning unless you explicitly tell it to trust the key. This is not necessary for one-off verification. The warning is [explained here](https://security.stackexchange.com/questions/147447/gpg-why-is-my-trusted-key-not-certified-with-a-trusted-signature). The signing keys are listed above to allow validation independent of the file repository. +GPG may also report a warning unless you explicitly tell it to trust the key. +This is not necessary for one-off verification. +The warning is +[explained here](https://security.stackexchange.com/questions/147447/gpg-why-is-my-trusted-key-not-certified-with-a-trusted-signature). The signing keys are listed above to allow validation independent of the file repository. diff --git a/index.md b/index.md index a8679bb..76affce 100644 --- a/index.md +++ b/index.md @@ -2,7 +2,15 @@ title: Home --- ## What is Jython? -Jython is a [Java](https://go.java/index.html) implementation of [Python](https://www.python.org/) that combines expressive power with clarity. Jython is freely available for both commercial and non-commercial use and is distributed with source code under the [PSF License v2](https://github.com/jythontools/jython/blob/master/LICENSE.txt). Jython is complementary to Java and is especially suited for the following tasks: +The Jython project provides implementations of [Python](https://www.python.org/) in [Java](https://go.java/index.html), +providing to Python the benefits of running on the JVM and access to classes written in Java. +The current release (a Jython 2.7.x) only supports Python 2 (sorry). +There is work towards a Python 3 in the project's GitHub repository. + +Jython implementations are freely available for both commercial and non-commercial use. +They are distributed with source code under the [PSF License v2](https://github.com/jython/jython/blob/master/LICENSE.txt). + +Jython is complementary to Java and is especially suited for the following tasks: * Embedded scripting - Java programmers can add the Jython libraries to their system to allow end users to write simple or complicated scripts that add functionality to the application. * Interactive experimentation - Jython provides an interactive interpreter that can be used to interact with Java packages or with running Java applications. This allows programmers to experiment and debug any Java system using Jython. @@ -46,6 +54,6 @@ Jython is embedded in lots of projects. See some from [MVNRepository](https://mv - [ImageJ](http://imagej.net) - Use Jython to provide scripted image processing. - [GDA](http://www.opengda.org/) - Use Jython to script scientific experiments. - [Robot Framework](http://robotframework.org/) - A generic test automation framework for acceptance testing and acceptance test-driven development (ATDD) which runs on Jython. -- [TigerJython](http://jython.tobiaskohn.ch/) - An educational programming environment that is based on Jython. +- [TigerJython](https://www.tigerjython.ch/en) - An educational programming environment that is based on Jython. - [JEM/JythonMusic](https://jythonmusic.me/) - An environment for music making and creative programming using Jython. diff --git a/jython-3-mvp.md b/jython-3-mvp.md new file mode 100644 index 0000000..7e23e7f --- /dev/null +++ b/jython-3-mvp.md @@ -0,0 +1,238 @@ +--- +title: Jython 3 Features and MVP +--- +# Jython 3 Features and a Viable Minimum + +This is a discussion document that attempts to describe, +and to some extent prioritise, +features for Jython 3, +based on suggestions collated from various voices on +[jython-dev](https://sourceforge.net/p/jython/mailman/jython-dev/) +and in off-list e-mail. + + +## Positioning + +We think people will continue to adopt and use Jython if Jython 3 ... + +* is a modern version of Python, close to standard in its features. +* runs on a Java platform that is supported in the long-term. +* integrates cleanly with Java for access to JDK and user libraries. +* offers correct concurrency (effectively utilising available CPUs). +* allows code developed on CPython 3.x to run on Jython 3.x. +* is well-tested for release and supported for bugs. + +The minimum viable product (MVP) is to approach *all* these targets closely, +that is, it isn't viable if it falls a long way short of any one of them. +This does not preclude the availability of immature alpha versions. +(It's a public project, so it is there for anyone to build.) + + +## Version and Forms + +* MVP: A Python 3.8 (?) close to standard in ability to run Python. + * Only essential differences (e.g. around GC, atomicity). + * The full syntax (plus some Java twists e.g. to import from Java). + * Close to the whole standard library (where use is not C-specific). + +* Builds for Gradle/Maven ecosystem. + * MVP: Slim JAR without bundled dependencies. + * MVP: Centrally available to cite as a dependency. + +* Provides an executable command + * MVP: `jython3` command installable on each major OS + * MVP: subset of commonly-used python3 command options + * Option-compatible with `python3` (MVP: a subset) + * Options specific to Jython (JVM options and others) + + +## Performance + +* MVP: speed comparable with CPython (say 2x either way). + * Higher performance (single-threaded) desirable but not MVP. +* Future: Work to improve speed. + * Compile Python to JVM byte code. + * Faster Python byte code interpreter. +* Have in mind performance for: + * scientific computing + * image, big data and ML libraries + +These choices, if valid, +make a Python byte code interpreter a legitimate MVP. + + +## Platforms and Environments + +It is difficult to enumerate the possibilities in a MECE way. +It is multidimensional, although not every combination makes sense. +Which of the things in this section are MVP? + +### OS platforms: + +* Windows desktop +* Linux desktop +* Mac desktop +* Raspberry Pi +* Android (minimum as discussed under "features") + * Risk: API gaps constrain us, or lead to a special Android version +* Small JVM devices (e.g. for IoT) + +### Runtime environments: + +These are imprecise definitions, but the intention is to run everywhere +Java does, and take full advantage of each environment. + +* Desktop +* J2EE + * Risk: Java version support +* AWS +* Azure +* IoT/embedded Java + +At the embedded end of the spectrum, Jython is probably only attractive if +Python is not available directly (and Java is, obviously). + +### Significant Integrations + +An unscientific, incomplete list based on projects we have noticed +(e.g. via a reported bug). + +* Robot Framework +* ImageJ +* Pig +* Ghidra +* OpenHAB +* ... ? + +There is a wider Python ecosystem that does not yet use Jython because they +depend on extensions in C. E.g. there is not much in SciPy without `numpy`. + +How do we find the time and collaborators +to test integration into these environments? +Have we enough understanding to avoid unintentionally making it difficult? + + +## Features + +* MVP: Runs on Java 11 SE. Chosen as a minimum because: + * It is the post-Java 9 workhorse for the time being. + * It has a rich set of libraries we can exploit in the implementation. + * LTS version characterises many enterprise Java installations. + * Enterprises favour security, ease of management. + * Risk to MVP: J2EE is based on Java 8. Must explore: + * have I misunderstood this? + * non-issue if JVM byte code is the same? + * attention needed to which libraries are on the path + +* Not MVP: Runs on Android 8.0 API level 26: + * Android 8.0 API level 26 is the first known to support `j.l.invoke`. + * Constraint on run-time class creation precludes: + * Compilation from Python to JVM byte code at run-time (`exec()`). + * Certain approaches to implementation in detail. + * Needs specialised tool chain. + * Desirable target, but unknown other obstacles. + +* MVP: Generate and consume CPython byte code: + * This addresses large modules (JVM class size problem) + * Makes it possible to adopt modules compiled by CPython (defined version) + * Would be essential to Android support? + +* MVP(?): Use of `threading` leads to actual concurrency. + * There is no Global Interpreter Lock (neither a local one). + * Built-in objects remain internally consistent under concurrent access. + * The programmer is responsible for synchronisation of his/her code. + * The value of a shared object seen by another thread may be stale: + * Behavioural differences from CPython will occur in unsynchronised code. + * Operations that [happen to be atomic in CPython]( + https://docs.python.org/3/faq/library.html#what-kinds-of-global-value-mutation-are-thread-safe + ) need not be atomic in Jython. + * Concurrency is close to a unique advantage: probably MVP. + +* High standard of compatibility with CPython. + * MVP: `os.name` no longer confuses popular tools (like `virtualenv`). + * Divergences fixed as discovered. (Adoption of stdlib is a help.) + +* Continue to integrate smoothly with Java + * MVP: Generally works as in Jython 2. + * Less magic: an object claiming Java type has the semantics in its Javadoc. + * Avoid semantic confusion (e.g. `list.pop()` vs `Deque.pop()`) + * Explicit cast or wrapper to choose Python semantics (possibly?) + * No special treatment of Swing and AWT names (as now in `PyJavaType`). + +* Support popular libraries (and their dependencies) progressively. + * MVP: An API that makes extensions possible. + * Encourage C to Java ports of the most popular (different projects!) + * Encourage JyNI or HPy experiments. + +* Compile Python source to Java byte code, and: + * persist compiled Java byte code (in some form). + * treat Python compiled to JVM as: + * equivalent to cached .pyc files. + * resources locatable in a JAR by Jython. + * classes visible from Java (maybe). + +* Command-line version. + * MVP: Launch script or other wrapper. (Generated by `jlink`? C?) + * The command you run *is* the interpreter, not a launcher. + * JNI appears to [support this readily]( + https://docs.oracle.com/javase/8/docs/technotes/guides/jni/spec/invocation.html + ). + * `sys.executable` designates the actual executable. + * Process objects designate the process doing the work (not the wrapper). + +* MVP: Interpreter embeddable in a Java application. + * Continue JSR-223 support with some clean-up. + * `PythonInterpreter` API (only) generally similar to Jython 2. + * Risk: current API is unbounded: too much is public. + * Reduce the public API aided by Java Jigsaw modules. + * There will be blood. + * Risk: much existing guidance invalidated (Jython Book). + +* Clear semantics for `import` from Java + * Semantics in Jython 2 have repeatedly changed. + * `import` as written tries the same thing repeatedly + + +## Implementation and API Features + +The Java API available for embedding and to extension writers, +will be heavily influenced by "internal" implementation choices. +Looked at the other way, premature API choices may constrain implementation +freedom in undesirable ways. + +This is especially true of the object model, since for efficiency's sake, +objects exchanged at the API will be in the implementations we use internally. + +This can be less difficult than in CPython because Java gives us good +tools for encapsulation: interfaces, packages and modules. +(Modules are important here. Many implementation details in Jython 2 +became public API, just to cross our own package boundaries.) + +* MVP: Resolve the object API before 3.x beta. One of: + * `PyObject` is an interface. + * Every `j.l.Object` is a Python object directly. + +* MVP: Abstract interface (along the lines of CPython `abstract.h`). + * Abstract interface for basic operations. + * The internals of `type` (slots, etc.) are private + (better encapsulated than CPython). + +* MVP: Clear relationships amongst interpreter, system state and + thread state. (At least the interpreter and its semantics are API.) + + +## Jython 2 Features not to Reproduce + +* **Not:** Java `List` and `Map` implicitly Python `list` and `map`. + * This is a tempting feature and it almost works, + but involves complex guesswork. + * Propose a brief way to be explicit instead. + +* **Not:** Java package cache. + * The location of this is problematic for users. + * It has been the subject of a CVE and follow-up bug. + * If there is evidence it significantly improves performance, + without being a security issue, + a reworked version could be added to 3. + + diff --git a/jython-3-roadmap.md b/jython-3-roadmap.md new file mode 100644 index 0000000..3ae8006 --- /dev/null +++ b/jython-3-roadmap.md @@ -0,0 +1,293 @@ +--- +title: Jython 3 Roadmap +--- +# Jython 3 Roadmap + +This discussion document attempts to outline the steps to Jython 3, +defined by the MVP Features. +There are probably glaring omissions. +It is deliberately without dates. + +Apart from delivering the features, +it aims to satisfy certain voluntary constraints, +perceived as healthy in the long-term: + +* Comprehensible and documented architecture. + * Accessible for contribution. + * Readable as a model implementation of Python. +* History is continuous with earlier contributed work, in spite of: + * Radical code re-organisation. + * Radical change (to some code). + * Rendering some code broken or dead (temporarily). + +In the interests of the second of these objectives (history), +in the following, +where it is implied we implement some class or package, +the default approach will be to build on and credit prior art. +To achieve this for each source file, +we git-move, (commit) and afterwards modify +the closest corresponding Jython 2 file. + +The middle commit will often produce a version that does not build, +and should not be pushed to the project repository as the tip. +Subsequent editing and another commit will correct that. +Dead code, +normally a Bad Thing, +should remain until we know we won't resurrect it +to supply a later feature. +It may be necessary to create stubs to satisfy references in +un-resurrected code. + + +## A Sketchy Plan + +### Scorched Earth + +1. Restructure the code base so it builds with Gradle. +Legacy code stays where it is, +waiting to be moved and modified. + +1. The first build target is a library `jython-3.8a1-DEV`, +but initially it will be empty. + +1. Provide some basic landmarks (modular project structure) +and a convention for controlling log messages by sub-system. +(It's a debugging aid for us +and evolves to information for production use.) + +### Type and Arithmetic + +1. Outline architecture for objects, types, operations, slots. +Specify the abstract object API (analogous CPython's). + +1. Implement `PyBaseObject`, `PyType`, +and some simple types (mostly without operations). +Implement only the Java API and write JUnit tests +for type construction and inheritance. + +1. Implement type slots, add slot functions to simple types, +and implement an abstract object API. +Test the whole via JUnit, calling the abstract object API. +From here on, new operations added imply +new abstract object API and JUnit tests to match. + +1. Validation that acceptable performance is achieved, +invoking arithmetic operations through the API. +Likely to be measured using micro-benchmarks, +built as an application over the library. +Parity in the performance of `add(a, b)` +with CPython `a+b` is acceptable performance. +(A range of operations is intended, not just `+`.) +The micro-benchmark suite should grow as features are added. + +### Interpreters and Threads + +1. Outline architecture for interpreters, frames and the thread model. + +1. `Interpreter`, `PyFrame` and `PyCode` supporting +execution of initial subset of CPython byte code. +From here on, +addition of a new feature includes corresponding additions +to the repertoire of the byte code interpreter, +in order to accept byte code that depends on that feature. + +1. The means to read a code object output by CPython. +It may be just a provisional mechanism, +or a partial implementation of `pickle`. + +1. `PyJavaFunction` and `PyJavaModule` (but not `import` yet). + +1. Rudimentary form of `builtins` module. +Subsequently, objects will be added here as needed. + +1. Micro-benchmarks that execute the compiled form of Python fragments +in the compatible Jython `PyFrame`. +Target is parity with CPython `timeit` results on the same fragment. +Code and reference generated from a string. +(Is a framework possible to make this ever-expanding suite least work?) + +1. Micro-benchmarks validating parity with CPython `f(args, kwargs)`, +over a variety of argument patterns `f()`, `f(x)`, ``f(x, k=1)``, etc.. + +1. Validation of correct operation with concurrent threads, +especially that types do not escape incomplete from construction. +This suite should grow as features are added +that carry a risk of incorrect concurrency. + +### Descriptor Protocol + +1. Further architecture of the object model, +aiming for a complete description of types defined in Python or Java +and of multiple inheritance. + +1. Implementation of classes defined in Python +(but still compiled by CPython). + +1. Descriptor protocol and mechanisms to populate +the `PyType` dictionary and slots from classes. +Test via JUnit (directly or via the abstract object API). + +1. Definition of classes, members and methods using annotations in Java. +(Something like the Jython 2 exposer but less opaque, documented, +and simplified using `MethodHandle`.) + +### Experiment with Object + +Consider the advantages to performance, +and to the transparency of Java integration, +of making every `Object` a Python object. +Explore the idea of "acceptable implementations" +of common built-in types to allow e.g. `String` to be a `str`. +Experiment with ``CallSite`` as a consumer of the `MethodHandle` +already in slots. + +Resolve the `PyObject` vs `Object` dilemma. + +### Java Integration + +Approach to and basic implementation of +treating Java objects as Python objects, +having a Python type related to their Java class, +when they have not been specifically identified (built-ins). +Performance micro-benchmarks modelling code compiled to Java. + +### Module Import + +1. Outline architecture for modules and importers, +giving special attention to the semantics of Java packages and modules. +Advances in the module concept in Python should allow us +to avoid some of the special cases and thrashing around we find in Jython 2. + +1. Rudimentary forms of `sys`, `io`. +Subsequently, objects to be added as needed. + +1. Implement import mechanism closely following CPython. + +1. Use custom finders (probably) to import objects from Java. + + +### Compiler + +1. Further selected `stdlib` modules as necessary in the compiler. + +1. AST classes generated from Python ASDL. +Generated classes are Python objects in an `ast` module. +(Question: should they be generated in Java? With ANTLR?) + +1. Compiler from Python source to AST, +probably using the PEG parser. +(If adopting PEG, compile it with CPython and run it with Jython.) + +1. Compiler from AST to CPython byte code: +using the version in Python if possible (compiled with CPython). +Otherwise, follow CPython implementation in Java. +(There is no CPython byte code compiler in Jython 2 legacy.) + +### Jython Command + +1. Jython 3 console command as a Java application +built over the library. + +1. Means to invoke Jython on all major OSes. + +### Python `stdlib` + +Progressively introduce the `stdlib` and its regression test suite. + +The CPython regression test suite is hugely useful +for driving our conformance and completeness, +but the test process itself relies on a large proportion +of the language and `stdlib` working already. + +## Implementation Notes + +A few principles, some drawn from discussions on `jython-dev` or off-list. + +* Adopt or write a higher proportion of modules in Python vs Java, + than is the case in Jython 2. + (Decent but not high performance interpreter is a pre-requisite.) + * Only performance-critical modules are hand-crafted in Java. + * Modules that take advantage of Java libraries call them from Python. + * Enthusiasm for writing in Java should be directed to re-implementing + popular libraries that broaden Jython use (`numpy`, etc.). + +* Use fewer external JARs than in Jython 2. + * Purpose of each JAR should be documented in the build. + * Avoid libraries that circumvent the JVM: + * Incompatibility in dealing strings and i/o has been expensive. + * Many bugs related to `jnr.posix`. (Replace with `java.nio.file`?) + * Carefully consider what `os.*` methods we offer and their semantics. + * Reconsider `jnr.jffi`. (Remove related `ctypes` support.) + +* Use the dynamic language features (at last) starting with `MethodHandle`. + * A core implementation closer to modern CPython. + * MVP: `MethodHandle` used to fill type slots (concept proven). + * When compiling to JVM byte code, create call sites using the same + or a related `MethodHandle`. + +* Use a PEG parser following GvR's lead. + * Gives us a lot for free (but not a whole compiler). + * MVP: Still need a Lexer. (ANTLR?) + * MVP: Generate the AST classes from ASDL. (Python or ANTLR?) + * MVP: Compiler from AST to Python byte code. (Available in Python?) + * Compiler from AST to Java byte code. (Ours to write/update.) + +* Use the six module during development with a view to ensuring our + users can migrate using it. (Suggestion needs exploration.) + + +## Build environment + +All this ought to be followed from the start +in order to maintain acceptable quality (which is MVP). + +* The project is homed at GitHub, where 3.8 is a branch. + +* We follow CPython processes + * Jython dev guide should reflect these processes + * Accepting integrations like as miss-islington may not be available. + +* Build with Gradle + * multi-project, e.g.: `core`, `compiler`, `lib`, `apps` sub-projects. + * composite project, with (say) `tools` for our build-time use only. + +* Build depends on CPython of the target version. + * Likely to need for code-generation + * as a processor with or instead of StringTemplate + * to generate CPython byte code (part of deliverable) + * Reference for performance microbenchmarks. + * Reference for test results (maybe just for the programmer). + * Delivered (MVP) does not require CPython to install or run. + +* Test at multiple layers routinely + * JUnit tests for core elements in isolation (per build/commit). + * `regrtest` test of integrated interpreter (before commit). + * Test parsing at the REPL simulated somehow (before merge). + * This is a shared need with CPython. + * Test what the user actually installs: JAR and application (before merge). + * Test typical user integrations (before merge). + + +## Some roads not to be taken + +* **Not:** Build directly on the `jython/jython3` repo. + * It reproduced the Jython 2 object model. We'd like to move on. + * It has never pulled any bug-fixes from the trunk, + and we judge the merge to be too difficult. + * It is desirable to acknowledge the work somehow, and to pull in some + content, perhaps converted modules, if this is efficient. + * We should make clear on `jython/Jython3` that it is not Jython 3. + * Reports of project death continually appear there. + * They are of course greatly exaggerated. + +* **Not:** Bend the use of Gradle to a file structure conceived for Ant. + * The existing Gradle build works this way and it was *hard work*. + * Git is capable of tracing the ancestry of files that have moved. + +* **Not:** Start from scratch. + * The Jython 2 code base contains a huge amount: + * solutions to problems we haven't even recognised in Jython 3. + * design choices (although mostly free of rationale). + * We'd like to trace our history back to early contributors. + * Downside: for an appreciable time, we shall have legacy code + in `/src` that is waiting to be incorporated. diff --git a/legacy-dev.md b/legacy-dev.md new file mode 100644 index 0000000..53090dc --- /dev/null +++ b/legacy-dev.md @@ -0,0 +1,13 @@ +--- +title: Legacy +--- +## Development before move to Github + +### [Bug tracker](https://bugs.jython.org/) +Good old “bjo” bugs.jython.org. + +### [Mercurial](https://hg.python.org/jython/) +Until June 2020, development took place here. + +### [Github mirror](https://github.com/jython/frozen-mirror/) +This mirror is now frozen. diff --git a/links.md b/links.md index 149d60b..fb4c885 100644 --- a/links.md +++ b/links.md @@ -3,7 +3,7 @@ title: Links --- ## Jython related projects -### [JyNI](https://jyni.org/) +### [JyNI](https://jyni.12hp.de) Aims to enable Jython to use native CPython extensions such as [NumPy](http://www.numpy.org/) or [SciPy](https://www.scipy.org/). ### [The Very Slow Jython Project](https://github.com/jeff5/very-slow-jython) diff --git a/news.md b/news.md index 04c398a..dca52cf 100644 --- a/news.md +++ b/news.md @@ -1,8 +1,54 @@ --- title: News --- + ## News +### Jython 2.7.3 release (v2.7.3 September 2022) + +A new full release is now available for Jython 2.7.3 at +[Maven Central](https://search.maven.org/search?q=g:org.python). +It is built and tested with Java 8 and tested against Java 11. + +The cumulative feature and bug-fix history is at +[NEWS](https://github.com/jython/jython/blob/v2.7.3/NEWS). + + +### Jython 2.7.3 release candidate (v2.7.3rc1 August 2022) + +A release candidate for Jython 2.7.3 is now available at +[Maven Central](https://search.maven.org/search?q=g:org.python). + +There is only one change from the beta +(a natural extension to the sequence-matching feature): + +- Support Java vararg constructors. + +The cumulative feature and bug-fix history is at +[NEWS](https://github.com/jython/jython/blob/v2.7.3rc1/NEWS). + + +### Jython 2.7.3 beta (v2.7.3b1 July 2022) + +A beta release is now available for Jython 2.7.3 at [Maven Central](https://search.maven.org/search?q=g:org.python). +It is tested against Java 8 and Java 11. +The project thanks all those who have helped identify and fix bugs. + +Notable new or changed features include: +- The jython command respects the ``PYTHONDONTWRITEBYTECODE`` environment variable. + +- Matching of sequence arguments to the parameters of Java methods is + improved. + +- ``array.array`` item size of unsigned types is now the same as their signed counterparts, where + previously it was mostly double. + Internal representations have changed. + Client code that was working around anomalies may have to change (in a good way, we hope). + Overall, the experience should be closer to that with CPython. + +Many more fixed bugs are listed in [NEWS](https://github.com/jython/jython/blob/v2.7.3b1/NEWS). + + ### Jython 2.7.2 release (v2.7.2 21 March 2020) A new full release is now available for Jython 2.7.2 at @@ -11,7 +57,7 @@ It is built and tested with Java 8 and tested against Java 11. There are no changes (apart from the version identification) from v2.7.2rc1. For a full list of bugs fixed in all versions see -[NEWS](https://github.com/jythontools/jython/blob/v2.7.2/NEWS). +[NEWS](https://github.com/jython/jython/blob/v2.7.2/NEWS). ### Jython 2.7.2 release candidate (v2.7.2rc1 5 March 2020) @@ -25,7 +71,7 @@ A notable change since beta 3 is the relocation of the package cache to the working directory. For a full list of bugs fixed see -[NEWS](https://github.com/jythontools/jython/blob/v2.7.2rc1/NEWS). +[NEWS](https://github.com/jython/jython/blob/v2.7.2rc1/NEWS). ### Jython 2.7.2 beta (v2.7.2b3 February 2020) @@ -39,7 +85,7 @@ we predict a release candidate in the week beginning 24 February. Notable new features are as already listed for v2.7.2b2. -Fixed bugs are listed in [NEWS](https://github.com/jythontools/jython/blob/v2.7.2b3/NEWS). +Fixed bugs are listed in [NEWS](https://github.com/jython/jython/blob/v2.7.2b3/NEWS). ### Jython 2.7.2 beta (v2.7.2b2 November 2019) @@ -58,7 +104,7 @@ Notable new features include: Numerous instances are corrected where we mis-handled the encoding of file, user and host names, which has been a frequent problem for users where ASCII won't do. -Many more fixed bugs are listed in [NEWS](https://github.com/jythontools/jython/blob/v2.7.2b2/NEWS). +Many more fixed bugs are listed in [NEWS](https://github.com/jython/jython/blob/v2.7.2b2/NEWS). ### New website (October 2018) @@ -73,7 +119,7 @@ Welcome to the new Jython website. The main improvements are: We thought 2017-07-01 was a perfect time to release version 2.7.1 This is a bugfix release. Bug fixes include improvements in SSL and pip support along with lots of improvements in CPython compatibility. -Please see the [NEWS](https://github.com/jythontools/jython/blob/master/NEWS) file for detailed release notes. This release of Jython requires JDK 7 or above. +Please see the [NEWS](https://github.com/jython/jython/blob/master/NEWS) file for detailed release notes. This release of Jython requires JDK 7 or above. This release is being hosted at maven central. There are three main distributions. In order of popularity: @@ -83,7 +129,7 @@ This release is being hosted at maven central. There are three main distribution ### Jython 2.7.0 Final Released (May 2015) -Please see the [NEWS](https://github.com/jythontools/jython/blob/master/NEWS) file for detailed release notes. +Please see the [NEWS](https://github.com/jython/jython/blob/master/NEWS) file for detailed release notes. On behalf of the Jython development team, I'm pleased to announce that the final release of Jython 2.7.0 is available! It's been a long road to get to 2.7, and it's finally here! I'd like to thank Amobee for sponsoring my work on Jython. I'd also like to thank the many contributors to Jython, including - but not limited to - bug reports, patches, pull requests, documentation changes, support emails, and fantastic conversation on Freenode at #jython. @@ -105,7 +151,7 @@ From announcement on [Frank Wierzbickis Weblog](http://fwierzbicki.blogspot.fi/2 ### Jython 2.7 Release Candidate 3 Released (April 2015) -Please see the [NEWS](https://github.com/jythontools/jython/blob/master/NEWS) file for detailed release notes. +Please see the [NEWS](https://github.com/jython/jython/blob/master/NEWS) file for detailed release notes. On behalf of the Jython development team, I'm pleased to announce that the third release candidate of Jython 2.7 is available! I'd like to thank Amobee for sponsoring my work on Jython. I'd also like to thank the many contributors to Jython. diff --git a/registry.md b/registry.md index ca8a040..8e06e1c 100644 --- a/registry.md +++ b/registry.md @@ -4,11 +4,11 @@ title: Jython Registry # Jython Registry -Because there is no good platform independent equivalent of the Windows Registry (or Unix envrionment variables) Java has its own environment variable namespace. Jython acquires its namespace from the following sources (later sources override defaults found in earlier places). +Because there is no good platform independent equivalent of the Windows Registry (or Unix environment variables) Java has its own environment variable namespace. Jython acquires its namespace from the following sources (later sources override defaults found in earlier places). - The Java system properties: typically passed in on the command line as options to the java interpreter. - The Jython "registry" file, which contains prop=value pairs. See below for the algorithm Jython uses to find the registry file. - - The user's personal registry file, which contains similarly formated prop/value pairs. The user's registry file is at `"user.home"+"/.jython"` + - The user's personal registry file, which contains similarly formatted prop/value pairs. The user's registry file is at `"user.home"+"/.jython"` - Jython properties: Specified on the command line as options to the jython class. See the -D option to the interpreter. ## Registry Properties