citi / parafun Goto Github PK

This issue lists Renovate updates and detected dependencies. Read the Dependency Dashboard docs to learn more.

Open

These updates have all been created already. Click a checkbox below to force a retry/rebase of any.

• Update actions/checkout action to v4

Detected dependencies

• Check this box to trigger a request for Renovate to run again on this repository

Automatically generate and publish Parfun's documentation on code merge into main as GitHub page.

See Gradle-helm-plugin's pages at https://citi.github.io/gradle-helm-plugin/.

The dependency review action scans your pull requests for dependency changes, and will raise an error if any vulnerabilities or invalid licenses are being introduced. The action is supported by an API endpoint that diffs the dependencies between any two revisions on your default branch.

name: 'Dependency Review'
on: [pull_request]

permissions:
  contents: read

jobs:
  dependency-review:
    runs-on: ubuntu-latest
    steps:
      - name: 'Checkout Repository'
        uses: actions/checkout@v4
      - name: 'Dependency Review'
        uses: actions/dependency-review-action@v4

Adding a new decorator that executes the function in the background.

When a decorated function gets called, it returns immediately, and the computation will be executed in the background using the currently setup BackendEngine.

The return value of the function will behave like a regular value, except that it reading it will block until the computation finishes.

Example:

@delayed
def delayed_pow(a: float, b: float) -> float:
    return math.pow(a, b)

# This will compute all the `delayed_pow()` calls in parallel:
total_sum = sum([delayed_pow(x, 2) for x in range(0, 1000)])

# Operators should work too
print((delayed_pow(2, 2) + delayed_pow(4, 2)) * 4)

# Can be used without a decorator
a = delayed(math.sqrt)(16)
b = delayed(math.sqrt)(9)
print(a + b)

While being simpler to use that @parfun, it has a few disadvantages:

• It does not try to find the optimal partitioning size of the parallelized tasks;
• Exceptions are harder to understand, as these will be raised when the function return value is first accessed, not when then function is called.

As Pargraph already has a @delayed decorator, I'm thinking about using a different name. Here are some ideas:

• @task;
• @parasync;
• @parallel_task;
• @concurrent_task;

I already have a basic implementation working in new_delayed_api.

CodeQL is the code analysis engine developed by GitHub to automate security checks. You can analyze your code using CodeQL and display the results as code scanning alerts..

There are a few deprecated APIs that should be discarded in Parfun 7.0.0.

Removing these old APIs will simplify the decorator's type signature.

Deprecated APIs include:

• @parafun(partition_on=..., partition_with=...);
• dfs_by_row(), partition_dfs_by_chunk(), dfs_by_group(), partition_dfs_group_by();
• lists_by_chunk(), zip_partition_on_args();
• lists_concat(), concat_lists(), unzip();
• partition_nested();