Unity-Technologies · BadSingleton · May 26, 2023 · Oct 15, 2021 · Oct 17, 2021 · Oct 17, 2021
diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md
@@ -16,5 +16,6 @@ Check all those that are applicable and complete.
 
 -   [ ] Make sure to include one or more tests for your change
 -   [ ] If an enhancement PR, please create docs and at best an example
+-   [ ] Ensure you have signed the [.NET Foundation CLA](https://cla.dotnetfoundation.org/pythonnet/pythonnet)
 -   [ ] Add yourself to [`AUTHORS`](../blob/master/AUTHORS.md)
 -   [ ] Updated the [`CHANGELOG`](../blob/master/CHANGELOG.md)
diff --git a/.github/workflows/ARM.yml b/.github/workflows/ARM.yml
@@ -0,0 +1,56 @@
+name: Main (ARM)
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+
+jobs:
+  build-test-arm:
+    name: Build and Test ARM64
+    runs-on: [self-hosted, linux, ARM64]
+    timeout-minutes: 15
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+
+      - name: Setup .NET
+        uses: actions/setup-dotnet@v1
+        with:
+          dotnet-version: '6.0.x'
+
+      - name: Clean previous install
+        run: |
+          pip uninstall -y pythonnet
+
+      - name: Install dependencies
+        run: |
+          pip install --upgrade -r requirements.txt
+          pip install pytest numpy # for tests
+
+      - name: Build and Install
+        run: |
+          pip install -v .
+
+      - name: Set Python DLL path (non Windows)
+        run: |
+          echo PYTHONNET_PYDLL=$(python -m find_libpython) >> $GITHUB_ENV
+
+      - name: Embedding tests
+        run: dotnet test --logger "console;verbosity=detailed" src/embed_tests/
+
+      - name: Python Tests (Mono)
+        run: python -m pytest --runtime mono
+
+      - name: Python Tests (.NET Core)
+        run: python -m pytest --runtime coreclr
+
+      - name: Python tests run from .NET
+        run: dotnet test src/python_tests_runner/
+
+      #- name: Perf tests
+      #  run: |
+      #    pip install --force --no-deps --target src/perf_tests/baseline/ pythonnet==2.5.2
+      #    dotnet test --configuration Release --logger "console;verbosity=detailed" src/perf_tests/
diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
@@ -1,23 +1,28 @@
-name: GitHub Actions
+name: Main
 
-on: [ pull_request, push ]
+on:
+  push:
+    branches:
+      - master
+  pull_request:
 
 jobs:
   build-test:
     name: Build and Test
     runs-on: ${{ matrix.os }}-latest
-    timeout-minutes: 5
+    timeout-minutes: 15
 
     strategy:
       fail-fast: false
       matrix:
         os: [windows, ubuntu, macos]
-        python: [3.6, 3.7, 3.8, 3.9]
-        platform: [x64]
-        shutdown_mode: [Normal, Soft]
-
-    env:
-      PYTHONNET_SHUTDOWN_MODE: ${{ matrix.SHUTDOWN_MODE }}
+        python: ["3.7", "3.8", "3.9", "3.10"]
+        platform: [x64, x86]
+        exclude:
+          - os: ubuntu
+            platform: x86
+          - os: macos
+            platform: x86
 
     steps:
       - name: Set Environment on macOS
@@ -31,6 +36,8 @@ jobs:
 
       - name: Setup .NET
         uses: actions/setup-dotnet@v1
+        with:
+          dotnet-version: '6.0.x'
 
       - name: Set up Python ${{ matrix.python }}
         uses: actions/setup-python@v2
@@ -41,22 +48,47 @@ jobs:
       - name: Install dependencies
         run: |
           pip install --upgrade -r requirements.txt
+          pip install numpy # for tests
 
       - name: Build and Install
         run: |
-          python setup.py configure
           pip install -v .
 
-      - name: Python Tests
-        run: pytest
+      - name: Set Python DLL path (non Windows)
+        if: ${{ matrix.os != 'windows' }}
+        run: |
+          echo PYTHONNET_PYDLL=$(python -m find_libpython) >> $GITHUB_ENV
+
+      - name: Set Python DLL path (Windows)
+        if: ${{ matrix.os == 'windows' }}
+        run: |
+          Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append -InputObject "PYTHONNET_PYDLL=$(python -m find_libpython)"
 
       - name: Embedding tests
-        run: dotnet test --runtime any-${{ matrix.platform }} src/embed_tests/
-        if: ${{ matrix.os != 'macos' }} # Not working right now, doesn't find libpython
+        run: dotnet test --runtime any-${{ matrix.platform }} --logger "console;verbosity=detailed" src/embed_tests/
+        env:
+          MONO_THREADS_SUSPEND: preemptive # https://github.com/mono/mono/issues/21466
+
+      - name: Python Tests (Mono)
+        if: ${{ matrix.os != 'windows' }}
+        run: pytest --runtime mono
+
+      # TODO: Run these tests on Windows x86
+      - name: Python Tests (.NET Core)
+        if: ${{ matrix.platform == 'x64' }}
+        run: pytest --runtime coreclr
+
+      - name: Python Tests (.NET Framework)
+        if: ${{ matrix.os == 'windows' }}
+        run: pytest --runtime netfx
 
       - name: Python tests run from .NET
         run: dotnet test --runtime any-${{ matrix.platform }} src/python_tests_runner/
-        if: ${{ matrix.os == 'windows' }} # Not working for others right now
 
-      # TODO: Run perf tests
+      - name: Perf tests
+        if: ${{ (matrix.python == '3.8') && (matrix.platform == 'x64') }}
+        run: |
+          pip install --force --no-deps --target src/perf_tests/baseline/ pythonnet==2.5.2
+          dotnet test --configuration Release --runtime any-${{ matrix.platform }} --logger "console;verbosity=detailed" src/perf_tests/
+
       # TODO: Run mono tests on Windows?
diff --git a/.github/workflows/nuget-preview.yml b/.github/workflows/nuget-preview.yml
@@ -0,0 +1,63 @@
+name: NuGet Preview Release
+
+on:
+  schedule:
+  - cron: "5 4 3 */1 *" # once a month, at 4:05 on 3rd
+  workflow_dispatch:
+
+jobs:
+  release:
+    name: Release Preview
+    runs-on: ubuntu-latest
+    environment: NuGet
+    timeout-minutes: 10
+
+    env:
+      PYTHONNET_SHUTDOWN_MODE: Normal
+
+    steps:
+      - name: Get Date
+        run: |
+          echo "DATE_VER=$(date "+%Y-%m-%d")" >> $GITHUB_ENV
+
+      - name: Checkout code
+        uses: actions/checkout@v2
+
+      - name: Setup .NET
+        uses: actions/setup-dotnet@v1
+        with:
+          dotnet-version: '6.0.x'
+
+      - name: Set up Python 3.8
+        uses: actions/setup-python@v2
+        with:
+          python-version: 3.8
+          architecture: x64
+
+      - name: Install dependencies
+        run: |
+          pip install --upgrade -r requirements.txt
+          pip install numpy # for tests
+
+      - name: Build and Install
+        run: |
+          pip install -v .
+
+      - name: Set Python DLL path (non Windows)
+        if: ${{ matrix.os != 'windows' }}
+        run: |
+          echo PYTHONNET_PYDLL=$(python -m find_libpython) >> $GITHUB_ENV
+
+      - name: Python Tests
+        run: pytest
+
+      - name: Embedding tests
+        run: dotnet test --runtime any-ubuntu src/embed_tests/
+
+      - name: Pack
+        run: dotnet pack --configuration Release --version-suffix preview${{env.DATE_VER}} --output "Release-Preview"
+
+      - name: Publish NuGet
+        run: |
+          dotnet nuget push --source https://api.nuget.org/v3/index.json --api-key ${{ secrets.NUGET_MONTHLY }} Release-Preview/*.nupkg
+          dotnet nuget push --skip-duplicate --source https://api.nuget.org/v3/index.json --api-key ${{ secrets.NUGET_MONTHLY }} Release-Preview/*.snupkg
diff --git a/.gitignore b/.gitignore
@@ -1,7 +1,5 @@
 /src/runtime/interopNative.cs
-
-# Configuration data
-configured.props
+/src/perf_tests/baseline/
 
 # General binaries and Build results
 *.dll

diff --git a/AUTHORS.md b/AUTHORS.md
@@ -55,6 +55,7 @@
 -   Meinrad Recheis ([@henon](https://github.com/henon))
 -   Mohamed Koubaa ([@koubaa](https://github.com/koubaa))
 -   Patrick Stewart ([@patstew](https://github.com/patstew))
+-   Peter Kese ([@pkese](https://github.com/pkese))
 -   Raphael Nestler ([@rnestler](https://github.com/rnestler))
 -   Rickard Holmberg ([@rickardraysearch](https://github.com/rickardraysearch))
 -   Sam Winstanley ([@swinstanley](https://github.com/swinstanley))
@@ -83,3 +84,4 @@
 -   ([@DanBarzilian](https://github.com/DanBarzilian))
 -   ([@alxnull](https://github.com/alxnull))
 -   ([@gpetrou](https://github.com/gpetrou))
+-   Ehsan Iran-Nejad ([@eirannejad](https://github.com/eirannejad))
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -12,47 +12,124 @@ This document follows the conventions laid out in [Keep a CHANGELOG][].
 -   Ability to instantiate new .NET arrays using `Array[T](dim1, dim2, ...)` syntax
 -   Python operator method will call C# operator method for supported binary and unary operators ([#1324][p1324]).
 -   Add GetPythonThreadID and Interrupt methods in PythonEngine
+-   Ability to implement delegates with `ref` and `out` parameters in Python, by returning the modified parameter values in a tuple. ([#1355][i1355])
+-   Ability to override .NET methods that have `out` or `ref` in Python by returning the modified parameter values in a tuple. ([#1481][i1481])
+-   `PyType` - a wrapper for Python type objects, that also permits creating new heap types from `TypeSpec`
+-    Improved exception handling:
+  *   exceptions can now be converted with codecs
+  *   `InnerException` and `__cause__` are propagated properly
+-   `__name__` and `__signature__` to reflected .NET methods
+-   .NET collection types now implement standard Python collection interfaces from `collections.abc`.
+See [Mixins/collections.py](src/runtime/Mixins/collections.py).
+-   you can cast objects to generic .NET interfaces without specifying generic arguments as long as there is no ambiguity.
+-   .NET arrays implement Python buffer protocol
+-   Python integer interoperability with `System.Numerics.BigInteger`
+-   Python.NET will correctly resolve .NET methods, that accept `PyList`, `PyInt`,
+and other `PyObject` derived types when called from Python.
+-   .NET classes, that have `__call__` method are callable from Python
+-   `PyIterable` type, that wraps any iterable object in Python
+-   `PythonEngine` properties for supported Python versions: `MinSupportedVersion`, `MaxSupportedVersion`, and `IsSupportedVersion`
+-   The runtime that is loaded on `import clr` can now be configured via environment variables
+
 
 ### Changed
--   Drop support for Python 2, 3.4, and 3.5
+-   Drop support for Python 2, 3.4, 3.5, and 3.6
 -   `wchar_t` size aka `Runtime.UCS` is now determined at runtime
 -   `clr.AddReference` may now throw errors besides `FileNotFoundException`, that provide more
 details about the cause of the failure
 -   `clr.AddReference` no longer adds ".dll" implicitly
 -   `PyIter(PyObject)` constructor replaced with static `PyIter.GetIter(PyObject)` method
+-   Python runtime can no longer be shut down if the Python error indicator is set, as it would have unpredictable behavior
 -   BREAKING: Return values from .NET methods that return an interface are now automatically
      wrapped in that interface. This is a breaking change for users that rely on being
      able to access members that are part of the implementation class, but not the
-     interface.  Use the new __implementation__ or __raw_implementation__ properties to
+     interface.  Use the new `__implementation__` or `__raw_implementation__` properties to
      if you need to "downcast" to the implementation class.
+-   BREAKING: `==` and `!=` operators on `PyObject` instances now use Python comparison
+     (previously was equivalent to `object.ReferenceEquals(,)`)
 -   BREAKING: Parameters marked with `ParameterAttributes.Out` are no longer returned in addition
      to the regular method return value (unless they are passed with `ref` or `out` keyword).
 -   BREAKING: Drop support for the long-deprecated CLR.* prefix.
 -   `PyObject` now implements `IEnumerable<PyObject>` in addition to `IEnumerable`
 -   floating point values passed from Python are no longer silently truncated
 when .NET expects an integer [#1342][i1342]
+-   More specific error messages for method argument mismatch
+-   members of `PyObject` inherited from `System.Object and `DynamicObject` now autoacquire GIL
+-   BREAKING: when inheriting from .NET types in Python if you override `__init__` you
+must explicitly call base constructor using `super().__init__(.....)`. Not doing so will lead
+to undefined behavior.
+-   BREAKING: most `PyScope` methods will never return `null`. Instead, `PyObject` `None` will be returned.
+-   BREAKING: `PyScope` was renamed to `PyModule`
+-   BREAKING: Methods with `ref` or `out` parameters and void return type return a tuple of only the `ref` and `out` parameters.
+-   BREAKING: to call Python from .NET `Runtime.PythonDLL` property must be set to Python DLL name
+or the DLL must be loaded in advance. This must be done before calling any other Python.NET functions.
+-   BREAKING: `PyObject.Length()` now raises a `PythonException` when object does not support a concept of length.
+-   BREAKING: disabled implicit conversion from C# enums to Python `int` and back.
+One must now either use enum members (e.g. `MyEnum.Option`), or use enum constructor
+(e.g. `MyEnum(42)` or `MyEnum(42, True)` when `MyEnum` does not have a member with value 42).
+-   Sign Runtime DLL with a strong name
+-   Implement loading through `clr_loader` instead of the included `ClrModule`, enables
+    support for .NET Core
+-   BREAKING: .NET and Python exceptions are preserved when crossing Python/.NET boundary
+-   BREAKING: custom encoders are no longer called for instances of `System.Type`
+-   `PythonException.Restore` no longer clears `PythonException` instance.
+-   Replaced the old `__import__` hook hack with a PEP302-style Meta Path Loader
+-   BREAKING: Names of .NET types (e.g. `str(__class__)`) changed to better support generic types
+-   BREAKING: overload resolution will no longer prefer basic types. Instead, first matching overload will
+be chosen.
+-   BREAKING: acquiring GIL using `Py.GIL` no longer forces `PythonEngine` to initialize
+-   BREAKING: `Exec` and `Eval` from `PythonEngine` no longer accept raw pointers.
+-   BREAKING: .NET collections and arrays are no longer automatically converted to
+Python collections. Instead, they implement standard Python
+collection interfaces from `collections.abc`.
+See [Mixins/collections.py](src/runtime/Mixins/collections.py).
+-   BREAKING: When trying to convert Python `int` to `System.Object`, result will
+be of type `PyInt` instead of `System.Int32` due to possible loss of information.
+Python `float` will continue to be converted to `System.Double`.
+-   BREAKING: Python.NET will no longer implicitly convert types like `numpy.float64`, that implement `__float__` to
+`System.Single` and `System.Double`. An explicit conversion is required on Python or .NET side.
+-   BREAKING: `PyObject.GetHashCode` can fail.
+-   BREAKING: Python.NET will no longer implicitly convert any Python object to `System.Boolean`.
+-   BREAKING: `PyObject.GetAttr(name, default)` now only ignores `AttributeError` (previously ignored all exceptions).
+-   BREAKING: `PyObject` no longer implements `IEnumerable<PyObject>`.
+Instead, `PyIterable` does that.
+-   BREAKING: `IPyObjectDecoder.CanDecode` `objectType` parameter type changed from `PyObject` to `PyType`
 
 ### Fixed
 
--    Fix incorrect dereference of wrapper object in `tp_repr`, which may result in a program crash
--    Fix incorrect dereference in params array handling
--    Fixes issue with function resolution when calling overloaded function with keyword arguments from python ([#1097][i1097])
--    Fix `object[]` parameters taking precedence when should not in overload resolution
--    Fixed a bug where all .NET class instances were considered Iterable
--    Fix incorrect choice of method to invoke when using keyword arguments.
--    Fix non-delegate types incorrectly appearing as callable.
--    Indexers can now be used with interface objects
--    Fixed a bug where indexers could not be used if they were inherited
--    Made it possible to use `__len__` also on `ICollection<>` interface objects
--    Fixed issue when calling PythonException.Format where another exception would be raise for unnormalized exceptions
--    Made it possible to call `ToString`, `GetHashCode`, and `GetType` on inteface objects
--    Fixed objects returned by enumerating `PyObject` being disposed too soon
--    Incorrectly using a non-generic type with type parameters now produces a helpful Python error instead of throwing NullReferenceException
+-   Fix incorrect dereference of wrapper object in `tp_repr`, which may result in a program crash
+-   Fixed parameterless .NET constructor being silently called when a matching constructor overload is not found ([#238][i238])
+-   Fix incorrect dereference in params array handling
+-   Fixes issue with function resolution when calling overloaded function with keyword arguments from python ([#1097][i1097])
+-   Fix `object[]` parameters taking precedence when should not in overload resolution
+-   Fixed a bug where all .NET class instances were considered Iterable
+-   Fix incorrect choice of method to invoke when using keyword arguments.
+-   Fix non-delegate types incorrectly appearing as callable.
+-   Indexers can now be used with interface objects
+-   Fixed a bug where indexers could not be used if they were inherited
+-   Made it possible to use `__len__` also on `ICollection<>` interface objects
+-   Fixed issue when calling PythonException.Format where another exception would be raise for unnormalized exceptions
+-   Made it possible to call `ToString`, `GetHashCode`, and `GetType` on inteface objects
+-   Fixed objects returned by enumerating `PyObject` being disposed too soon
+-   Incorrectly using a non-generic type with type parameters now produces a helpful Python error instead of throwing NullReferenceException
 -   `import` may now raise errors with more detail than "No module named X"
+-   Exception stacktraces on `PythonException.StackTrace` are now properly formatted
+-   Providing an invalid type parameter to a generic type or method produces a helpful Python error
+-   Empty parameter names (as can be generated from F#) do not cause crashes
+-   Unicode strings with surrogates were truncated when converting from Python
+-   `Reload` mode now supports generic methods (previously Python would stop seeing them after reload)
+-   Temporarily fixed issue resolving method overload when method signature has `out` parameters ([#1672](i1672))
+-   Decimal default parameters are now correctly taken into account
 
 ### Removed
 
+-   `ShutdownMode` has been removed. The only shutdown mode supported now is an equivalent of `ShutdownMode.Reload`.
+There is no need to specify it.
 -   implicit assembly loading (you have to explicitly `clr.AddReference` before doing import)
+-   messages in `PythonException` no longer start with exception type
+-   `PyScopeManager`, `PyScopeException`, `PyScope` (use `PyModule` instead)
+-   support for .NET Framework 4.0-4.6; Mono before 5.4. Python.NET now requires .NET Standard 2.0
+(see [the matrix](https://docs.microsoft.com/en-us/dotnet/standard/net-standard#net-implementation-support))
 
 ## [2.5.0][] - 2020-06-14
 
@@ -813,3 +890,6 @@ This version improves performance on benchmarks significantly compared to 2.3.
 [p534]: https://github.com/pythonnet/pythonnet/pull/534
 [i449]: https://github.com/pythonnet/pythonnet/issues/449
 [i1342]: https://github.com/pythonnet/pythonnet/issues/1342
+[i238]: https://github.com/pythonnet/pythonnet/issues/238
+[i1481]: https://github.com/pythonnet/pythonnet/issues/1481
+[i1672]: https://github.com/pythonnet/pythonnet/pull/1672