def integer_double_or_string(card: BDFCard, ifield: int,
fieldname: str) -> Union[int, float, str]:
"""
Casts a value to an integer/double/string
Parameters
----------
card : BDFCard()
BDF card as a list
ifield : int
field number
fieldname : str
name of field
Returns
-------
value : varies
the value of the field
"""
svalue = card.field(ifield)
if isinstance(svalue, integer_float_types):
return svalue
elif svalue is None:
dtype = _get_dtype(svalue)
raise SyntaxError(
'%s = %r (field #%s) on card must be an integer or float (not %s).\n'
'card=%s' % (fieldname, svalue, ifield, dtype, card))
svalue = str(svalue.strip())
if svalue: # integer/float/string
if '.' in svalue or '-' in svalue or '+' in svalue:
# float
value = double(card, ifield, fieldname)
elif svalue.isdigit(): # 1, not +1, or -1
# int
try:
value = int(svalue)
except (ValueError, TypeError):
raise SyntaxError(
'%s = %r (field #%s) on card must be an integer, float, '
'or string (not blank).\n'
'card=%s' % (fieldname, svalue, ifield, card))
elif ' ' in svalue:
raise SyntaxError(
'%s = %r (field #%s) on card must be an integer, float, or string '
'(not a string with a blank).\n'
'card=%s' % (fieldname, svalue, ifield, card))
elif svalue[0].isdigit():
raise SyntaxError(
'%s = %r (field #%s) on card must be an integer, float, or string '
'(not a string with a leading integer).\n'
'card=%s' % (fieldname, svalue, ifield, card))
else:
value = interpret_value(svalue, card)
return value
dtype = _get_dtype(svalue)
raise SyntaxError(
'%s = %r (field #%s) on card must be an integer, float, or string (not %s).\n'
'card=%s' % (fieldname, svalue, ifield, dtype, card))
def integer_double_or_blank(card: BDFCard,
ifield: int,
fieldname: str,
default=None):
"""
Parameters
----------
card : BDFCard()
BDF card as a list
ifield : int
field number
fieldname : str
name of field
default : int / float / None
the default value for the field (default=None)
"""
svalue = card.field(ifield)
if isinstance(svalue, integer_float_types):
return svalue
elif svalue is None:
return default
if svalue:
# integer/float
try:
return integer_or_double(card, ifield, fieldname)
except:
dtype = _get_dtype(svalue)
raise SyntaxError(
'%s = %r (field #%s) on card must be an integer, float, or '
'blank (not %s).\n'
'card=%s' % (fieldname, svalue, ifield, dtype, card))
return default
def components_or_blank(card: BDFCard,
ifield: int,
fieldname: str,
default: Optional[str] = None) -> Optional[str]:
"""
:param card: BDF card as a list
:type card: BDFCard()
:param ifield: field number
:type ifield: int
:param fieldname: name of field
:type fieldname: int
:param default: the default value for the field (default=None)
:type default: str, None
:return components: a string of the dofs '0' or '123456' (not all are required)
"""
#assert isinstance(card, BDFCard), type(card)
assert isinstance(ifield, int), type(ifield)
assert isinstance(fieldname, str), type(fieldname)
svalue = card.field(ifield)
if svalue is None:
return default
elif isinstance(svalue, integer_types):
svalue = str(svalue)
else:
svalue = svalue.strip()
if svalue:
return parse_components(card, ifield, fieldname)
return default
def blank(card: BDFCard, ifield: int, fieldname: str, default=None):
# type: (BDFCard, int, str, None) -> None
"""
Parameters
----------
card : BDFCard()
BDF card as a list
ifield : int
field number
fieldname : str
name of field
default : None
the default value for the field (default=None)
"""
assert isinstance(card, BDFCard), type(card)
assert isinstance(ifield, int), type(ifield)
assert isinstance(fieldname, str), type(fieldname)
svalue = card.field(ifield)
if svalue is None:
return default
if isinstance(svalue, str):
svalue = svalue.strip().upper()
if len(svalue) == 0:
return default
dtype = _get_dtype(svalue)
raise SyntaxError('%s = %r (field #%s) on card must be blank (not %s).\n'
'card=%s' % (fieldname, svalue, ifield, dtype, card))
def blank(card: BDFCard, ifield: int, fieldname: str, default=None) -> None:
"""
:param card: BDF card as a list
:type card: BDFCard()
:param ifield: field number
:type ifield: int
:param fieldname: name of field
:type fieldname: str
:param default: the default value for the field (default=None)
:type default: None
"""
assert isinstance(card, BDFCard), type(card)
assert isinstance(ifield, int), type(ifield)
assert isinstance(fieldname, str), type(fieldname)
svalue = card.field(ifield)
if svalue is None:
return default
if isinstance(svalue, str):
svalue = svalue.strip().upper()
if len(svalue) == 0:
return default
dtype = _get_dtype(svalue)
raise SyntaxError('%s = %r (field #%s) on card must be blank (not %s).\n'
'card=%s' % (fieldname, svalue, ifield, dtype, card))
def run_function(self, f, card, exact):
"""
Helper function
Parameters
----------
f : function
integer_or_blank
card : List[varies]
a series of values to add
exacts : List[float]
list of results
"""
assert len(card) == len(
exact), 'len(card)=%s len(exact)=%s' % (len(card), len(exact))
i = 0
fieldname = 'f'
bdf_card = BDFCard(card)
for i, exacti in enumerate(exact):
if exacti == SyntaxError:
with self.assertRaises(SyntaxError):
msg = 'field=%r exact=%r' % (bdf_card.field(i), exacti)
#print msg
f(bdf_card, i, fieldname)
else:
value = f(bdf_card, i, fieldname)
self.assertEqual(value, exacti)
i += 1
def exact_string_or_blank(card: BDFCard,
ifield: int,
fieldname: str,
default=None):
"""
Parameters
----------
card : BDFCard()
BDF card as a list
ifield : int
field number
fieldname : str
name of field
default : str, None
the default value for the field (default=None)
Returns
-------
value : varies
the value of the field
"""
svalue = card.field(ifield)
if svalue is None:
return default
svalue = '%-8s' % svalue
if svalue == '':
return default
return svalue
def integer(card: BDFCard, ifield: int, fieldname: str) -> int:
"""
Casts a value to an integer
Parameters
----------
card : BDFCard()
BDF card as a list
ifield : int
field number
fieldname : str
name of field
"""
svalue = card.field(ifield)
if isinstance(svalue, float_types):
dtype = _get_dtype(svalue)
raise SyntaxError(
'%s = %r (field #%s) on card must be an integer (not %s).\n'
'card=%s' % (fieldname, svalue, ifield, dtype, card))
try:
return int(svalue)
except (ValueError, TypeError):
dtype = _get_dtype(svalue)
raise SyntaxError(
'%s = %r (field #%s) on card must be an integer (not %s).\n'
'card=%s' % (fieldname, svalue, ifield, dtype, card))
def string_choice_or_blank(card: BDFCard,
ifield: int,
fieldname: str,
choices: Tuple[str],
default=None):
"""
:param card: BDF card as a list
:type card: BDFCard()
:param ifield: field number
:type ifield: int
:param fieldname: name of field
:type fieldname: str
:param default: the default value for the field (default=None)
:type default: int, float, None
:return value: the value from the desired field
"""
svalue = card.field(ifield)
if svalue is None:
return default
elif isinstance(svalue, str):
svalue = svalue.strip().upper()
else:
dtype = _get_dtype(svalue)
raise SyntaxError(
'%s = %r (field #%s) on card must be a string (not %s).\n'
'card=%s' % (fieldname, svalue, ifield, dtype, card))
if svalue: # string
svalue = svalue.upper()
if svalue not in choices:
raise RuntimeError(
f'{fieldname} = {svalue} (field #{ifield}) on card is a string, but must be {choices}.\n'
f'card={card}')
return svalue
return default
def integer_double_string_or_blank(card: BDFCard,
ifield: int,
fieldname: str,
default=None):
# type (BDFCard, int, str, Union[int, float, str]) -> Optional[Union[int, float, str]]
"""
Parameters
----------
card : BDFCard()
BDF card as a list
ifield : int
field number
fieldname : str
name of field
default : int, float, str, None (default=None)
the default value for the field
Returns
-------
value : int, float, str, None
the field value
"""
svalue = card.field(ifield)
if isinstance(svalue, integer_float_types):
return svalue
elif svalue is None:
return default
svalue = svalue.strip().upper()
if svalue:
# integer/float/string
if '.' in svalue or '-' in svalue[1:] or '+' in svalue[1:]:
# float
try:
value = double(card, ifield, fieldname)
except SyntaxError:
value = interpret_value(card[ifield], card)
elif RE_INT.match(
svalue): # svalue[0].isdigit() or svalue[1:].isdigit():
# int
try:
value = int(svalue)
except ValueError:
dtype = _get_dtype(svalue)
msg = (
'%s = %r (field #%s) on card must be an integer, float, '
'or string (not %s).\n'
'card=%s' % (fieldname, svalue, ifield, dtype, card))
raise SyntaxError(msg)
elif ' ' in svalue:
raise SyntaxError(
'%s = %r (field #%s) on card must be an integer, float or string '
'(without a blank space).\n'
'card=%s' % (fieldname, svalue, ifield, card))
else:
value = svalue
return value
return default
def integer_double_or_blank(card: BDFCard,
ifield: int,
fieldname: str,
default=None):
"""Casts a value to an integer/double/blank
:param card: BDF card as a list
:type card: BDFCard()
:param ifield: field number
:type ifield: int
:param fieldname: name of field
:type fieldname: str
:return value: the value from the desired field
:param default: the default value for the field (default=None)
:type default: int, float, None
"""
svalue = card.field(ifield)
if isinstance(svalue, integer_float_types):
return svalue
elif svalue is None:
return default
if svalue:
# integer/float
try:
return integer_or_double(card, ifield, fieldname)
except:
dtype = _get_dtype(svalue)
raise SyntaxError(
'%s = %r (field #%s) on card must be an integer, float, or '
'blank (not %s).\n'
'card=%s' % (fieldname, svalue, ifield, dtype, card))
return default
def double_or_string(card: BDFCard, ifield: int,
fieldname: str) -> Union[float, str]:
"""
Casts a value to an double/string
Parameters
----------
card : BDFCard()
BDF card as a list
ifield : int
field number
fieldname : str
name of field
"""
svalue = card.field(ifield)
if isinstance(svalue, float_types):
return svalue
elif svalue is None or isinstance(svalue, integer_types):
dtype = _get_dtype(svalue)
raise SyntaxError(
'%s = %r (field #%s) on card must be an float or string (not %s).\n'
'card=%s' % (fieldname, svalue, ifield, dtype, card))
elif isinstance(svalue, str):
svalue = svalue.strip().upper()
if '.' in svalue or '-' in svalue[1:] or '+' in svalue[1:]:
# float
try:
return double(card, ifield, fieldname)
except:
dtype = _get_dtype(svalue)
raise SyntaxError(
'%s = %r (field #%s) on card must be an float or string (not %s).\n'
'card=%s' % (fieldname, svalue, ifield, dtype, card))
elif svalue.isdigit(): # 1, not +1, or -1
# fail
pass
elif svalue:
# string
if ' ' in svalue:
dtype = _get_dtype(svalue)
raise SyntaxError(
'%s = %r (field #%s) on card must be an float or '
'string (without a blank space; not %s).\n'
'card=%s' % (fieldname, svalue, ifield, dtype, card))
elif svalue[0].isdigit(
) or '.' in svalue or '+' in svalue or '-' in svalue:
dtype = _get_dtype(svalue)
raise SyntaxError(
'%s = %r (field #%s) on card must be an float or '
'string (without a blank space; not %s).\n'
'card=%s' % (fieldname, svalue, ifield, dtype, card))
return str(svalue)
dtype = _get_dtype(svalue)
raise SyntaxError(
'%s = %r (field #%s) on card must be an float or string (not %s).\n'
'card=%s' % (fieldname, svalue, ifield, dtype, card))
def integer_or_string(card: BDFCard, ifield: int,
fieldname: str) -> Union[int, str]:
"""Casts a value to an integer/string
:param card: BDF card as a list
:type card: BDFCard()
:param ifield: field number
:type ifield: int
:param fieldname: name of field
:type fieldname: str
:return value: the value from the desired field
:param default: the default value for the field (default=None)
:type default: int, float, None
"""
svalue = card.field(ifield)
if isinstance(svalue, integer_types):
return svalue
elif isinstance(svalue, float_types):
dtype = _get_dtype(svalue)
raise SyntaxError(
'%s = %r (field #%s) on card must be an integer or string (not %s).\n'
'card=%s' % (fieldname, svalue, ifield, dtype, card))
elif svalue is None:
dtype = _get_dtype(svalue)
raise SyntaxError(
'%s = %r (field #%s) on card must be an integer or string (not %s).\n'
'card=%s' % (fieldname, svalue, ifield, dtype, card))
try:
value = int(svalue)
return value
except ValueError:
pass
if svalue[0].isdigit():
dtype = _get_dtype(svalue)
raise SyntaxError(
'%s = %r (field #%s) on card must be an integer or string (not %s; '
'strings must start with a character).\n'
'card=%s' % (fieldname, svalue, ifield, dtype, card))
elif ' ' in svalue:
raise SyntaxError(
'%s = %r (field #%s) on card must be an integer or string '
'(without a blank space).\n'
'card=%s' % (fieldname, svalue, ifield, card))
# string
try:
value = double(card, ifield, fieldname)
except SyntaxError:
return str(svalue.upper())
if isinstance(value, float_types):
dtype = _get_dtype(svalue)
raise SyntaxError(
'%s = %r (field #%s) on card must be an integer or string (not %s).\n'
'card=%s' % (fieldname, svalue, ifield, dtype, card))
def parse_components(card: BDFCard, ifield: int, fieldname: str) -> str:
"""
Parameters
----------
card : BDFCard()
BDF card as a list
ifield : int
field number
fieldname : str
name of field
Returns
-------
components : str
a string of the dofs '0' or '123456' (not all are required)
"""
assert isinstance(card, BDFCard), type(card)
assert isinstance(ifield, int), type(ifield)
assert isinstance(fieldname, str), type(fieldname)
svalue = card.field(ifield)
if isinstance(svalue, integer_types):
pass
elif svalue is None or '.' in svalue:
dtype = _get_dtype(svalue)
msg = ('%s = %r (field #%s) on card must be an integer (not %s).\n'
'card=%s' % (fieldname, svalue, ifield, dtype, card))
raise SyntaxError(msg)
try:
value = int(svalue)
except ValueError:
dtype = _get_dtype(svalue)
msg = ('%s = %r (field #%s) on card must be an integer (not %s).\n'
'card=%s' % (fieldname, svalue, ifield, dtype, card))
raise SyntaxError(msg)
if value > 0 and isinstance(svalue, str):
if '0' in svalue:
value2 = str(svalue).replace('0', '')
msg = (
'%s = %r (field #%s) on card must contain 0 or %s (not both).\n'
'card=%s' % (fieldname, svalue, ifield, value2, card))
raise SyntaxError(msg)
svalue2 = str(value)
svalue3 = ''.join(sorted(svalue2))
for i, component in enumerate(svalue3):
if component not in '0123456':
msg = (
'%s = %r (field #%s) on card contains an invalid component %r.\n'
'card=%s' % (fieldname, svalue, ifield, component, card))
raise SyntaxError(msg)
if component in svalue3[i + 1:]:
msg = (
'%s = %r (field #%s) on card must not contain duplicate entries.\n'
'card=%s' % (fieldname, svalue, ifield, card))
raise SyntaxError(msg)
return svalue3
def force_double(card: BDFCard, ifield: int, fieldname: str) -> float:
"""see ``double``"""
svalue = card.field(ifield)
if isinstance(svalue, float_types):
return svalue
elif isinstance(svalue, integer_types):
dtype = _get_dtype(svalue)
warnings.warn('%s = %r (field #%s) on card must be a float (not %s).\n'
'card=%s' % (fieldname, svalue, ifield, dtype, card))
return float(value)
elif svalue is None or len(svalue) == 0: ## None
dtype = _get_dtype(svalue)
raise SyntaxError(
'%s = %r (field #%s) on card must be a float (not %s).\n'
'card=%s' % (fieldname, svalue, ifield, dtype, card))
if svalue.isdigit(): # 1, not +1, or -1
# if only int
raise SyntaxError(
'%s = %r (field #%s) on card must be a float (not an integer).\n'
'card=%s' % (fieldname, svalue, ifield, card))
try:
# 1.0, 1.0E+3, 1.0E-3
value = float(svalue)
except TypeError:
dtype = _get_dtype(svalue)
raise SyntaxError(
'%s = %r (field #%s) on card must be a float (not %s).\n'
'card=%s' % (fieldname, svalue, ifield, dtype, card))
except ValueError:
# 1D+3, 1D-3, 1-3
try:
svalue = svalue.upper()
if 'D' in svalue:
# 1.0D+3, 1.0D-3
svalue2 = svalue.replace('D', 'E')
return float(svalue2)
# 1.0+3, 1.0-3
sign = ''
if svalue[0] in ('+', '-'):
sign = svalue[0]
svalue = svalue[1:]
if '+' in svalue:
svalue = sign + svalue.replace('+', 'E+')
elif '-' in svalue:
svalue = sign + svalue.replace('-', 'E-')
value = float(svalue)
except ValueError:
dtype = _get_dtype(svalue)
raise SyntaxError(
'%s = %r (field #%s) on card must be a float (not %s).\n'
'card=%s' % (fieldname, svalue, ifield, dtype, card))
return value
def integer_or_string(card: BDFCard, ifield: int, fieldname: str) -> Union[int, str]:
"""
Converts a field into an integer or string
Parameters
----------
card : BDFCard()
BDF card as a list
ifield : int
field number
fieldname : str
name of field
default : int / str
the default value for the field (default=None)
"""
svalue = card.field(ifield)
if isinstance(svalue, integer_types):
return svalue
elif isinstance(svalue, float_types):
dtype = _get_dtype(svalue)
raise SyntaxError('%s = %r (field #%s) on card must be an integer or string (not %s).\n'
'card=%s' % (fieldname, svalue, ifield, dtype, card))
elif svalue is None:
dtype = _get_dtype(svalue)
raise SyntaxError('%s = %r (field #%s) on card must be an integer or string (not %s).\n'
'card=%s' % (fieldname, svalue, ifield, dtype, card))
try:
value = int(svalue)
return value
except ValueError:
pass
if svalue[0].isdigit():
dtype = _get_dtype(svalue)
raise SyntaxError('%s = %r (field #%s) on card must be an integer or string (not %s; '
'strings must start with a character).\n'
'card=%s' % (fieldname, svalue, ifield, dtype, card))
elif ' ' in svalue:
raise SyntaxError('%s = %r (field #%s) on card must be an integer or string '
'(without a blank space).\n'
'card=%s' % (fieldname, svalue, ifield, card))
# string
try:
value = double(card, ifield, fieldname)
except SyntaxError:
return str(svalue.upper())
if isinstance(value, float_types):
dtype = _get_dtype(svalue)
raise SyntaxError('%s = %r (field #%s) on card must be an integer or string (not %s).\n'
'card=%s' % (fieldname, svalue, ifield, dtype, card))
def double_string_or_blank(card: BDFCard,
ifield: int,
fieldname: str,
default=None):
# type (BDFCard, int, str, Optional[Union[float, str]]) -> Optional[Union[float, str]]
"""Casts a value to an double/string/blank
:param card: BDF card as a list
:type card: BDFCard()
:param ifield: field number
:type ifield: int
:param fieldname: name of field
:type fieldname: str
:param default: the default value for the field (default=None)
:type default: double, None
:return value: the typed value
:raises SyntaxError: if there is an invalid type
"""
svalue = card.field(ifield)
if isinstance(svalue, float_types):
return svalue
elif svalue is None:
return default
elif isinstance(svalue, str):
svalue = svalue.strip().upper()
elif isinstance(svalue, integer_types):
dtype = _get_dtype(svalue)
msg = (
'%s = %r (field #%s) on card must be an float, string, or blank (not %s).\n'
'card=%s' % (fieldname, svalue, ifield, dtype, card))
raise SyntaxError(msg)
if '.' in svalue or '-' in svalue[1:] or '+' in svalue[1:]:
try:
return double(card, ifield, fieldname)
except:
dtype = _get_dtype(svalue)
raise SyntaxError(
'%s = %r (field #%s) on card must be a float, string '
'or blank (not %s).\n'
'card=%s' % (fieldname, svalue, ifield, dtype, card))
elif svalue.isdigit(): # 1, not +1, or -1
dtype = _get_dtype(svalue)
raise SyntaxError(
'%s = %r (field #%s) on card must be a float, string or blank (not %s).\n'
'card=%s' % (fieldname, svalue, ifield, dtype, card))
elif svalue == '':
return default
if ' ' in svalue:
dtype = _get_dtype(svalue)
raise SyntaxError('%s = %r (field #%s) on card must be an float, '
'string (without a blank space) or blank (not %s).\n'
'card=%s' % (fieldname, svalue, ifield, dtype, card))
return svalue
def integer_or_double(card: BDFCard, ifield: int,
fieldname: str) -> Union[int, float]:
"""
Casts a value to an integer/double
Parameters
----------
card : BDFCard()
BDF card as a list
ifield : int
field number
fieldname : str
name of field
Returns
-------
value : int/float
the value with the proper type
:raises SyntaxError: if there's an invalid type
"""
svalue = card.field(ifield)
if isinstance(svalue, integer_float_types):
return svalue
elif svalue is None:
dtype = _get_dtype(svalue)
raise SyntaxError(
'%s = %r (field #%s) on card must be an integer or float (not %s).\n'
'card=%s' % (fieldname, svalue, ifield, dtype, card))
if '.' in svalue or '-' in svalue[1:] or '+' in svalue[1:]:
# float/exponent
try:
value = double(card, ifield, fieldname)
except ValueError:
dtype = _get_dtype(svalue)
raise SyntaxError(
'%s = %r (field #%s) on card must be a integer or a float (not %s).\n'
'card=%s' % (fieldname, svalue, ifield, dtype, card))
else:
# int
try:
value = int(svalue)
except (ValueError, TypeError):
value = interpret_value(svalue, card)
if isinstance(value, (int, float)):
return value
dtype = _get_dtype(svalue)
raise SyntaxError(
'%s = %r (field #%s) on card must be an integer or a '
'float (not %s).\n'
'card=%s' % (fieldname, svalue, ifield, dtype, card))
return value
def loose_string_or_blank(card: BDFCard,
ifield: int,
fieldname: str,
default=None):
"""
Parameters
----------
card : BDFCard()
BDF card as a list
ifield : int
field number
fieldname : str
name of field
default : str, None
the default value for the field (default=None)
Returns
-------
value : varies
the value of the field
"""
svalue = card.field(ifield)
if svalue is None:
return default
elif isinstance(svalue, str):
svalue = svalue.strip().upper()
if ' ' in svalue:
raise SyntaxError(
'%s = %r (field #%s) on card must be a string without a space.\n'
'card=%s' % (fieldname, svalue, ifield, card))
if svalue[0].isdigit() or '+' in svalue or '-' in svalue[0]:
chars = ''.join(
list(set('%s+-' % svalue[0] if svalue[0].isdigit() else '')))
raise SyntaxError('%s = %r (field #%s) on card must not have the '
'following characters %s\n'
'card=%s' %
(fieldname, svalue, ifield, chars, card))
else:
dtype = _get_dtype(svalue)
raise SyntaxError(
'%s = %r (field #%s) on card must be a string (not %s).\n'
'card=%s' % (fieldname, svalue, ifield, dtype, card))
svalue = svalue.strip()
if svalue.isdigit() or '+' in svalue or '-' in svalue[0]:
# integer or float
dtype = _get_dtype(svalue)
raise SyntaxError(
'%s = %r (field #%s) on card must be a string or blank (not %s).\n'
'card=%s' % (fieldname, svalue, ifield, dtype, card))
if svalue: # string
return str(svalue.upper())
return default
def force_integer(card: BDFCard, ifield: int, fieldname: str) -> int:
"""see ``integer``"""
svalue = card.field(ifield)
if isinstance(svalue, float_types):
warnings.warn(
'%s = %r (field #%s) on card must be an integer (not a double).\n'
'card=%s' % (fieldname, svalue, ifield, card))
return int(svalue)
try:
return int(svalue)
except (ValueError, TypeError):
dtype = _get_dtype(svalue)
raise SyntaxError(
'%s = %r (field #%s) on card must be an integer (not %s).\n'
'card=%s' % (fieldname, svalue, ifield, dtype, card))
def run_function(self, f, card, exact):
assert len(card) == len(exact), 'len(card)=%s len(exact)=%s' % (len(card), len(exact))
i = 0
fieldname = 'f'
card = BDFCard(card)
for i, exacti in enumerate(exact):
if exacti == SyntaxError:
with self.assertRaises(SyntaxError):
msg = 'field=%r exact=%r' % (card.field(i), exacti)
#print msg
f(card, i, fieldname)
else:
value = f(card, i, fieldname)
self.assertEqual(value, exacti)
i += 1
def integer_or_blank(card: BDFCard,
ifield: int,
fieldname: str,
default: Optional[int] = None):
# (card, ifield, fieldname, default) -> Optional[int]
"""
Casts a value to an integer
Parameters
----------
card : BDFCard()
BDF card as a list
ifield : int
field number
fieldname : str
name of field
default : int, None
the default value for the field (default=None)
"""
svalue = card.field(ifield)
if isinstance(svalue, integer_types):
return svalue
elif svalue is None:
return default
elif isinstance(svalue, str):
if len(svalue) == 0:
return default
elif '.' in svalue or '-' in svalue[1:] or '+' in svalue[1:]:
dtype = _get_dtype(svalue)
raise SyntaxError(
'%s = %r (field #%s) on card must be an integer or blank (not %s).\n'
'card=%s' % (fieldname, svalue, ifield, dtype, card))
try:
return int(svalue)
except (ValueError, TypeError):
dtype = _get_dtype(svalue)
raise SyntaxError(
'%s = %r (field #%s) on card must be an integer or blank (not %s).\n'
'card=%s' % (fieldname, svalue, ifield, dtype, card))
dtype = _get_dtype(svalue)
raise SyntaxError(
'%s = %r (field #%s) on card must be an integer (not %s).\n'
'card=%s' % (fieldname, svalue, ifield, dtype, card))
def string_or_blank(card: BDFCard, ifield: int, fieldname: str, default=None):
"""
:param card: BDF card as a list
:type card: BDFCard()
:param ifield: field number
:type ifield: int
:param fieldname: name of field
:type fieldname: str
:param default: the default value for the field (default=None)
:type default: int, float, None
:return value: the value from the desired field
"""
svalue = card.field(ifield)
if svalue is None:
return default
elif isinstance(svalue, str):
svalue = svalue.strip().upper()
if ' ' in svalue:
raise SyntaxError(
'%s = %r (field #%s) on card must be a string without a space.\n'
'card=%s' % (fieldname, svalue, ifield, card))
if svalue[0].isdigit(
) or '.' in svalue or '+' in svalue or '-' in svalue[0]:
chars = ''.join(
list(set('%s.+-' % svalue[0] if svalue[0].isdigit() else '')))
raise SyntaxError('%s = %r (field #%s) on card must not have the '
'following characters %s\n'
'card=%s' %
(fieldname, svalue, ifield, chars, card))
else:
dtype = _get_dtype(svalue)
raise SyntaxError(
'%s = %r (field #%s) on card must be a string (not %s).\n'
'card=%s' % (fieldname, svalue, ifield, dtype, card))
svalue = svalue.strip()
if svalue.isdigit() or '.' in svalue or '+' in svalue or '-' in svalue[0]:
# integer or float
dtype = _get_dtype(svalue)
raise SyntaxError(
'%s = %r (field #%s) on card must be a string or blank (not %s).\n'
'card=%s' % (fieldname, svalue, ifield, dtype, card))
if svalue: # string
return str(svalue.upper())
return default
def run_function_default(self, f, card, exact, default):
fieldname = 'f'
assert len(card) == len(exact), 'len(card)=%s len(exact)=%s' % (len(card), len(exact))
assert len(card) == len(default), 'len(card)=%s len(default)=%s' % (len(card), len(default))
i = 0
card = BDFCard(card)
for i, exacti in enumerate(exact):
defaulti = default[i]
if exacti == SyntaxError:
with self.assertRaises(exacti):
msg = 'field=%r exact=%r default=%r' % (card.field(i), exacti, defaulti)
#print msg
f(card, i, fieldname, defaulti)
else:
value = f(card, i, fieldname, defaulti)
self.assertEqual(value, exacti)
i += 1
def run_function(self, f, card, exact):
assert len(card) == len(
exact), 'len(card)=%s len(exact)=%s' % (len(card), len(exact))
i = 0
fieldname = 'f'
card = BDFCard(card)
for i, exacti in enumerate(exact):
if exacti == SyntaxError:
with self.assertRaises(SyntaxError):
msg = 'field=%r exact=%r' % (card.field(i), exacti)
#print msg
f(card, i, fieldname)
else:
value = f(card, i, fieldname)
self.assertEqual(value, exacti)
i += 1
def string(card: BDFCard, ifield: int, fieldname: str) -> str:
"""
Casts a value to a string
Parameters
----------
card : BDFCard()
BDF card as a list
ifield : int
field number
fieldname : str
name of field
Returns
-------
value : str
the value of the field
"""
svalue = card.field(ifield)
if isinstance(svalue, str):
svalue = svalue.strip()
if ' ' in svalue:
raise SyntaxError(
'%s = %r (field #%s) on card must be a string without a space.\n'
'card=%s' % (fieldname, svalue, ifield, card))
else:
dtype = _get_dtype(svalue)
raise SyntaxError(
'%s = %r (field #%s) on card must be a string (not %s).\n'
'card=%s' % (fieldname, svalue, ifield, dtype, card))
if svalue[0].isdigit(
) or '.' in svalue or '+' in svalue or '-' in svalue[0]:
value = integer_or_double(card, ifield, fieldname)
dtype = _get_dtype(value)
raise SyntaxError('%s = %r (field #%s) on card must be a '
'string with a character (not %s).\n'
'card=%s' % (fieldname, value, ifield, dtype, card))
if svalue: # string
return str(svalue.upper())
dtype = _get_dtype(svalue)
raise SyntaxError(
'%s = %r (field #%s) on card must be a string (not %s).\n'
'card=%s' % (fieldname, svalue, ifield, dtype, card))
def double_or_blank(card: BDFCard,
ifield: int,
fieldname: str,
default: Optional[Union[float]] = None):
# (card, ifield, fieldname, default) -> Optional[Union[float]]
"""
Casts a value to an double/blank
Parameters
----------
card : BDFCard()
BDF card as a list
ifield : int
field number
fieldname : str
name of field
default : double, None
the default value for the field (default=None)
"""
svalue = card.field(ifield)
if isinstance(svalue, float_types):
return svalue
elif isinstance(svalue, integer_types):
dtype = _get_dtype(svalue)
raise SyntaxError(
'%s = %r (field #%s) on card must be a float or blank (not %s).\n'
'card=%s' % (fieldname, svalue, ifield, dtype, card))
elif isinstance(svalue, str):
svalue = svalue.strip().upper()
if not svalue:
return default
try:
return double(card, ifield, fieldname)
except:
if svalue == '.':
return 0.
dtype = _get_dtype(svalue)
raise SyntaxError(
'%s = %r (field #%s) on card must be a float or blank (not %s).\n'
'card=%s' % (fieldname, svalue, ifield, dtype, card))
return default
def integer_string_or_blank(card: BDFCard,
ifield: int,
fieldname: str,
default=None):
"""
Casts a value to an integer/string/blank
Parameters
----------
card : BDFCard()
BDF card as a list
ifield : int
field number
fieldname : str
name of field
default : int, str, None
the default value for the field (default=None)
"""
svalue = card.field(ifield)
if isinstance(svalue, integer_types):
return svalue
elif svalue is None:
return default
elif isinstance(svalue, float_types):
dtype = _get_dtype(svalue)
raise SyntaxError(
'%s = %r (field #%s) on card must be an integer or string (not %s).\n'
'card=%s' % (fieldname, svalue, ifield, dtype, card))
svalue = svalue.strip()
if svalue:
# integer/string
try:
return integer_or_string(card, ifield, fieldname)
except:
dtype = _get_dtype(svalue)
raise SyntaxError(
'%s = %r (field #%s) on card must be an integer, '
'string (without a blank space), or blank (not %s).\n'
'card=%s' % (fieldname, svalue, ifield, dtype, card))
return default
def string_choice_or_blank(card: BDFCard,
ifield: int,
fieldname: str,
choices: Tuple[str],
default=None):
"""
Parameters
----------
card : BDFCard()
BDF card as a list
ifield : int
field number
fieldname : str
name of field
default : str, None
the default value for the field (default=None)
Returns
-------
value : varies
the value of the field
"""
svalue = card.field(ifield)
if svalue is None:
return default
elif isinstance(svalue, str):
svalue = svalue.strip().upper()
else:
dtype = _get_dtype(svalue)
raise SyntaxError(
'%s = %r (field #%s) on card must be a string (not %s).\n'
'card=%s' % (fieldname, svalue, ifield, dtype, card))
if svalue: # string
svalue = svalue.upper()
if svalue not in choices:
raise RuntimeError(
f'{fieldname} = {svalue} (field #{ifield}) on card is a string, but must be {choices}.\n'
f'card={card}')
return svalue
return default
def run_function_default(self, f, card, exact, default):
fieldname = 'f'
assert len(card) == len(
exact), 'len(card)=%s len(exact)=%s' % (len(card), len(exact))
assert len(card) == len(default), 'len(card)=%s len(default)=%s' % (
len(card), len(default))
i = 0
card = BDFCard(card)
for i, exacti in enumerate(exact):
defaulti = default[i]
if exacti == SyntaxError:
with self.assertRaises(exacti):
msg = 'field=%r exact=%r default=%r' % (card.field(i),
exacti, defaulti)
#print msg
f(card, i, fieldname, defaulti)
else:
value = f(card, i, fieldname, defaulti)
self.assertEqual(value, exacti)
i += 1
def exact_string_or_blank(card: BDFCard,
ifield: int,
fieldname: str,
default=None):
"""
:param card: BDF card as a list
:type card: BDFCard()
:param ifield: field number
:type ifield: int
:param fieldname: name of field
:type fieldname: str
:return value: the value from the desired field
:param default: the default value for the field (default=None)
:type default: int, float, None
"""
svalue = card.field(ifield)
if svalue is None:
return default
svalue = '%-8s' % svalue
if svalue == '':
return default
return svalue
def force_integer_or_blank(card: BDFCard,
ifield: int,
fieldname: str,
default: Optional[int] = None):
# (card, ifield, fieldname, default) -> Optional[int]
"""see ``integer_or_blank``"""
svalue = card.field(ifield)
if isinstance(svalue, integer_types):
return svalue
elif svalue is None:
return default
elif '.' in svalue:
# float
fvalue = force_double(card, ifield, fieldname)
# TODO: warn if not a whole number
return int(fvalue)
elif isinstance(svalue, str):
if len(svalue) == 0:
return default
elif '.' in svalue or '-' in svalue[1:] or '+' in svalue[1:]:
dtype = _get_dtype(svalue)
raise SyntaxError(
'%s = %r (field #%s) on card must be an integer or blank (not %s).\n'
'card=%s' % (fieldname, svalue, ifield, dtype, card))
try:
return int(svalue)
except (ValueError, TypeError):
dtype = _get_dtype(svalue)
raise SyntaxError(
'%s = %r (field #%s) on card must be an integer or blank (not %s).\n'
'card=%s' % (fieldname, svalue, ifield, dtype, card))
# float
dtype = _get_dtype(svalue)
raise SyntaxError(
'%s = %r (field #%s) on card must be an integer (not %s).\n'
'card=%s' % (fieldname, svalue, ifield, dtype, card))
