Implement Python-to-Java type deconversion for additional types (time, datetime, list, etc.), enhance utility class structure, and add support for various java.time formats.

Author: maksymuimanov

.idea/misc.xml

@@ -14,7 +14,7 @@
 public abstract class AbstractPythonTypeDeconverter<R extends PythonRepresentation, P> implements PythonTypeDeconverter<R> {
     private final Map<CharSequence, P> cache;
 
-    public AbstractPythonTypeDeconverter() {
+    protected AbstractPythonTypeDeconverter() {
         this(new ConcurrentHashMap<>());
     }
 

bind/python-executor-bind-core/src/main/java/io/maksymuimanov/python/deconverter/AbstractPythonTypeDeconverter.java

@@ -9,6 +9,11 @@
 import java.math.BigDecimal;
 
 public class PythonBigDecimalDeconverter extends AbstractPythonTypeDeconverter<PythonBigDecimal, BigDecimal> {
+    @Override
+    public @Nullable Object deconvert(PythonBigDecimal pythonRepresentation, PythonDeserializer pythonDeserializer) {
+        return this.deconvert(pythonRepresentation, BigDecimal.class, pythonDeserializer);
+    }
+
     @Override
     @Nullable
     @SuppressWarnings("unchecked")
@@ -23,7 +28,7 @@ public <T> T deconvert(PythonBigDecimal pythonRepresentation, Class<T> clazz, Py
 
     @Override
     public PythonBigDecimal resolve(CharSequence value, PythonDeserializer pythonDeserializer) {
-        BigDecimal result = this.getValue(value, (key) -> new BigDecimal(key.toString()));
+        BigDecimal result = this.getValue(value, key -> new BigDecimal(key.toString()));
         return new PythonBigDecimal(result);
     }
 

bind/python-executor-bind-core/src/main/java/io/maksymuimanov/python/deconverter/PythonBigDecimalDeconverter.java

@@ -9,6 +9,11 @@
 import java.math.BigInteger;
 
 public class PythonBigIntegerDeconverter extends AbstractPythonTypeDeconverter<PythonBigInteger, BigInteger> {
+    @Override
+    public @Nullable Object deconvert(PythonBigInteger pythonRepresentation, PythonDeserializer pythonDeserializer) {
+        return this.deconvert(pythonRepresentation, BigInteger.class, pythonDeserializer);
+    }
+
     @Override
     @Nullable
     @SuppressWarnings("unchecked")
@@ -23,7 +28,7 @@ public <T> T deconvert(PythonBigInteger pythonRepresentation, Class<T> clazz, Py
 
     @Override
     public PythonBigInteger resolve(CharSequence value, PythonDeserializer pythonDeserializer) {
-        BigInteger result = this.getValue(value, (key) -> new BigInteger(key.toString()));
+        BigInteger result = this.getValue(value, key -> new BigInteger(key.toString()));
         return new PythonBigInteger(result);
     }
 

bind/python-executor-bind-core/src/main/java/io/maksymuimanov/python/deconverter/PythonBigIntegerDeconverter.java

@@ -7,6 +7,11 @@
 import org.jspecify.annotations.Nullable;
 
 public class PythonBooleanDeconverter extends AbstractPythonTypeDeconverter<PythonBoolean, Boolean> {
+    @Override
+    public @Nullable Object deconvert(PythonBoolean pythonRepresentation, PythonDeserializer pythonDeserializer) {
+        return this.deconvert(pythonRepresentation, Boolean.class, pythonDeserializer);
+    }
+
     @Override
     @Nullable
     @SuppressWarnings("unchecked")
@@ -20,7 +25,7 @@ public <T> T deconvert(PythonBoolean pythonRepresentation, Class<T> clazz, Pytho
 
     @Override
     public PythonBoolean resolve(CharSequence value, PythonDeserializer pythonDeserializer) {
-        Boolean result = this.getValue(value, (key) -> Boolean.parseBoolean(key.toString()));
+        Boolean result = this.getValue(value, key -> Boolean.parseBoolean(key.toString()));
         return new PythonBoolean(result);
     }
 

bind/python-executor-bind-core/src/main/java/io/maksymuimanov/python/deconverter/PythonBooleanDeconverter.java

@@ -8,19 +8,25 @@
 
 import java.time.LocalDate;
 import java.time.Month;
+import java.time.ZoneId;
 import java.util.Arrays;
 import java.util.Map;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 
 public class PythonDateDeconverter extends AbstractPythonTypeDeconverter<PythonDate, LocalDate> {
-    public static final Map<String, Integer> MONTHS = Arrays.stream(Month.values())
+    protected static final Map<String, Integer> MONTHS = Arrays.stream(Month.values())
             .collect(Collectors.toUnmodifiableMap(month -> month.name().substring(0, 3), Month::getValue));
-    public static final Pattern YEAR_PATTERN = Pattern.compile("[0-9]{4}");
-    public static final Pattern MONTH_PATTERN = Pattern.compile("[A-Za-z]{3}");
-    public static final Pattern DAY_PATTERN = Pattern.compile("[0-9]{2}");
-    public static final int TOTAL_MONTHS = 12;
+    protected static final Pattern YEAR_PATTERN = Pattern.compile("[0-9]{4}");
+    protected static final Pattern MONTH_PATTERN = Pattern.compile("[A-Za-z]{3}");
+    protected static final Pattern DAY_PATTERN = Pattern.compile("[0-9]{2}");
+    protected static final int TOTAL_MONTHS = 12;
+
+    @Override
+    public @Nullable Object deconvert(PythonDate pythonRepresentation, PythonDeserializer pythonDeserializer) {
+        return this.deconvert(pythonRepresentation, LocalDate.class, pythonDeserializer);
+    }
 
     @Override
     @Nullable
@@ -29,14 +35,18 @@ public <T> T deconvert(PythonDate pythonRepresentation, Class<T> clazz, PythonDe
         LocalDate date = pythonRepresentation.getValue();
         if (LocalDate.class.equals(clazz)) {
             return (T) date;
+        } else if (java.util.Date.class.equals(clazz)) {
+            return (T) java.util.Date.from(date.atStartOfDay(ZoneId.systemDefault()).toInstant());
+        } else if (java.sql.Date.class.equals(clazz)) {
+            return (T) java.sql.Date.valueOf(date);
         } else {
             throw new PythonUnsupportedTypeDeconversionException(clazz + " is not supported");
         }
     }
 
     @Override
     public PythonDate resolve(CharSequence value, PythonDeserializer pythonDeserializer) {
-        LocalDate result = this.getValue(value, (key) -> {
+        LocalDate result = this.getValue(value, key -> {
             StringBuilder dateBuilder = new StringBuilder(key);
             int year = -1, month = -1, day = -1;
 
@@ -55,22 +65,33 @@ public PythonDate resolve(CharSequence value, PythonDeserializer pythonDeseriali
                 dateBuilder.delete(monthMatcher.start(), monthMatcher.end());
             }
 
+            int first = -1, second = -1;
             Matcher dayMatcher = DAY_PATTERN.matcher(dateBuilder);
             while (dayMatcher.find()) {
                 int datePart = Integer.parseInt(dayMatcher.group());
                 if (month != -1) {
                     day = datePart;
-                } else if (day == -1) {
-                    if (datePart > TOTAL_MONTHS) {
-                        day = datePart;
+                } else if (second == -1) {
+                    if (first != -1) {
+                        second = datePart;
                     } else {
-                        month = datePart;
+                        first = datePart;
                     }
                 } else {
                     break;
                 }
             }
-            
+
+            if (month == -1) {
+                if (first > TOTAL_MONTHS || second <= TOTAL_MONTHS) {
+                    day = first;
+                    month = second;
+                } else {
+                    month = first;
+                    day = second;
+                }
+            }
+
             return LocalDate.of(year, month, day);
         });
         return new PythonDate(result);

bind/python-executor-bind-core/src/main/java/io/maksymuimanov/python/deconverter/PythonDateDeconverter.java

@@ -0,0 +1,63 @@
+package io.maksymuimanov.python.deconverter;
+
+import io.maksymuimanov.python.bind.PythonDateTime;
+import io.maksymuimanov.python.deserializer.PythonDeserializer;
+import io.maksymuimanov.python.exception.PythonUnsupportedTypeDeconversionException;
+import io.maksymuimanov.python.util.StringUtils;
+import org.jspecify.annotations.Nullable;
+
+import java.sql.Timestamp;
+import java.time.*;
+import java.util.Arrays;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class PythonDateTimeDeconverter extends AbstractPythonTypeDeconverter<PythonDateTime, LocalDateTime> {
+    public static final Pattern NUMBER_PATTERN = Pattern.compile("\\d+");
+
+    @Override
+    public @Nullable Object deconvert(PythonDateTime pythonRepresentation, PythonDeserializer pythonDeserializer) {
+        return this.deconvert(pythonRepresentation, LocalDateTime.class, pythonDeserializer);
+    }
+
+    @Override
+    @Nullable
+    @SuppressWarnings("unchecked")
+    public <T> T deconvert(PythonDateTime pythonRepresentation, Class<T> clazz, PythonDeserializer pythonDeserializer) {
+        LocalDateTime dateTime = pythonRepresentation.getValue();
+        if (LocalDateTime.class.equals(clazz)) {
+            return (T) dateTime;
+        } else if (Timestamp.class.equals(clazz)) {
+            return (T) Timestamp.valueOf(dateTime);
+        } else if (ZonedDateTime.class.equals(clazz)) {
+            return (T) ZonedDateTime.of(dateTime, ZoneId.systemDefault());
+        } else if (OffsetDateTime.class.equals(clazz)) {
+            return (T) OffsetDateTime.of(dateTime, (ZoneOffset) ZoneOffset.systemDefault());
+        } else {
+            throw new PythonUnsupportedTypeDeconversionException(clazz + " is not supported");
+        }
+    }
+
+    @Override
+    public PythonDateTime resolve(CharSequence value, PythonDeserializer pythonDeserializer) {
+        LocalDateTime result = this.getValue(value, key -> {
+            int[] dateTimeParts = new int[7];
+            Arrays.fill(dateTimeParts, 0);
+            Matcher matcher = NUMBER_PATTERN.matcher(key);
+            int partIndex = 0;
+            while (matcher.find()) {
+                String group = matcher.group();
+                dateTimeParts[partIndex++] = Integer.parseInt(group);
+            }
+
+            return LocalDateTime.of(dateTimeParts[0], dateTimeParts[1], dateTimeParts[2], dateTimeParts[3], dateTimeParts[4], dateTimeParts[5], dateTimeParts[6] * 1000);
+        });
+
+        return new PythonDateTime(result);
+    }
+
+    @Override
+    public boolean matches(CharSequence value) {
+        return StringUtils.isDateTime(value);
+    }
+}

bind/python-executor-bind-core/src/main/java/io/maksymuimanov/python/deconverter/PythonDateTimeDeconverter.java

@@ -7,6 +7,11 @@
 import org.jspecify.annotations.Nullable;
 
 public class PythonFloatDeconverter extends AbstractPythonTypeDeconverter<PythonFloat, Number> {
+    @Override
+    public @Nullable Object deconvert(PythonFloat pythonRepresentation, PythonDeserializer pythonDeserializer) {
+        return this.deconvert(pythonRepresentation, Number.class, pythonDeserializer);
+    }
+
     @Override
     @Nullable
     @SuppressWarnings("unchecked")
@@ -23,13 +28,13 @@ public <T> T deconvert(PythonFloat pythonRepresentation, Class<T> clazz, PythonD
 
     @Override
     public PythonFloat resolve(CharSequence value, PythonDeserializer pythonDeserializer) {
-        Number result = this.getValue(value, (key) -> Double.parseDouble(key.toString()));
+        Number result = this.getValue(value, key -> Double.parseDouble(key.toString()));
         return new PythonFloat(result);
     }
 
     @Override
     public boolean matches(CharSequence value) {
-        return this.matches(value, StringUtils::isFloat, (cs) -> {
+        return this.matches(value, StringUtils::isFloat, cs -> {
             try {
                 Number doubleValue = Double.parseDouble(value.toString());
                 this.saveValue(value, doubleValue);

bind/python-executor-bind-core/src/main/java/io/maksymuimanov/python/deconverter/PythonFloatDeconverter.java

@@ -7,6 +7,11 @@
 import org.jspecify.annotations.Nullable;
 
 public class PythonIntDeconverter extends AbstractPythonTypeDeconverter<PythonInt, Number> {
+    @Override
+    public @Nullable Object deconvert(PythonInt pythonRepresentation, PythonDeserializer pythonDeserializer) {
+        return this.deconvert(pythonRepresentation, Number.class, pythonDeserializer);
+    }
+
     @Override
     @Nullable
     @SuppressWarnings("unchecked")
@@ -27,13 +32,13 @@ public <T> T deconvert(PythonInt pythonRepresentation, Class<T> clazz, PythonDes
 
     @Override
     public PythonInt resolve(CharSequence value, PythonDeserializer pythonDeserializer) {
-        Number result = this.getValue(value, (key) -> Long.parseLong(key.toString()));
+        Number result = this.getValue(value, key -> Long.parseLong(key.toString()));
         return new PythonInt(result);
     }
 
     @Override
     public boolean matches(CharSequence value) {
-        return this.matches(value, StringUtils::isInteger, (cs) -> {
+        return this.matches(value, StringUtils::isInteger, cs -> {
             try {
                 Number longValue = Long.parseLong(value.toString());
                 this.saveValue(value, longValue);

bind/python-executor-bind-core/src/main/java/io/maksymuimanov/python/deconverter/PythonIntDeconverter.java

@@ -0,0 +1,52 @@
+package io.maksymuimanov.python.deconverter;
+
+import io.maksymuimanov.python.bind.PythonList;
+import io.maksymuimanov.python.deserializer.PythonDeserializer;
+import io.maksymuimanov.python.exception.PythonUnsupportedTypeDeconversionException;
+import io.maksymuimanov.python.script.PythonRepresentation;
+import io.maksymuimanov.python.util.StringUtils;
+import org.jspecify.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class PythonListDeconverter extends AbstractPythonTypeDeconverter<PythonList, List<PythonRepresentation>> {
+    @Override
+    public @Nullable Object deconvert(PythonList pythonRepresentation, PythonDeserializer pythonDeserializer) {
+        return this.deconvert(pythonRepresentation, List.class, pythonDeserializer);
+    }
+
+    @Override
+    @Nullable
+    @SuppressWarnings("unchecked")
+    public <T> T deconvert(PythonList pythonRepresentation, Class<T> clazz, PythonDeserializer pythonDeserializer) {
+        Stream<?> stream = pythonRepresentation.getValue()
+                .stream()
+                .map(pr -> pythonDeserializer.deserialize(pythonRepresentation));
+        if (List.class.equals(clazz)) {
+            return (T) stream.toList();
+        } else if (ArrayList.class.equals(clazz)) {
+            return (T) stream.collect(Collectors.toCollection(ArrayList::new));
+        } else if (LinkedList.class.equals(clazz)) {
+            return (T) stream.collect(Collectors.toCollection(LinkedList::new));
+        } else {
+            throw new PythonUnsupportedTypeDeconversionException(clazz + " is not supported");
+        }
+    }
+
+    @Override
+    public PythonList resolve(CharSequence value, PythonDeserializer pythonDeserializer) {
+        List<PythonRepresentation> result = this.getValue(value, key -> {
+            return List.of();
+        });
+        return new PythonList(result);
+    }
+
+    @Override
+    public boolean matches(CharSequence value) {
+        return StringUtils.isList(value);
+    }
+}