mapFolding 0.3.12__py3-none-any.whl → 0.4.1__py3-none-any.whl

tests/test_computations.py

@@ -0,0 +1,79 @@
+from pathlib import Path
+from tests.conftest import *
+import importlib.util
+import pytest
+
+def test_algorithmSourceParallel(listDimensionsTestParallelization: List[int], foldsTotalKnown: Dict[Tuple[int, ...], int], useAlgorithmSourceDispatcher: None) -> None:
+	standardizedEqualTo(foldsTotalKnown[tuple(listDimensionsTestParallelization)], countFolds, listDimensionsTestParallelization, None, 'maximum')
+
+def test_algorithmSourceSequential(listDimensionsTestCountFolds: List[int], foldsTotalKnown: Dict[Tuple[int, ...], int], useAlgorithmSourceDispatcher: None) -> None:
+	standardizedEqualTo(foldsTotalKnown[tuple(listDimensionsTestCountFolds)], countFolds, listDimensionsTestCountFolds)
+
+def test_aOFn_calculate_value(oeisID: str) -> None:
+	for n in settingsOEIS[oeisID]['valuesTestValidation']:
+		standardizedEqualTo(settingsOEIS[oeisID]['valuesKnown'][n], oeisIDfor_n, oeisID, n)
+
+# Python doesn't want me to test this
+# @pytest.mark.parametrize('pathFilenameTmpTesting', ['.py'], indirect=True)
+# def test_writeJobNumba(listDimensionsTestCountFolds: List[int], foldsTotalKnown: Dict[Tuple[int, ...], int], pathFilenameTmpTesting: Path) -> None:
+# 	from mapFolding.syntheticModules import numba_countSequential
+# 	algorithmSourceHARDCODED: ModuleType = numba_countSequential
+# 	algorithmSource = algorithmSourceHARDCODED
+# 	pathFilenameModule = writeJobNumba(listDimensionsTestCountFolds, algorithmSource, pathFilenameWriteJob=pathFilenameTmpTesting.absolute())
+
+# 	Don_Lapre_Road_to_Self_Improvement = importlib.util.spec_from_file_location("__main__", pathFilenameModule)
+# 	if Don_Lapre_Road_to_Self_Improvement is None:
+# 		raise ImportError(f"Failed to create module specification from {pathFilenameModule}")
+# 	if Don_Lapre_Road_to_Self_Improvement.loader is None:
+# 		raise ImportError(f"Failed to get loader for module {pathFilenameModule}")
+# 	module = importlib.util.module_from_spec(Don_Lapre_Road_to_Self_Improvement)
+
+# 	module.__name__ = "__main__"
+# 	Don_Lapre_Road_to_Self_Improvement.loader.exec_module(module)
+
+# 	pathFilenameFoldsTotal = getPathFilenameFoldsTotal(listDimensionsTestCountFolds)
+# 	standardizedEqualTo(str(foldsTotalKnown[tuple(listDimensionsTestCountFolds)]), pathFilenameFoldsTotal.read_text().strip)
+
+# def test_makeFlowNumbaOptimized(pathTmpTesting: Path, useThisDispatcher):
+# def test_makeFlowNumbaOptimized(useThisDispatcher):
+# 	"""To get this to work:
+# 	walk_up=True doesn't work on 3.10, so that has to go
+# 	the _logical_ import must be in the logical path of the package
+# 	fuck python
+# 	"""
+# 	listCallablesInlineHARDCODED: List[str] = ['countInitialize', 'countParallel', 'countSequential']
+# 	listCallablesInline = listCallablesInlineHARDCODED
+# 	callableDispatcher = True
+# 	algorithmSource = None
+# 	relativePathWrite = None
+# 	# relativePathWrite = pathTmpTesting.absolute().relative_to(getPathPackage(), walk_up=True)
+# 	formatFilenameWrite = "pytest_{callableTarget}"
+# 	listSynthesizedModules: List[youOughtaKnow] = makeFlowNumbaOptimized(listCallablesInline, callableDispatcher, algorithmSource, relativePathWrite, formatFilenameWrite)
+# 	for stuff in listSynthesizedModules:
+# 		registrarRecordsTmpObject(stuff.pathFilenameForMe)
+# 		if stuff.callableSynthesized not in listCallablesInline:
+# 			dispatcherSynthetic: youOughtaKnow = stuff
+# 	if not dispatcherSynthetic: raise FREAKOUT
+# 		# dispatcherSynthetic: youOughtaKnow = next(filter(lambda x: x.callableSynthesized not in listCallablesInline, listSynthesizedModules))
+
+# 	# Import the synthetic dispatcher module to get the callable
+# 	dispatcherSpec = importlib.util.spec_from_file_location(
+# 		dispatcherSynthetic.callableSynthesized,
+# 		dispatcherSynthetic.pathFilenameForMe
+# 	)
+# 	if dispatcherSpec is None:
+# 		raise ImportError(f"Failed to create module specification from {dispatcherSynthetic.pathFilenameForMe}")
+# 	if dispatcherSpec.loader is None:
+# 		raise ImportError(f"Failed to get loader for module {dispatcherSynthetic.pathFilenameForMe}")
+
+# 	dispatcherModule = importlib.util.module_from_spec(dispatcherSpec)
+# 	dispatcherSpec.loader.exec_module(dispatcherModule)
+# 	callableDispatcherSynthetic = getattr(dispatcherModule, dispatcherSynthetic.callableSynthesized)
+
+# 	useThisDispatcher(callableDispatcherSynthetic)
+
+# 	def test_syntheticSequential(listDimensionsTestCountFolds: List[int], foldsTotalKnown: Dict[Tuple[int, ...], int]):
+# 		standardizedEqualTo(foldsTotalKnown[tuple(listDimensionsTestCountFolds)], countFolds, listDimensionsTestCountFolds)
+
+# 	def test_syntheticParallel(listDimensionsTestParallelization: List[int], foldsTotalKnown: Dict[Tuple[int, ...], int]):
+# 		standardizedEqualTo(foldsTotalKnown[tuple(listDimensionsTestParallelization)], countFolds, listDimensionsTestParallelization, None, 'maximum')

tests/test_oeis.py

@@ -2,7 +2,6 @@ from contextlib import redirect_stdout
 from datetime import datetime, timedelta
 from mapFolding.oeis import _getFilenameOEISbFile, _getOEISidValues, _parseBFileOEIS, _validateOEISid, _getOEISidInformation
 from tests.conftest import *
-from typing import NoReturn
 from urllib.error import URLError
 import io
 import os
@@ -15,127 +14,119 @@ import unittest.mock
 import urllib
 import urllib.request
 
-def test_algorithmSourceSequential(oeisID: str, useAlgorithmDirectly: None) -> None:
-    for n in settingsOEIS[oeisID]['valuesTestValidation']:
-        standardizedEqualTo(settingsOEIS[oeisID]['valuesKnown'][n], oeisIDfor_n, oeisID, n)
-
-def test_aOFn_calculate_value(oeisID: str) -> None:
-    for n in settingsOEIS[oeisID]['valuesTestValidation']:
-        standardizedEqualTo(settingsOEIS[oeisID]['valuesKnown'][n], oeisIDfor_n, oeisID, n)
-
 @pytest.mark.parametrize("badID", ["A999999", "  A999999  ", "A999999extra"])
 def test__validateOEISid_invalid_id(badID: str) -> None:
-    standardizedEqualTo(KeyError, _validateOEISid, badID)
+	standardizedEqualTo(KeyError, _validateOEISid, badID)
 
 def test__validateOEISid_partially_valid(oeisID_1random: str) -> None:
-    standardizedEqualTo(KeyError, _validateOEISid, f"{oeisID_1random}extra")
+	standardizedEqualTo(KeyError, _validateOEISid, f"{oeisID_1random}extra")
 
 def test__validateOEISid_valid_id(oeisID: str) -> None:
-    standardizedEqualTo(oeisID, _validateOEISid, oeisID)
+	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())
+	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")
+	# (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)
+	"""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)
+	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()
+	"""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")
+	"""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)))
+	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()
+	"""Test that help text is complete and examples are valid."""
+	outputStream = io.StringIO()
+	with redirect_stdout(outputStream):
+		getOEISids()
 
-    helpText = outputStream.getvalue()
+	helpText = outputStream.getvalue()
 
-    # Verify content
-    for oeisID in oeisIDsImplemented:
-        assert oeisID in helpText
-        assert settingsOEIS[oeisID]['description'] in helpText
+	# Verify content
+	for oeisID in oeisIDsImplemented:
+		assert oeisID in helpText
+		assert settingsOEIS[oeisID]['description'] in helpText
 
-    # Extract and verify examples
+	# Extract and verify examples
 
-    cliMatch = regex.search(r'OEIS_for_n (\w+) (\d+)', helpText)
-    pythonMatch = regex.search(r"oeisIDfor_n\('(\w+)', (\d+)\)", helpText)
+	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)
+	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 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)
+	# 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]))
+	# 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)
+	"""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)
+	"""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)