parsl 2025.9.8__py3-none-any.whl → 2025.9.15__py3-none-any.whl

parsl/tests/site_tests/test_provider.py

@@ -1,88 +0,0 @@
-import argparse
-import logging
-import time
-
-import pytest
-
-import parsl
-from parsl.app.app import python_app  # , bash_app
-from parsl.jobs.states import JobState
-from parsl.tests.site_tests.site_config_selector import fresh_config
-
-logger = logging.getLogger(__name__)
-
-
-@python_app
-def platform(sleep=10, stdout=None):
-    import time
-    time.sleep(sleep)
-    return True
-
-
-@pytest.mark.local
-@pytest.mark.skip("This test cannot run on sites which cannot be identified by site_config_selector")
-def test_provider():
-    """ Provider scaling
-    """
-    logger.info("Starting test_provider")
-    config = fresh_config()
-    name = config.executors[0].label
-    parsl.load(config)
-
-    dfk = parsl.dfk()
-    logger.info("Trying to get executor : {}".format(name))
-
-    x = platform(sleep=0)
-    logger.info("Result is {}".format(x.result()))
-
-    executor = dfk.executors[name]
-    provider = dfk.executors[name].provider
-
-    # At this point we should have 1 job
-    _, current_jobs = executor._get_block_and_job_ids()
-    assert len(current_jobs) == 1, "Expected 1 job at init, got {}".format(len(current_jobs))
-
-    logger.info("Getting provider status (1)")
-    status = provider.status(current_jobs)
-    logger.info("Got provider status")
-    assert status[0].state == JobState.RUNNING, "Expected job to be in state RUNNING"
-
-    # Scale down to 0
-    scale_in_blocks = executor.scale_in(blocks=1)
-    logger.info("Now sleeping 60 seconds")
-    time.sleep(60)
-    logger.info("Sleep finished")
-    logger.info("Getting provider status (2)")
-    status = executor.status()
-    logger.info("Got executor status")
-    logger.info("Block status: {}".format(status))
-    assert status[scale_in_blocks[0]].terminal is True, "Terminal state"
-    logger.info("Job in terminal state")
-
-    _, current_jobs = executor._get_block_and_job_ids()
-    # PR 1952 stoped removing scale_in blocks from self.blocks_to_job_id
-    # A new PR will handle removing blocks from self.block
-    # this includes failed/completed/canceled blocks
-    assert len(current_jobs) == 1, "Expected current_jobs == 1"
-    dfk.cleanup()
-    parsl.clear()
-    logger.info("Ended test_provider")
-    return True
-
-
-if __name__ == '__main__':
-
-    parser = argparse.ArgumentParser()
-    parser.add_argument("-c", "--count", default="4",
-                        help="Count of apps to launch")
-    parser.add_argument("-t", "--time", default="60",
-                        help="Sleep time for each app")
-
-    parser.add_argument("-d", "--debug", action='store_true',
-                        help="Count of apps to launch")
-    args = parser.parse_args()
-
-    if args.debug:
-        parsl.set_stream_logger()
-
-    x = test_provider()

parsl/tests/site_tests/test_site.py

@@ -1,70 +0,0 @@
-import argparse
-
-import pytest
-
-import parsl
-from parsl.app.app import python_app
-from parsl.tests.site_tests.site_config_selector import fresh_config
-
-
-@python_app
-def platform(sleep=10, stdout=None):
-    import platform
-    import time
-    time.sleep(sleep)
-    return platform.uname()
-
-
-@pytest.mark.local
-@pytest.mark.skip("The behaviour this test is testing is unclear: there is no guarantee that tasks will go to different nodes")
-def test_platform(n=2, sleep_dur=10):
-    """ This should sleep to make sure that concurrent apps will go to different workers
-    on different nodes.
-    """
-    config = fresh_config()
-    if config.executors[0].label == "htex_local":
-        return
-
-    parsl.load(fresh_config())
-
-    dfk = parsl.dfk()
-    name = list(dfk.executors.keys())[0]
-    print("Trying to get executor : ", name)
-
-    x = [platform(sleep=1) for i in range(2)]
-    print([i.result() for i in x])
-
-    print("Executor : ", dfk.executors[name])
-    print("Connected   : ", dfk.executors[name].connected_workers())
-    print("Outstanding : ", dfk.executors[name].outstanding())
-
-    d = []
-    for i in range(0, n):
-        x = platform(sleep=sleep_dur)
-        d.append(x)
-
-    pinfo = set([i.result()for i in d])
-    assert len(pinfo) == 2, "Expected two nodes, instead got {}".format(pinfo)
-
-    print("Test passed")
-
-    dfk.cleanup()
-    parsl.clear()
-    return True
-
-
-if __name__ == '__main__':
-
-    parser = argparse.ArgumentParser()
-    parser.add_argument("-c", "--count", default="4",
-                        help="Count of apps to launch")
-    parser.add_argument("-t", "--time", default="60",
-                        help="Sleep time for each app")
-    parser.add_argument("-d", "--debug", action='store_true',
-                        help="Count of apps to launch")
-    args = parser.parse_args()
-
-    if args.debug:
-        parsl.set_stream_logger()
-
-    x = test_platform(n=int(args.count), sleep_dur=int(args.time))

parsl/tests/test_aalst_patterns.py

@@ -1,474 +0,0 @@
-import random
-import time
-
-import pytest
-
-from parsl.app.app import python_app
-from parsl.tests.configs.local_threads import config
-
-pytestmark = pytest.mark.skip('not asserting anything')
-
-
-local_config = config
-
-
-@python_app
-def multiply_rand(x):
-    return x * random.randint(1, 10)
-
-
-@python_app
-def square_sum(x, y):
-    return (x + y) ** 2
-
-
-@python_app
-def double_sum(x, y):
-    return 2 * (x + y)
-
-
-@python_app
-def subtract(x, y):
-    return y - x
-
-
-@python_app
-def add_two(x):
-    return x + 2
-
-
-@python_app
-def rand():
-    x = random.randint(1, 100)
-    return x
-
-
-@python_app
-def square(x):
-    z = x ** 2
-    return z
-
-
-@python_app
-def cubed(x):
-    return x ** 3
-
-
-@python_app
-def sleep_cubed(x):
-    if x < 5:
-        time.sleep(7)
-        return x ** 3
-    else:
-        return x ** 3
-
-
-@python_app
-def increment(x):
-    return x + 1
-
-
-@python_app
-def slow_increment(x, dur=1):
-    import time
-    time.sleep(dur)
-    return x + 1
-
-
-@python_app
-def join(inputs=[]):
-    return sum(inputs)
-
-
-@python_app
-def join_three(x, y, z):
-    return x + y + z
-
-
-@python_app
-def sleep_square(x):
-    if x > 5:
-        return x ** 2
-    else:
-        time.sleep(5)
-        return x ** 2
-
-
-@python_app
-def sum_results(x=[]):
-    total = 0
-    for r in x:
-        total += r.result()
-    return total
-
-
-@python_app
-def add(x, y):
-    return x + y
-
-
-@python_app
-def sum_list(x=[]):
-    return sum(x)
-
-
-@python_app
-def sum_lists(x=[], y=[], z=[]):
-    total = 0
-    for i in range(len(x)):
-        total += x[i].result()
-    for j in range(len(y)):
-        total += y[j].result()
-    for k in range(len(z)):
-        total += z[k].result()
-    return total
-
-
-@python_app
-def sum_elements(x=[], y=[], z=[]):
-    total = 0
-    for i in range(len(x)):
-        total += x[i].result()
-    for j in range(len(y)):
-        if y[j] is not None:
-            total += y[j].result()
-    for k in range(len(z)):
-        total += z[k].result()
-    return total
-
-
-@python_app
-def simple_sum_elements(x, y, z):
-    return x + y + z
-
-
-@python_app
-def eval_number(x):
-    if x > 5:
-        print("Larger than 5")
-        return return_one().result()
-    else:
-        print("Less than or equal to 5")
-        return return_zero().result()
-
-
-@python_app
-def return_one():
-    return 1
-
-
-@python_app
-def return_zero():
-    return 0
-
-
-@python_app
-def xor_split():
-    """Test XOR split. Do A if x else B
-    """
-    x = rand()
-
-    if x.result() > 5:
-        print("Result > 5")
-        return 0
-    else:
-        print("Result < 5")
-        return 1
-
-
-@python_app
-def arb_rand():
-    x = random.randint(2, 10)
-    print(x)
-    print("random")
-    return arb_square(x).result()
-
-
-@python_app
-def arb_square(x):
-    y = x ** 2
-    if y > 25:
-        return increment(y).result()
-    else:
-        return arb_cubed(x).result()
-
-
-@python_app
-def arb_cubed(x):
-    y = x ** 3
-    return arb_square(y).result()
-
-
-def test_increment_p1a(depth=5):
-    """Test simple pipeline A->B...->N
-    """
-    futs = {0: 0}
-    for i in range(1, depth):
-        futs[i] = increment(futs[i - 1])
-
-    print([futs[i].result() for i in futs if not isinstance(futs[i], int)])
-
-
-def test_increment_slow_p1b(depth=4):
-    """Test simple pipeline A->B...->N with delay
-    """
-    futs = {0: 0}
-    for i in range(1, depth):
-        futs[i] = slow_increment(futs[i - 1], 0.5)
-
-    print(futs[i])
-    print([futs[i].result() for i in futs if not isinstance(futs[i], int)])
-
-
-def test_sequence_p1c(x=5):
-    flights = []
-    miles = []
-    for i in range(x):
-        flights.append(rand())
-    for j in range(len(flights)):
-        miles.append(multiply_rand(flights[j].result()))
-    for k in range(len(miles)):
-        print(miles[k].result())
-
-
-def test_and_split_p2a(depth=5):
-    """Test simple pipeline A->B...->N
-    """
-    futs = {}
-    for i in range(depth):
-        futs[i] = increment(i)
-
-    print([futs[i].result() for i in futs])
-
-
-def test_parallel_split_p2b(x=4):
-    for i in range(x):
-        num = rand().result()
-        y = square(num).result()
-        z = cubed(num).result()
-        print(y)
-        print(z)
-
-
-def test_and_join_p3a(depth=5):
-    """Test simple pipeline A->B...->N
-    """
-    futs = {}
-    for i in range(depth):
-        futs[i] = increment(i)
-
-    x = join(inputs=futs.values())
-    print("Final sum: ", x.result())
-    assert x.result() == sum([i + 1 for i in range(depth)])
-
-
-def test_synchronization_p3b(x=5):
-    i = []
-    for j in range(x):
-        a = increment(j).result()
-        b = square(j).result()
-        i.append(add(a, b).result())
-    total = sum(i)
-    print(total)
-
-
-def test_xor_split_p4a():
-    """Test XOR split. Do A if x else B
-    """
-    x = rand()
-
-    if x.result() > 5:
-        print("Result > 5")
-    else:
-        print("Result < 5")
-
-
-def test_xor_split_p4b(x=4):
-    num = []
-    for i in range(x):
-        num.append(eval_number(rand().result()))
-    for i in range(len(num)):
-        print(num[i].result())
-
-
-def test_xor_join_p5(x=2):
-    print(join_three(square(x).result(), increment(
-        x).result(), cubed(x).result()).result())
-
-
-def test_or_split_p6(x=4, y=5):
-    if x < 5:
-        print(add(x, y).result())
-    if y > 7:
-        print(subtract(x, y).result())
-    if x >= 5:
-        print(square_sum(x, y).result())
-    if y <= 7:
-        print(double_sum(x, y).result())
-
-
-def test_synchronizing_merge_p7(x=4, y=5):
-    num = []
-    if x < 5:
-        num.append(add(x, y).result())
-    if y > 7:
-        num.append(subtract(x, y).result())
-    if x >= 5:
-        num.append(square_sum(x, y).result())
-    if y <= 7:
-        num.append(double_sum(x, y).result())
-    print(sum_list(num).result())
-
-
-def test_multi_merge_p8():
-    r = rand().result()
-    num1 = cubed(add_two(square(r).result()).result())
-    num2 = cubed(add_two(increment(r).result()).result())
-    print(add(num1.result(), num2.result()).result())
-
-
-def test_discriminator_p9(x=4):
-    squares = []
-    cubes = []
-    total = []
-    for i in range(x):
-        squares.append(square(rand().result()))
-        cubes.append(cubed(rand().result()))
-        while squares[i].done() is False and cubes[i].done() is False:
-            pass
-        total.append(squares[i].result() + cubes[i].result())
-    for i in range(x):
-        print(total[i])
-
-
-def test_arbitrary_cycles_p10(x=2):
-    numbers = []
-    for i in range(x):
-        numbers.append(arb_rand())
-    for i in range(x):
-        print(numbers[i].result())
-
-
-def test_implicit_termination_p11(x=5):
-    numbers = []
-    numbers.append(slow_increment(rand().result()))
-    for i in range(x):
-        y = rand().result()
-        numbers.append(square(increment(y).result()).result())
-    print(numbers[0].result())
-    return
-
-
-def test_multi_instances_p12(x=5):
-    numbers = []
-    for i in range(x):
-        numbers.append(square(rand().result()))
-    print(numbers[i])
-    print([numbers[i].result() for i in range(len(numbers))])
-
-
-def test_multi_instances_priori_p13():
-    x = increment(square(rand().result()).result()).result()
-    y = increment(square(rand().result()).result()).result()
-    z = increment(square(rand().result()).result()).result()
-    total = simple_sum_elements(x, y, z).result()
-    print(total)
-
-
-def test_multi_instances_without_runtime_p15():
-    numbers = []
-    while sum_list(numbers).result() < 20:
-        numbers.append(increment(rand().result()).result())
-    print(sum_list(numbers).result())
-
-
-def test_multi_instances_runtime_p14(x=5):
-    numbers = []
-    [numbers.append(increment(square(rand().result()).result()))
-     for i in range(x)]
-    total = sum_results(numbers)
-    print(total.result())
-
-
-def test_deferred_choice_p16():
-    r = rand().result()
-    s = sleep_square(r)
-    i = slow_increment(r)
-    print(s.done())
-    while s.done() is not True and i.done() is not True:
-        pass
-    if s.done() is True:
-        print(s.result())
-    elif i.done() is True:
-        print(i.result())
-
-
-def test_unordered_sequence_p17():
-    r = rand().result()
-    s = sleep_square(r)
-    i = slow_increment(r)
-    print(s.done())
-    while s.done() is not True and i.done() is not True:
-        pass
-    if i.done() is True:
-        print(i.result())
-        print(sleep_square(i.result()).result())
-    elif s.done() is True:
-        print(s.result())
-        print(slow_increment(s.result()).result())
-
-
-def test_milestone_p18():
-    r = rand().result()
-    i = increment(r)
-    s = sleep_square(r)
-    while s.done() is not True:
-        if i.done() is True:
-            print(cubed(r).result())
-            return
-
-
-def test_withdraw_activity_p19(x=3):
-    cubes = []
-    squares = []
-    increments = []
-    for i in range(x):
-        r = rand().result()
-        cubes.append(sleep_cubed(r))
-        squares.append(square(r))
-        if cubes[i].done() is True:
-            print(True)
-            squares[i] = None
-        else:
-            print(False)
-        increments.append(increment(r))
-    print(sum_elements(cubes, squares, increments).result())
-
-
-def test_cancel_case_p20(x=3):
-    cubes = []
-    squares = []
-    increments = []
-    for i in range(x):
-        r = rand().result()
-        cubes.append(cubed(r))
-        squares.append(square(r))
-        increments.append(increment(r))
-    r = random.randint(1, 30)
-    print(r)
-    if r > 20:
-        del cubes[:]
-    if r < 20 and r > 10:
-        del squares[:]
-    if r < 10:
-        del increments[:]
-    print(sum_lists(cubes, squares, increments).result())
-
-
-def test_xor_parallel_split(width=2):
-    futures = {}
-
-    for i in range(width):
-        futures[i] = xor_split()
-
-    print([futures[key].result() for key in futures])

parsl/tests/test_docs/test_workflow2.py

@@ -1,42 +0,0 @@
-import time
-
-import pytest
-
-from parsl.app.app import python_app
-from parsl.tests.configs.local_threads import config
-
-local_config = config
-
-
-@python_app
-def wait_sleep_double(x, fu_1, fu_2):
-    import time
-    time.sleep(2)   # Sleep for 2 seconds
-    return x * 2
-
-
-@pytest.mark.skip('fails with pytest+xdist')
-def test_parallel(N=2):
-    """Parallel workflow example from docs on composing a workflow
-    """
-
-    # Launch two apps, which will execute in parallel, since they don't have to
-    # wait on any futures
-    start = time.time()
-    doubled_x = wait_sleep_double(N, None, None)
-    doubled_y = wait_sleep_double(N, None, None)
-
-    # The third depends on the first two :
-    #    doubled_x   doubled_y     (2 s)
-    #           \     /
-    #           doublex_z          (2 s)
-    doubled_z = wait_sleep_double(N, doubled_x, doubled_y)
-
-    # doubled_z will be done in ~4s
-    print(doubled_z.result())
-    time.time()
-    delta = time.time() - start
-
-    assert doubled_z.result() == N * \
-        2, "Expected doubled_z = N*2 = {0}".format(N * 2)
-    assert delta > 4 and delta < 5, "Time delta exceeded expected 4 < duration < 5"