tree 43a79104068a2392a809c82653d2bd2c9fe45071
parent f7a6840443f8878d3ecca2f74f8b2e513a0eb07c
author dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> 1708006569 +0900
committer GitHub <noreply@github.com> 1708006569 +0000
gpgsig -----BEGIN PGP SIGNATURE-----
 
 wsFcBAABCAAQBQJlzhy4CRC1aQ7uu5UhlAAA4jgQAJY5rY+6cFBS9F79ozUWV3WY
 27cDXNlWWqUsq9ytpzb2Utbydo5K+2eC48EyczISTjLTAlEO8QVUQ/h20Y9Dzqnz
 qU8Zuq4HUe2OVRZxn9rdVY5A7DDDuz4wN0oANNJ4TbPY+8o9+QP4jH12H6qd3OWL
 18E/3R7wWolw+jSsh7ZTzTHWn8Wd1ThcBVFZoqHQQ9Ynkroty5jYIUuTK3agckzF
 P2XD0x0Xxd8sNpqFr+R976C4fwLhLCXynuh5s+CRsgtcyTr43rO2y+h8VXAtnRio
 4vtOhv3yVcxObCLUWKsaNYHS/EmoqMi7T0funjLWUXHAZBGtEQKBRJD35j+KOJb1
 K0GI/h4KY6yThHLjLRi1Afz1RqRkEYmHnUtwqcTnOOJm0twusQhQ0ZKGclhtS8JB
 3wc36YUST9jNNLzd5+Qo88NZ0+TWk34NekcTt3qrzf6yfJcMIf516UKvjDnW486D
 0pjaT4Hacj4GoSRSBYyd6TLGX2PGYIumww9O45M3RmkTXKxi/OzXQudKMT047Htt
 BW1F766FELCRtF8lrtLDhHCBdjEKuWlI+LdvyWIeg3smNH8/XoD7xtzxJBdtLUY/
 3kwST2bIi+uB+nkiSghduboBf4CP1Iuu6x11BmxwkKDqb8briGGsyrBMAwUrv7bA
 FGVAdj1dSFi1ilGIZ3p4
 =+U/1
 -----END PGP SIGNATURE-----
 

build(deps): bump certifi from 2022.12.7 to 2023.7.22 in /examples/bzlmod_build_file_generation (#1378)

Bumps [certifi](https://github.com/certifi/python-certifi) from
2022.12.7 to 2023.7.22.
<details>
<summary>Commits</summary>
<ul>
<li><a
href="https://github.com/certifi/python-certifi/commit/8fb96ed81f71e7097ed11bc4d9b19afd7ea5c909"><code>8fb96ed</code></a>
2023.07.22</li>
<li><a
href="https://github.com/certifi/python-certifi/commit/afe77220e0eaa722593fc5d294213ff5275d1b40"><code>afe7722</code></a>
Bump actions/setup-python from 4.6.1 to 4.7.0 (<a
href="https://redirect.github.com/certifi/python-certifi/issues/230">#230</a>)</li>
<li><a
href="https://github.com/certifi/python-certifi/commit/2038739ad56abec7aaddfa90ad2ce6b3ed7f5c7b"><code>2038739</code></a>
Bump dessant/lock-threads from 3.0.0 to 4.0.1 (<a
href="https://redirect.github.com/certifi/python-certifi/issues/229">#229</a>)</li>
<li><a
href="https://github.com/certifi/python-certifi/commit/44df761f4c09d19f32b3cc09208a739043a5e25b"><code>44df761</code></a>
Hash pin Actions and enable dependabot (<a
href="https://redirect.github.com/certifi/python-certifi/issues/228">#228</a>)</li>
<li><a
href="https://github.com/certifi/python-certifi/commit/8b3d7bae85bbc87c9181cc1d39548db3d31627f0"><code>8b3d7ba</code></a>
2023.05.07</li>
<li><a
href="https://github.com/certifi/python-certifi/commit/53da2405b1af430f6bafa21ba45d8dd8dfc726b8"><code>53da240</code></a>
ci: Add Python 3.12-dev to the testing (<a
href="https://redirect.github.com/certifi/python-certifi/issues/224">#224</a>)</li>
<li><a
href="https://github.com/certifi/python-certifi/commit/c2fc3b1f64d6946f1057971ee897ea828ae848d8"><code>c2fc3b1</code></a>
Create a Security Policy (<a
href="https://redirect.github.com/certifi/python-certifi/issues/222">#222</a>)</li>
<li><a
href="https://github.com/certifi/python-certifi/commit/c211ef482a01aff5f1bc92c4128bfa0c955f4a01"><code>c211ef4</code></a>
Set up permissions to github workflows (<a
href="https://redirect.github.com/certifi/python-certifi/issues/218">#218</a>)</li>
<li><a
href="https://github.com/certifi/python-certifi/commit/2087de5d0aa1d472145fc1dbdfece3fe652bbac5"><code>2087de5</code></a>
Don't let deprecation warning fail CI (<a
href="https://redirect.github.com/certifi/python-certifi/issues/219">#219</a>)</li>
<li><a
href="https://github.com/certifi/python-certifi/commit/e0b9fc5c8f52ac8c300da502e5760ce3d41429ec"><code>e0b9fc5</code></a>
remove paragraphs about 1024-bit roots from README</li>
<li>Additional commits viewable in <a
href="https://github.com/certifi/python-certifi/compare/2022.12.07...2023.07.22">compare
view</a></li>
</ul>
</details>
<br />


[![Dependabot compatibility
score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=certifi&package-manager=pip&previous-version=2022.12.7&new-version=2023.7.22)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

You can trigger a rebase of this PR by commenting `@dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@dependabot rebase` will rebase this PR
- `@dependabot recreate` will recreate this PR, overwriting any edits
that have been made to it
- `@dependabot merge` will merge this PR after your CI passes on it
- `@dependabot squash and merge` will squash and merge this PR after
your CI passes on it
- `@dependabot cancel merge` will cancel a previously requested merge
and block automerging
- `@dependabot reopen` will reopen this PR if it is closed
- `@dependabot close` will close this PR and stop Dependabot recreating
it. You can achieve the same result by closing it manually
- `@dependabot show <dependency name> ignore conditions` will show all
of the ignore conditions of the specified dependency
- `@dependabot ignore this major version` will close this PR and stop
Dependabot creating any more for this major version (unless you reopen
the PR or upgrade to it yourself)
- `@dependabot ignore this minor version` will close this PR and stop
Dependabot creating any more for this minor version (unless you reopen
the PR or upgrade to it yourself)
- `@dependabot ignore this dependency` will close this PR and stop
Dependabot creating any more for this dependency (unless you reopen the
PR or upgrade to it yourself)
You can disable automated security fix PRs for this repo from the
[Security Alerts
page](https://github.com/bazelbuild/rules_python/network/alerts).

</details>

> **Note**
> Automatic rebases have been disabled on this pull request as it has
been open for over 30 days.

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>