mapFolding 0.4.3__py3-none-any.whl → 0.5.1__py3-none-any.whl

tests/test_oeis.py

@@ -1,129 +0,0 @@
-from contextlib import redirect_stdout
-from tests.conftest import *
-from urllib.error import URLError
-import io
-import pathlib
-import pytest
-import random
-import re as regex
-import unittest
-import unittest.mock
-import urllib
-import urllib.request
-
-@pytest.mark.parametrize("badID", ["A999999", "  A999999  ", "A999999extra"])
-def test__validateOEISid_invalid_id(badID: str) -> None:
-	standardizedEqualTo(KeyError, validateOEISid, badID)
-
-def test__validateOEISid_partially_valid(oeisID_1random: str) -> None:
-	standardizedEqualTo(KeyError, validateOEISid, f"{oeisID_1random}extra")
-
-def test__validateOEISid_valid_id(oeisID: str) -> None:
-	standardizedEqualTo(oeisID, validateOEISid, oeisID)
-
-def test__validateOEISid_valid_id_case_insensitive(oeisID: str) -> None:
-	standardizedEqualTo(oeisID.upper(), validateOEISid, oeisID.lower())
-	standardizedEqualTo(oeisID.upper(), validateOEISid, oeisID.upper())
-	standardizedEqualTo(oeisID.upper(), validateOEISid, oeisID.swapcase())
-
-parameters_test_aOFn_invalid_n = [
-	# (2, "ok"), # test the test template
-	(-random.randint(1, 100), "randomNegative"),
-	("foo", "string"),
-	(1.5, "float")
-]
-badValues, badValuesIDs = zip(*parameters_test_aOFn_invalid_n)
-@pytest.mark.parametrize("badN", badValues, ids=badValuesIDs)
-def test_aOFn_invalid_n(oeisID_1random: str, badN: Any) -> None:
-	"""Check that negative or non-integer n raises ValueError."""
-	standardizedEqualTo(ValueError, oeisIDfor_n, oeisID_1random, badN)
-
-def test_aOFn_zeroDim_A001418() -> None:
-	standardizedEqualTo(ArithmeticError, oeisIDfor_n, 'A001418', 0)
-
-# ===== OEIS Cache Tests =====
-@pytest.mark.parametrize("cacheExists", [True, False])
-@unittest.mock.patch('pathlib.Path.exists')
-@unittest.mock.patch('pathlib.Path.unlink')
-def test_clearOEIScache(mock_unlink: unittest.mock.MagicMock, mock_exists: unittest.mock.MagicMock, cacheExists: bool) -> None:
-	"""Test OEIS cache clearing with both existing and non-existing cache."""
-	mock_exists.return_value = cacheExists
-	clearOEIScache()
-
-	if cacheExists:
-		# Each OEIS ID has two cache files
-		expected_calls = len(settingsOEIS) * 2
-		assert mock_unlink.call_count == expected_calls
-		mock_unlink.assert_has_calls([unittest.mock.call(missing_ok=True)] * expected_calls)
-	else:
-		mock_exists.assert_called_once()
-		mock_unlink.assert_not_called()
-
-def testNetworkError(monkeypatch: pytest.MonkeyPatch, pathCacheTesting: pathlib.Path) -> None:
-	"""Test network error handling."""
-	def mockUrlopen(*args: Any, **kwargs: Any) -> NoReturn:
-		raise URLError("Network error")
-
-	monkeypatch.setattr(urllib.request, 'urlopen', mockUrlopen)
-	standardizedEqualTo(URLError, getOEISidValues, next(iter(settingsOEIS)))
-
-# ===== Command Line Interface Tests =====
-def testHelpText() -> None:
-	"""Test that help text is complete and examples are valid."""
-	outputStream = io.StringIO()
-	with redirect_stdout(outputStream):
-		getOEISids()
-
-	helpText = outputStream.getvalue()
-
-	# Verify content
-	for oeisID in oeisIDsImplemented:
-		assert oeisID in helpText
-		assert settingsOEIS[oeisID]['description'] in helpText
-
-	# Extract and verify examples
-
-	cliMatch = regex.search(r'OEIS_for_n (\w+) (\d+)', helpText)
-	pythonMatch = regex.search(r"oeisIDfor_n\('(\w+)', (\d+)\)", helpText)
-
-	assert cliMatch and pythonMatch, "Help text missing examples"
-	oeisID, n = pythonMatch.groups()
-	n = int(n)
-
-	# Verify CLI and Python examples use same values
-	assert cliMatch.groups() == (oeisID, str(n)), "CLI and Python examples inconsistent"
-
-	# Verify the example works
-	expectedValue = oeisIDfor_n(oeisID, n)
-
-	# Test CLI execution of the example
-	with unittest.mock.patch('sys.argv', ['OEIS_for_n', oeisID, str(n)]):
-		outputStream = io.StringIO()
-		with redirect_stdout(outputStream):
-			OEIS_for_n()
-		standardizedEqualTo(expectedValue, lambda: int(outputStream.getvalue().strip().split()[0]))
-
-def testCLI_InvalidInputs() -> None:
-	"""Test CLI error handling."""
-	testCases = [
-		(['OEIS_for_n'], "missing arguments"),
-		(['OEIS_for_n', 'A999999', '1'], "invalid OEIS ID"),
-		(['OEIS_for_n', 'A001415', '-1'], "negative n"),
-		(['OEIS_for_n', 'A001415', 'abc'], "non-integer n"),
-	]
-
-	for arguments, testID in testCases:
-		with unittest.mock.patch('sys.argv', arguments):
-			standardizedSystemExit("error", OEIS_for_n)
-
-def testCLI_HelpFlag() -> None:
-	"""Verify --help output contains required information."""
-	with unittest.mock.patch('sys.argv', ['OEIS_for_n', '--help']):
-		outputStream = io.StringIO()
-		with redirect_stdout(outputStream):
-			standardizedSystemExit("nonError", OEIS_for_n)
-
-		helpOutput = outputStream.getvalue()
-		assert "Available OEIS sequences:" in helpOutput
-		assert "Usage examples:" in helpOutput
-		assert all(oeisID in helpOutput for oeisID in oeisIDsImplemented)

tests/test_other.py

@@ -1,171 +0,0 @@
-from contextlib import redirect_stdout
-from tests.conftest import *
-from Z0Z_tools import intInnit
-import io
-import itertools
-import numba
-import numpy
-import pathlib
-import pytest
-import random
-import sys
-
-@pytest.mark.parametrize("listDimensions,expected_intInnit,expected_parseListDimensions,expected_validateListDimensions,expected_getLeavesTotal", [
-	(None, ValueError, ValueError, ValueError, ValueError),  # None instead of list
-	(['a'], ValueError, ValueError, ValueError, ValueError),  # string
-	([-4, 2], [-4, 2], ValueError, ValueError, ValueError),  # negative
-	([-3], [-3], ValueError, ValueError, ValueError),  # negative
-	([0, 0], [0, 0], [0, 0], NotImplementedError, 0),  # no positive dimensions
-	([0, 5, 6], [0, 5, 6], [0, 5, 6], [5, 6], 30),  # zeros ignored
-	([0], [0], [0], NotImplementedError, 0),  # edge case
-	([1, 2, 3, 4, 5], [1, 2, 3, 4, 5], [1, 2, 3, 4, 5], [1, 2, 3, 4, 5], 120),  # sequential
-	([1, sys.maxsize], [1, sys.maxsize], [1, sys.maxsize], [1, sys.maxsize], sys.maxsize),  # maxint
-	([7.5], ValueError, ValueError, ValueError, ValueError),  # float
-	([1] * 1000, [1] * 1000, [1] * 1000, [1] * 1000, 1),  # long list
-	([11], [11], [11], NotImplementedError, 11),  # single dimension
-	([13, 0, 17], [13, 0, 17], [13, 0, 17], [13, 17], 221),  # zeros handled
-	([2, 2, 2, 2], [2, 2, 2, 2], [2, 2, 2, 2], [2, 2, 2, 2], 16),  # repeated dimensions
-	([2, 3, 4], [2, 3, 4], [2, 3, 4], [2, 3, 4], 24),
-	([2, 3], [2, 3], [2, 3], [2, 3], 6),
-	([2] * 11, [2] * 11, [2] * 11, [2] * 11, 2048),  # power of 2
-	([3, 2], [3, 2], [3, 2], [2, 3], 6),  # return value is the input when valid
-	([3] * 5, [3] * 5, [3] * 5, [3, 3, 3, 3, 3], 243),  # power of 3
-	([None], TypeError, TypeError, TypeError, TypeError),  # None
-	([True], TypeError, TypeError, TypeError, TypeError),  # bool
-	([[17, 39]], TypeError, TypeError, TypeError, TypeError),  # nested
-	([], ValueError, ValueError, ValueError, ValueError),  # empty
-	([complex(1,1)], ValueError, ValueError, ValueError, ValueError),  # complex number
-	([float('inf')], ValueError, ValueError, ValueError, ValueError),  # infinity
-	([float('nan')], ValueError, ValueError, ValueError, ValueError),  # NaN
-	([sys.maxsize - 1, 1], [sys.maxsize - 1, 1], [sys.maxsize - 1, 1], [1, sys.maxsize - 1], sys.maxsize - 1),  # near maxint
-	([sys.maxsize // 2, sys.maxsize // 2, 2], [sys.maxsize // 2, sys.maxsize // 2, 2], [sys.maxsize // 2, sys.maxsize // 2, 2], [2, sys.maxsize // 2, sys.maxsize // 2], OverflowError),  # overflow protection
-	([sys.maxsize, sys.maxsize], [sys.maxsize, sys.maxsize], [sys.maxsize, sys.maxsize], [sys.maxsize, sys.maxsize], OverflowError),  # overflow protection
-	(range(3, 7), [3, 4, 5, 6], [3, 4, 5, 6], [3, 4, 5, 6], 360),  # range sequence type
-	(tuple([3, 5, 7]), [3, 5, 7], [3, 5, 7], [3, 5, 7], 105),  # tuple sequence type
-])
-def test_listDimensionsAsParameter(listDimensions: None | List[str] | List[int] | List[float] | List[None] | List[bool] | List[List[int]] | List[complex] | range | tuple[int, ...], expected_intInnit: type[ValueError] | List[int] | type[TypeError], expected_parseListDimensions: type[ValueError] | List[int] | type[TypeError], expected_validateListDimensions: type[ValueError] | type[NotImplementedError] | List[int] | type[TypeError], expected_getLeavesTotal: type[ValueError] | int | type[TypeError] | type[OverflowError]) -> None:
-	"""Test both validateListDimensions and getLeavesTotal with the same inputs."""
-	standardizedEqualTo(expected_intInnit, intInnit, listDimensions)
-	standardizedEqualTo(expected_parseListDimensions, parseDimensions, listDimensions)
-	standardizedEqualTo(expected_validateListDimensions, validateListDimensions, listDimensions)
-	standardizedEqualTo(expected_getLeavesTotal, getLeavesTotal, listDimensions)
-
-def test_getLeavesTotal_edge_cases() -> None:
-	"""Test edge cases for getLeavesTotal."""
-	# Order independence
-	standardizedEqualTo(getLeavesTotal([2, 3, 4]), getLeavesTotal, [4, 2, 3])
-
-	# Immutability
-	listOriginal = [2, 3]
-	standardizedEqualTo(6, getLeavesTotal, listOriginal)
-	standardizedEqualTo([2, 3], lambda x: x, listOriginal)  # Check that the list wasn't modified
-
-@pytest.mark.parametrize("nameOfTest,callablePytest", PytestFor_intInnit())
-def testIntInnit(nameOfTest: str, callablePytest: Callable[[], None]) -> None:
-	callablePytest()
-
-@pytest.mark.parametrize("nameOfTest,callablePytest", PytestFor_oopsieKwargsie())
-def testOopsieKwargsie(nameOfTest: str, callablePytest: Callable[[], None]) -> None:
-	callablePytest()
-
-@pytest.mark.parametrize("CPUlimit, expectedLimit", [
-	(None, numba.get_num_threads()),
-	(False, numba.get_num_threads()),
-	(True, 1),
-	(4, 4),
-	(0.5, max(1, numba.get_num_threads() // 2)),
-	(-0.5, max(1, numba.get_num_threads() // 2)),
-	(-2, max(1, numba.get_num_threads() - 2)),
-	(0, numba.get_num_threads()),
-	(1, 1),
-])
-def test_setCPUlimit(CPUlimit: None | float | bool | Literal[4] | Literal[-2] | Literal[0] | Literal[1], expectedLimit: Any | int) -> None:
-	standardizedEqualTo(expectedLimit, setCPUlimit, CPUlimit)
-
-def test_makeConnectionGraph_nonNegative(listDimensionsTestFunctionality: List[int]) -> None:
-	connectionGraph = makeConnectionGraph(listDimensionsTestFunctionality)
-	assert numpy.all(connectionGraph >= 0), "All values in the connection graph should be non-negative."
-
-@pytest.fixture
-def parameterIterator() -> Callable[[List[int]], Generator[Dict[str, Any], None, None]]:
-	"""Generate random combinations of parameters for outfitCountFolds testing."""
-	parameterSets: Dict[str, List[Any]] = {
-		'computationDivisions': [
-			None,
-			'maximum',
-			'cpu',
-		],
-		'CPUlimit': [
-			None, True, False, 0, 1, -1,
-		],
-		'datatypeMedium': [
-			None,
-			numpy.int64,
-			numpy.intc,
-			numpy.uint16
-		],
-		'datatypeLarge': [
-			None,
-			numpy.int64,
-			numpy.intp,
-			numpy.uint32
-		]
-	}
-
-	def makeParametersDynamic(listDimensions: List[int]) -> Dict[str, List[Any]]:
-		"""Add context-dependent parameter values."""
-		parametersDynamic = parameterSets.copy()
-		leavesTotal = getLeavesTotal(listDimensions)
-		concurrencyLimit = min(leavesTotal, 16)
-
-		# Add dynamic computationDivisions values
-		dynamicDivisions = [random.randint(2, leavesTotal-1) for iterator in range(3)]
-		parametersDynamic['computationDivisions'] = parametersDynamic['computationDivisions'] + dynamicDivisions
-
-		# Add dynamic CPUlimit values
-		parameterDynamicCPU = [
-			random.random(),  # 0 to 1
-			-random.random(), # -1 to 0
-		]
-		parameterDynamicCPU.extend(
-			[random.randint(2, concurrencyLimit-1) for iterator in range(2)]
-		)
-		parameterDynamicCPU.extend(
-			[random.randint(-concurrencyLimit+1, -2) for iterator in range(2)]
-		)
-		parametersDynamic['CPUlimit'] = parametersDynamic['CPUlimit'] + parameterDynamicCPU
-
-		return parametersDynamic
-
-	def generateCombinations(listDimensions: List[int]) -> Generator[Dict[str, Any], None, None]:
-		parametersDynamic = makeParametersDynamic(listDimensions)
-		parameterKeys = list(parametersDynamic.keys())
-		parameterValues = [parametersDynamic[key] for key in parameterKeys]
-
-		# Shuffle each parameter list
-		for valueList in parameterValues:
-			random.shuffle(valueList)
-
-		# Use zip_longest to iterate, filling with None when shorter lists are exhausted
-		for combination in itertools.zip_longest(*parameterValues, fillvalue=None):
-			yield dict(zip(parameterKeys, combination))
-
-	return generateCombinations
-
-def test_saveFoldsTotal_fallback(pathTmpTesting: pathlib.Path) -> None:
-	foldsTotal = 123
-	pathFilename = pathTmpTesting / "foldsTotal.txt"
-	with unittest.mock.patch("pathlib.Path.write_text", side_effect=OSError("Simulated write failure")):
-		with unittest.mock.patch("os.getcwd", return_value=str(pathTmpTesting)):
-			capturedOutput = io.StringIO()
-			with redirect_stdout(capturedOutput):
-				saveFoldsTotal(pathFilename, foldsTotal)
-	fallbackFiles = list(pathTmpTesting.glob("foldsTotalYO_*.txt"))
-	assert len(fallbackFiles) == 1, "Fallback file was not created upon write failure."
-
-def test_makeDataContainer_default_datatype() -> None:
-	"""Test that makeDataContainer uses dtypeLargeDEFAULT when no datatype is specified."""
-	testShape = (3, 4)
-	container = makeDataContainer(testShape)
-	assert container.dtype == hackSSOTdtype('dtypeFoldsTotal'), f"Expected datatype but got {container.dtype}"
-	assert container.shape == testShape, f"Expected shape {testShape}, but got {container.shape}"

tests/test_tasks.py

@@ -1,40 +0,0 @@
-from tests.conftest import *
-import pytest
-
-# TODO add a test. `C` = number of logical cores available. `n = C + 1`. Ensure that `[2,n]` is computed correctly.
-# Or, probably smarter: limit the number of cores, then run a test with C+1.
-
-def test_countFoldsComputationDivisionsInvalid(listDimensionsTestFunctionality: List[int]) -> None:
-	standardizedEqualTo(ValueError, countFolds, listDimensionsTestFunctionality, None, {"wrong": "value"})
-
-def test_countFoldsComputationDivisionsMaximum(listDimensionsTestParallelization: List[int], foldsTotalKnown: Dict[Tuple[int, ...], int]) -> None:
-	standardizedEqualTo(foldsTotalKnown[tuple(listDimensionsTestParallelization)], countFolds, listDimensionsTestParallelization, None, 'maximum')
-
-@pytest.mark.parametrize("nameOfTest,callablePytest", PytestFor_defineConcurrencyLimit())
-def test_defineConcurrencyLimit(nameOfTest: str, callablePytest: Callable[[], None]) -> None:
-	callablePytest()
-
-@pytest.mark.parametrize("CPUlimitParameter", [{"invalid": True}, ["weird"]])
-def test_countFolds_cpuLimitOopsie(listDimensionsTestFunctionality: List[int], CPUlimitParameter: Dict[str, bool] | List[str]) -> None:
-	standardizedEqualTo(ValueError, countFolds, listDimensionsTestFunctionality, None, 'cpu', CPUlimitParameter)
-
-@pytest.mark.parametrize("computationDivisions, concurrencyLimit, listDimensions, expectedTaskDivisions", [
-	(None, 4, [9, 11], 0),
-	("maximum", 4, [7, 11], 77),
-	("cpu", 4, [3, 7], 4),
-	(["invalid"], 4, [19, 23], ValueError),
-	(20, 4, [3,5], ValueError)
-])
-def test_getTaskDivisions(computationDivisions: None | List[str] | Literal['maximum'] | Literal['cpu'] | Literal[20], concurrencyLimit: Literal[4], listDimensions: List[int], expectedTaskDivisions: type[ValueError] | Literal[0] | Literal[77] | Literal[4]) -> None:
-	standardizedEqualTo(expectedTaskDivisions, getTaskDivisions, computationDivisions, concurrencyLimit, None, listDimensions)
-
-@pytest.mark.parametrize("expected,parameter", [
-	(2, "2"),  # string
-	(ValueError, [4]),  # list
-	(ValueError, (2,)), # tuple
-	(ValueError, {2}),  # set
-	(ValueError, {"cores": 2}),  # dict
-])
-def test_setCPUlimitMalformedParameter(expected: type[ValueError] | Literal[2], parameter: List[int] | Tuple[int] | set[int] | Dict[str, int] | Literal['2']) -> None:
-	"""Test that invalid CPUlimit types are properly handled."""
-	standardizedEqualTo(expected, setCPUlimit, parameter)

tests/test_types.py

@@ -1,5 +0,0 @@
-"""Type checking tests for mapFolding package."""
-
-def test_static_typing() -> None:
-	"""This is a placeholder. pytest-mypy will run type checking automatically."""
-	pass