import org.python.core.PyType; //导入依赖的package包/类
/**
 * Returns {@code null} if not script-based processor.
 */
@Override
public String getScriptKnowledgeBaseProcessorClassName(Object processorClass) {
    if (processorClass instanceof PyType) {
        PyType pyType = (PyType) processorClass;

        return pyType.getName();
    }

    return null;
}
 

import org.python.core.PyType; //导入依赖的package包/类
@Override
public void scanToAutoEnable() {
    PyScriptEngineScope scope = eval("globals()");

    List<PyType> processorPyTypes =
            PROCESSOR_CLASSES.values().stream().map(cls -> (PyType) Py.java2py(cls)).collect(Collectors.toList());

    List<Object> autoEnabled = new ArrayList<>();
    SpongeUtils.stream(((ScopeIterator) scope.__iter__()).iterator()).forEachOrdered(element -> {
        String name = element.toString();
        PyObject pyObject = scope.__finditem__(name);

        if (pyObject != null && pyObject instanceof PyType) {
            PyType pyType = (PyType) pyObject;
            if (processorPyTypes.stream().filter(processorClass -> !pyType.equals(processorClass) && pyType.isSubType(processorClass))
                    .findFirst().isPresent()) {
                if (!isProcessorAbstract(name)) {
                    autoEnabled.add(name);
                    ((JythonKnowledgeBaseEngineOperations) getEngineOperations()).enable(pyType);
                }
            }
        }
    });

    if (logger.isDebugEnabled() && !autoEnabled.isEmpty()) {
        logger.debug("Auto-enabling: {}", autoEnabled);
    }
}
 

import org.python.core.PyType; //导入依赖的package包/类
public static String getPyObjectValueAsString(PyObject obj) {
	if (obj == null)
		return "";
	PyType type = obj.getType();
	if (type.getName().equals("long"))
		return Long.toString(obj.asLong());
	else if (type.getName().equals("int"))
		return Integer.toString(obj.asInt());
	else if (type.getName().equals("bool")) 
		return obj.asInt() != 0 ? "true" : "false";
	return obj.asString();
}
 

import org.python.core.PyType; //导入依赖的package包/类
public static boolean getPyObjectValueAsBoolean(PyObject obj) {
	if (obj == null)
		return false;
	PyType type = obj.getType();
	if (type.getName().equals("long"))
		return (obj.asLong() != 0);
	else if (type.getName().equals("int"))
		return (obj.asInt() != 0);
	else if (type.getName().equals("bool")) 
		return (obj.asInt() != 0);
	else if (type.getName().equals("NoneType")) 
		return false;

	return obj.asString().length() != 0;
}
 

import org.python.core.PyType; //导入依赖的package包/类
private boolean keyIsExcluded(String key, PyObject value) {
    return (key.startsWith("__") && key.endsWith("__")) ||
            value instanceof PyFile ||
            value instanceof PyModule ||
            value instanceof PyFunction ||
            value instanceof PySystemState ||
            value instanceof PyClass ||
            value instanceof PyType ||
            value instanceof PyReflectedFunction;
}
 

import org.python.core.PyType; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private static Object getParamDefaultValue(PyObject pyObject, Class<?> parameterType) throws Exception {
    if (parameterType.equals(PyType.class)) {
        return pyObject.getType();
    } else if (parameterType.isPrimitive()) {
        return ClassUtils.primitiveToWrapper(parameterType).getConstructor(String.class).newInstance("0");
    } else if (Number.class.isAssignableFrom(parameterType) || String.class.isAssignableFrom(parameterType)) {
        return parameterType.getConstructor(String.class).newInstance("0");
    } else {
        return null;
    }
}
 

import org.python.core.PyType; //导入依赖的package包/类
public void disable(PyType processorClass) {
    engine.getProcessorManager().disable(getKnowledgeBase(), processorClass);
}
 

import org.python.core.PyType; //导入依赖的package包/类
public void disableAll(PyType... processorClasses) {
    Stream.of(processorClasses).forEachOrdered(processorClass -> disable(processorClass));
}
 

import org.python.core.PyType; //导入依赖的package包/类
/**
 * Enables filters.
 *
 * @param filterClasses filter classes.
 */
public void enableFilters(PyType... filterClasses) {
    for (PyType filterClass : filterClasses) {
        enableFilter(filterClass);
    }
}
 

import org.python.core.PyType; //导入依赖的package包/类
public void enableTriggers(PyType... triggerClasses) {
    for (PyType triggerClass : triggerClasses) {
        enableTrigger(triggerClass);
    }
}
 

import org.python.core.PyType; //导入依赖的package包/类
/**
 * Enables rules.
 *
 * @param ruleClasses rule classes.
 */
public void enableRules(PyType... ruleClasses) {
    for (PyType ruleClass : ruleClasses) {
        enableRule(ruleClass);
    }
}
 

import org.python.core.PyType; //导入依赖的package包/类
public void enableCorrelator(PyType correlatorClass) {
    engine.getProcessorManager().enableCorrelator(getKnowledgeBase(), correlatorClass);
}
 

import org.python.core.PyType; //导入依赖的package包/类
public void enableCorrelators(PyType... correlatorClasses) {
    for (PyType correlatorClass : correlatorClasses) {
        enableCorrelator(correlatorClass);
    }
}
 

import org.python.core.PyType; //导入依赖的package包/类
public void disableCorrelator(PyType correlatorClass) {
    engine.getProcessorManager().disableCorrelator(getKnowledgeBase(), correlatorClass);
}
 

import org.python.core.PyType; //导入依赖的package包/类
/**
 * Enables actions.
 *
 * @param actionClasses action classes.
 */
public void enableActions(PyType... actionClasses) {
    for (PyType actionClass : actionClasses) {
        enableAction(actionClass);
    }
}
 

import org.python.core.PyType; //导入依赖的package包/类
@Override
public PyType getType() {
    return PyFunction.TYPE;
}
 

import org.python.core.PyType; //导入依赖的package包/类
@Override
public PyType getType() {
    return PyList.TYPE;
}
 

import org.python.core.PyType; //导入依赖的package包/类
/**
 * Enables a processor.
 *
 * @param processorClass a processor class.
 */
public void enable(PyType processorClass) {
    engine.getProcessorManager().enable(getKnowledgeBase(), processorClass);
}
 

import org.python.core.PyType; //导入依赖的package包/类
/**
 * Enables processors.
 *
 * @param processorClasses processor classes.
 */
public void enableAll(PyType... processorClasses) {
    Stream.of(processorClasses).forEachOrdered(processorClass -> enable(processorClass));
}
 

import org.python.core.PyType; //导入依赖的package包/类
/**
 * Enables a filter.
 *
 * @param filterClass filter class.
 */
public void enableFilter(PyType filterClass) {
    engine.getProcessorManager().enableFilter(getKnowledgeBase(), filterClass);
}