Bump OpenML API version to 1.0.1 (#30)

* Bump OpenML API version to 1.0.1

Summary:
Since OpenML 1.0.0 had some missing changes, this commits bumps the version to 1.0.1 and adapts the code the new changes

* Simplify implementation

* Test invalid classes on ClassificationPythonModel

* Address codacy reports

Author: JPDSousa

openml-python-common/src/main/java/com/feedzai/openml/python/ClassificationPythonModel.java

@@ -20,6 +20,7 @@
 import com.feedzai.openml.data.schema.AbstractValueSchema;
 import com.feedzai.openml.data.schema.CategoricalValueSchema;
 import com.feedzai.openml.data.schema.DatasetSchema;
+import com.feedzai.openml.data.schema.FieldSchema;
 import com.feedzai.openml.model.ClassificationMLModel;
 import com.feedzai.openml.provider.exception.ModelLoadingException;
 import com.feedzai.openml.python.jep.instance.JepInstance;
@@ -191,7 +192,11 @@ public int classify(final Instance instance) {
             asNotNullable = this.classToIndexConverter.apply(classValue);
         } catch (final NullPointerException e) {
 
-            final AbstractValueSchema targetVarSchema = this.schema.getTargetFieldSchema().getValueSchema();
+            //noinspection OptionalGetWithoutIsPresent
+            final AbstractValueSchema targetVarSchema = this.schema.getTargetFieldSchema()
+                    .map(FieldSchema::getValueSchema)
+                    // since the dataset schema is immutable and the target variable existence was already checked in construction
+                    .get();
             final Function<CategoricalValueSchema, String> block = targetSchema -> String.format(
                     "Unexpected class provided by model: %s. Expected values: %s",
                     classValue,
@@ -201,7 +206,7 @@ public int classify(final Instance instance) {
             final String msg = ClassificationDatasetSchemaUtil.withCategoricalValueSchema(targetVarSchema, block)
                     .orElseThrow(() -> new RuntimeException("The target variable is not a categorical value: " + targetVarSchema));
 
-            logger.warn(msg, e);
+            logger.error(msg, e);
             throw e;
         }
         return asNotNullable;
@@ -255,9 +260,14 @@ public void close() {
      * @return The conversion function.
      */
     private Function<Serializable, Integer> getClassToIndexConverter(final DatasetSchema schema) {
-        final AbstractValueSchema targetVariableSchema = schema.getTargetFieldSchema().getValueSchema();
+        //noinspection OptionalGetWithoutIsPresent
+        final AbstractValueSchema targetVariableSchema = schema.getTargetFieldSchema()
+                .map(FieldSchema::getValueSchema)
+                // since the dataset schema is immutable and the target variable existence was already checked in construction
+                .get();
+
         if (!(targetVariableSchema instanceof CategoricalValueSchema)) {
-            logger.warn("Provided schema's target field is not categorical: {}", schema);
+            logger.error("Provided schema's target field is not categorical: {}", schema);
             throw new IllegalArgumentException("Classification models require Categorical target fields. Got " + targetVariableSchema);
         }
         return EncodingHelper.classToIndexConverter((CategoricalValueSchema) targetVariableSchema);

openml-python-common/src/test/java/com/feedzai/openml/python/ClassificationPythonModelTest.java

@@ -1,36 +1,60 @@
-package com.feedzai.openml.python;/*
- * The copyright of this file belongs to Feedzai. The file cannot be
- * reproduced in whole or in part, stored in a retrieval system,
- * transmitted in any form, or by any means electronic, mechanical,
- * photocopying, or otherwise, without the prior permission of the owner.
+/*
+ * Copyright (c) 2019 Feedzai
  *
- * © 2019 Feedzai, Strictly Confidential
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
  */
 
+package com.feedzai.openml.python;
+
+import com.feedzai.openml.data.schema.CategoricalValueSchema;
 import com.feedzai.openml.data.schema.DatasetSchema;
 import com.feedzai.openml.data.schema.FieldSchema;
 import com.feedzai.openml.data.schema.NumericValueSchema;
+import com.feedzai.openml.mocks.MockInstance;
 import com.feedzai.openml.python.jep.instance.JepInstance;
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
 import org.junit.Before;
 import org.junit.Test;
 
+import java.net.URISyntaxException;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.List;
+import java.util.Random;
+import java.util.concurrent.ExecutionException;
+
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
 /**
  * Tests the behaviour of a {@link ClassificationPythonModel}.
  *
  * @author Joao Sousa (joao.sousa@feedzai.com)
- * @since @@@feedzai.next.release@@@
+ * @since 0.2.0
  */
 public class ClassificationPythonModelTest {
 
     /**
-     * A field to use in the tests.
+     * A numerical field to use in the tests.
      */
     private static final FieldSchema FIELD_SCHEMA =
             new FieldSchema("field", 0, new NumericValueSchema(false));
 
+    /**
+     * A categorical field to use in the tests.
+     */
+    private static final FieldSchema CATEGORICAL_FIELD_SCHEMA =
+            new FieldSchema("categorical", 1, new CategoricalValueSchema(false, ImmutableSet.of("this", "that")));
 
     /**
      * The wrapper for the Jep object used in the tests.
@@ -59,4 +83,36 @@ public final void testSchemaWithoutTargetVariable() {
                 .isInstanceOf(IllegalArgumentException.class);
     }
 
+    /**
+     * Tests that a classifier which classifies an instance with an invalid target value will cause the model to return
+     * NullPointerException.
+     */
+    @Test
+    public final void testInvalidClass() throws URISyntaxException, ExecutionException, InterruptedException {
+        final Path modelPath = Paths.get(getClass().getResource("/dummy_model").toURI());
+        final String id = "classificationModel";
+        final List<FieldSchema> fields = ImmutableList.of(FIELD_SCHEMA, CATEGORICAL_FIELD_SCHEMA);
+        final String illegalTargetValue = "those";
+        final DatasetSchema schema = new DatasetSchema(1, fields);
+        final Random random = new Random();
+
+        this.jepInstance.submitEvaluation(jep -> {
+            // Add the model folder to the python import path
+            jep.eval("import sys");
+            jep.eval(String.format("sys.path.append(\"%s\")", modelPath.toAbsolutePath()));
+
+            // Import the Classifier custom class and store an instance of it in a variable with the name passed in "id"
+            jep.eval("from classifier import Classifier");
+            jep.eval(String.format("%s = Classifier('%s')", id, illegalTargetValue));
+
+            return null;
+        }).get();
+
+        final ClassificationPythonModel model = new ClassificationPythonModel(this.jepInstance, schema, id, "classify", "getClassDistribution");
+
+        assertThatThrownBy(() -> model.classify(new MockInstance(schema, random)))
+                .as("A classifier that does not return a valid target value will fail with a null pointer exception")
+                .isInstanceOf(NullPointerException.class);
+    }
+
 }

openml-python-common/src/test/resources/dummy_model/classifier.py

@@ -0,0 +1,12 @@
+class Classifier(object):
+
+    def __init__(self, target_value):
+        self.target_value = target_value
+        self.multiplier = [1, 0, 0]
+
+    def classify(self, instances):
+        return self.target_value
+
+
+    def getClassDistribution(self, instances):
+        return [self.multiplier] * len(instances)

pom.xml

@@ -79,7 +79,7 @@
         <assertj.version>3.7.0</assertj.version>
         <jackson.version>2.6.7</jackson.version>
         <jackson-databind.version>2.6.7</jackson-databind.version>
-        <openml-api.version>1.0.0</openml-api.version>
+        <openml-api.version>1.0.1</openml-api.version>
         <jep.version>3.7.0</jep.version>
     </properties>