numdaplot 0.1.0__py3-none-any.whl

numdaplot/tables/joining/joined_frame.py

@@ -0,0 +1,166 @@
+"""
+Columns of the result of a join of two Tables.
+
+.. versionadded:: 0.1.0
+"""
+
+import numpy
+import pandas
+from numpy.typing import NDArray
+
+from numdaplot.tables.joining.join import Join
+from numdaplot.tables.joining.join_keys import align_key_frames
+from numdaplot.tables.joining.join_relation import require_relation
+from numdaplot.tables.joining.joined_names import name_joined_columns
+from numdaplot.tables.joining.joined_rows import pair_rows
+from numdaplot.tables.table_data import read_stored_frame
+
+COLUMN_AXIS = 1
+
+
+def join_frames(frame: pandas.DataFrame, join: Join) -> pandas.DataFrame:
+	"""
+	Return the columns of the join of the columns of a Table with the other Table of a join.
+
+	.. versionadded:: 0.1.0
+
+	Parameters
+	----------
+	frame
+		The columns of the joined Table.
+	join
+		The other Table, the keys and the settings of the join.
+
+	Returns
+	-------
+	pandas.DataFrame
+		The keys, then the other columns of the joined Table, then those of the other Table, one row per pair of
+		rows, missing values where a Table has no row.
+
+	Raises
+	------
+	ColumnNotFoundError
+		When a key is missing from one of the Tables.
+	IncompatibleTypesError
+		When the two columns of a key cannot match.
+	TimeZoneMismatchError
+		When the two columns of a key hold datetimes of different time zones, or with and without one.
+	JoinRelationError
+		When a key is repeated in a Table where the relation of the join expects it once.
+	DuplicateColumnError
+		When both Tables have a column besides the keys and no suffixes are given, or a suffixed name is already
+		taken.
+
+	Examples
+	--------
+	>>> import pandas
+	>>> import numdaplot as ndp
+	>>> from numdaplot.tables.joining.joined_frame import join_frames
+	>>> users = ndp.Table.from_arrays({"id": ndp.Array.from_list([1, 3]), "age": ndp.Array.from_list([34, 51])})
+	>>> frame = pandas.DataFrame({"id": pandas.array([1, 2], dtype="Int64")})
+	>>> join_frames(frame, ndp.Join(other=users, keys=["id"], mode=ndp.JoinMode.LEFT))["age"].tolist()
+	[34, <NA>]
+	"""
+	other_frame = read_stored_frame(join.other)
+	key_frame, other_key_frame = align_key_frames(frame, other_frame, join.keys, join.key_types)
+	require_relation(key_frame, other_key_frame, join.relation)
+	column_names = frame.columns.tolist()
+	other_names = other_frame.columns.tolist()
+	joined_names, other_joined_names = name_joined_columns(column_names, other_names, join.keys, join.suffixes)
+	rows, other_rows = pair_rows(key_frame, other_key_frame, join.mode)
+	joined_keys = join_key_columns(key_frame, other_key_frame, rows, other_rows)
+	kept_frame = frame.drop(columns=join.keys)
+	other_kept_frame = other_frame.drop(columns=join.keys)
+	joined_frame = take_rows(kept_frame, rows)
+	other_joined_frame = take_rows(other_kept_frame, other_rows)
+	joined_frame.columns = pandas.Index(joined_names)
+	other_joined_frame.columns = pandas.Index(other_joined_names)
+	result_frame = pandas.concat([joined_keys, joined_frame, other_joined_frame], axis=COLUMN_AXIS)
+
+	return result_frame
+
+
+def join_key_columns(
+	key_frame: pandas.DataFrame,
+	other_key_frame: pandas.DataFrame,
+	rows: NDArray[numpy.intp],
+	other_rows: NDArray[numpy.intp],
+) -> pandas.DataFrame:
+	"""
+	Return one column per key: the key of the joined Table, or of the other Table where the joined one has no row.
+
+	.. versionadded:: 0.1.0
+
+	Parameters
+	----------
+	key_frame
+		The key columns of the joined Table.
+	other_key_frame
+		The key columns of the other Table, of the same names and types.
+	rows
+		The row of the joined Table of each row of the result, -1 where it has none.
+	other_rows
+		The row of the other Table of each row of the result, -1 where it has none.
+
+	Returns
+	-------
+	pandas.DataFrame
+		The keys of each row of the result, numbered from 0.
+
+	Examples
+	--------
+	>>> import numpy
+	>>> import pandas
+	>>> from numdaplot.tables.joining.joined_frame import join_key_columns
+	>>> key_frame = pandas.DataFrame({"id": [1.0, 2.0]})
+	>>> other_key_frame = pandas.DataFrame({"id": [3.0, 1.0]})
+	>>> join_key_columns(key_frame, other_key_frame, numpy.array([0, 1, -1]), numpy.array([1, -1, 0]))["id"].tolist()
+	[1.0, 2.0, 3.0]
+	"""
+	joined_keys = take_rows(key_frame, rows)
+	other_joined_keys = take_rows(other_key_frame, other_rows)
+	has_row = rows >= 0
+	key_columns = dict[str, pandas.Series]()
+
+	for key_name in key_frame.columns:
+		key_column = joined_keys[key_name]
+		other_key_column = other_joined_keys[key_name]
+		combined_column = key_column.where(has_row, other_key_column)
+		key_columns[key_name] = combined_column
+
+	key_columns_frame = pandas.DataFrame(key_columns)
+
+	return key_columns_frame
+
+
+def take_rows(frame: pandas.DataFrame, rows: NDArray[numpy.intp]) -> pandas.DataFrame:
+	"""
+	Return the given rows of the columns of a Table, a row of missing values for each -1.
+
+	.. versionadded:: 0.1.0
+
+	Parameters
+	----------
+	frame
+		The columns of a Table, rows numbered from 0.
+	rows
+		The row numbers taken, in order, possibly repeated, -1 for a row of missing values.
+
+	Returns
+	-------
+	pandas.DataFrame
+		The rows taken, numbered from 0, each column keeping its type.
+
+	Examples
+	--------
+	>>> import numpy
+	>>> import pandas
+	>>> from numdaplot.tables.joining.joined_frame import take_rows
+	>>> ages = pandas.DataFrame({"age": pandas.array([34, 51], dtype="Int64")})
+	>>> take_rows(ages, numpy.array([1, -1]))["age"].tolist()
+	[51, <NA>]
+	"""
+	taken_frame = frame.reindex(rows)
+	numbered_frame = taken_frame.reset_index(drop=True)
+
+	return numbered_frame

numdaplot/tables/joining/joined_names.py

@@ -0,0 +1,107 @@
+"""
+Names of the columns of a join that are not keys.
+
+.. versionadded:: 0.1.0
+"""
+
+from numdaplot.errors.duplicate_column_error import DuplicateColumnError
+from numdaplot.tables.columns.column_names import require_unique_names
+from numdaplot.tables.joining.join_suffixes import JoinSuffixes
+
+
+def name_joined_columns(
+	column_names: list[str], other_names: list[str], keys: list[str], suffixes: JoinSuffixes | None
+) -> tuple[list[str], list[str]]:
+	"""
+	Return the names the columns of both Tables take in a join, besides the keys.
+
+	.. versionadded:: 0.1.0
+
+	Parameters
+	----------
+	column_names
+		The column names of the joined Table.
+	other_names
+		The column names of the other Table.
+	keys
+		The names of the key columns, left out of both lists.
+	suffixes
+		The suffixes of the columns both Tables have, or None.
+
+	Returns
+	-------
+	tuple[list[str], list[str]]
+		The names of the other columns of the joined Table, then of the other Table, in their order, a suffix added
+		to each name both have.
+
+	Raises
+	------
+	DuplicateColumnError
+		When both Tables have a column besides the keys and no suffixes are given, or a suffixed name is already the
+		name of another column.
+
+	Examples
+	--------
+	>>> import numdaplot as ndp
+	>>> from numdaplot.tables.joining.joined_names import name_joined_columns
+	>>> years = ndp.JoinSuffixes(left="_2024", right="_2025")
+	>>> name_joined_columns(["dep", "deaths", "area"], ["dep", "deaths"], ["dep"], years)
+	(['deaths_2024', 'area'], ['deaths_2025'])
+	"""
+	key_names = set(keys)
+	kept_names = [column_name for column_name in column_names if column_name not in key_names]
+	other_kept_names = [other_name for other_name in other_names if other_name not in key_names]
+	shared_names = set(kept_names) & set(other_kept_names)
+	shared_name_list = [column_name for column_name in kept_names if column_name in shared_names]
+	needs_suffixes = suffixes is None and shared_name_list != []
+	if needs_suffixes:
+		raise DuplicateColumnError(shared_name_list[0])
+
+	joined_names = kept_names
+	other_joined_names = other_kept_names
+	if suffixes is not None:
+		joined_names = add_suffix(kept_names, shared_names, suffixes.left)
+		other_joined_names = add_suffix(other_kept_names, shared_names, suffixes.right)
+
+	all_names = [*keys, *joined_names, *other_joined_names]
+	require_unique_names(all_names)
+
+	return joined_names, other_joined_names
+
+
+def add_suffix(column_names: list[str], shared_names: set[str], suffix: str) -> list[str]:
+	"""
+	Return the column names with a suffix added to each name both Tables of a join have.
+
+	.. versionadded:: 0.1.0
+
+	Parameters
+	----------
+	column_names
+		The column names of one Table, besides the keys.
+	shared_names
+		The names both Tables have, besides the keys.
+	suffix
+		The suffix of this Table.
+
+	Returns
+	-------
+	list[str]
+		The names in their order, the shared ones followed by the suffix.
+
+	Examples
+	--------
+	>>> from numdaplot.tables.joining.joined_names import add_suffix
+	>>> add_suffix(["deaths", "area"], {"deaths"}, "_2024")
+	['deaths_2024', 'area']
+	"""
+	suffixed_names = list[str]()
+
+	for column_name in column_names:
+		suffixed_name = column_name
+		if column_name in shared_names:
+			suffixed_name = column_name + suffix
+
+		suffixed_names.append(suffixed_name)
+
+	return suffixed_names

numdaplot/tables/joining/joined_rows.py

@@ -0,0 +1,235 @@
+"""
+The rows of two Tables that a join puts side by side.
+
+.. versionadded:: 0.1.0
+"""
+
+import numpy
+import pandas
+from numpy.typing import NDArray
+
+from numdaplot.tables.joining.join_mode import JoinMode
+
+NO_ROW = -1
+ROW_DTYPE = numpy.dtype(numpy.intp)
+ROWS_AXIS = 1
+KEEPS_UNMATCHED_ROWS = frozenset({JoinMode.LEFT, JoinMode.OUTER})
+KEEPS_UNMATCHED_OTHER_ROWS = frozenset({JoinMode.RIGHT, JoinMode.OUTER})
+INNER_MERGE = "inner"
+STABLE_SORT = "stable"
+
+
+def pair_rows(
+	key_frame: pandas.DataFrame, other_key_frame: pandas.DataFrame, mode: JoinMode
+) -> tuple[NDArray[numpy.intp], NDArray[numpy.intp]]:
+	"""
+	Return the row numbers of both Tables that each row of a join puts side by side.
+
+	The rows of the joined Table come first, in their order, each with its matches in the order of the other Table,
+	then the unmatched rows of the other Table, in their order. A row with a missing key never matches.
+
+	.. versionadded:: 0.1.0
+
+	Parameters
+	----------
+	key_frame
+		The key columns of the joined Table.
+	other_key_frame
+		The key columns of the other Table, of the same names and types.
+	mode
+		Which rows are kept.
+
+	Returns
+	-------
+	tuple[NDArray[numpy.intp], NDArray[numpy.intp]]
+		The row number of each Table for each row of the result, -1 where a Table has no row.
+
+	Examples
+	--------
+	>>> import pandas
+	>>> import numdaplot as ndp
+	>>> from numdaplot.tables.joining.joined_rows import pair_rows
+	>>> key_frame = pandas.DataFrame({"id": [1, 2, None]})
+	>>> other_key_frame = pandas.DataFrame({"id": [3, 1]})
+	>>> pair_rows(key_frame, other_key_frame, ndp.JoinMode.OUTER)
+	(array([ 0,  1,  2, -1]), array([ 1, -1, -1,  0]))
+	"""
+	rows, other_rows = match_rows(key_frame, other_key_frame)
+	if mode in KEEPS_UNMATCHED_ROWS:
+		row_count = len(key_frame)
+		rows, other_rows = add_unmatched_rows(rows, other_rows, row_count)
+
+	if mode in KEEPS_UNMATCHED_OTHER_ROWS:
+		other_row_count = len(other_key_frame)
+		other_rows, rows = add_unmatched_other_rows(other_rows, rows, other_row_count)
+
+	return rows, other_rows
+
+
+def match_rows(
+	key_frame: pandas.DataFrame, other_key_frame: pandas.DataFrame
+) -> tuple[NDArray[numpy.intp], NDArray[numpy.intp]]:
+	"""
+	Return the pairs of rows whose keys are all present and equal, sorted by row of the joined Table.
+
+	.. versionadded:: 0.1.0
+
+	Parameters
+	----------
+	key_frame
+		The key columns of the joined Table.
+	other_key_frame
+		The key columns of the other Table, of the same names and types.
+
+	Returns
+	-------
+	tuple[NDArray[numpy.intp], NDArray[numpy.intp]]
+		The row number in each Table of each pair.
+
+	Examples
+	--------
+	>>> import pandas
+	>>> from numdaplot.tables.joining.joined_rows import match_rows
+	>>> match_rows(pandas.DataFrame({"id": [1, 1, None]}), pandas.DataFrame({"id": [1, None]}))
+	(array([0, 1]), array([0, 0]))
+	"""
+	key_count = len(key_frame.columns)
+	key_labels = list(range(key_count))
+	row_label = key_count
+	other_row_label = key_count + 1
+	numbered_keys = number_present_rows(key_frame, row_label)
+	other_numbered_keys = number_present_rows(other_key_frame, other_row_label)
+	merged_rows = numbered_keys.merge(other_numbered_keys, how=INNER_MERGE, on=key_labels)
+	row_column = merged_rows[row_label]
+	other_row_column = merged_rows[other_row_label]
+	merged_row_numbers = row_column.to_numpy(dtype=ROW_DTYPE)
+	merged_other_row_numbers = other_row_column.to_numpy(dtype=ROW_DTYPE)
+	# numpy.lexsort sorts by the last array first.
+	pair_order = numpy.lexsort((merged_other_row_numbers, merged_row_numbers))
+	rows = merged_row_numbers[pair_order]
+	other_rows = merged_other_row_numbers[pair_order]
+
+	return rows, other_rows
+
+
+def number_present_rows(key_frame: pandas.DataFrame, row_label: int) -> pandas.DataFrame:
+	"""
+	Return the rows whose keys are all present, with their row numbers after the keys.
+
+	The keys are labeled by their position, so that no key name can meet the label of the row numbers.
+
+	.. versionadded:: 0.1.0
+
+	Parameters
+	----------
+	key_frame
+		The key columns of a Table.
+	row_label
+		The label of the row numbers, after the labels of the keys.
+
+	Returns
+	-------
+	pandas.DataFrame
+		The keys labeled 0, 1... and the row numbers labeled ``row_label``.
+
+	Examples
+	--------
+	>>> import pandas
+	>>> from numdaplot.tables.joining.joined_rows import number_present_rows
+	>>> number_present_rows(pandas.DataFrame({"id": [1, None, 3]}), 1)[1].tolist()
+	[0, 2]
+	"""
+	key_count = len(key_frame.columns)
+	row_count = len(key_frame)
+	missing_keys = key_frame.isna()
+	has_missing_key = missing_keys.any(axis=ROWS_AXIS)
+	missing_rows = has_missing_key.to_numpy()
+	present_rows = ~missing_rows
+	row_numbers = numpy.arange(row_count, dtype=ROW_DTYPE)
+	numbered_frame = key_frame.copy()
+	numbered_frame.columns = pandas.RangeIndex(key_count)
+	numbered_frame[row_label] = row_numbers
+	present_frame = numbered_frame[present_rows]
+
+	return present_frame
+
+
+def add_unmatched_rows(
+	rows: NDArray[numpy.intp], other_rows: NDArray[numpy.intp], row_count: int
+) -> tuple[NDArray[numpy.intp], NDArray[numpy.intp]]:
+	"""
+	Return the pairs of rows with each unmatched row of the joined Table placed at its row, without other row.
+
+	.. versionadded:: 0.1.0
+
+	Parameters
+	----------
+	rows
+		The rows of the joined Table of each pair, sorted.
+	other_rows
+		The rows of the other Table of each pair.
+	row_count
+		The number of rows of the joined Table.
+
+	Returns
+	-------
+	tuple[NDArray[numpy.intp], NDArray[numpy.intp]]
+		Every row of the joined Table in its order, -1 as other row where it has no match.
+
+	Examples
+	--------
+	>>> import numpy
+	>>> from numdaplot.tables.joining.joined_rows import add_unmatched_rows
+	>>> add_unmatched_rows(numpy.array([1, 1]), numpy.array([0, 2]), 3)
+	(array([0, 1, 1, 2]), array([-1,  0,  2, -1]))
+	"""
+	all_rows = numpy.arange(row_count, dtype=ROW_DTYPE)
+	unmatched_rows = numpy.setdiff1d(all_rows, rows)
+	unmatched_count = len(unmatched_rows)
+	no_other_rows = numpy.full(unmatched_count, NO_ROW, dtype=ROW_DTYPE)
+	joined_rows = numpy.concatenate([rows, unmatched_rows])
+	joined_other_rows = numpy.concatenate([other_rows, no_other_rows])
+	row_order = numpy.argsort(joined_rows, kind=STABLE_SORT)
+	ordered_rows = joined_rows[row_order]
+	ordered_other_rows = joined_other_rows[row_order]
+
+	return ordered_rows, ordered_other_rows
+
+
+def add_unmatched_other_rows(
+	other_rows: NDArray[numpy.intp], rows: NDArray[numpy.intp], other_row_count: int
+) -> tuple[NDArray[numpy.intp], NDArray[numpy.intp]]:
+	"""
+	Return the pairs of rows followed by the unmatched rows of the other Table, in their order, without row.
+
+	.. versionadded:: 0.1.0
+
+	Parameters
+	----------
+	other_rows
+		The rows of the other Table of each pair.
+	rows
+		The rows of the joined Table of each pair.
+	other_row_count
+		The number of rows of the other Table.
+
+	Returns
+	-------
+	tuple[NDArray[numpy.intp], NDArray[numpy.intp]]
+		The rows of the other Table, then the rows of the joined Table, -1 for each unmatched row added.
+
+	Examples
+	--------
+	>>> import numpy
+	>>> from numdaplot.tables.joining.joined_rows import add_unmatched_other_rows
+	>>> add_unmatched_other_rows(numpy.array([1]), numpy.array([0]), 3)
+	(array([1, 0, 2]), array([ 0, -1, -1]))
+	"""
+	all_other_rows = numpy.arange(other_row_count, dtype=ROW_DTYPE)
+	unmatched_other_rows = numpy.setdiff1d(all_other_rows, other_rows)
+	unmatched_count = len(unmatched_other_rows)
+	no_rows = numpy.full(unmatched_count, NO_ROW, dtype=ROW_DTYPE)
+	joined_other_rows = numpy.concatenate([other_rows, unmatched_other_rows])
+	joined_rows = numpy.concatenate([rows, no_rows])
+
+	return joined_other_rows, joined_rows

numdaplot/tables/joining/key_types.py

@@ -0,0 +1,57 @@
+"""
+How close the types of the keys of a join must be.
+
+.. versionadded:: 0.1.0
+"""
+
+from enum import Enum, auto
+
+
+class KeyTypes(Enum):
+	"""
+	How close the types of the two columns of each key of a join must be, used by ``Join``.
+
+	A ``DATE`` key never matches a ``DATETIME`` key, and datetimes must have the same time zone on both sides.
+
+	.. versionadded:: 0.1.0
+
+	Examples
+	--------
+	>>> import numdaplot as ndp
+	>>> accidents = ndp.Table.from_arrays({"id": ndp.Array.from_list([1, 2])})
+	>>> users = ndp.Table.from_arrays({"id": ndp.Array.from_list([1.0, 2.0]), "age": ndp.Array.from_list([34, 51])})
+	>>> accidents.join(ndp.Join(other=users, keys=["id"], key_types=ndp.KeyTypes.SAME_FAMILY)).column_types
+	{'id': <Type.FLOAT64: 10>, 'age': <Type.INT64: 4>}
+	"""
+
+	SAME_FAMILY = auto()
+	"""
+	Both columns hold numbers, texts, booleans, dates, datetimes, durations or times of day. Default value.
+
+	The key of the result takes the type holding both: ``INT64`` and ``FLOAT64`` give ``FLOAT64``, ``TEXT`` and
+	``CATEGORY`` give ``TEXT``.
+
+	Examples
+	--------
+	>>> import numdaplot as ndp
+	>>> accidents = ndp.Table.from_arrays({"id": ndp.Array.from_list([1, 2])})
+	>>> users = ndp.Table.from_arrays({"id": ndp.Array.from_list([1.0, 2.0]), "age": ndp.Array.from_list([34, 51])})
+	>>> accidents.join(ndp.Join(other=users, keys=["id"], key_types=ndp.KeyTypes.SAME_FAMILY)).column_types
+	{'id': <Type.FLOAT64: 10>, 'age': <Type.INT64: 4>}
+	"""
+
+	SAME_TYPE = auto()
+	"""
+	Both columns have the same type: ``INT64`` and ``FLOAT64`` are refused.
+
+	Examples
+	--------
+	>>> import numdaplot as ndp
+	>>> accidents = ndp.Table.from_arrays({"id": ndp.Array.from_list([1, 2])})
+	>>> users = ndp.Table.from_arrays({"id": ndp.Array.from_list([1.0, 2.0])})
+	>>> try:
+	... 	accidents.join(ndp.Join(other=users, keys=["id"], key_types=ndp.KeyTypes.SAME_TYPE))
+	... except ndp.IncompatibleTypesError as error:
+	... 	print(error)
+	Cannot apply Join to the INT64 column 'id' and FLOAT64.
+	"""

numdaplot/tables/joining/relation.py

@@ -0,0 +1,78 @@
+"""
+How many times each key may appear in the Tables of a join.
+
+.. versionadded:: 0.1.0
+"""
+
+from enum import Enum, auto
+
+
+class Relation(Enum):
+	"""
+	How many times each key may appear in the two Tables of a join, checked by ``Join`` before joining.
+
+	The first word is for the left Table, the one joined, the second for the right Table, the other one. With
+	several keys, their combination is checked. Rows with a missing key are not checked, as they never match.
+
+	.. versionadded:: 0.1.0
+
+	Examples
+	--------
+	>>> import numdaplot as ndp
+	>>> accidents = ndp.Table.from_arrays({"Num_Acc": ndp.Array.from_list([101, 102])})
+	>>> users = ndp.Table.from_arrays({"Num_Acc": ndp.Array.from_list([101, 101, 102])})
+	>>> accidents.join(ndp.Join(other=users, keys=["Num_Acc"], relation=ndp.Relation.ONE_TO_MANY)).row_count
+	3
+	"""
+
+	MANY_TO_MANY = auto()
+	"""
+	Nothing is checked: each key may appear several times on both sides. Default value.
+
+	Examples
+	--------
+	>>> import numdaplot as ndp
+	>>> accidents = ndp.Table.from_arrays({"Num_Acc": ndp.Array.from_list([101, 101])})
+	>>> users = ndp.Table.from_arrays({"Num_Acc": ndp.Array.from_list([101, 101])})
+	>>> accidents.join(ndp.Join(other=users, keys=["Num_Acc"], relation=ndp.Relation.MANY_TO_MANY)).row_count
+	4
+	"""
+
+	ONE_TO_ONE = auto()
+	"""
+	Each key appears at most once in each Table.
+
+	Examples
+	--------
+	>>> import numdaplot as ndp
+	>>> accidents = ndp.Table.from_arrays({"Num_Acc": ndp.Array.from_list([101, 102])})
+	>>> places = ndp.Table.from_arrays({"Num_Acc": ndp.Array.from_list([101, 102])})
+	>>> accidents.join(ndp.Join(other=places, keys=["Num_Acc"], relation=ndp.Relation.ONE_TO_ONE)).row_count
+	2
+	"""
+
+	ONE_TO_MANY = auto()
+	"""
+	Each key appears at most once in the left Table, and any number of times in the right Table.
+
+	Examples
+	--------
+	>>> import numdaplot as ndp
+	>>> accidents = ndp.Table.from_arrays({"Num_Acc": ndp.Array.from_list([101, 102])})
+	>>> users = ndp.Table.from_arrays({"Num_Acc": ndp.Array.from_list([101, 101, 102])})
+	>>> accidents.join(ndp.Join(other=users, keys=["Num_Acc"], relation=ndp.Relation.ONE_TO_MANY)).row_count
+	3
+	"""
+
+	MANY_TO_ONE = auto()
+	"""
+	Each key appears any number of times in the left Table, and at most once in the right Table.
+
+	Examples
+	--------
+	>>> import numdaplot as ndp
+	>>> users = ndp.Table.from_arrays({"Num_Acc": ndp.Array.from_list([101, 101, 102])})
+	>>> accidents = ndp.Table.from_arrays({"Num_Acc": ndp.Array.from_list([101, 102])})
+	>>> users.join(ndp.Join(other=accidents, keys=["Num_Acc"], relation=ndp.Relation.MANY_TO_ONE)).row_count
+	3
+	"""

numdaplot/tables/missing/__init__.py

@@ -0,0 +1,5 @@
+"""
+Missing values of a Table: count, summary and removal.
+
+.. versionadded:: 0.1.0
+"""