Skip to content

Use Py_UCS4 instead of Py_UNICODE in unicodectype.c #49377

Closed

Description

@bupjae
mannequin
BPO 5127
Nosy @malemburg, @amauryfa, @vstinner, @ezio-melotti
Superseder
  • bpo-7663: narrow build incorrectly translates cases for non-BMP code points
  • Files
  • unicodectype_ucs4.patch
  • unicodectype_ucs4-2.patch
  • unicodectype_ucs4_3.patch: refreshed; don't forget to run makeunicodedata.py
  • unicodectype_ucs4_4.patch
  • unicodectype_ucs4_5.patch
  • unicodectype_ucs4_6.patch
  • Note: these values reflect the state of the issue at the time it was migrated and might not reflect the current state.

    Show more details

    GitHub fields:

    assignee = 'https://github.com/amauryfa'
    closed_at = <Date 2010-08-19.12:56:22.263>
    created_at = <Date 2009-02-02.01:31:39.408>
    labels = ['type-bug', 'expert-unicode']
    title = 'Use Py_UCS4 instead of Py_UNICODE in unicodectype.c'
    updated_at = <Date 2010-08-19.12:56:22.261>
    user = 'https://bugs.python.org/bupjae'

    bugs.python.org fields:

    activity = <Date 2010-08-19.12:56:22.261>
    actor = 'amaury.forgeotdarc'
    assignee = 'amaury.forgeotdarc'
    closed = True
    closed_date = <Date 2010-08-19.12:56:22.263>
    closer = 'amaury.forgeotdarc'
    components = ['Unicode']
    creation = <Date 2009-02-02.01:31:39.408>
    creator = 'bupjae'
    dependencies = []
    files = ['12934', '15047', '15058', '17909', '17911', '17924']
    hgrepos = []
    issue_num = 5127
    keywords = ['patch']
    message_count = 54.0
    messages = ['80924', '80928', '80971', '81044', '81048', '81049', '81051', '81052', '81053', '81057', '81061', '81081', '81090', '81115', '93562', '93585', '93587', '93588', '93589', '93590', '93594', '93595', '93596', '93604', '93611', '93615', '93617', '93636', '93659', '93662', '97441', '97447', '97535', '109509', '109513', '109518', '109519', '109522', '109523', '109526', '109527', '109529', '109530', '109626', '109631', '109644', '109646', '109687', '109689', '109692', '109693', '109695', '109795', '114360']
    nosy_count = 6.0
    nosy_names = ['lemburg', 'amaury.forgeotdarc', 'Rhamphoryncus', 'vstinner', 'ezio.melotti', 'bupjae']
    pr_nums = []
    priority = 'normal'
    resolution = 'fixed'
    stage = 'resolved'
    status = 'closed'
    superseder = '7663'
    type = 'behavior'
    url = 'https://bugs.python.org/issue5127'
    versions = ['Python 3.1', 'Python 3.2']

    Activity

    1. bupjae commented on Feb 2, 2009

      bupjaemannequin
      MannequinAuthor
      >>> license
      Traceback (most recent call last):
        File "<stdin>", line 1, in <module>
        File "C:\Python30\lib\site.py", line 372, in __repr__
          self.__setup()
        File "C:\Python30\lib\site.py", line 359, in __setup
          data = fp.read()
        File "C:\Python30\lib\io.py", line 1724, in read
          decoder.decode(self.buffer.read(), final=True))
        File "C:\Python30\lib\io.py", line 1295, in decode
          output = self.decoder.decode(input, final=final)
      UnicodeDecodeError: 'cp949' codec can't decode bytes in position 15164-
      15165: il
      legal multibyte sequence
      >>> chr(0x10000)
      '\U00010000'
      >>> chr(0x11000)
      Traceback (most recent call last):
        File "<stdin>", line 1, in <module>
        File "C:\Python30\lib\io.py", line 1491, in write
          b = encoder.encode(s)
      UnicodeEncodeError: 'cp949' codec can't encode character '\ud804' in 
      position 1:
       illegal multibyte sequence
      >>>

      I also can't understand why chr(0x10000) and chr(0x11000) has different
      behavior

    2. ezio-melotti commented on Feb 2, 2009

      @ezio-melotti
      Member
      Here (winxpsp2, Py3, cp850-terminal) the license works fine:
      >>> license
      Type license() to see the full license text

      and license() works as well.

      I get this output for the chr()s:
      >>> chr(0x10000)
      '\U00010000'
      >>> chr(0x11000)
      Traceback (most recent call last):
        File "<stdin>", line 1, in <module>
        File "C:\Programs\Python30\lib\io.py", line 1491, in write
          b = encoder.encode(s)
        File "C:\Programs\Python30\lib\encodings\cp850.py", line 19, in encode
          return codecs.charmap_encode(input,self.errors,encoding_map)[0]
      UnicodeEncodeError: 'charmap' codec can't encode characters in position
      1-2: character maps to <undefined>

      I believe that chr(0x10000) and chr(0x11000) should have the opposite
      behavior.
      U+10000 (LINEAR B SYLLABLE B008 A) belongs to the 'Lo' category and
      should be printed (and possibly raise a UnicodeError, see bpo-5110
      1), U+11000 belongs to the 'Cn' category and should be escaped2.

      On Linux with Py3 and a UTF-8 terminal, chr(0x10000) prints '\U00010000'
      and chr(0x11000) prints the char (actually I see two boxes, but it
      shouldn't be a problem of Python). The license() works fine too.

      Also note that with cp850 the error message is 'character maps to
      <undefined>' and with cp949 is 'illegal multibyte sequence'.

    3. amauryfa commented on Feb 2, 2009

      @amauryfa
      Contributor

      There were non-ascii characters in the Windows license file. This was
      corrected with r67860.

      I believe that chr(0x10000) and chr(0x11000) should have the
      opposite behavior.

      This other problem is because on a narrow unicode build,
      Py_UNICODE_ISPRINTABLE takes a 16bit integer.
      And indeed,

      >>> unicodedata.category(chr(0x10000 % 65536))
      'Cc'
      >>> unicodedata.category(chr(0x11000 % 65536))
      'Lo'
    4. vstinner commented on Feb 3, 2009

      @vstinner
      Member

      I don't understand the behaviour of unichr():

      Python 2.7a0 (trunk:68963M, Jan 30 2009, 00:49:28)
      >>> import unicodedata
      >>> unicodedata.category(u"\U00010000")
      'Lo'
      >>> unicodedata.category(u"\U00011000")
      'Cn'
      >>> unicodedata.category(unichr(0x10000))
      Traceback (most recent call last):
        File "<stdin>", line 1, in <module>
      ValueError: unichr() arg not in range(0x10000) (narrow Python build)

      Why unichr() fails whereas \Uxxxxxxxx works?

      >>> len(u"\U00010000")
      2
      >>> ord(u"\U00010000")
      Traceback (most recent call last):
        File "<stdin>", line 1, in <module>
      TypeError: ord() expected a character, but string of length 2 found
    5. ezio-melotti commented on Feb 3, 2009

      @ezio-melotti
      Member
      FWIW, on Python3 it seems to work:
      >>> import unicodedata
      >>> unicodedata.category("\U00010000")
      'Lo'
      >>> unicodedata.category("\U00011000")
      'Cn'
      >>> unicodedata.category(chr(0x10000))
      'Lo'
      >>> unicodedata.category(chr(0x11000))
      'Cn'
      >>> ord(chr(0x10000)), 0x10000
      (65536, 65536)
      >>> ord(chr(0x11000)), 0x11000
      (69632, 69632)
      
      I'm using a narrow build too:
      >>> import sys
      >>> sys.maxunicode
      65535
      >>> len('\U00010000')
      2
      >>> ord('\U00010000')
      65536

      On Python2 unichr() is supposed to raise a ValueError on a narrow build
      if the value is greater than 0xFFFF 1, but if the characters above
      0xFFFF can be represented with u"\Uxxxxxxxx" there should be a way to
      fix unichr so it can return them. Python3 already does it with chr().

      Maybe we should open a new issue for this if it's not present already.

    6. amauryfa commented on Feb 3, 2009

      @amauryfa
      Contributor

      Since r56395, ord() and chr() accept and return surrogate pairs even in
      narrow builds.

      The goal is to remove most differences between narrow and wide unicode
      builds (except for string lengths, indices or slices)

      To address this problem, I suggest to change all functions in
      unicodectype.c so that they accept Py_UCS4 characters (instead of
      Py_UNICODE).
      This would be a binary-incompatible change; and --with-wctype-functions
      would have an effect only if sizeof(wchar_t)==4 (instead of the current
      condition sizeof(wchar_t)==sizeof(PY_UNICODE_TYPE))

    7. malemburg commented on Feb 3, 2009

      @malemburg
      Member

      On 2009-02-03 13:39, Amaury Forgeot d'Arc wrote:

      Amaury Forgeot d'Arc <amauryfa@gmail.com> added the comment:

      Since r56395, ord() and chr() accept and return surrogate pairs even in
      narrow builds.

      The goal is to remove most differences between narrow and wide unicode
      builds (except for string lengths, indices or slices)

      To address this problem, I suggest to change all functions in
      unicodectype.c so that they accept Py_UCS4 characters (instead of
      Py_UNICODE).

      -1.

      That would cause major breakage in the C API and is not inline with the
      intention of having a Py_UNICODE type in the first place.

      Users who are interested in UCS4 builds should simply use UCS4 builds.

      This would be a binary-incompatible change; and --with-wctype-functions
      would have an effect only if sizeof(wchar_t)==4 (instead of the current
      condition sizeof(wchar_t)==sizeof(PY_UNICODE_TYPE))

      --with-wctype-functions was scheduled for removal many releases ago,
      but I never got around to it. The only reason it's still there is
      that some Linux distribution use this config option (AFAIR, RedHat).
      I'd be +1 on removing the option in 3.0.1 or deprecating it in
      3.0.1 and removing it in 3.1.

      It's not useful in any way, and causes compatibility problems
      with regular builds.

    8. vstinner commented on Feb 3, 2009

      @vstinner
      Member

      amaury> Since r56395, ord() and chr() accept and return surrogate pairs
      amaury> even in narrow builds.

      Note: My examples are made with Python 2.x.

      The goal is to remove most differences between narrow and wide unicode
      builds (except for string lengths, indices or slices)

      It would be nice to get the same behaviour in Python 2.x and 3.x to help
      migration from Python2 to Python3 ;-)

      unichr() (in Python 2.x) documentation is correct. But I would approciate to
      support surrogates using unichr() which means also changing ord() behaviour.

      To address this problem, I suggest to change all functions in
      unicodectype.c so that they accept Py_UCS4 characters (instead of
      Py_UNICODE).

      Why? Using surrogates, you can use 16-bits Py_UNICODE to store non-BMP
      characters (code > 0xffff).

      --

      I can open a new issue if you agree that we can change unichr() / ord()
      behaviour on narrow build. We may ask on the mailing list?

    9. malemburg commented on Feb 3, 2009

      @malemburg
      Member

      On 2009-02-03 14:14, STINNER Victor wrote:

      STINNER Victor <victor.stinner@haypocalc.com> added the comment:

      amaury> Since r56395, ord() and chr() accept and return surrogate pairs
      amaury> even in narrow builds.

      Note: My examples are made with Python 2.x.

      > The goal is to remove most differences between narrow and wide unicode
      > builds (except for string lengths, indices or slices)

      It would be nice to get the same behaviour in Python 2.x and 3.x to help
      migration from Python2 to Python3 ;-)

      unichr() (in Python 2.x) documentation is correct. But I would approciate to
      support surrogates using unichr() which means also changing ord() behaviour.

      This is not possible for unichr() in Python 2.x, since applications
      always expect len(unichr(x)) == 1.

      Changing ord() would be possible in Python 2.x is easier, since
      this would only extend the range of returned values for UCS2
      builds.

      > To address this problem, I suggest to change all functions in
      > unicodectype.c so that they accept Py_UCS4 characters (instead of
      > Py_UNICODE).

      Why? Using surrogates, you can use 16-bits Py_UNICODE to store non-BMP
      characters (code > 0xffff).

      --

      I can open a new issue if you agree that we can change unichr() / ord()
      behaviour on narrow build. We may ask on the mailing list?

    10. amauryfa commented on Feb 3, 2009

      @amauryfa
      Contributor

      That would cause major breakage in the C API

      Not if you recompile. I don't see how this breaks the API at the C level.

      and is not inline with the intention of having a Py_UNICODE
      type in the first place.

      Py_UNICODE is still used as the allocation unit for unicode strings.

      To get correct results, we need a way to access the whole unicode
      database even on ucs2 builds; it's possible with the unicodedata module,
      why not from C?

      My motivation for the change is this post:
      http://mail.python.org/pipermail/python-dev/2008-July/080900.html

    11. vstinner commented on Feb 3, 2009

      @vstinner
      Member

      lemburg> This is not possible for unichr() in Python 2.x, since applications
      lemburg> always expect len(unichr(x)) == 1

      Oh, ok.

      lemburg> Changing ord() would be possible in Python 2.x is easier, since
      lemburg> this would only extend the range of returned values for UCS2
      lemburg> builds.

      ord() of Python3 (narrow build) rejects surrogate characters:

      '\U00010000'
      >>> len(chr(0x10000))
      2
      >>> ord(0x10000)
      Traceback (most recent call last):
        File "<stdin>", line 1, in <module>
      TypeError: ord() expected string of length 1, but int found

      It looks that narrow builds with surrogates have some more problems...

      Test with U+10000: "LINEAR B SYLLABLE B008 A", category: Letter, Other.

      Correct result (Python 2.5, wide build):

         $ python
         Python 2.5.1 (r251:54863, Jul 31 2008, 23:17:40)
         >>> unichr(0x10000)
         u'\U00010000'
         >>> unichr(0x10000).isalpha()
         True

      Error in Python3 (narrow build):

         marge$ ./python
         Python 3.1a0 (py3k:69105M, Feb  3 2009, 15:04:35)
         >>> chr(0x10000).isalpha()
         False
         >>> list(chr(0x10000))
         ['\ud800', '\udc00']
         >>> chr(0xd800).isalpha()
         False
         >>> chr(0xdc00).isalpha()
         False

      Unicode ranges, all in the category "Other, Surrogate":

      • U+D800..U+DB7F: Non Private Use High Surrogate
      • U+DB80..U+DBFF: Private Use High Surrogate
      • U+DC00..U+DFFF: Low Surrogate" range
    12. malemburg commented on Feb 3, 2009

      @malemburg
      Member

      On 2009-02-03 14:50, Amaury Forgeot d'Arc wrote:

      Amaury Forgeot d'Arc <amauryfa@gmail.com> added the comment:

      > That would cause major breakage in the C API

      Not if you recompile. I don't see how this breaks the API at the C level.

      Well, then try to look at such a change from a C extension
      writer's perspective.

      They'd have to change all their function calls and routines to work
      with Py_UCS4.

      Supporting both the old API and the new one would
      be nearly impossible and require either an adapter API or a lot
      of #ifdef'ery.

      Please remember that the public Python C API is not only meant for
      Python developers. It's main purpose is for it to be used by
      other developers extending or embedding Python and those developers
      use different release cycles and want to support more than just the
      bleeding edge Python version.

      Python has a long history of providing very stable APIs, both in
      C and in Python.

      FWIW: The last major change in the C API (the change to Py_ssize_t
      from Python 2.4 to 2.5) has not even propogated to all major C
      extensions yet. It's only now that people start to realize problems
      with this, since their extensions start failing with segfaults
      on 64-bit machines.

      That said, we can of course provide additional UCS4 APIs for
      certain things and also provide conversion helpers between
      Py_UNICODE and Py_UCS4 where needed.

      > and is not inline with the intention of having a Py_UNICODE
      > type in the first place.

      Py_UNICODE is still used as the allocation unit for unicode strings.

      To get correct results, we need a way to access the whole unicode
      database even on ucs2 builds; it's possible with the unicodedata module,
      why not from C?

      I must be missing some detail, but what does the Unicode database
      have to do with the unicodeobject.c C API ?

      My motivation for the change is this post:
      http://mail.python.org/pipermail/python-dev/2008-July/080900.html

      There are certainly other ways to make Python deal with surrogates
      in more cases than the ones we already support.

    13. ezio-melotti commented on Feb 3, 2009

      @ezio-melotti
      Member
      haypo> ord() of Python3 (narrow build) rejects surrogate characters:
      haypo> '\U00010000'
      haypo> >>> len(chr(0x10000))
      haypo> 2
      haypo> >>> ord(0x10000)
      haypo> TypeError: ord() expected string of length 1, but int found
      
      ord() works fine on Py3, you probably meant to do 
      >>> ord('\U00010000')
      65536
      or
      >>> ord(chr(0x10000))
      65536
      
      In Py3 is also stated that it accepts surrogate pairs (help(ord)).
      Py2 instead doesn't support them:
      >>> ord(u'\U00010000')
      TypeError: ord() expected a character, but string of length 2 found
    14. amauryfa commented on Feb 3, 2009

      @amauryfa
      Contributor

      I must be missing some detail, but what does the Unicode database
      have to do with the unicodeobject.c C API ?

      Ah, now I understand your concerns. My suggestion is to change only the 20 functions in
      unicodectype.c: _PyUnicode_IsAlpha, _PyUnicode_ToLowercase... and no change in
      unicodeobject.c at all.
      They all take a single code point as argument, some also return a single code point.
      Changing these functions is backwards compatible.

      I join a patch so we can argue on concrete code (tests are missing).

      Another effect of the patch: unicodedata.numeric('\N{AEGEAN NUMBER TWO}') can return 2.0.

      The str.isalpha() (and others) methods did not change: they still split the surrogate pairs.

    15. 30 remaining items

    16. malemburg commented on Jul 8, 2010

      @malemburg
      Member

      Ezio Melotti wrote:

      Marc-Andre Lemburg wrote:
      > I was never a fan of the Unicode repr() change to begin with. The
      > repr() of an object should work in almost all cases.

      I still think that bpo-5110 should be fixed (there's also a patch to fix the issue on Windows). If you agree please comment there and/or reopen that issue.

      Let's discuss this on bpo-9198.

    17. amauryfa commented on Jul 8, 2010

      @amauryfa
      Contributor

      consider replacing the tab characters before the comments with spaces
      It's actually already the case in my working copy.

    18. amauryfa commented on Jul 8, 2010

      @amauryfa
      Contributor

      A new patch, generated on top of r82662

    19. malemburg commented on Jul 8, 2010

      @malemburg
      Member

      Amaury Forgeot d'Arc wrote:

      Amaury Forgeot d'Arc <amauryfa@gmail.com> added the comment:

      A new patch, generated on top of r82662

      Could you explain what this bit is about ?

      @@ -349,7 +313,7 @@
      configure Python using --with-wctype-functions. This reduces the
      interpreter's code size. */

      -#if defined(HAVE_USABLE_WCHAR_T) && defined(WANT_WCTYPE_FUNCTIONS)
      +#if defined(Py_UNICODE_WIDE) && defined(WANT_WCTYPE_FUNCTIONS)

       #include <wctype.h>
    20. amauryfa commented on Jul 8, 2010

      @amauryfa
      Contributor

      A new patch that doesn't remove an important check, avoids a crash when the C macro is called with a huge number. thanks Ezio.

    21. amauryfa commented on Jul 8, 2010

      @amauryfa
      Contributor

      Could you explain what this bit is about ?
      -#if defined(HAVE_USABLE_WCHAR_T) && defined(WANT_WCTYPE_FUNCTIONS)
      +#if defined(Py_UNICODE_WIDE) && defined(WANT_WCTYPE_FUNCTIONS)

      On Windows at least, HAVE_USABLE_WCHAR_T is True, this means that Py_Unicode can be converted to wchar_t. But now that Py_UNICODE_ISSPACE() takes Py_UCS4, it cannot be converted to wchar_t anymore.

      Now that the unicode database functions claim to use Py_UCS4, the functions of wctypes.h are usable only if they also support Py_UCS4.

      OTOH the symbol WANT_WCTYPE_FUNCTIONS is defined only if ./configure is called with --with-wctype-functions, I don't expect it to be common.
      BTW, the comment says that "This reduces the interpreter's code size". I don't really agree, these functions are two-liners.

    22. malemburg commented on Jul 9, 2010

      @malemburg
      Member

      Amaury Forgeot d'Arc wrote:

      Amaury Forgeot d'Arc <amauryfa@gmail.com> added the comment:

      > Could you explain what this bit is about ?
      > -#if defined(HAVE_USABLE_WCHAR_T) && defined(WANT_WCTYPE_FUNCTIONS)
      > +#if defined(Py_UNICODE_WIDE) && defined(WANT_WCTYPE_FUNCTIONS)

      On Windows at least, HAVE_USABLE_WCHAR_T is True, this means that Py_Unicode can be converted to wchar_t. But now that Py_UNICODE_ISSPACE() takes Py_UCS4, it cannot be converted to wchar_t anymore.

      Right, but you still have to check whether wchar_t is usable, don't
      you ? If wchar_t is 2 bytes on a non-Windows platform, using the
      wctypes functions won't work either.

      The line should probably read:

      #if defined(WANT_WCTYPE_FUNCTIONS) && defined(HAVE_USABLE_WCHAR_T) && defined(Py_UNICODE_WIDE)
      

      Now that the unicode database functions claim to use Py_UCS4, the functions of wctypes.h are usable only if they also support Py_UCS4.

      OTOH the symbol WANT_WCTYPE_FUNCTIONS is defined only if ./configure is called with --with-wctype-functions, I don't expect it to be common.
      BTW, the comment says that "This reduces the interpreter's code size". I don't really agree, these functions are two-liners.

      True.

      The support for the wctype functions should have been remove long ago,
      since they cause subtle incompatibilities between Python builds. I should
      have probably never added it in the first place... people were worried
      about the size of the type record tables at the time, which is why
      I thought it would be a good idea to try to optionally use the C lib
      functions.

      The comment was true before the Python type tables were changed
      into a type record database: the switch used to remove the
      Python tables required for those functions. With the type records
      database, this is no longer the case, since the records are also
      being used for properties that are not exposed via wctype functions.

    23. malemburg commented on Jul 9, 2010

      @malemburg
      Member

      Amaury Forgeot d'Arc wrote:

      Amaury Forgeot d'Arc <amauryfa@gmail.com> added the comment:

      A new patch that doesn't remove an important check, avoids a crash when the C macro is called with a huge number. thanks Ezio.

      Could you please be more specific on what you changed ?

      At least visually, there don't appear to be any differences between
      v4 and v5 of the patch.

      Thanks,

      Marc-Andre Lemburg
      eGenix.com


      2010-07-19: EuroPython 2010, Birmingham, UK 9 days to go

      ::: Try our new mxODBC.Connect Python Database Interface for free ! ::::

      eGenix.com Software, Skills and Services GmbH Pastor-Loeh-Str.48
      D-40764 Langenfeld, Germany. CEO Dipl.-Math. Marc-Andre Lemburg
      Registered at Amtsgericht Duesseldorf: HRB 46611
      http://www.egenix.com/company/contact/

    24. ezio-melotti commented on Jul 9, 2010

      @ezio-melotti
      Member

      The 'if' in 'gettyperecord'. (I would also rewrite that as "if (code > 0x10FFFF)", it looks more readable to me.)

      The patch seems OK to me. In the NEWS message 'python' should be capitalized and I would also mention .isprintable() and possibly other functions that are affected directly -- mentioning repr() is good too, but it's only affected indirectly.

    25. malemburg commented on Jul 9, 2010

      @malemburg
      Member

      Ezio Melotti wrote:

      Ezio Melotti <ezio.melotti@gmail.com> added the comment:

      The 'if' in 'gettyperecord'. (I would also rewrite that as "if (code > 0x10FFFF)", it looks more readable to me.)

      Ah, good catch !

      The patch seems OK to me. In the NEWS message 'python' should be capitalized and I would also mention .isprintable() and possibly other functions that are affected directly -- mentioning repr() is good too, but it's only affected indirectly.

    26. amauryfa commented on Jul 9, 2010

      @amauryfa
      Contributor

      str.isprintable() &co are not changed by this patch, because they enumerate Py_UNICODE units and do not join surrogates. See bpo-9200

    27. amauryfa commented on Jul 9, 2010

      @amauryfa
      Contributor

      In this 6th patch, the wctype part was changed as suggested.
      there is one more condition, Py_UNICODE_WIDE:

      -#if defined(HAVE_USABLE_WCHAR_T) && defined(WANT_WCTYPE_FUNCTIONS)
      +#if defined(WANT_WCTYPE_FUNCTIONS) && defined(HAVE_USABLE_WCHAR_T) && defined(Py_UNICODE_WIDE)

    28. amauryfa commented on Aug 19, 2010

      @amauryfa
      Contributor

      Committed with r84177.

    29. transferred this issue fromon Apr 10, 2022
    Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

    Metadata

    Metadata

    Assignees

    Labels

    Projects

    No projects

      Milestone

      No milestone

      Relationships

      None yet

      Development

      No branches or pull requests

      Issue actions