# `autonomi` - Autonomi client API
[](https://crates.io/crates/autonomi)
[](https://docs.rs/autonomi)
Connect to and build on the Autonomi network.
## Usage
Add the autonomi crate to your `Cargo.toml`:
```toml
[dependencies]
autonomi = { path = "../autonomi", version = "0.1.0" }
```
## Running tests
### Using a local EVM testnet
1. If you haven't, install Foundry, to be able to run Anvil
nodes: https://book.getfoundry.sh/getting-started/installation
2. Run a local EVM node:
```sh
cargo run --bin evm_testnet
```
3. Run a local network with the `local` feature and use the local evm node.
```sh
cargo run --bin=safenode-manager --features=local -- local run --build --clean --rewards-address <ETHEREUM_ADDRESS> evm-local
```
4. Then run the tests with the `local` feature and pass the EVM params again:
```sh
EVM_NETWORK=local cargo test --package=autonomi --features=local
# Or with logs
RUST_LOG=autonomi EVM_NETWORK=local cargo test --package=autonomi --features=local -- --nocapture
```
### Using a live testnet or mainnet
Using the hardcoded `Arbitrum One` option as an example, but you can also use the command flags of the steps above and
point it to a live network.
1. Run a local network with the `local` feature:
```sh
cargo run --bin=safenode-manager --features=local -- local run --build --clean --rewards-address <ETHEREUM_ADDRESS> evm-arbitrum-one
```
2. Then run the tests with the `local` feature. Make sure that the wallet of the private key you pass has enough gas and
payment tokens on the network (in this case Arbitrum One):
```sh
EVM_NETWORK=arbitrum-one EVM_PRIVATE_KEY=<PRIVATE_KEY> cargo test --package=autonomi --features=local
# Or with logs
RUST_LOG=autonomi EVM_NETWORK=arbitrum-one EVM_PRIVATE_KEY=<PRIVATE_KEY> cargo test --package=autonomi --features=local -- --nocapture
```
### WebAssembly
To run a WASM test
- Install `wasm-pack`
- Make sure your Rust supports the `wasm32-unknown-unknown` target. (If you
have `rustup`: `rustup target add wasm32-unknown-unknown`.)
- Pass a bootstrap peer via `SAFE_PEERS`. This *has* to be the websocket address,
e.g. `/ip4/<ip>/tcp/<port>/ws/p2p/<peer ID>`.
- As well as the other environment variables needed for EVM payments (e.g. `RPC_URL`).
- Optionally specify the specific test, e.g. `-- put` to run `put()` in `wasm.rs` only.
Example:
```sh
SAFE_PEERS=/ip4/<ip>/tcp/<port>/ws/p2p/<peer ID> wasm-pack test --release --firefox autonomi --features=data,files --test wasm -- put
```
#### Test from JS in the browser
`wasm-pack test` does not execute JavaScript, but runs mostly WebAssembly. Again make sure the environment variables are
set and build the JS package:
```sh
wasm-pack build --dev --target=web autonomi --features=vault
```
Then cd into `autonomi/tests-js`, and use `npm` to install and serve the test html file.
```
cd autonomi/tests-js
npm install
npm run serve
```
Then go to `http://127.0.0.1:8080/tests-js` in the browser. Here, enter a `ws` multiaddr of a local node and press '
run'.
#### MetaMask example
There is a MetaMask example for doing a simple put operation.
Build the package with the `external-signer` feature (and again with the env variables) and run a webserver, e.g. with
Python:
```sh
wasm-pack build --dev --target=web autonomi --features=external-signer
python -m http.server --directory=autonomi 8000
```
Then visit `http://127.0.0.1:8000/examples/metamask` in your (modern) browser.
Here, enter a `ws` multiaddr of a local node and press 'run'.
## Faucet (local)
There is no faucet server, but instead you can use the `Deployer wallet private key` printed in the EVM node output to
initialise a wallet from with almost infinite gas and payment tokens. Example:
```rust
let rpc_url = "http://localhost:54370/";
let payment_token_address = "0x5FbDB2315678afecb367f032d93F642f64180aa3";
let data_payments_address = "0x8464135c8F25Da09e49BC8782676a84730C318bC";
let private_key = "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80";
let network = Network::Custom(CustomNetwork::new(
rpc_url,
payment_token_address,
data_payments_address,
));
let deployer_wallet = Wallet::new_from_private_key(network, private_key).unwrap();
let receiving_wallet = Wallet::new_with_random_wallet(network);
// Send 10 payment tokens (atto)
let _ = deployer_wallet
.transfer_tokens(receiving_wallet.address(), Amount::from(10))
.await;
```
Alternatively, you can provide the wallet address that should own all the gas and payment tokens to the EVM testnet
startup command using the `--genesis-wallet` flag:
```sh
cargo run --bin evm_testnet -- --genesis-wallet <ETHEREUM_ADDRESS>
```
```shell
*************************
* Ethereum node started *
*************************
RPC URL: http://localhost:60093/
Payment token address: 0x5FbDB2315678afecb367f032d93F642f64180aa3
Chunk payments address: 0x8464135c8F25Da09e49BC8782676a84730C318bC
Deployer wallet private key: 0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80
Genesis wallet balance: (tokens: 20000000000000000000000000, gas: 9998998011366954730202)
```
## Python Bindings
The Autonomi client library provides Python bindings for easy integration with Python applications.
### Installation
```bash
pip install autonomi-client
```
### Quick Start
```python
from autonomi_client import Client, Wallet, PaymentOption
# Initialize wallet with private key
wallet = Wallet("your_private_key_here")
print(f"Wallet address: {wallet.address()}")
print(f"Balance: {wallet.balance()}")
# Connect to network
client = Client.connect(["/ip4/127.0.0.1/tcp/12000"])
# Create payment option
payment = PaymentOption.wallet(wallet)
# Upload data
data = b"Hello, Safe Network!"
addr = client.data_put(data, payment)
print(f"Data uploaded to: {addr}")
# Download data
retrieved = client.data_get(addr)
print(f"Retrieved: {retrieved.decode()}")
```
### Available Modules
#### Core Components
- `Client`: Main interface to the Autonomi network
- `connect(peers: List[str])`: Connect to network nodes
- `data_put(data: bytes, payment: PaymentOption)`: Upload data
- `data_get(addr: str)`: Download data
- `private_data_put(data: bytes, payment: PaymentOption)`: Store private data
- `private_data_get(access: PrivateDataAccess)`: Retrieve private data
- `register_generate_key()`: Generate register key
- `Wallet`: Ethereum wallet management
- `new(private_key: str)`: Create wallet from private key
- `address()`: Get wallet address
- `balance()`: Get current balance
- `PaymentOption`: Payment configuration
- `wallet(wallet: Wallet)`: Create payment option from wallet
#### Private Data
- `PrivateDataAccess`: Handle private data storage
- `from_hex(hex: str)`: Create from hex string
- `to_hex()`: Convert to hex string
- `address()`: Get short reference address
```python
# Private data example
access = client.private_data_put(secret_data, payment)
print(f"Private data stored at: {access.to_hex()}")
retrieved = client.private_data_get(access)
```
#### Registers
- Register operations for mutable data
- `register_create(value: bytes, name: str, key: RegisterSecretKey, wallet: Wallet)`
- `register_get(address: str)`
- `register_update(register: Register, value: bytes, key: RegisterSecretKey)`
```python
# Register example
key = client.register_generate_key()
register = client.register_create(b"Initial value", "my_register", key, wallet)
client.register_update(register, b"New value", key)
```
#### Vaults
- `VaultSecretKey`: Manage vault access
- `new()`: Generate new key
- `from_hex(hex: str)`: Create from hex string
- `to_hex()`: Convert to hex string
- `UserData`: User data management
- `new()`: Create new user data
- `add_file_archive(archive: str)`: Add file archive
- `add_private_file_archive(archive: str)`: Add private archive
- `file_archives()`: List archives
- `private_file_archives()`: List private archives
```python
# Vault example
vault_key = VaultSecretKey.new()
cost = client.vault_cost(vault_key)
client.write_bytes_to_vault(data, payment, vault_key, content_type=1)
data, content_type = client.fetch_and_decrypt_vault(vault_key)
```
#### Utility Functions
- `encrypt(data: bytes)`: Self-encrypt data
- `hash_to_short_string(input: str)`: Generate short reference
### Complete Examples
#### Data Management
```python
def handle_data_operations(client, payment):
# Upload text
text_data = b"Hello, Safe Network!"
text_addr = client.data_put(text_data, payment)
# Upload binary data
with open("image.jpg", "rb") as f:
image_data = f.read()
image_addr = client.data_put(image_data, payment)
# Download and verify
downloaded = client.data_get(text_addr)
assert downloaded == text_data
```
#### Private Data and Encryption
```python
def handle_private_data(client, payment):
# Create and encrypt private data
secret = {"api_key": "secret_key"}
data = json.dumps(secret).encode()
# Store privately
access = client.private_data_put(data, payment)
print(f"Access token: {access.to_hex()}")
# Retrieve
retrieved = client.private_data_get(access)
secret = json.loads(retrieved.decode())
```
#### Vault Management
```python
def handle_vault(client, payment):
# Create vault
vault_key = VaultSecretKey.new()
# Store user data
user_data = UserData()
user_data.add_file_archive("archive_address")
# Save to vault
cost = client.put_user_data_to_vault(vault_key, payment, user_data)
# Retrieve
retrieved = client.get_user_data_from_vault(vault_key)
archives = retrieved.file_archives()
```
### Error Handling
All operations can raise exceptions. It's recommended to use try-except blocks:
```python
try:
client = Client.connect(peers)
# ... operations ...
except Exception as e:
print(f"Error: {e}")
```
### Best Practices
1. Always keep private keys secure
2. Use error handling for all network operations
3. Clean up resources when done
4. Monitor wallet balance for payments
5. Use appropriate content types for vault storage
For more examples, see the `examples/` directory in the repository.
Raw data
{
"_id": null,
"home_page": "https://maidsafe.net",
"name": "autonomi-client",
"maintainer": null,
"docs_url": null,
"requires_python": ">=3.8",
"maintainer_email": null,
"keywords": "safe, network, autonomi",
"author": "MaidSafe Developers <dev@maidsafe.net>",
"author_email": "MaidSafe Developers <dev@maidsafe.net>",
"download_url": "https://files.pythonhosted.org/packages/4d/e5/95c874572442e945f511a2765e12df7aee83e0be54fad254cd05b2042520/autonomi_client-0.2.32.tar.gz",
"platform": null,
"description": "# `autonomi` - Autonomi client API\n\n[](https://crates.io/crates/autonomi)\n[](https://docs.rs/autonomi)\n\nConnect to and build on the Autonomi network.\n\n## Usage\n\nAdd the autonomi crate to your `Cargo.toml`:\n\n```toml\n[dependencies]\nautonomi = { path = \"../autonomi\", version = \"0.1.0\" }\n```\n\n## Running tests\n\n### Using a local EVM testnet\n\n1. If you haven't, install Foundry, to be able to run Anvil\n nodes: https://book.getfoundry.sh/getting-started/installation\n2. Run a local EVM node:\n\n```sh\ncargo run --bin evm_testnet\n```\n\n3. Run a local network with the `local` feature and use the local evm node.\n\n```sh\ncargo run --bin=safenode-manager --features=local -- local run --build --clean --rewards-address <ETHEREUM_ADDRESS> evm-local\n```\n\n4. Then run the tests with the `local` feature and pass the EVM params again:\n\n```sh\nEVM_NETWORK=local cargo test --package=autonomi --features=local\n# Or with logs\nRUST_LOG=autonomi EVM_NETWORK=local cargo test --package=autonomi --features=local -- --nocapture\n```\n\n### Using a live testnet or mainnet\n\nUsing the hardcoded `Arbitrum One` option as an example, but you can also use the command flags of the steps above and\npoint it to a live network.\n\n1. Run a local network with the `local` feature:\n\n```sh\ncargo run --bin=safenode-manager --features=local -- local run --build --clean --rewards-address <ETHEREUM_ADDRESS> evm-arbitrum-one\n```\n\n2. Then run the tests with the `local` feature. Make sure that the wallet of the private key you pass has enough gas and\n payment tokens on the network (in this case Arbitrum One):\n\n```sh\nEVM_NETWORK=arbitrum-one EVM_PRIVATE_KEY=<PRIVATE_KEY> cargo test --package=autonomi --features=local\n# Or with logs\nRUST_LOG=autonomi EVM_NETWORK=arbitrum-one EVM_PRIVATE_KEY=<PRIVATE_KEY> cargo test --package=autonomi --features=local -- --nocapture\n```\n\n### WebAssembly\n\nTo run a WASM test\n\n- Install `wasm-pack`\n- Make sure your Rust supports the `wasm32-unknown-unknown` target. (If you\n have `rustup`: `rustup target add wasm32-unknown-unknown`.)\n- Pass a bootstrap peer via `SAFE_PEERS`. This *has* to be the websocket address,\n e.g. `/ip4/<ip>/tcp/<port>/ws/p2p/<peer ID>`.\n - As well as the other environment variables needed for EVM payments (e.g. `RPC_URL`).\n- Optionally specify the specific test, e.g. `-- put` to run `put()` in `wasm.rs` only.\n\nExample:\n\n```sh\nSAFE_PEERS=/ip4/<ip>/tcp/<port>/ws/p2p/<peer ID> wasm-pack test --release --firefox autonomi --features=data,files --test wasm -- put\n```\n\n#### Test from JS in the browser\n\n`wasm-pack test` does not execute JavaScript, but runs mostly WebAssembly. Again make sure the environment variables are\nset and build the JS package:\n\n```sh\nwasm-pack build --dev --target=web autonomi --features=vault\n```\n\nThen cd into `autonomi/tests-js`, and use `npm` to install and serve the test html file.\n\n```\ncd autonomi/tests-js\nnpm install\nnpm run serve\n```\n\nThen go to `http://127.0.0.1:8080/tests-js` in the browser. Here, enter a `ws` multiaddr of a local node and press '\nrun'.\n\n#### MetaMask example\n\nThere is a MetaMask example for doing a simple put operation.\n\nBuild the package with the `external-signer` feature (and again with the env variables) and run a webserver, e.g. with\nPython:\n\n```sh\nwasm-pack build --dev --target=web autonomi --features=external-signer\npython -m http.server --directory=autonomi 8000\n```\n\nThen visit `http://127.0.0.1:8000/examples/metamask` in your (modern) browser.\n\nHere, enter a `ws` multiaddr of a local node and press 'run'.\n\n## Faucet (local)\n\nThere is no faucet server, but instead you can use the `Deployer wallet private key` printed in the EVM node output to\ninitialise a wallet from with almost infinite gas and payment tokens. Example:\n\n```rust\nlet rpc_url = \"http://localhost:54370/\";\nlet payment_token_address = \"0x5FbDB2315678afecb367f032d93F642f64180aa3\";\nlet data_payments_address = \"0x8464135c8F25Da09e49BC8782676a84730C318bC\";\nlet private_key = \"0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80\";\n\nlet network = Network::Custom(CustomNetwork::new(\nrpc_url,\npayment_token_address,\ndata_payments_address,\n));\n\nlet deployer_wallet = Wallet::new_from_private_key(network, private_key).unwrap();\nlet receiving_wallet = Wallet::new_with_random_wallet(network);\n\n// Send 10 payment tokens (atto)\nlet _ = deployer_wallet\n.transfer_tokens(receiving_wallet.address(), Amount::from(10))\n.await;\n```\n\nAlternatively, you can provide the wallet address that should own all the gas and payment tokens to the EVM testnet\nstartup command using the `--genesis-wallet` flag:\n\n```sh\ncargo run --bin evm_testnet -- --genesis-wallet <ETHEREUM_ADDRESS>\n```\n\n```shell\n*************************\n* Ethereum node started *\n*************************\nRPC URL: http://localhost:60093/\nPayment token address: 0x5FbDB2315678afecb367f032d93F642f64180aa3\nChunk payments address: 0x8464135c8F25Da09e49BC8782676a84730C318bC\nDeployer wallet private key: 0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80\nGenesis wallet balance: (tokens: 20000000000000000000000000, gas: 9998998011366954730202)\n```\n\n## Python Bindings\n\nThe Autonomi client library provides Python bindings for easy integration with Python applications.\n\n### Installation\n\n```bash\npip install autonomi-client\n```\n\n### Quick Start\n\n```python\nfrom autonomi_client import Client, Wallet, PaymentOption\n\n# Initialize wallet with private key\nwallet = Wallet(\"your_private_key_here\")\nprint(f\"Wallet address: {wallet.address()}\")\nprint(f\"Balance: {wallet.balance()}\")\n\n# Connect to network\nclient = Client.connect([\"/ip4/127.0.0.1/tcp/12000\"])\n\n# Create payment option\npayment = PaymentOption.wallet(wallet)\n\n# Upload data\ndata = b\"Hello, Safe Network!\"\naddr = client.data_put(data, payment)\nprint(f\"Data uploaded to: {addr}\")\n\n# Download data\nretrieved = client.data_get(addr)\nprint(f\"Retrieved: {retrieved.decode()}\")\n```\n\n### Available Modules\n\n#### Core Components\n\n- `Client`: Main interface to the Autonomi network\n - `connect(peers: List[str])`: Connect to network nodes\n - `data_put(data: bytes, payment: PaymentOption)`: Upload data\n - `data_get(addr: str)`: Download data\n - `private_data_put(data: bytes, payment: PaymentOption)`: Store private data\n - `private_data_get(access: PrivateDataAccess)`: Retrieve private data\n - `register_generate_key()`: Generate register key\n\n- `Wallet`: Ethereum wallet management\n - `new(private_key: str)`: Create wallet from private key\n - `address()`: Get wallet address\n - `balance()`: Get current balance\n\n- `PaymentOption`: Payment configuration\n - `wallet(wallet: Wallet)`: Create payment option from wallet\n\n#### Private Data\n\n- `PrivateDataAccess`: Handle private data storage\n - `from_hex(hex: str)`: Create from hex string\n - `to_hex()`: Convert to hex string\n - `address()`: Get short reference address\n\n```python\n# Private data example\naccess = client.private_data_put(secret_data, payment)\nprint(f\"Private data stored at: {access.to_hex()}\")\nretrieved = client.private_data_get(access)\n```\n\n#### Registers\n\n- Register operations for mutable data\n - `register_create(value: bytes, name: str, key: RegisterSecretKey, wallet: Wallet)`\n - `register_get(address: str)`\n - `register_update(register: Register, value: bytes, key: RegisterSecretKey)`\n\n```python\n# Register example\nkey = client.register_generate_key()\nregister = client.register_create(b\"Initial value\", \"my_register\", key, wallet)\nclient.register_update(register, b\"New value\", key)\n```\n\n#### Vaults\n\n- `VaultSecretKey`: Manage vault access\n - `new()`: Generate new key\n - `from_hex(hex: str)`: Create from hex string\n - `to_hex()`: Convert to hex string\n\n- `UserData`: User data management\n - `new()`: Create new user data\n - `add_file_archive(archive: str)`: Add file archive\n - `add_private_file_archive(archive: str)`: Add private archive\n - `file_archives()`: List archives\n - `private_file_archives()`: List private archives\n\n```python\n# Vault example\nvault_key = VaultSecretKey.new()\ncost = client.vault_cost(vault_key)\nclient.write_bytes_to_vault(data, payment, vault_key, content_type=1)\ndata, content_type = client.fetch_and_decrypt_vault(vault_key)\n```\n\n#### Utility Functions\n\n- `encrypt(data: bytes)`: Self-encrypt data\n- `hash_to_short_string(input: str)`: Generate short reference\n\n### Complete Examples\n\n#### Data Management\n\n```python\ndef handle_data_operations(client, payment):\n # Upload text\n text_data = b\"Hello, Safe Network!\"\n text_addr = client.data_put(text_data, payment)\n \n # Upload binary data\n with open(\"image.jpg\", \"rb\") as f:\n image_data = f.read()\n image_addr = client.data_put(image_data, payment)\n \n # Download and verify\n downloaded = client.data_get(text_addr)\n assert downloaded == text_data\n```\n\n#### Private Data and Encryption\n\n```python\ndef handle_private_data(client, payment):\n # Create and encrypt private data\n secret = {\"api_key\": \"secret_key\"}\n data = json.dumps(secret).encode()\n \n # Store privately\n access = client.private_data_put(data, payment)\n print(f\"Access token: {access.to_hex()}\")\n \n # Retrieve\n retrieved = client.private_data_get(access)\n secret = json.loads(retrieved.decode())\n```\n\n#### Vault Management\n\n```python\ndef handle_vault(client, payment):\n # Create vault\n vault_key = VaultSecretKey.new()\n \n # Store user data\n user_data = UserData()\n user_data.add_file_archive(\"archive_address\")\n \n # Save to vault\n cost = client.put_user_data_to_vault(vault_key, payment, user_data)\n \n # Retrieve\n retrieved = client.get_user_data_from_vault(vault_key)\n archives = retrieved.file_archives()\n```\n\n### Error Handling\n\nAll operations can raise exceptions. It's recommended to use try-except blocks:\n\n```python\ntry:\n client = Client.connect(peers)\n # ... operations ...\nexcept Exception as e:\n print(f\"Error: {e}\")\n```\n\n### Best Practices\n\n1. Always keep private keys secure\n2. Use error handling for all network operations\n3. Clean up resources when done\n4. Monitor wallet balance for payments\n5. Use appropriate content types for vault storage\n\nFor more examples, see the `examples/` directory in the repository.\n\n",
"bugtrack_url": null,
"license": "GPL-3.0",
"summary": "Autonomi client API",
"version": "0.2.32",
"project_urls": {
"Homepage": "https://maidsafe.net",
"Source Code": "https://github.com/maidsafe/safe_network"
},
"split_keywords": [
"safe",
" network",
" autonomi"
],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "2c192c9aba09d7e660703b6109b251d25f50822fafc3e85810932c183b2857dc",
"md5": "035ec37a69a2c96c553b94f42f4a1743",
"sha256": "a551383822166318515f12be1e04798027dce08c7980da2483c30c7df6b62dbe"
},
"downloads": -1,
"filename": "autonomi_client-0.2.32-cp38-abi3-macosx_10_12_x86_64.whl",
"has_sig": false,
"md5_digest": "035ec37a69a2c96c553b94f42f4a1743",
"packagetype": "bdist_wheel",
"python_version": "cp38",
"requires_python": ">=3.8",
"size": 7190900,
"upload_time": "2024-11-11T11:18:01",
"upload_time_iso_8601": "2024-11-11T11:18:01.952438Z",
"url": "https://files.pythonhosted.org/packages/2c/19/2c9aba09d7e660703b6109b251d25f50822fafc3e85810932c183b2857dc/autonomi_client-0.2.32-cp38-abi3-macosx_10_12_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "a74922d7a56fa169f2329100347653a2c295397032089f88a9d00930dd84fc2d",
"md5": "f3276d501e82dea9426f2c47ded524ce",
"sha256": "4d4c7fccb6a40845c77e33abfdd9299b0bf45457eae3cd925cea206ca7144c29"
},
"downloads": -1,
"filename": "autonomi_client-0.2.32-cp38-abi3-macosx_11_0_arm64.whl",
"has_sig": false,
"md5_digest": "f3276d501e82dea9426f2c47ded524ce",
"packagetype": "bdist_wheel",
"python_version": "cp38",
"requires_python": ">=3.8",
"size": 6968914,
"upload_time": "2024-11-11T11:18:04",
"upload_time_iso_8601": "2024-11-11T11:18:04.677444Z",
"url": "https://files.pythonhosted.org/packages/a7/49/22d7a56fa169f2329100347653a2c295397032089f88a9d00930dd84fc2d/autonomi_client-0.2.32-cp38-abi3-macosx_11_0_arm64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "e436dde3b9d090dd50b598beb236124990764638c6e140e6ef1d3f2fe68ad8af",
"md5": "2aee7234d15f1774dcd965d88845c149",
"sha256": "220398dc0cf082c7e96f6bd687b3db9d5420efc7434ebb2d10a128e318132494"
},
"downloads": -1,
"filename": "autonomi_client-0.2.32-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"has_sig": false,
"md5_digest": "2aee7234d15f1774dcd965d88845c149",
"packagetype": "bdist_wheel",
"python_version": "cp38",
"requires_python": ">=3.8",
"size": 67774877,
"upload_time": "2024-11-11T11:18:08",
"upload_time_iso_8601": "2024-11-11T11:18:08.111235Z",
"url": "https://files.pythonhosted.org/packages/e4/36/dde3b9d090dd50b598beb236124990764638c6e140e6ef1d3f2fe68ad8af/autonomi_client-0.2.32-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "e0cbc4a0a73dcab3a3e7604c81cc3cdc492eb52e948c7ec7bfada5050aa47e44",
"md5": "302eca20ee48c7e1a9112f722c046bc2",
"sha256": "0cb97b60ce97b3267f03df18523c122675b1f9c07bc7b4b4945e56ba09770895"
},
"downloads": -1,
"filename": "autonomi_client-0.2.32-cp38-abi3-win_amd64.whl",
"has_sig": false,
"md5_digest": "302eca20ee48c7e1a9112f722c046bc2",
"packagetype": "bdist_wheel",
"python_version": "cp38",
"requires_python": ">=3.8",
"size": 6231786,
"upload_time": "2024-11-11T11:18:11",
"upload_time_iso_8601": "2024-11-11T11:18:11.975811Z",
"url": "https://files.pythonhosted.org/packages/e0/cb/c4a0a73dcab3a3e7604c81cc3cdc492eb52e948c7ec7bfada5050aa47e44/autonomi_client-0.2.32-cp38-abi3-win_amd64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "4de595c874572442e945f511a2765e12df7aee83e0be54fad254cd05b2042520",
"md5": "84885eaac3ec7ddf1a2ce38162d40a95",
"sha256": "bc73767ece1395e7a7530eec6c601f5d17b8cb00f2c8a318a388a8039f89158f"
},
"downloads": -1,
"filename": "autonomi_client-0.2.32.tar.gz",
"has_sig": false,
"md5_digest": "84885eaac3ec7ddf1a2ce38162d40a95",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.8",
"size": 411720,
"upload_time": "2024-11-11T11:18:14",
"upload_time_iso_8601": "2024-11-11T11:18:14.521817Z",
"url": "https://files.pythonhosted.org/packages/4d/e5/95c874572442e945f511a2765e12df7aee83e0be54fad254cd05b2042520/autonomi_client-0.2.32.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2024-11-11 11:18:14",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "maidsafe",
"github_project": "safe_network",
"travis_ci": false,
"coveralls": false,
"github_actions": true,
"lcname": "autonomi-client"
}
JSON
