Skip to content
GitLab
  1. Dec 28, 2021
  3. Dec 24, 2021
  5. Dec 22, 2021
  7. Dec 21, 2021
  9. Dec 14, 2021
    • Bobby Impollonia's avatar
      fix(setup_helpers): ensure ThreadPool is closed (#3548) · 75168113
      Bobby Impollonia authored 
      

* Ensure ThreadPool is closed in setup_helpers

The ParallelCompile setup helper using a ThreadPool to enable its
parallelism. It does not properly close the pool when it is done with
it.
This can lead to a "Exception ignored in: <function Pool.__del__..."
message with traceback being printed at shutdown.
Use pool.terminate() instead of context manager for Python 2.7
compatibility

* Add note to remove code that supports Python 2

Co-authored-by: default avatarBobby Impollonia <bobby@k13capital.com>
      75168113
  11. Dec 07, 2021
  13. Dec 04, 2021
    • Boris Rasin's avatar
      fix: vs2022 compilation, issue #3477 (#3497) · a224d0cc
      Boris Rasin authored 
      

* fix: vs2022 compilation, issue #3477

* silence warning for python 2.7

* disable warning around mbstowcs call

* move disable warning code closer to call site

* turn on vs2022 ci test

* ci: don't run helpers on Windows 2022 & Python 3.5

* limit workaround for stdlib shipped with vs2022 or later

* fix for: limit workaround for stdlib shipped with vs2022 or later

* fix 2 for: limit workaround for stdlib shipped with vs2022 or later

* comment

* ci: add a Windows 2019 run

* ci: add Python 2.7 check too

Co-authored-by: default avatarHenry Schreiner <HenrySchreinerIII@gmail.com>
      a224d0cc
    • Jason Rhinelander's avatar
      Expand std::string_view support to str, bytes, memoryview (#3521) · b4939fcb
      Jason Rhinelander authored 
      * Expand string_view support to str, bytes, memoryview

1. Allows constructing a str or bytes implicitly from a string_view;
   this is essentially a small shortcut allowing a caller to write
   `py::bytes{sv}` rather than `py::bytes{sv.data(), sv.size()}`.

2. Allows implicit conversion *to* string_view from py::bytes -- this
   saves a fair bit more as currently there is no simple way to get such
   a view of the bytes without copying it (or resorting to Python API
   calls).

   (This is not done for `str` because when the str contains unicode we
   have to allocate to a temporary and so there might not be some string
   data we can properly view without owning.)

3. Allows `memoryview::from_memory` to accept a string_view.  As with
   the other from_memory calls, it's entirely your responsibility to
   keep it alive.

This also required moving the string_view availability detection into
detail/common.h because this PR needs it in pytypes.h, which is higher
up the include chain than cast.h where it was being detected currently.

* Move string_view include to pytypes.h

* CI-testing a fix for the "ambiguous conversion" issue.

This change is known to fix the `tensorflow::tstring` issue reported under https://github.com/pybind/pybind11/pull/3521#issuecomment-985100965



TODO: Minimal reproducer for the `tensorflow::tstring` issue.

* Make clang-tidy happy (hopefully).

* Adding minimal reproducer for the `tensorflow::tstring` issue.

Error without the enable_if trick:

```
/usr/local/google/home/rwgk/forked/pybind11/tests/test_builtin_casters.cpp:169:16: error: ambiguous conversion for functional-style cast from 'TypeWithBothOperatorStringAndStringView' to 'py::bytes'
        return py::bytes(TypeWithBothOperatorStringAndStringView());
               ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/local/google/home/rwgk/forked/pybind11/include/pybind11/detail/../pytypes.h:1174:5: note: candidate constructor
    bytes(const std::string &s) : bytes(s.data(), s.size()) { }
    ^
/usr/local/google/home/rwgk/forked/pybind11/include/pybind11/detail/../pytypes.h:1191:5: note: candidate constructor
    bytes(std::string_view s) : bytes(s.data(), s.size()) { }
    ^
```

* Adding missing NOLINTNEXTLINE

* Also apply ambiguous conversion workaround to str()

Co-authored-by: default avatarRalf W. Grosse-Kunstleve <rwgk@google.com>
      b4939fcb
  15. Dec 03, 2021
  17. Nov 23, 2021
  19. Nov 22, 2021
  21. Nov 21, 2021
    • Jason Rhinelander's avatar
      Fix py::kw_only when used before the first arg of a method (#3488) · 673b4be3
      Jason Rhinelander authored 
      * Fix py::kw_only when used before the first arg of a method

The implicit space for the `self` argument isn't added until we hit the
first argument, but this wasn't being done for kw_only or pos_only, and
so a kw_only before the first argument would break.

This fixes it by properly checking whether we need to add the self arg.

(The pos_only issue here was extremely mild -- you didn't get the `/` in
the docstring, but AFAICT it has no other effect since there are no
meaningful arguments before it anyway).

* Style changes

- rename check_have_self_arg -> append_self_arg_if_needed

- move the argument name inline comments before the args instead of
  after
      673b4be3
  23. Nov 19, 2021
  25. Nov 18, 2021
  27. Nov 17, 2021
  29. Nov 16, 2021
  31. Nov 14, 2021
  33. Nov 12, 2021
  35. Nov 11, 2021
  37. Nov 09, 2021
  39. Nov 08, 2021
  41. Nov 06, 2021
  43. Nov 02, 2021
  45. Oct 29, 2021
    • Jason Rhinelander's avatar
      feat: allow kw-only args after a py::args (#3402) · e7c9753f
      Jason Rhinelander authored 
      

* Simply has_kw_only_args handling

This simplifies tracking the number of kw-only args by instead tracking
the number of positional arguments (which is really what we care about
everywhere this is used).

* Allow keyword-only arguments to follow py::args

This removes the constraint that py::args has to be last (or
second-last, with py::kwargs) and instead makes py::args imply
py::kw_only for any remaining arguments, allowing you to bind a function
that works the same way as a Python function such as:

    def f(a, *args, b):
        return a * b + sum(args)

    f(10, 1, 2, 3, b=20)  # == 206

With this change, you can bind such a function using:

    m.def("f", [](int a, py::args args, int b) { /* ... */ },
        "a"_a, "b"_a);

Or, to be more explicit about the keyword-only arguments:

    m.def("g", [](int a, py::args args, int b) { /* ... */ },
        "a"_a, py::kw_only{}, "b"_a);

(The only difference between the two is that the latter will fail at
binding time if the `kw_only{}` doesn't match the `py::args` position).

This doesn't affect backwards compatibility at all because, currently,
you can't have a py::args anywhere except the end/2nd-last.

* Take args/kwargs by const lvalue ref

Co-authored-by: default avatarHenry Schreiner <HenrySchreinerIII@gmail.com>

Co-authored-by: default avatarHenry Schreiner <HenrySchreinerIII@gmail.com>
      e7c9753f
  47. Oct 28, 2021
  49. Oct 27, 2021
    • Henry Schreiner's avatar
      fix: improve support for Python 3.11-dev (#3368) · e7e2c79f
      Henry Schreiner authored 
      * ci: support Python 3.11-dev

Also update 3.10 to final, better PyPy usage

* fix: use PyFrame_GetCode on Python 3.9+

* ci: some bitiness of pypy not supported on win

* chore: update CMake support to 3.22rc1 to quiet warning

* fix: use dev version of py to fix Py 3.11

* tests: print proper Eigen version

* ci: include pypy2, not sure why

* ci: avoid running on Python 3.11 for now

* ci: fix runs

* ci: simpler PyPy usage, drop unmaintained scipy + pypy index

* ci: only binary numpy, wait on pypy 3.8

* refactor: address review
      e7e2c79f