def removePrio(self, animeTitleOrAlias, key):
animeTitle = self.getTitleFromAlias(animeTitleOrAlias)
if not animeTitle:
return False
if checkers.is_integer(key):
prioManager = self.numPrioManager
else:
prioManager = self.tagPrioManager
prioManager.removePrio(animeTitle, key)
def validate_favorite_form(json: dict):
try:
user_id = json['user_id']
user_id_valid = checkers.is_integer(user_id)
except TypeError:
user_id_valid = False
serie_id_valid = False
try:
serie_id = json['serie_id']
serie_id_valid = checkers.is_integer(serie_id)
except TypeError:
serie_id_valid = False
invalid_fields = []
if not serie_id_valid:
invalid_fields.append(InvalidField('serie_id', f'Invalid value'))
if not user_id_valid:
invalid_fields.append(InvalidField('user_id', f'Invalid value'))
if len(invalid_fields) > 0:
raise InvalidForm(invalid_fields)
return user_id, serie_id
def validate_add_serie_form(json: dict):
try:
serie_id = json['serie_id']
serie_id_valid = checkers.is_integer(serie_id)
except TypeError:
serie_id_valid = False
invalid_fields = []
if not serie_id_valid:
invalid_fields.append(InvalidField('serie_id', f'Invalid value'))
raise InvalidForm(invalid_fields)
return serie_id
async def setCurrEp(message, args):
args = message.content.split()
if len(args) != 3:
errMsg = 'Please enter the form of: "!setEp animeTitle/animeAlias epNum".'
await message.channel.send(errMsg)
ep = args[-1]
if checkers.is_integer(ep):
key = "".join(args[1:-1])
trueKey = amadeusDriver.getTitleFromKey(key)
amadeusDriver.setEpisode(trueKey, ep)
succMsg = 'Updated stack of {0} to episode {1}'.format(trueKey, ep)
await message.channel.send(succMsg)
else:
errMsg = 'Please ensure "{0}" is a valid number'.format(ep)
await message.channel.send(errMsg)
def decode(data: str) -> [int, float, bool, str]:
if data.endswith('%'):
data = data.replace('%', '')
elif data.endswith("B"):
i = len(data)
for i, character in enumerate(data):
if character in ascii_uppercase:
break
data, m = decode(data[:i]), data[i:].replace('B', '').lower()
if m == 'm':
m = 10**6
elif m == 'k':
m = 10**3
return data * m
if checkers.is_integer(data):
return int(float(data))
elif checkers.is_float(data):
return float(data)
elif data.lower() == 'false':
return False
elif data.lower() == 'true':
return True
else:
return data
def get_type_mapping(value,
type_mapping=None,
skip_nested=True,
default_to_str=False):
"""Retrieve the SQL type mapping for ``value``.
:param value: The value whose SQL type will be returned.
:param type_mapping: Determines how the value type of ``value`` map to
SQL column data types. To add a new mapping or override a default, set a
key to the name of the value type in Python, and set the value to a
:doc:`SQLAlchemy Data Type <sqlalchemy:core/types>`. The following are the
default mappings applied:
.. list-table::
:widths: 30 30
:header-rows: 1
* - Python Literal
- SQL Column Type
* - ``bool``
- :class:`Boolean <sqlalchemy:sqlalchemy.types.Boolean>`
* - ``str``
- :class:`Text <sqlalchemy:sqlalchemy.types.Text>`
* - ``int``
- :class:`Integer <sqlalchemy:sqlalchemy.types.Integer>`
* - ``float``
- :class:`Float <sqlalchemy:sqlalchemy.types.Float>`
* - ``date``
- :class:`Date <sqlalchemy:sqlalchemy.types.Date>`
* - ``datetime``
- :class:`DateTime <sqlalchemy:sqlalchemy.types.DateTime>`
* - ``time``
- :class:`Time <sqlalchemy:sqlalchemy.types.Time>`
* - ``timedelta``
- :class:`Interval <sqlalchemy:sqlalchemy.types.Interval>`
:type type_mapping: :class:`dict <python:dict>` with type names as keys and
column data types as values / :obj:`None <python:None>`
:param skip_nested: If ``True`` then if ``value`` is a nested item (e.g.
iterable, :class:`dict <python:dict>` objects, etc.) it will return
:obj:`None <python:None>`. If ``False``, will treat nested items as
:class:`str <python:str>`. Defaults to ``True``.
:type skip_nested: :class:`bool <python:bool>`
:param default_to_str: If ``True``, will automatically set a ``value`` whose
value type cannot be determined to ``str``
(:class:`Text <sqlalchemy:sqlalchemy.types.Text>`). If ``False``, will
use the value type's ``__name__`` attribute and attempt to find a mapping.
Defaults to ``False``.
:type default_to_str: :class:`bool <python:bool>`
:returns: The :doc:`SQLAlchemy Data Type <sqlalchemy:core/types>` for ``value``, or
:obj:`None <python:None>` if the value should be skipped
:rtype: :doc:`SQLAlchemy Data Type <sqlalchemy:core/types>` / :obj:`None`
:raises UnsupportedValueTypeError: when ``value`` does not have corresponding
:doc:`SQLAlchemy Data Type <sqlalchemy:core/types>`
"""
if not type_mapping:
type_mapping = DEFAULT_PYTHON_SQL_TYPE_MAPPING
for key in DEFAULT_PYTHON_SQL_TYPE_MAPPING:
if key not in type_mapping:
type_mapping[key] = DEFAULT_PYTHON_SQL_TYPE_MAPPING[key]
if checkers.is_callable(value):
raise UnsupportedValueTypeError('value ("%s") cannot be callable' %
value)
elif checkers.is_iterable(value) and skip_nested:
return None
elif checkers.is_iterable(value) and default_to_str:
target_type = 'str'
elif value is None and default_to_str:
target_type = 'str'
elif isinstance(value, bool):
target_type = 'bool'
elif checkers.is_numeric(value):
if checkers.is_integer(value):
target_type = 'int'
else:
target_type = 'float'
elif checkers.is_time(value) and not checkers.is_datetime(value):
target_type = 'time'
elif checkers.is_datetime(value):
target_type = 'datetime'
elif checkers.is_date(value):
target_type = 'date'
elif default_to_str:
target_type = 'str'
else:
target_type = type(value).__name__
column_type = type_mapping.get(target_type, None)
if not column_type:
raise UnsupportedValueTypeError(
'value ("%s") is not a supported type (%s)' % (value, target_type))
return column_type