remove str support from JArray __class_getitem__

doc/CHANGELOG.rst

@@ -7,7 +7,7 @@ Latest Changes:
 
 - **1.5.1_dev0 - 2023-12-15**
 
-  - Added support for typing ``JArray``. ``JArray[java.lang.Object]`` ``JArray["java.lang.Object"]``
+  - Added support for typing ``JArray`` (Java type only), e.g. ``JArray[java.lang.Object]`` ``"JArray[java.lang.Object]"``
 
   - Fixed uncaught exception while setting traceback causing issues in Python 3.11/3.12.
 
@@ -53,10 +53,10 @@ Latest Changes:
 
   - Add additional matching level for derived types to resolve ambiguities when
     a derived type is used in place of base class when determining the method
-    overload.  This will resolve some previous ambiguities between methods.
+    overload.  This will resolve some previous ambiguities between methods.  
 
 - **1.4.1 - 2022-10-26**
-
+  
   - Fixed issue with startJVM changing locale settings.
 
   - Changes to support Python 3.11
@@ -76,7 +76,7 @@ Latest Changes:
     - Support for byte order channels on buffer transfers.
 
     - Byte size for buffers now fixed to Java definitions.
-
+      
     - When directly accessing Java arrays using memory view, Python requires a
       cast from buffers.  Required because Python does not support memory view
       alterations on non-native sizes.
@@ -91,8 +91,8 @@ Latest Changes:
 
   - dbapi2 handles drivers that don't support autocommit.
 
-  - Fixed issue when Java classes with dunder methods such as  ``__del__``
-    caused conflicts in Python type system.   Java method which match dunder
+  - Fixed issue when Java classes with dunder methods such as  ``__del__`` 
+    caused conflicts in Python type system.   Java method which match dunder 
     patterns are longer translated to Python.
 
   - Fix issue with numpy arrays with no dimensions resulting in crash.
@@ -110,7 +110,7 @@ Latest Changes:
 
   - Fixed issue with classes with unsatified dependencies leading to a crash
     on windows.
-
+  
   - Fixed a bug with arrays created using the short cut.  The wrong type
     was being returned.
 
@@ -154,10 +154,10 @@ Latest Changes:
 
 - **1.1.1 - 2020-10-21**
 
-  - Fixed packaging problem on linux.
+  - Fixed packaging problem on linux.  
 
 - **1.1.0 - 2020-10-13**
-
+  
   - Correct bug resulting in reporting ambiguous overloads when resolving
     methods with variadic arguments.
 
@@ -169,7 +169,7 @@ Latest Changes:
 
   - Fixed crash with Ctrl+C when multiple exceptions were generated.
 
-  - Removed extraneous exception when calling Ctrl+C before Java code is
+  - Removed extraneous exception when calling Ctrl+C before Java code is 
     executed for methods and fields.
 
   - Fixed memory leak with string cache.
@@ -203,9 +203,9 @@ Latest Changes:
 
   - Improved speed on transfer of lists, tuples, buffers to arrays of Java
     primitives by a factor of 4 to 100 depending on the data type.  The
-    conversion uses optimized path for memory buffers, rather than the
+    conversion uses optimized path for memory buffers, rather than the 
     Sequence API.  When a Python buffer is encountered only the
-    first element is checked for conversion as Python buffers are homogeneous.
+    first element is checked for conversion as Python buffers are homogeneous. 
 
   - Corrected symbol problem with Python 3.5.3.  PySlice_Unpack was introduced
     in a later patch release and should not have been used.
@@ -225,15 +225,15 @@ Latest Changes:
 
   - A bug was reported with numpy.linalg.inv resulting in crashes.  This was
     traced to an interaction with threading between the JVM and some compilations
-    of numpy.  The workaround appears to be calling numpy.linalg.inv prior to
+    of numpy.  The workaround appears to be calling numpy.linalg.inv prior to 
     starting the JVM.
 
 - **1.0.1 - 2020-07-16**
 
   - Workarounds for Python 3.8.4 release.  Python altered logic regarding the
     use of ``__setattr__`` for object and type, preventing it from being used
     to alter derived classes.  Also the checking for errors was delegated from
-    the ``__setattr__`` method so exception types on some sanity checks
+    the ``__setattr__`` method so exception types on some sanity checks 
     needed to be updated accordingly.
 
 - **1.0.0 - 2020-07-12**
@@ -248,27 +248,27 @@ Latest Changes:
 
   - Introduced Python operator for Java casting.  In Java to cast
     to a type you would use ``(Type) obj``, but Python does not support
-    anything similar.  Therefore, we are enlisting the rarely used
+    anything similar.  Therefore, we are enlisting the rarely used 
     ``matmul`` operator as to allow an easy way to cast an object
     to a Java type.  When a cast to a Java type is required, use
-    ``Type@obj`` or ``(Type)@obj``.
+    ``Type@obj`` or ``(Type)@obj``.  
 
   - Introduced array notation to create Java arrays.  In earlier versions,
     JArray factory was required to make a new array type.  But this is
     tedious to read.  In Java the notation would be ``Type[]`` to declare
-    a type or ``new Type[sz]`` to make a new array.  Python does not
-    directly support this notation, but it does allow for unspecifed
+    a type or ``new Type[sz]`` to make a new array.  Python does not 
+    directly support this notation, but it does allow for unspecifed 
     array sizes using a slice.  All Java class types support
-    ``Type[sz]`` to create an array of a fixed size and ``Type[:]`` to
+    ``Type[sz]`` to create an array of a fixed size and ``Type[:]`` to 
     create an array type which can be intiated later.   This call be applied
     to multiple dimensions to create fixed sized arrays ``Type[s1][s2][s3]``
-    to declare multidimension array types ``Type[:][:][:]`` or to
+    to declare multidimension array types ``Type[:][:][:]`` or to 
     create a new multi dimensional array with unspecified dimensions
     ``Type[sz][:][:]``.  Applying a slice with limits to a class is
     unsupported.
 
-  - Java classes annotated with ``@FunctionalInterface`` can be
-    converted from any Python object that implements ``__call__``.
+  - Java classes annotated with ``@FunctionalInterface`` can be 
+    converted from any Python object that implements ``__call__``. 
     This allows functions, lambdas, and class constructors to be used
     whereever Java accepts a lambda.
 
@@ -287,7 +287,7 @@ Latest Changes:
     float and integer types will produce a ``TypeError``.
 
   - Use of ``JException`` is discouraged.  To catch all exceptions
-    or test if an object is a Java exception type,
+    or test if an object is a Java exception type, 
     use ``java.lang.Throwable``.
 
   - Chained Java exception causes are now reflected in the Python stackframes.
@@ -301,7 +301,7 @@ Latest Changes:
     and ``collections.abc.MutableSequence``.
 
   - ``java.util.Collection`` completes the contract for ``collections.abc.Collection``.
-
+  
   - Java classes are closed and will raise ``TypeError`` if extended in Python.
 
   - Handles Control-C gracefully.  Previous versions crash whenever
@@ -320,7 +320,7 @@ Latest Changes:
 - **0.7.4 - 4-28-2020**
 
   - Corrected a resource leak in arrays that affects array initialization, and variable
-    argument methods.
+    argument methods.  
 
   - Upgraded diagnostic tracing and JNI checks to prevent future resource leaks.
 
@@ -330,13 +330,13 @@ Latest Changes:
     classes is now completely in Java to allow enhancements for
     buffer support and revised type conversion system.
 
-  - Python module ``jpype.reflect`` will be removed in the next release.
-
+  - Python module ``jpype.reflect`` will be removed in the next release.  
+    
   - ``jpype.startJVM`` option ``convertStrings`` default will become False
     in the next release.
 
-  - Undocumented feature of using a Python type in ``JObject(obj, type=tp)``
-    is deprecated to support casting to Python wrapper types in Java in a
+  - Undocumented feature of using a Python type in ``JObject(obj, type=tp)`` 
+    is deprecated to support casting to Python wrapper types in Java in a 
     future release.
 
   - Dropped support for Cygwin platform.
@@ -370,7 +370,7 @@ Latest Changes:
     are direct.  They can be converted to NumPy arrays with
     ``numpy.asarray(memoryview(obj))``.
 
-  - Proxies created with ``@JImplements`` properly implement ``toString``,
+  - Proxies created with ``@JImplements`` properly implement ``toString``, 
     ``hashCode``, and ``equals``.
 
   - Proxies pass Python exceptions properly rather converting to
@@ -388,16 +388,16 @@ Latest Changes:
     as Java holds on to it.
 
   - jpype.imports and JPackage verify existance of packages and classes.
-    Imports from Java packages support wildcards.
+    Imports from Java packages support wildcards.  
 
   - Bug with JPackage that imported private and protected classes
     inappropriately has been corrected.  Protected classes can still be
     imported using JClass.
 
-  - Undocumented feature of using a Python type in ``JObject(obj, type=tp)``
-    is deprecated to support casting to Python wrapper types in Java in a
+  - Undocumented feature of using a Python type in ``JObject(obj, type=tp)`` 
+    is deprecated to support casting to Python wrapper types in Java in a 
 
-  - ``@JImplements`` with keyword argument ``deferred`` can be started
+  - ``@JImplements`` with keyword argument ``deferred`` can be started 
     prior to starting the JVM.  Methods are checked at first object
     creation.
 
@@ -428,7 +428,7 @@ Latest Changes:
     Converter function must produce a Java class instance.
 
   - ``pathlib.Path`` can be implicitly converted into ``java.lang.File``
-    and ``java.lang.Path``.
+    and ``java.lang.Path``.  
 
   - ``datetime.datatime`` can implicitly convert to ``java.time.Instant``.
 

jpype/_jarray.py

@@ -16,6 +16,7 @@
 #
 # *****************************************************************************
 import _jpype
+import typing
 from . import _jcustomizer
 
 
@@ -29,7 +30,7 @@ class JArray(_jpype._JObject, internal=True):  # type: ignore[call-arg]
     The resulting Java array class can be used to construct a new
     array with a given size or specified members.
 
-    JPype arrays support Python operators for iterating, length, equals, 
+    JPype arrays support Python operators for iterating, length, equals,
     not equals, subscripting, and slicing. They also support Java
     object methods, clone, and length property. Java arrays may not
     be resized, and as such elements cannot be added nor deleted. Currently,
@@ -96,9 +97,9 @@ def __class_getitem__(cls, key):
         if key is _jpype.JClass:
             # explicit check for JClass
             # _toJavaClass cannot be used
-            # passing int, float, etc is not allowed
+            # passing int, float, str, etc is not allowed
             key = _jpype._java_lang_Class
-        if isinstance(key, (str, _jpype._java_lang_Class)):
+        if isinstance(key, _jpype._java_lang_Class):
             key = _jpype.JClass(key)
         if isinstance(key, _jpype.JClass):
             return type(key[0])

test/jpypetest/test_array.py

@@ -613,13 +613,6 @@ def testJArrayGeneric_Init(self):
     def testJArrayInvalidGeneric(self):
         with self.assertRaises(TypeError):
             jpype.JArray[object]
-    
+
     def testJArrayGenericJClass(self):
         self.assertEqual(type(JClass[0]), JArray[JClass])
-
-    def testJArrayGenericString(self):
-        self.assertEqual(type(JClass[0]), JArray["java.lang.Class"])
-
-    def testJArrayGenericStringInvalid(self):
-        with self.assertRaises(TypeError):
-            JArray["foo.bar"] # type: ignore