| Name | matrix-bgpsim JSON |
| Version |
1.0.1
JSON |
| download |
| home_page | None |
| Summary | Matrix-based BGP simulation tool for AS-level routing analysis, supporting GPU acceleration. |
| upload_time | 2025-09-03 03:47:26 |
| maintainer | None |
| docs_url | None |
| author | None |
| requires_python | >=3.8 |
| license | MIT |
| keywords |
bgp
simulation
networking
as-level
gpu
|
| VCS |
 |
| bugtrack_url |
|
| requirements |
No requirements were recorded.
|
| Travis-CI |
No Travis.
|
| coveralls test coverage |
No coveralls.
|
<h1 align="center">matrix-bgpsim: A fast and efficient matrix-based BGP simulator with GPU acceleration</h1>
<p align="center">
<a href="https://github.com/yhchen-tsinghua/matrix-bgpsim/releases/latest"><img src="https://img.shields.io/github/release/yhchen-tsinghua/matrix-bgpsim.svg?maxAge=600" alt="Latest release" /></a>
<a href="https://pypi.org/project/matrix-bgpsim/"><img src="https://img.shields.io/pypi/v/matrix-bgpsim.svg?maxAge=600" alt="PyPI version"></a>
<a href="https://matrix-bgpsim.readthedocs.io/en/latest/"><img src="https://readthedocs.org/projects/matrix-bgpsim/badge/?version=latest" alt="Docs Status" />
<a href="https://www.python.org/"><img src="https://img.shields.io/badge/python-3.8%2B-brightgreen.svg?maxAge=2592000" alt="Python version"></a>
<a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-yellowgreen.svg?maxAge=2592000" alt="License"></a>
</a>
</p>
`matrix-bgpsim` is a Python project that provides a high-performance BGP routing simulator built on matrix operations. It enables full-scale AS-level route generation across the entire global Internet topology (77k+ ASes) in just a few hours, following the Gao-Rexford simulation model. It supports CPU backend with Python-native multiprocessing, and optionally GPU acceleration via PyTorch and CuPy backends.
✅ Use `matrix-bgpsim` when you need large-scale simulation to compute all-pairs AS-level routes.
❌ Do not use `matrix-bgpsim` if you only want to query a small number of routes on-demand.
## Table of Contents
- [Features](#features)
- [Installation](#installation)
- [From PyPI](#from-pypi)
- [From Source](#from-source)
- [Requirements](#requirements)
- [Usage](#usage)
- [Initialization](#1-initialization)
- [Simulation](#2-simulation)
- [Query](#3-query)
- [Save and Load](#4-save-and-load)
- [Documentation](#documentation)
- [How It Works](#how-it-works)
- [Simulation Criteria](#simulation-criteria)
- [Topology Compression](#topology-compression)
- [One-Byte Encoding](#one-byte-encoding)
- [Matrix Operations](#matrix-operations)
- [Contact](#contact)
## Features
- Full-scale simulation for all AS pairs in a single run
- High performance with matrix-based computations
- GPU acceleration with PyTorch and CuPy backends
- Compact state representation that uses one byte per route
- Flexible multiprocessing backends with CPU and GPU
- Research friendly with CAIDA-format input and Gao-Rexford model
## Installation
### From PyPI
You can install `matrix-bgpsim` with desired backends directly from PyPI:
* To install CPU-only backend (without GPU acceleration):
```bash
pip install matrix-bgpsim
```
* To install optional PyTorch backend (for GPU acceleration with PyTorch):
```bash
pip install matrix-bgpsim[torch]
```
* To install optional CuPy backend (for GPU acceleration with CuPy):
```bash
pip install matrix-bgpsim[cupy]
```
* To install multiple optional backends at once:
```bash
pip install matrix-bgpsim[torch,cupy]
```
### From Source
You can clone this repository and install `matrix-bgpsim` from source:
* To install CPU-only backend (without GPU acceleration):
```bash
git clone https://github.com/yhchen-tsinghua/matrix-bgpsim.git
cd matrix-bgpsim
pip install .
```
* To install optional PyTorch backend (for GPU acceleration with PyTorch):
```bash
git clone https://github.com/yhchen-tsinghua/matrix-bgpsim.git
cd matrix-bgpsim
pip install ".[torch]"
```
* To install optional CuPy backend (for GPU acceleration with CuPy):
```bash
git clone https://github.com/yhchen-tsinghua/matrix-bgpsim.git
cd matrix-bgpsim
pip install ".[cupy]"
```
* To install multiple optional backends at once:
```bash
git clone https://github.com/yhchen-tsinghua/matrix-bgpsim.git
cd matrix-bgpsim
pip install ".[torch,cupy]"
```
### Requirements
* Python 3.8 or higher
* `lz4` for file compression
* `numpy>=1.21` for CPU-only backend
* `torch>=2.0.0` for PyTorch backend
* `cupy>=12.0.0` for CuPy backend
## Usage
### 1. Initialization
To initialize with CAIDA-format AS relationship data:
```python
from matrix_bgpsim import RMatrix
rmatrix = RMatrix(
input_rels="20250101.as-rel2.txt", # file path to AS relationship data
excluded={"1234", "5678"}, # ASes to exclude from the topology
)
```
### 2. Simulation
To run simulation with a certain backend:
- Using CPU backend:
```python
rmatrix.run(
n_jobs=4, # number of parallel CPU processes
max_iter=32, # maximum route propagation iterations
save_next_hop=True, # store next-hop information
backend="cpu", # use CPU multiprocessing
)
```
- Using PyTorch backend:
```python
rmatrix.run(
max_iter=32, # maximum route propagation iterations
save_next_hop=True, # store next-hop information
backend="torch", # use PyTorch CPU/GPU backend
device="cuda:0" # specify CPU/GPU device (defaults to "cuda:0" if available)
)
```
- Using CuPy backend:
```python
rmatrix.run(
max_iter=32, # maximum route propagation iterations
save_next_hop=True, # store next-hop information
backend="cupy", # use CuPy GPU backend
device=0 # specify GPU ID (defaults to 0 if available)
)
```
### 3. Query
To query the priority (i.e., whether it is from customer, peer, or provider) and path length of a certain route:
```python
# Query the priority and path length of the route from AS7018 to AS3356
# priority: [1|0|-1|None] for [customer|peer|provider|unavailable] route
# length: the number of AS hops
priority, length = rmatrix.get_state("7018", "3356")
```
To query the full AS path (must run the simulation with `save_next_hop=True`):
```python
# Query the full AS path from AS7018 to AS3356
# as_path: a list of ASNs, excluding "7018" and including "3356"
as_path = rmatrix.get_path("7018", "3356")
```
### 4. Save and Load
To save the computed results to disk:
```python
rmatrix.dump("rmatrix.lz4")
```
To load the computed results from disk:
```python
rmatrix = RMatrix.load("rmatrix.lz4")
```
## Documentation
The full API reference and usage guide are available at 👉 https://matrix-bgpsim.readthedocs.io
## How It Works
### Simulation Criteria
`matrix-bgpsim` follows the standard Gao-Rexford simulation principles for AS-level routing. Route selection proceeds in three steps::
* Highest local preference: routes from customers are preferred over peers, which in turn are preferred over providers.
* Shortest AS path: among routes with equal local preference, the path with fewer AS hops is chosen.
* Random tie-breaking: if multiple routes remain equivalent, the one with smallest ASN is selected (looks random).
The valley-free constraint is also enforced: routes learned from a peer or provider are only propagated to customers, preventing "valley" paths in the network.
### Topology Compression
To improve simulation efficiency, `matrix-bgpsim` compresses the Internet topology by separating _core ASes_ from _branch ASes_.
* Core ASes are the main nodes in the network that participate directly in the matrix-based BGP route inference. These typically include ASes with multiple providers, multiple customers, or any peers.
* Branch ASes are typically single-homed ASes or stub networks whose routing tables can be fully derived from their upstream access AS. A branch is defined recursively as a sequence of ASes starting from a stub AS and following its single provider until reaching a core AS (the access AS) with either:
- more than one provider,
- more than one customer, or
- any peers.
The key intuition is that all routes to or from branch ASes pass through their access AS (called "root" in the code). Therefore, branch ASes do not need to participate in the main matrix simulation. Instead:
1. The core topology is extracted by pruning all branch ASes.
2. BGP routing simulation is performed only on the core topology.
3. outes for branch ASes are efficiently reconstructed afterwards using their access AS’s routing table, e.g., by concatenating the branch sequence.
This approach significantly reduces simulation complexity while preserving complete routing information. In practice, it can reduce topology size by over 30% in vertices, leaving only the core ASes for matrix-based computation.
### One-Byte Encoding
Route selection in BGP can be computationally expensive. `matrix-bgpsim` speeds this up using a one-byte route priority encoding, which packs both local preference and path length into a single byte.
* Structure of the byte:
- The two most significant bits encode local preference:
- `11`: customer route
- `10`: peer route
- `01`: provider route
- `00`: unreachable origin
- The six least significant bits store the bitwise complement of the path length (max 63 hops).
* Why design so:
- Higher byte values indicate more preferred routes.
- Best-route selection becomes a simple max operation over the byte array.
- Updating the route during propagation only requires basic arithmetic, e.g., subtracting one per hop to adjust the path length field.
This encoding allows `matrix-bgpsim` to turn complex BGP iterations into highly optimized matrix operations, making large-scale AS-level simulations fast and memory-efficient.
### Matrix Operations
`matrix-bgpsim` represents the network as matrices, allowing route propagation and next-hop computation to be performed in a fully vectorized way.
* State matrix: Each element encodes the route priority (local preference + path length) from a source AS to a destination AS using the one-byte encoding.
* Next-hop matrix: Stores the index of the first AS to forward a route toward a destination. It is updated simultaneously with the state matrix.
* Initialization:
- The diagonal of the state matrix is set to enforce self-reachability.
- Neighbor relationships (C2P, P2P, P2C) are initialized with appropriate priorities in the state matrix.
- Link matrices (link1 and link2) help track propagation directions.
* Propagation loop:
1. Prepare state updates: Bitwise operations separate the local preference and path length fields and combine them for propagation.
2. Compute new priorities: For each destination, the algorithm evaluates all incoming routes via neighbors and selects the maximum priority route.
3. Update next-hop matrix: The index corresponding to the chosen route becomes the next hop for that destination.
4. Repeat: Iteration continues until the routing state converges.
* Path reconstruction:
Once the next-hop matrix is computed:
1. Start from a source AS and repeatedly look up the next-hop AS for the desired destination.
2. Follow the chain of next hops recursively until the destination is reached.
3. This reconstructs the full AS-level path without needing to store all intermediate route information during propagation.
* Advantages:
- Fully vectorized using PyTorch (or CuPy/NumPy for other backends).
- Efficient next-hop tracking allows fast path reconstruction on demand.
- Matrix operations reduce BGP propagation to bitwise and arithmetic operations, maximizing speed and memory efficiency.
## Contact
Copyright (c) 2025 [Yihao Chen](https://yhchen.cn)
Email: yh-chen21@mails.tsinghua.edu.cn
---
Raw data
{
"_id": null,
"home_page": null,
"name": "matrix-bgpsim",
"maintainer": null,
"docs_url": null,
"requires_python": ">=3.8",
"maintainer_email": null,
"keywords": "bgp, simulation, networking, as-level, gpu",
"author": null,
"author_email": "Yihao Chen <yh-chen21@mails.tsinghua.edu.cn>",
"download_url": "https://files.pythonhosted.org/packages/2f/04/3b8060fe2801153b37ecd57836ff0950aef4998a58b574fcaa666c540f57/matrix_bgpsim-1.0.1.tar.gz",
"platform": null,
"description": "<h1 align=\"center\">matrix-bgpsim: A fast and efficient matrix-based BGP simulator with GPU acceleration</h1>\n\n<p align=\"center\">\n <a href=\"https://github.com/yhchen-tsinghua/matrix-bgpsim/releases/latest\"><img src=\"https://img.shields.io/github/release/yhchen-tsinghua/matrix-bgpsim.svg?maxAge=600\" alt=\"Latest release\" /></a>\n <a href=\"https://pypi.org/project/matrix-bgpsim/\"><img src=\"https://img.shields.io/pypi/v/matrix-bgpsim.svg?maxAge=600\" alt=\"PyPI version\"></a>\n <a href=\"https://matrix-bgpsim.readthedocs.io/en/latest/\"><img src=\"https://readthedocs.org/projects/matrix-bgpsim/badge/?version=latest\" alt=\"Docs Status\" />\n <a href=\"https://www.python.org/\"><img src=\"https://img.shields.io/badge/python-3.8%2B-brightgreen.svg?maxAge=2592000\" alt=\"Python version\"></a>\n <a href=\"LICENSE\"><img src=\"https://img.shields.io/badge/license-MIT-yellowgreen.svg?maxAge=2592000\" alt=\"License\"></a>\n</a>\n</p>\n\n`matrix-bgpsim` is a Python project that provides a high-performance BGP routing simulator built on matrix operations. It enables full-scale AS-level route generation across the entire global Internet topology (77k+ ASes) in just a few hours, following the Gao-Rexford simulation model. It supports CPU backend with Python-native multiprocessing, and optionally GPU acceleration via PyTorch and CuPy backends.\n\n✅ Use `matrix-bgpsim` when you need large-scale simulation to compute all-pairs AS-level routes.\n\n❌ Do not use `matrix-bgpsim` if you only want to query a small number of routes on-demand.\n\n## Table of Contents\n\n- [Features](#features)\n- [Installation](#installation)\n - [From PyPI](#from-pypi)\n - [From Source](#from-source)\n - [Requirements](#requirements)\n- [Usage](#usage)\n - [Initialization](#1-initialization)\n - [Simulation](#2-simulation)\n - [Query](#3-query)\n - [Save and Load](#4-save-and-load)\n- [Documentation](#documentation)\n- [How It Works](#how-it-works)\n - [Simulation Criteria](#simulation-criteria)\n - [Topology Compression](#topology-compression)\n - [One-Byte Encoding](#one-byte-encoding)\n - [Matrix Operations](#matrix-operations)\n- [Contact](#contact)\n\n## Features\n\n- Full-scale simulation for all AS pairs in a single run\n\n- High performance with matrix-based computations\n\n- GPU acceleration with PyTorch and CuPy backends\n\n- Compact state representation that uses one byte per route\n\n- Flexible multiprocessing backends with CPU and GPU\n\n- Research friendly with CAIDA-format input and Gao-Rexford model\n\n## Installation\n\n### From PyPI\n\nYou can install `matrix-bgpsim` with desired backends directly from PyPI:\n\n* To install CPU-only backend (without GPU acceleration):\n\n ```bash\n pip install matrix-bgpsim\n ```\n\n* To install optional PyTorch backend (for GPU acceleration with PyTorch):\n\n ```bash\n pip install matrix-bgpsim[torch]\n ```\n\n* To install optional CuPy backend (for GPU acceleration with CuPy):\n\n ```bash\n pip install matrix-bgpsim[cupy]\n ```\n\n* To install multiple optional backends at once:\n\n ```bash\n pip install matrix-bgpsim[torch,cupy]\n ```\n\n### From Source\n\nYou can clone this repository and install `matrix-bgpsim` from source:\n\n* To install CPU-only backend (without GPU acceleration):\n\n ```bash\n git clone https://github.com/yhchen-tsinghua/matrix-bgpsim.git\n cd matrix-bgpsim\n pip install .\n ```\n\n* To install optional PyTorch backend (for GPU acceleration with PyTorch):\n\n ```bash\n git clone https://github.com/yhchen-tsinghua/matrix-bgpsim.git\n cd matrix-bgpsim\n pip install \".[torch]\"\n ```\n\n* To install optional CuPy backend (for GPU acceleration with CuPy):\n\n ```bash\n git clone https://github.com/yhchen-tsinghua/matrix-bgpsim.git\n cd matrix-bgpsim\n pip install \".[cupy]\"\n ```\n\n* To install multiple optional backends at once:\n\n ```bash\n git clone https://github.com/yhchen-tsinghua/matrix-bgpsim.git\n cd matrix-bgpsim\n pip install \".[torch,cupy]\"\n ```\n\n### Requirements\n\n* Python 3.8 or higher\n* `lz4` for file compression\n* `numpy>=1.21` for CPU-only backend\n* `torch>=2.0.0` for PyTorch backend\n* `cupy>=12.0.0` for CuPy backend\n\n## Usage\n\n### 1. Initialization\n\nTo initialize with CAIDA-format AS relationship data:\n\n```python\nfrom matrix_bgpsim import RMatrix\nrmatrix = RMatrix(\n input_rels=\"20250101.as-rel2.txt\", # file path to AS relationship data\n excluded={\"1234\", \"5678\"}, # ASes to exclude from the topology\n)\n```\n\n### 2. Simulation\n\nTo run simulation with a certain backend:\n\n- Using CPU backend:\n\n ```python\n rmatrix.run(\n n_jobs=4, # number of parallel CPU processes\n max_iter=32, # maximum route propagation iterations\n save_next_hop=True, # store next-hop information\n backend=\"cpu\", # use CPU multiprocessing\n )\n ```\n\n- Using PyTorch backend:\n\n ```python\n rmatrix.run(\n max_iter=32, # maximum route propagation iterations\n save_next_hop=True, # store next-hop information\n backend=\"torch\", # use PyTorch CPU/GPU backend\n device=\"cuda:0\" # specify CPU/GPU device (defaults to \"cuda:0\" if available)\n )\n ```\n\n- Using CuPy backend:\n\n ```python\n rmatrix.run(\n max_iter=32, # maximum route propagation iterations\n save_next_hop=True, # store next-hop information\n backend=\"cupy\", # use CuPy GPU backend\n device=0 # specify GPU ID (defaults to 0 if available)\n )\n ```\n\n### 3. Query\n\nTo query the priority (i.e., whether it is from customer, peer, or provider) and path length of a certain route:\n\n```python\n# Query the priority and path length of the route from AS7018 to AS3356\n# priority: [1|0|-1|None] for [customer|peer|provider|unavailable] route\n# length: the number of AS hops\npriority, length = rmatrix.get_state(\"7018\", \"3356\")\n```\n\nTo query the full AS path (must run the simulation with `save_next_hop=True`):\n```python\n# Query the full AS path from AS7018 to AS3356\n# as_path: a list of ASNs, excluding \"7018\" and including \"3356\"\nas_path = rmatrix.get_path(\"7018\", \"3356\")\n```\n\n### 4. Save and Load\n\nTo save the computed results to disk:\n\n```python\nrmatrix.dump(\"rmatrix.lz4\")\n```\n\nTo load the computed results from disk:\n\n```python\nrmatrix = RMatrix.load(\"rmatrix.lz4\")\n```\n\n## Documentation\n\nThe full API reference and usage guide are available at \ud83d\udc49 https://matrix-bgpsim.readthedocs.io\n\n## How It Works\n\n### Simulation Criteria\n\n`matrix-bgpsim` follows the standard Gao-Rexford simulation principles for AS-level routing. Route selection proceeds in three steps:: \n\n* Highest local preference: routes from customers are preferred over peers, which in turn are preferred over providers.\n* Shortest AS path: among routes with equal local preference, the path with fewer AS hops is chosen.\n* Random tie-breaking: if multiple routes remain equivalent, the one with smallest ASN is selected (looks random).\n\nThe valley-free constraint is also enforced: routes learned from a peer or provider are only propagated to customers, preventing \"valley\" paths in the network.\n\n### Topology Compression\n\nTo improve simulation efficiency, `matrix-bgpsim` compresses the Internet topology by separating _core ASes_ from _branch ASes_.\n\n* Core ASes are the main nodes in the network that participate directly in the matrix-based BGP route inference. These typically include ASes with multiple providers, multiple customers, or any peers.\n\n* Branch ASes are typically single-homed ASes or stub networks whose routing tables can be fully derived from their upstream access AS. A branch is defined recursively as a sequence of ASes starting from a stub AS and following its single provider until reaching a core AS (the access AS) with either:\n - more than one provider,\n - more than one customer, or\n - any peers.\n\nThe key intuition is that all routes to or from branch ASes pass through their access AS (called \"root\" in the code). Therefore, branch ASes do not need to participate in the main matrix simulation. Instead:\n\n1. The core topology is extracted by pruning all branch ASes.\n2. BGP routing simulation is performed only on the core topology.\n3. outes for branch ASes are efficiently reconstructed afterwards using their access AS\u2019s routing table, e.g., by concatenating the branch sequence.\n\nThis approach significantly reduces simulation complexity while preserving complete routing information. In practice, it can reduce topology size by over 30% in vertices, leaving only the core ASes for matrix-based computation.\n\n### One-Byte Encoding\n\nRoute selection in BGP can be computationally expensive. `matrix-bgpsim` speeds this up using a one-byte route priority encoding, which packs both local preference and path length into a single byte.\n\n* Structure of the byte:\n - The two most significant bits encode local preference:\n - `11`: customer route\n - `10`: peer route\n - `01`: provider route\n - `00`: unreachable origin\n - The six least significant bits store the bitwise complement of the path length (max 63 hops).\n\n* Why design so:\n - Higher byte values indicate more preferred routes.\n - Best-route selection becomes a simple max operation over the byte array.\n - Updating the route during propagation only requires basic arithmetic, e.g., subtracting one per hop to adjust the path length field.\n\nThis encoding allows `matrix-bgpsim` to turn complex BGP iterations into highly optimized matrix operations, making large-scale AS-level simulations fast and memory-efficient.\n\n### Matrix Operations\n\n`matrix-bgpsim` represents the network as matrices, allowing route propagation and next-hop computation to be performed in a fully vectorized way.\n\n* State matrix: Each element encodes the route priority (local preference + path length) from a source AS to a destination AS using the one-byte encoding.\n\n* Next-hop matrix: Stores the index of the first AS to forward a route toward a destination. It is updated simultaneously with the state matrix.\n\n* Initialization:\n - The diagonal of the state matrix is set to enforce self-reachability.\n - Neighbor relationships (C2P, P2P, P2C) are initialized with appropriate priorities in the state matrix.\n - Link matrices (link1 and link2) help track propagation directions.\n\n* Propagation loop:\n 1. Prepare state updates: Bitwise operations separate the local preference and path length fields and combine them for propagation.\n 2. Compute new priorities: For each destination, the algorithm evaluates all incoming routes via neighbors and selects the maximum priority route.\n 3. Update next-hop matrix: The index corresponding to the chosen route becomes the next hop for that destination.\n 4. Repeat: Iteration continues until the routing state converges. \n\n* Path reconstruction:\n\n Once the next-hop matrix is computed:\n\n 1. Start from a source AS and repeatedly look up the next-hop AS for the desired destination.\n 2. Follow the chain of next hops recursively until the destination is reached.\n 3. This reconstructs the full AS-level path without needing to store all intermediate route information during propagation.\n\n* Advantages:\n\n - Fully vectorized using PyTorch (or CuPy/NumPy for other backends).\n - Efficient next-hop tracking allows fast path reconstruction on demand.\n - Matrix operations reduce BGP propagation to bitwise and arithmetic operations, maximizing speed and memory efficiency.\n\n## Contact\n\nCopyright (c) 2025 [Yihao Chen](https://yhchen.cn)\n\nEmail: yh-chen21@mails.tsinghua.edu.cn\n\n---\n",
"bugtrack_url": null,
"license": "MIT",
"summary": "Matrix-based BGP simulation tool for AS-level routing analysis, supporting GPU acceleration.",
"version": "1.0.1",
"project_urls": {
"Documentation": "https://matrix-bgpsim.readthedocs.io/en/latest/",
"Homepage": "https://github.com/yhchen-tsinghua/matrix-bgpsim",
"Issues": "https://github.com/yhchen-tsinghua/matrix-bgpsim/issues",
"Repository": "https://github.com/yhchen-tsinghua/matrix-bgpsim"
},
"split_keywords": [
"bgp",
" simulation",
" networking",
" as-level",
" gpu"
],
"urls": [
{
"comment_text": null,
"digests": {
"blake2b_256": "e9a22d91c1a4806ac511dcc7e4168504be8ee66bb35b3765eec7a1150905e56a",
"md5": "ee11471641c320974b35870eaeaa503f",
"sha256": "750c3b438c1b8fc53bb6fa8014539ecea452e167f119eb60dd11f51583adfead"
},
"downloads": -1,
"filename": "matrix_bgpsim-1.0.1-py3-none-any.whl",
"has_sig": false,
"md5_digest": "ee11471641c320974b35870eaeaa503f",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.8",
"size": 14904,
"upload_time": "2025-09-03T03:47:25",
"upload_time_iso_8601": "2025-09-03T03:47:25.587640Z",
"url": "https://files.pythonhosted.org/packages/e9/a2/2d91c1a4806ac511dcc7e4168504be8ee66bb35b3765eec7a1150905e56a/matrix_bgpsim-1.0.1-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "2f043b8060fe2801153b37ecd57836ff0950aef4998a58b574fcaa666c540f57",
"md5": "b42ee91e5a54060d097d8f3d5a489bfe",
"sha256": "fa4952b12a3cbf9fea741a8fdad79714e2719e4aa2b535f513653eb9098a1291"
},
"downloads": -1,
"filename": "matrix_bgpsim-1.0.1.tar.gz",
"has_sig": false,
"md5_digest": "b42ee91e5a54060d097d8f3d5a489bfe",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.8",
"size": 19060,
"upload_time": "2025-09-03T03:47:26",
"upload_time_iso_8601": "2025-09-03T03:47:26.951305Z",
"url": "https://files.pythonhosted.org/packages/2f/04/3b8060fe2801153b37ecd57836ff0950aef4998a58b574fcaa666c540f57/matrix_bgpsim-1.0.1.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2025-09-03 03:47:26",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "yhchen-tsinghua",
"github_project": "matrix-bgpsim",
"travis_ci": false,
"coveralls": false,
"github_actions": false,
"lcname": "matrix-bgpsim"
}
