bare-script 5.0.4__tar.gz → 5.0.5__tar.gz

{bare_script-5.0.4/src/bare_script.egg-info → bare_script-5.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bare-script
-Version: 5.0.4
+Version: 5.0.5
 Summary: bare-script
 Home-page: https://github.com/craigahobbs/bare-script
 Author: Craig A. Hobbs

{bare_script-5.0.4 → bare_script-5.0.5}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = bare-script
-version = 5.0.4
+version = 5.0.5
 url = https://github.com/craigahobbs/bare-script
 author = Craig A. Hobbs
 author_email = craigahobbs@gmail.com

{bare_script-5.0.4 → bare_script-5.0.5}/src/bare_script/runtime.py

@@ -337,18 +337,16 @@ def _evaluate_expression_helper(expr, options, globals_, locals_, builtins, scri
                         if func_args_length < 1:
                             raise ValueArgsError('array', None)
                         array_value = func_args[0]
-                        array_type = type(array_value)
-                        if array_type is not list:
+                        if not isinstance(array_value, list):
                             raise ValueArgsError('array', array_value)
                         if func_args_length < 2:
                             raise ValueArgsError('index', None)
                         index_value = func_args[1]
-                        index_type = type(index_value)
-                        if index_type is float:
+                        if isinstance(index_value, float):
                             if index_value < 0 or not index_value.is_integer():
                                 raise ValueArgsError('index', index_value)
                             index_value = int(index_value)
-                        elif index_type is int:
+                        elif isinstance(index_value, int) and not isinstance(index_value, bool):
                             if index_value < 0:
                                 raise ValueArgsError('index', index_value)
                         else:
@@ -362,8 +360,7 @@ def _evaluate_expression_helper(expr, options, globals_, locals_, builtins, scri
                         if func_args_length < 1:
                             raise ValueArgsError('array', None, 0)
                         array_value = func_args[0]
-                        array_type = type(array_value)
-                        if array_type is not list:
+                        if not isinstance(array_value, list):
                             raise ValueArgsError('array', array_value, 0)
                         if func_args_length > 1:
                             raise ValueArgsError(None, func_args_length, 0)
@@ -372,8 +369,7 @@ def _evaluate_expression_helper(expr, options, globals_, locals_, builtins, scri
                         if func_args_length < 1:
                             raise ValueArgsError('array', None)
                         array_value = func_args[0]
-                        array_type = type(array_value)
-                        if array_type is not list:
+                        if not isinstance(array_value, list):
                             raise ValueArgsError('array', array_value)
                         array_value.extend(func_args[1:])
                         return array_value
@@ -381,18 +377,16 @@ def _evaluate_expression_helper(expr, options, globals_, locals_, builtins, scri
                         if func_args_length < 1:
                             raise ValueArgsError('array', None)
                         array_value = func_args[0]
-                        array_type = type(array_value)
-                        if array_type is not list:
+                        if not isinstance(array_value, list):
                             raise ValueArgsError('array', array_value)
                         if func_args_length < 2:
                             raise ValueArgsError('index', None)
                         index_value = func_args[1]
-                        index_type = type(index_value)
-                        if index_type is float:
+                        if isinstance(index_value, float):
                             if index_value < 0 or not index_value.is_integer():
                                 raise ValueArgsError('index', index_value)
                             index_value = int(index_value)
-                        elif index_type is int:
+                        elif isinstance(index_value, int) and not isinstance(index_value, bool):
                             if index_value < 0:
                                 raise ValueArgsError('index', index_value)
                         else:
@@ -408,8 +402,7 @@ def _evaluate_expression_helper(expr, options, globals_, locals_, builtins, scri
                         if func_args_length < 1:
                             raise ValueArgsError('x', None)
                         x_value = func_args[0]
-                        x_type = type(x_value)
-                        if (x_type is not int and x_type is not float) or not x_value >= 0:
+                        if not isinstance(x_value, (int, float)) or isinstance(x_value, bool) or not x_value >= 0:
                             raise ValueArgsError('x', x_value)
                         if func_args_length > 1:
                             raise ValueArgsError(None, func_args_length)
@@ -419,14 +412,12 @@ def _evaluate_expression_helper(expr, options, globals_, locals_, builtins, scri
                         if func_args_length < 1:
                             raise ValueArgsError('object', None, default_value)
                         object_value = func_args[0]
-                        object_type = type(object_value)
-                        if object_type is not dict:
+                        if not isinstance(object_value, dict):
                             raise ValueArgsError('object', object_value, default_value)
                         if func_args_length < 2:
                             raise ValueArgsError('key', None, default_value)
                         key_value = func_args[1]
-                        key_type = type(key_value)
-                        if key_type is not str:
+                        if not isinstance(key_value, str):
                             raise ValueArgsError('key', key_value, default_value)
                         if func_args_length > 3:
                             raise ValueArgsError(None, func_args_length, default_value)
@@ -435,14 +426,12 @@ def _evaluate_expression_helper(expr, options, globals_, locals_, builtins, scri
                         if func_args_length < 1:
                             raise ValueArgsError('object', None, False)
                         object_value = func_args[0]
-                        object_type = type(object_value)
-                        if object_type is not dict:
+                        if not isinstance(object_value, dict):
                             raise ValueArgsError('object', object_value, False)
                         if func_args_length < 2:
                             raise ValueArgsError('key', None, False)
                         key_value = func_args[1]
-                        key_type = type(key_value)
-                        if key_type is not str:
+                        if not isinstance(key_value, str):
                             raise ValueArgsError('key', key_value, False)
                         if func_args_length > 2:
                             raise ValueArgsError(None, func_args_length, False)
@@ -451,8 +440,7 @@ def _evaluate_expression_helper(expr, options, globals_, locals_, builtins, scri
                         if func_args_length < 1:
                             raise ValueArgsError('object', None)
                         object_value = func_args[0]
-                        object_type = type(object_value)
-                        if object_type is not dict:
+                        if not isinstance(object_value, dict):
                             raise ValueArgsError('object', object_value)
                         if func_args_length > 1:
                             raise ValueArgsError(None, func_args_length)
@@ -461,14 +449,12 @@ def _evaluate_expression_helper(expr, options, globals_, locals_, builtins, scri
                         if func_args_length < 1:
                             raise ValueArgsError('object', None)
                         object_value = func_args[0]
-                        object_type = type(object_value)
-                        if object_type is not dict:
+                        if not isinstance(object_value, dict):
                             raise ValueArgsError('object', object_value)
                         if func_args_length < 2:
                             raise ValueArgsError('key', None)
                         key_value = func_args[1]
-                        key_type = type(key_value)
-                        if key_type is not str:
+                        if not isinstance(key_value, str):
                             raise ValueArgsError('key', key_value)
                         if func_args_length > 3:
                             raise ValueArgsError(None, func_args_length)
@@ -479,8 +465,7 @@ def _evaluate_expression_helper(expr, options, globals_, locals_, builtins, scri
                         if func_args_length < 1:
                             raise ValueArgsError('string', None, 0)
                         string_value = func_args[0]
-                        string_type = type(string_value)
-                        if string_type is not str:
+                        if not isinstance(string_value, str):
                             raise ValueArgsError('string', string_value, 0)
                         if func_args_length > 1:
                             raise ValueArgsError(None, func_args_length, 0)

{bare_script-5.0.4 → bare_script-5.0.5}/src/bare_script/runtime_c.c

@@ -265,6 +265,26 @@ static int obj_setitem(PyObject *obj, PyObject *key, PyObject *value)
 }
 
 
+// key in mapping semantics: 1 = found, 0 = missing, -1 = error
+static int obj_contains(PyObject *obj, PyObject *key)
+{
+    if (PyDict_CheckExact(obj)) {
+        return PyDict_Contains(obj, key);
+    }
+    return PySequence_Contains(obj, key);
+}
+
+
+// del mapping[key] semantics: 0 = success, -1 = error
+static int obj_delitem(PyObject *obj, PyObject *key)
+{
+    if (PyDict_CheckExact(obj)) {
+        return PyDict_DelItem(obj, key);
+    }
+    return PyObject_DelItem(obj, key);
+}
+
+
 //
 // Execution context
 //
@@ -576,18 +596,17 @@ static int value_boolean_c(PyObject *value)
     if (value == Py_False || value == Py_None) {
         return 0;
     }
-    PyTypeObject *type = Py_TYPE(value);
-    if (type == &PyFloat_Type) {
+    if (PyFloat_Check(value)) {
         // NaN != 0 is true, matching the reference implementation
         return PyFloat_AS_DOUBLE(value) != 0.;
     }
-    if (type == &PyLong_Type) {
+    if (PyLong_Check(value)) {
         return PyObject_IsTrue(value);
     }
-    if (type == &PyUnicode_Type) {
+    if (PyUnicode_Check(value)) {
         return PyUnicode_GetLength(value) != 0;
     }
-    if (type == &PyList_Type) {
+    if (PyList_Check(value)) {
         return PyList_GET_SIZE(value) != 0;
     }
 
@@ -597,12 +616,21 @@ static int value_boolean_c(PyObject *value)
 
 
 // Is the value an exact int or float (bool is a subclass of int but has its own exact type)?
+// This is the binary-operator fast-path check, mirroring the reference runtime's exact checks.
 static inline int is_number(PyObject *value)
 {
     return PyLong_CheckExact(value) || PyFloat_CheckExact(value);
 }
 
 
+// Is the value a number per the value model (int/float subclasses count, bool is excluded)?
+// This is the argument-validation check, mirroring value.value_args_validate's isinstance checks.
+static inline int is_number_arg(PyObject *value)
+{
+    return !PyBool_Check(value) && (PyLong_Check(value) || PyFloat_Check(value));
+}
+
+
 // Convert an int, or a float with an integral value, to a new int reference. Returns NULL with no
 // exception set if the value is not an integral number.
 static PyObject *integral_long(PyObject *value)
@@ -810,12 +838,12 @@ static void intrinsic_count_error(Py_ssize_t nargs, PyObject *return_value)
 static PyObject *intrinsic_one_number(PyObject *args, const char *name, int constraint, PyObject *error_return)
 {
     PyObject *value = (PyList_GET_SIZE(args) >= 1) ? PyList_GET_ITEM(args, 0) : NULL;
-    if (value == NULL || value == Py_None || !is_number(value)) {
+    if (value == NULL || value == Py_None || !is_number_arg(value)) {
         intrinsic_args_error(name, value, error_return);
         return NULL;
     }
     if (constraint != 0) {
-        if (PyFloat_CheckExact(value)) {
+        if (PyFloat_Check(value)) {
             // NaN fails both constraints, mirroring the reference's "not (value >= 0)"
             double number = PyFloat_AS_DOUBLE(value);
             if ((constraint == 1) ? !(number >= 0.) : !(number > 0.)) {
@@ -846,20 +874,25 @@ static PyObject *intrinsic_one_number(PyObject *args, const char *name, int cons
 // like passing the int to a math-module function). Returns -1. with an exception set on error.
 static double intrinsic_number_as_double(PyObject *value)
 {
-    if (PyFloat_CheckExact(value)) {
+    if (PyFloat_Check(value)) {
         return PyFloat_AS_DOUBLE(value);
     }
     return PyFloat_AsDouble(value);
 }
 
 
-// Validate an exact-typed argument at position ix: 'a' = array (list), 'o' = object (dict),
-// 's' = string. Returns the argument (borrowed from args) or NULL with ValueArgsError raised.
+// Validate a typed argument at position ix: 'a' = array (list), 'o' = object (dict),
+// 's' = string. Subclasses are accepted, mirroring value.value_args_validate's isinstance
+// checks. Dict subclass values must be accessed through the obj_* mapping helpers (subclasses
+// like OrderedDict keep state that direct PyDict_* mutation corrupts); list/str subclass values
+// are accessed directly (PyList_*/PyUnicode_* operate on the shared base storage, bypassing any
+// overridden methods). Returns the argument (borrowed from args) or NULL with ValueArgsError
+// raised.
 static PyObject *intrinsic_typed_arg(PyObject *args, Py_ssize_t ix, char type, const char *name, PyObject *error_return)
 {
     PyObject *value = (PyList_GET_SIZE(args) > ix) ? PyList_GET_ITEM(args, ix) : NULL;
     int type_ok = (value != NULL) &&
-        ((type == 'a') ? PyList_CheckExact(value) : (type == 'o') ? PyDict_CheckExact(value) : PyUnicode_CheckExact(value));
+        ((type == 'a') ? PyList_Check(value) : (type == 'o') ? PyDict_Check(value) : PyUnicode_Check(value));
     if (!type_ok) {
         intrinsic_args_error(name, value, error_return);
         return NULL;
@@ -879,7 +912,7 @@ static int intrinsic_index_validate(PyObject *args, Py_ssize_t ix, const char *n
         intrinsic_args_error(name, value, NULL);
         return -1;
     }
-    if (PyLong_CheckExact(value)) {
+    if (PyLong_Check(value) && !PyBool_Check(value)) {
         int overflow = 0;
         long long index = PyLong_AsLongLongAndOverflow(value, &overflow);
         if (index == -1 && !overflow && PyErr_Occurred()) {
@@ -892,7 +925,7 @@ static int intrinsic_index_validate(PyObject *args, Py_ssize_t ix, const char *n
         *index_out = (overflow > 0 || index > (long long)PY_SSIZE_T_MAX) ? PY_SSIZE_T_MAX : (Py_ssize_t)index;
         return 0;
     }
-    if (PyFloat_CheckExact(value)) {
+    if (PyFloat_Check(value)) {
         double number = PyFloat_AS_DOUBLE(value);
         // int(value) raises for NaN and infinity, exactly like the reference's integer check
         if (isnan(number)) {
@@ -920,7 +953,7 @@ static void intrinsic_index_bounds_error(PyObject *args, Py_ssize_t ix, const ch
 {
     PyObject *value = PyList_GET_ITEM(args, ix);
     PyObject *normalized =
-        PyLong_CheckExact(value) ? Py_NewRef(value) : PyLong_FromDouble(PyFloat_AS_DOUBLE(value));
+        PyLong_Check(value) ? Py_NewRef(value) : PyLong_FromDouble(PyFloat_AS_DOUBLE(value));
     if (normalized != NULL) {
         intrinsic_args_error(name, normalized, NULL);
         Py_DECREF(normalized);
@@ -962,7 +995,7 @@ static PyObject *intrinsic_math_abs(PyObject *args)
     if (x == NULL) {
         return NULL;
     }
-    if (PyFloat_CheckExact(x)) {
+    if (PyFloat_Check(x)) {
         return PyFloat_FromDouble(fabs(PyFloat_AS_DOUBLE(x)));
     }
     return PyNumber_Absolute(x);
@@ -977,7 +1010,7 @@ static PyObject *intrinsic_math_ceil(PyObject *args)
     if (x == NULL) {
         return NULL;
     }
-    if (PyFloat_CheckExact(x)) {
+    if (PyFloat_Check(x)) {
         return PyLong_FromDouble(ceil(PyFloat_AS_DOUBLE(x)));
     }
     return Py_NewRef(x);
@@ -990,7 +1023,7 @@ static PyObject *intrinsic_math_floor(PyObject *args)
     if (x == NULL) {
         return NULL;
     }
-    if (PyFloat_CheckExact(x)) {
+    if (PyFloat_Check(x)) {
         return PyLong_FromDouble(floor(PyFloat_AS_DOUBLE(x)));
     }
     return Py_NewRef(x);
@@ -1005,7 +1038,7 @@ static PyObject *intrinsic_math_sign(PyObject *args)
         return NULL;
     }
     long sign;
-    if (PyFloat_CheckExact(x)) {
+    if (PyFloat_Check(x)) {
         double number = PyFloat_AS_DOUBLE(x);
         sign = (number < 0.) ? -1 : ((number == 0.) ? 0 : 1);
     } else {
@@ -1169,6 +1202,9 @@ static PyObject *intrinsic_object_get(PyObject *args)
         return NULL;
     }
     PyObject *value;
+    // dict_get_ref reads the shared dict storage, matching the reference's object.get(key) - the
+    // inherited dict.get - for dict subclasses too (PyObject_GetItem would call __getitem__,
+    // which e.g. triggers defaultdict.__missing__)
     int found = dict_get_ref(object, key, &value);
     if (found < 0) {
         return NULL;
@@ -1189,7 +1225,7 @@ static PyObject *intrinsic_object_set(PyObject *args)
         return NULL;
     }
     PyObject *value = (PyList_GET_SIZE(args) > 2) ? PyList_GET_ITEM(args, 2) : Py_None;
-    if (PyDict_SetItem(object, key, value) < 0) {
+    if (obj_setitem(object, key, value) < 0) {
         return NULL;
     }
     return Py_NewRef(value);
@@ -1207,7 +1243,7 @@ static PyObject *intrinsic_object_has(PyObject *args)
     if (key == NULL || intrinsic_count_check(args, 2, Py_False) < 0) {
         return NULL;
     }
-    int has_key = PyDict_Contains(object, key);
+    int has_key = obj_contains(object, key);
     if (has_key < 0) {
         return NULL;
     }
@@ -1222,7 +1258,8 @@ static PyObject *intrinsic_object_keys(PyObject *args)
     if (object == NULL || intrinsic_count_check(args, 1, NULL) < 0) {
         return NULL;
     }
-    return PyDict_Keys(object);
+    // Call keys() for dict subclasses (e.g. OrderedDict iteration order can differ from the dict's)
+    return PyDict_CheckExact(object) ? PyDict_Keys(object) : PyMapping_Keys(object);
 }
 
 
@@ -1237,11 +1274,11 @@ static PyObject *intrinsic_object_delete(PyObject *args)
     if (key == NULL || intrinsic_count_check(args, 2, NULL) < 0) {
         return NULL;
     }
-    int has_key = PyDict_Contains(object, key);
+    int has_key = obj_contains(object, key);
     if (has_key < 0) {
         return NULL;
     }
-    if (has_key && PyDict_DelItem(object, key) < 0) {
+    if (has_key && obj_delitem(object, key) < 0) {
         return NULL;
     }
     Py_RETURN_NONE;
@@ -1255,7 +1292,8 @@ static PyObject *intrinsic_object_copy(PyObject *args)
     if (object == NULL || intrinsic_count_check(args, 1, NULL) < 0) {
         return NULL;
     }
-    return PyDict_Copy(object);
+    // Call dict(object) for dict subclasses, exactly like the reference implementation
+    return PyDict_CheckExact(object) ? PyDict_Copy(object) : PyObject_CallOneArg((PyObject *)&PyDict_Type, object);
 }
 
 
@@ -1340,7 +1378,7 @@ static PyObject *intrinsic_string_from_char_code(PyObject *args)
     for (Py_ssize_t ix = 0; ix < nargs; ix++) {
         PyObject *code = PyList_GET_ITEM(args, ix);
         double number;
-        if (PyFloat_CheckExact(code)) {
+        if (PyFloat_Check(code)) {
             number = PyFloat_AS_DOUBLE(code);
             // The reference's int(code) conversion raises for NaN and infinity (of either sign)
             // before the integral and sign checks
@@ -1356,7 +1394,7 @@ static PyObject *intrinsic_string_from_char_code(PyObject *args)
                 intrinsic_args_error("charCodes", code, NULL);
                 goto done;
             }
-        } else if (PyLong_CheckExact(code)) {
+        } else if (PyLong_Check(code) && !PyBool_Check(code)) {
             int overflow = 0;
             long long code_ll = PyLong_AsLongLongAndOverflow(code, &overflow);
             if (code_ll == -1 && !overflow && PyErr_Occurred()) {

{bare_script-5.0.4 → bare_script-5.0.5}/src/bare_script/value.py

@@ -23,18 +23,17 @@ def value_type(value):
 
     if value is None:
         return 'null'
-    t = type(value)
-    if t is str:
+    elif isinstance(value, str):
         return 'string'
-    elif t is bool:
+    elif isinstance(value, bool):
         return 'boolean'
-    elif t is int or t is float:
+    elif isinstance(value, (int, float)):
         return 'number'
     elif isinstance(value, datetime.date):
         return 'datetime'
-    elif t is dict:
+    elif isinstance(value, dict):
         return 'object'
-    elif t is list:
+    elif isinstance(value, list):
         return 'array'
     elif callable(value):
         return 'function'
@@ -59,14 +58,13 @@ def value_string(value):
 
     if value is None:
         return 'null'
-    t = type(value)
-    if t is str:
+    elif isinstance(value, str):
         return value
-    elif t is bool:
+    elif isinstance(value, bool):
         return 'true' if value else 'false'
-    elif t is int:
+    elif isinstance(value, int):
         return str(value)
-    elif t is float:
+    elif isinstance(value, float):
         return R_NUMBER_CLEANUP.sub('', str(value))
     elif isinstance(value, datetime.date):
         iso = value_normalize_datetime(value).astimezone().isoformat()
@@ -76,9 +74,9 @@ def value_string(value):
             millisecond = int(iso[microsecond_begin + 1:microsecond_end]) // 1000
             iso = f'{iso[0:microsecond_begin]}.{millisecond:0{3}d}{iso[microsecond_end:]}'
         return _R_DATETIME_TZ_CLEANUP.sub(r'\1', iso)
-    elif t is dict:
+    elif isinstance(value, dict):
         return value_json(value)
-    elif t is list:
+    elif isinstance(value, list):
         return value_json(value)
     elif callable(value):
         return '<function>'
@@ -143,14 +141,13 @@ def value_boolean(value):
     :rtype: bool
     """
 
-    t = type(value)
-    if t is bool:
+    if isinstance(value, bool):
         return value
-    elif t is str:
+    elif isinstance(value, str):
         return value != ''
-    elif t is int or t is float:
+    elif isinstance(value, (int, float)):
         return value != 0
-    elif t is list:
+    elif isinstance(value, list):
         return len(value) != 0
 
     # Everything else non-null is true
@@ -188,25 +185,24 @@ def value_compare(left, right):
         return 0 if right is None else -1
     elif right is None:
         return 1
-    left_type = type(left)
-    right_type = type(right)
-    if left_type is str and right_type is str:
+    if isinstance(left, str) and isinstance(right, str):
         return -1 if left < right else (0 if left == right else 1)
-    elif left_type is bool and right_type is bool:
+    elif isinstance(left, bool) and isinstance(right, bool):
         return -1 if left < right else (0 if left == right else 1)
-    elif (left_type is int or left_type is float) and (right_type is int or right_type is float):
+    elif isinstance(left, (int, float)) and not isinstance(left, bool) and \
+         isinstance(right, (int, float)) and not isinstance(right, bool):
         return -1 if left < right else (0 if left == right else 1)
     elif isinstance(left, datetime.date) and isinstance(right, datetime.date):
         left_dt = value_normalize_datetime(left)
         right_dt = value_normalize_datetime(right)
         return -1 if left_dt < right_dt else (0 if left_dt == right_dt else 1)
-    elif left_type is list and right_type is list:
+    elif isinstance(left, list) and isinstance(right, list):
         for ix in range(min(len(left), len(right))):
             item_compare = value_compare(left[ix], right[ix])
             if item_compare != 0:
                 return item_compare
         return -1 if len(left) < len(right) else (0 if len(left) == len(right) else 1)
-    elif left_type is dict and right_type is dict:
+    elif isinstance(left, dict) and isinstance(right, dict):
         left_key_values = sorted(left.items())
         right_key_values = sorted(right.items())
         for ix in range(min(len(left_key_values), len(right_key_values))):
@@ -297,8 +293,7 @@ def value_args_validate(fn_args, args, error_return_value=None):
 
         # Type-specific validation
         if arg_type == 'number':
-            arg_value_type = type(arg_value)
-            if not (arg_value_type is int or arg_value_type is float):
+            if not isinstance(arg_value, (int, float)) or isinstance(arg_value, bool):
                 raise ValueArgsError(fn_arg['name'], arg_value, error_return_value)
             arg_lt = fn_arg.get('lt')
             arg_lte = fn_arg.get('lte')
@@ -316,16 +311,13 @@ def value_args_validate(fn_args, args, error_return_value=None):
             if arg_integer:
                 args[ix] = int(arg_value)
         elif arg_type == 'string':
-            arg_value_type = type(arg_value)
-            if arg_value_type is not str:
+            if not isinstance(arg_value, str):
                 raise ValueArgsError(fn_arg['name'], arg_value, error_return_value)
         elif arg_type == 'array':
-            arg_value_type = type(arg_value)
-            if arg_value_type is not list:
+            if not isinstance(arg_value, list):
                 raise ValueArgsError(fn_arg['name'], arg_value, error_return_value)
         elif arg_type == 'object':
-            arg_value_type = type(arg_value)
-            if arg_value_type is not dict:
+            if not isinstance(arg_value, dict):
                 raise ValueArgsError(fn_arg['name'], arg_value, error_return_value)
         elif arg_type == 'datetime':
             if not isinstance(arg_value, datetime.date):

{bare_script-5.0.4 → bare_script-5.0.5/src/bare_script.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bare-script
-Version: 5.0.4
+Version: 5.0.5
 Summary: bare-script
 Home-page: https://github.com/craigahobbs/bare-script
 Author: Craig A. Hobbs