from importlib.metadata import PackageNotFoundError, version

from .add import add
from .all_pass import all_pass
from .any_pass import any_pass
from .apply import apply
from .capitalise import capitalise
from .ceil import ceil
from .chunk import chunk
from .clamp import clamp
from .concat import concat
from .conditional import conditional
from .constant import constant
from .count_by import count_by
from .default_to import default_to
from .difference import difference
from .difference_with import difference_with
from .do_nothing import do_nothing
from .drop import drop
from .drop_first_by import drop_first_by
from .drop_last import drop_last
from .drop_last_while import drop_last_while
from .drop_while import drop_while
from .ends_with import ends_with
from .entries import entries
from .eq import eq
from .evolve import evolve
from .filter import filter
from .find import find
from .find_index import find_index
from .find_last import find_last
from .find_last_index import find_last_index
from .first import first
from .first_by import first_by
from .flat import flat
from .flat_map import flat_map
from .floor import floor
from .fold import fold
from .for_each import for_each
from .for_each_dict import for_each_dict
from .from_entries import from_entries
from .from_keys import from_keys
from .ge import ge
from .get import get
from .group_by import group_by
from .group_by_prop import group_by_prop
from .gt import gt
from .identity import identity
from .index_by import index_by
from .intersection import intersection
from .intersection_with import intersection_with
from .invert import invert
from .is_bool import is_bool
from .is_callable import is_callable
from .is_divisible_by import is_divisible_by
from .is_empty import is_empty
from .is_even import is_even
from .is_float import is_float
from .is_int import is_int
from .is_list import is_list
from .is_none import is_none
from .is_number import is_number
from .is_odd import is_odd
from .is_sequence import is_sequence
from .is_sized import is_sized
from .is_string import is_string
from .is_subset import is_subset
from .is_superset import is_superset
from .is_truthy import is_truthy
from .join import join
from .keys import keys
from .last import last
from .le import le
from .length import length
from .lt import lt
from .map import map
from .map_keys import map_keys
from .map_to_obj import map_to_obj
from .map_values import map_values
from .map_with_feedback import map_with_feedback
from .mean import mean
from .mean_by import mean_by
from .merge import merge
from .merge_all import merge_all
from .merge_deep import merge_deep
from .mod import mod
from .multiply import multiply
from .negate import negate
from .neq import neq
from .nth_by import nth_by
from .omit import omit
from .omit_by import omit_by
from .once import once
from .only import only
from .partial import partial
from .partition import partition
from .path_or import path_or
from .pick import pick
from .pick_by import pick_by
from .pipe import pipe
from .piped import piped
from .prop import prop
from .pull_object import pull_object
from .random_string import random_string
from .range import range
from .rank_by import rank_by
from .reduce import reduce
from .reverse import reverse
from .round import round
from .sample import sample
from .set import set
from .set_path import set_path
from .shuffle import shuffle
from .slice import slice
from .slice_string import slice_string
from .sort import sort
from .sorted_index import sorted_index
from .sorted_index_by import sorted_index_by
from .sorted_index_with import sorted_index_with
from .sorted_last_index import sorted_last_index
from .sorted_last_index_by import sorted_last_index_by
from .splice import splice
from .split import split
from .split_at import split_at
from .split_when import split_when
from .starts_with import starts_with
from .subtract import subtract
from .sum import sum
from .sum_by import sum_by
from .swap_indices import swap_indices
from .swap_props import swap_props
from .take import take
from .take_first_by import take_first_by
from .take_last import take_last
from .take_last_while import take_last_while
from .take_while import take_while
from .tap import tap
from .times import times
from .to_camel_case import to_camel_case
from .to_kebab_case import to_kebab_case
from .to_lower_case import to_lower_case
from .to_snake_case import to_snake_case
from .to_title_case import to_title_case
from .to_upper_case import to_upper_case
from .to_words import to_words
from .truncate import truncate
from .uncapitalise import uncapitalise
from .unique import unique
from .unique_by import unique_by
from .unique_with import unique_with
from .values import values
from .when import when
from .zip import zip
from .zip_with import zip_with

try:
    __version__ = version('remedapy')
except PackageNotFoundError:  # pragma: no cover
    __version__ = '0.0.0'

__all__ = [
    'add',
    'all_pass',
    'any_pass',
    'apply',
    'capitalise',
    'ceil',
    'chunk',
    'clamp',
    'concat',
    'conditional',
    'constant',
    'count_by',
    'default_to',
    'difference',
    'difference_with',
    'do_nothing',
    'drop',
    'drop_first_by',
    'drop_last',
    'drop_last_while',
    'drop_while',
    'ends_with',
    'entries',
    'eq',
    'evolve',
    'filter',
    'find',
    'find_index',
    'find_last',
    'find_last_index',
    'first',
    'first_by',
    'flat',
    'flat_map',
    'floor',
    'fold',
    'for_each',
    'for_each_dict',
    'from_entries',
    'from_keys',
    'ge',
    'get',
    'group_by',
    'group_by_prop',
    'gt',
    'identity',
    'index_by',
    'intersection',
    'intersection_with',
    'invert',
    'is_bool',
    'is_callable',
    'is_divisible_by',
    'is_empty',
    'is_even',
    'is_float',
    'is_int',
    'is_list',
    'is_none',
    'is_number',
    'is_odd',
    'is_sequence',
    'is_sized',
    'is_string',
    'is_subset',
    'is_superset',
    'is_truthy',
    'join',
    'keys',
    'last',
    'le',
    'length',
    'lt',
    'map',
    'map_keys',
    'map_to_obj',
    'map_values',
    'map_with_feedback',
    'mean',
    'mean_by',
    'merge',
    'merge_all',
    'merge_deep',
    'mod',
    'multiply',
    'negate',
    'neq',
    'nth_by',
    'omit',
    'omit_by',
    'once',
    'only',
    'partial',
    'partition',
    'path_or',
    'pick',
    'pick_by',
    'pipe',
    'piped',
    'prop',
    'pull_object',
    'random_string',
    'range',
    'rank_by',
    'reduce',
    'reverse',
    'round',
    'sample',
    'set',
    'set_path',
    'shuffle',
    'slice',
    'slice_string',
    'sort',
    'sorted_index',
    'sorted_index_by',
    'sorted_index_with',
    'sorted_last_index',
    'sorted_last_index_by',
    'splice',
    'split',
    'split_at',
    'split_when',
    'starts_with',
    'subtract',
    'sum',
    'sum_by',
    'swap_indices',
    'swap_props',
    'take',
    'take_first_by',
    'take_last',
    'take_last_while',
    'take_while',
    'tap',
    'times',
    'to_camel_case',
    'to_kebab_case',
    'to_lower_case',
    'to_snake_case',
    'to_title_case',
    'to_upper_case',
    'to_words',
    'truncate',
    'uncapitalise',
    'unique',
    'unique_by',
    'unique_with',
    'values',
    'when',
    'zip',
    'zip_with',
]
