diff --git a/.github/workflows/sphinx-docs.yml b/.github/workflows/sphinx-docs.yml new file mode 100644 index 0000000..6267ffa --- /dev/null +++ b/.github/workflows/sphinx-docs.yml @@ -0,0 +1,38 @@ +name: Build and Deploy Sphinx Documentation + +on: + push: + branches: + - docs # Trigger workflow on push to the docs branch + +jobs: + build: + name: Build Sphinx Documentation + runs-on: ubuntu-latest + + steps: + - name: Checkout Repository + uses: actions/checkout@v4 + + - name: Set up Python + uses: actions/setup-python@v5 + with: + python-version: '3.11' # Adjust the version to match your project + + - name: Install Poetry + uses: abatilo/actions-poetry@v2 + with: + poetry-version: "1.8.4" # Use the desired Poetry version + + - name: Install Dependencies + run: | + poetry install --no-root + + - name: Build HTML + run: | + cd docs/ + poetry run make html + + - name: Run ghp-import + run: | + poetry run ghp-import -n -p -f docs/_build/html \ No newline at end of file diff --git a/atom/base/miner.py b/atom/base/miner.py index cba63b2..d40e7ef 100644 --- a/atom/base/miner.py +++ b/atom/base/miner.py @@ -18,14 +18,29 @@ class BaseMinerNeuron(BaseNeuron): """ Base class for Bittensor miners. + + This class provides the fundamental structure and functionality for miners in the Bittensor network. + It handles network registration, request processing, and network synchronization. """ @classmethod def add_args(cls, parser: argparse.ArgumentParser): + """ + Adds miner-specific arguments to the command line parser. + + Args: + parser (argparse.ArgumentParser): The argument parser to add arguments to. + """ super().add_args(parser) add_miner_args(cls, parser) def __init__(self, config=None): + """ + Initializes the BaseMinerNeuron. + + Args: + config: Configuration object containing miner settings. Defaults to None. + """ super().__init__(config=config) # Warn if allowing incoming requests from anyone. @@ -62,6 +77,7 @@ def run(self): Initiates and manages the main loop for the miner on the Bittensor network. The main loop handles graceful shutdown on keyboard interrupts and logs unforeseen errors. This function performs the following primary tasks: + 1. Check for registration on the Bittensor network. 2. Starts the miner's axon, making it active on the network. 3. Periodically resynchronizes with the chain; updating the metagraph with the latest network state and setting weights. @@ -86,14 +102,17 @@ def run(self): # Serve passes the axon information to the network + netuid we are hosting on. # This will auto-update if the axon port of external ip have changed. bt.logging.info( - f"Serving miner axon {self.axon} on network: {self.config.subtensor.chain_endpoint} with netuid: {self.config.netuid}" + "Serving miner axon %s on network: %s with netuid: %s", + self.axon, + self.config.subtensor.chain_endpoint, + self.config.netuid ) self.axon.serve(netuid=self.config.netuid, subtensor=self.subtensor) # Start starts the miner's axon, making it active on the network. self.axon.start() - bt.logging.info(f"Miner starting at block: {self.block}") + bt.logging.info("Miner starting at block: %s", self.block) # This loop maintains the miner's operations until intentionally stopped. try: @@ -109,12 +128,15 @@ def run(self): # In case of unforeseen errors, the miner will log the error and continue operations. except Exception as e: - bt.logging.error(traceback.format_exc()) + bt.logging.error("Error: %s\n%s", str(e), traceback.format_exc()) def __enter__(self): """ Starts the miner's operations in a background thread upon entering the context. This method facilitates the use of the miner in a 'with' statement. + + Returns: + BaseMinerNeuron: The instance of the miner. """ self.run_in_background_thread() return self @@ -126,46 +148,59 @@ def __exit__(self, exc_type, exc_value, traceback): Args: exc_type: The type of the exception that caused the context to be exited. - None if the context was exited without an exception. + None if the context was exited without an exception. exc_value: The instance of the exception that caused the context to be exited. - None if the context was exited without an exception. + None if the context was exited without an exception. traceback: A traceback object encoding the stack trace. - None if the context was exited without an exception. + None if the context was exited without an exception. """ self.stop_run_thread() def resync_metagraph(self): - """Resyncs the metagraph and updates the hotkeys and moving averages based on the new metagraph.""" + """ + Resyncs the metagraph and updates network state. + + Updates the local copy of the network's metagraph, including hotkeys and moving averages, + by synchronizing with the latest state of the Bittensor network. + """ bt.logging.info("resync_metagraph()") # Sync the metagraph. self.metagraph.sync(subtensor=self.subtensor) def set_weights(self): + """ + Empty implementation as miners do not set weights on the network. + + This method is inherited from BaseNeuron but is intentionally left empty as + miners are not responsible for setting weights - this is a validator function. + """ pass @abstractmethod def blacklist(self, synapse: bt.Synapse) -> Tuple[bool, str]: """ - Blacklist function for miner handles. + Determines whether to blacklist an incoming request. Args: - synapse: The synapse to handle. + synapse (bt.Synapse): The synapse object containing the request details. Returns: - bool: Whether to blacklist the synapse or not. + Tuple[bool, str]: A tuple containing: + - bool: Whether to blacklist the request (True) or not (False) + - str: A message explaining the blacklist decision """ ... @abstractmethod def priority(self, synapse: bt.Synapse) -> float: """ - Priority function for miner handles. + Determines the priority level of an incoming request. Args: - synapse: The synapse to handle. + synapse (bt.Synapse): The synapse object containing the request details. Returns: - float: The priority of the synapse. + float: The priority value assigned to the request. Higher values indicate higher priority. """ ... diff --git a/atom/base/neuron.py b/atom/base/neuron.py index 51514c9..dd5d283 100644 --- a/atom/base/neuron.py +++ b/atom/base/neuron.py @@ -8,29 +8,55 @@ import bittensor as bt from atom.base.ttl import ttl_get_block -from atom.base.config import check_config, add_args, config +from atom.base.config import check_config, add_args +from atom.base.config import config as bittensor_config from atom.mock.mock import MockSubtensor, MockMetagraph, create_wallet class BaseNeuron(ABC): """ - Base class for Bittensor miners. This class is abstract and should be inherited by a subclass. It contains the core logic for all neurons; validators and miners. + Base class for Bittensor miners and validators. - In addition to creating a wallet, subtensor, and metagraph, this class also handles the synchronization of the network state via a basic checkpointing mechanism based on epoch length. + This class provides the core functionality for all neurons in the Bittensor network. + It handles wallet management, network synchronization, and state management through + a basic checkpointing mechanism based on epoch length. + + Attributes: + subtensor (bt.subtensor): Interface to the Bittensor blockchain + wallet (bt.wallet): Wallet containing cryptographic keys + metagraph (bt.metagraph): Network state information """ @classmethod def check_config(cls, config: "bt.Config"): + """ + Validates the configuration for the neuron. + + Args: + config (bt.Config): Configuration object to validate + """ check_config(cls, config) @classmethod def add_args(cls, parser): + """ + Adds neuron-specific arguments to the command line parser. + + Args: + parser: The argument parser to add arguments to + """ add_args(cls, parser) @classmethod - def config(cls): - return config(cls) + def get_config(cls): + """ + Returns the default configuration for the neuron. + + Returns: + bt.Config: Default configuration object + """ + return bittensor_config(cls) subtensor: "bt.subtensor" wallet: "bt.wallet" @@ -39,15 +65,27 @@ def config(cls): @property @abstractmethod def spec_version(self): + """ + Abstract property for the neuron's specification version. + + Returns: + Version information for the neuron implementation + """ ... @property def block(self): + """ + Gets the current block number from the Bittensor network. + + Returns: + int: Current block number + """ return ttl_get_block(self) def __init__(self, config=None): - base_config = copy.deepcopy(config or BaseNeuron.config()) - self.config = self.config() + base_config = copy.deepcopy(config or BaseNeuron.get_config()) + self.config = self.get_config() self.config.merge(base_config) self.check_config(self.config) @@ -99,7 +137,13 @@ def run(self): def sync(self): """ - Wrapper for synchronizing the state of the network for the given miner or validator. + Synchronizes the neuron's state with the network. + + Performs the following tasks: + 1. Verifies registration status + 2. Syncs metagraph if necessary + 3. Sets weights if conditions are met + 4. Saves current state """ # Ensure miner or validator hotkey is still registered on the network. self.check_registered() @@ -114,6 +158,12 @@ def sync(self): self.save_state() def check_registered(self): + """ + Verifies that the neuron's hotkey is registered on the network. + + Raises: + SystemExit: If the hotkey is not registered on the specified subnet + """ # --- Check for registration. if self.config.mock: return @@ -130,13 +180,22 @@ def check_registered(self): def should_sync_metagraph(self): """ - Check if enough epoch blocks have elapsed since the last checkpoint to sync. + Determines if the metagraph should be synchronized. + + Returns: + bool: True if enough blocks have elapsed since last sync, False otherwise """ return ( self.block - self.metagraph.last_update[self.uid] ) > self.config.neuron.metagraph_resync_length def should_set_weights(self) -> bool: + """ + Determines if the neuron should set weights on the network. + + Returns: + bool: True if weights should be set, False otherwise + """ # Don't set weights on initialization. if self.step == 0: return False @@ -156,8 +215,9 @@ def should_set_weights(self) -> bool: def run_in_background_thread(self): """ - Starts the operations in a separate background thread. - This is useful for non-blocking operations. + Starts the neuron's operations in a background thread. + + The thread runs as a daemon, allowing the program to exit when the main thread ends. """ if not self.is_running: bt.logging.debug("Starting in background thread.") @@ -169,7 +229,9 @@ def run_in_background_thread(self): def stop_run_thread(self): """ - Stops the operations that are running in the background thread. + Stops the neuron's background operations. + + Attempts to gracefully stop the background thread with a 5-second timeout. """ if self.is_running: bt.logging.debug("Stopping in background thread.") @@ -179,22 +241,67 @@ def stop_run_thread(self): bt.logging.debug("Stopped") def __enter__(self): - # should call self.run_in_background_thread() or self.run() here + """ + Context manager entry point. + + Raises: + NotImplementedError: Must be implemented by subclasses + """ raise NotImplementedError async def __aenter__(self): + """ + Asynchronous context manager entry point. + + Raises: + NotImplementedError: Must be implemented by subclasses + """ raise NotImplementedError def __exit__(self, exc_type, exc_value, traceback): + """ + Context manager exit point. + + Args: + exc_type: Type of the exception that caused the context to be exited + exc_value: Instance of the exception that caused the context to be exited + traceback: Traceback if an exception occurred + + Raises: + NotImplementedError: Must be implemented by subclasses + """ raise NotImplementedError async def __aexit__(self, exc_type, exc_value, traceback): + """ + Asynchronous context manager exit point. + + Args: + exc_type: Type of the exception that caused the context to be exited + exc_value: Instance of the exception that caused the context to be exited + traceback: Traceback if an exception occurred + + Raises: + NotImplementedError: Must be implemented by subclasses + """ raise NotImplementedError def save_state(self): + """ + Saves the current state of the neuron. + + This is an empty implementation that can be overridden by subclasses + to save model checkpoints or other state information. + """ pass def load_state(self): + """ + Loads the previously saved state of the neuron. + + This is a placeholder implementation that logs a warning. Subclasses + should override this method to load their specific state information. + """ bt.logging.warning( "load_state() not implemented for this neuron. You can implement this function to load model checkpoints or other useful data." ) diff --git a/atom/base/validator.py b/atom/base/validator.py index 50fabd6..fc3728d 100644 --- a/atom/base/validator.py +++ b/atom/base/validator.py @@ -17,15 +17,39 @@ class BaseValidatorNeuron(BaseNeuron): """ - Base class for Bittensor validators. Your validator should inherit from this class. + Base class for Bittensor validators. + + This class provides the fundamental structure and functionality for validators in the Bittensor network. + It handles network synchronization, weight setting, and score management for miners in the network. + + Attributes: + hotkeys (List[str]): Copy of metagraph hotkeys for local reference + dendrite (bt.dendrite): Interface for sending messages to other nodes + scores (torch.FloatTensor): Scoring weights for validation + should_exit (bool): Flag indicating if validator should stop + is_running (bool): Flag indicating if validator is currently running + thread (threading.Thread): Background thread for validator operations + lock (asyncio.Lock): Lock for thread-safe operations """ @classmethod def add_args(cls, parser: argparse.ArgumentParser): + """ + Adds validator-specific arguments to the command line parser. + + Args: + parser (argparse.ArgumentParser): The argument parser to add arguments to. + """ super().add_args(parser) add_validator_args(cls, parser) def __init__(self, config=None): + """ + Initializes the BaseValidatorNeuron. + + Args: + config: Configuration object containing validator settings. Defaults to None. + """ super().__init__(config=config) # Save a copy of the hotkeys to local memory. @@ -64,10 +88,14 @@ def __init__(self, config=None): self.lock = asyncio.Lock() async def async_updater(self): - """Intended to be run as an async entrypoint for the validator to: - 1. Sync the metagraph. - 2. Set the weights. - 3. Save the state of the validator. + """ + Asynchronous update loop for the validator. + + This method runs continuously in the background, performing the following tasks: + 1. Synchronizes the metagraph with the network + 2. Sets validator weights + 3. Saves the validator state + 4. Waits for the configured epoch length before the next update """ bt.logging.info("starting the sync_loop") while True: @@ -76,13 +104,24 @@ async def async_updater(self): await asyncio.sleep(self.config.neuron.epoch_length * SECONDS_PER_BLOCK) def serve_axon(self): - """Serve axon to enable external connections""" + """ + Serves the validator's axon to enable external connections. + + Attempts to start the axon service on the specified network UID. + Logs an error if the axon fails to start. + """ try: self.axon.serve(netuid=self.config.netuid, subtensor=self.subtensor).start() except Exception as e: bt.logging.error(f"Failed to serve axon: {e}") def run(self): + """ + Starts the validator's operations. + + Returns: + BaseValidatorNeuron: The validator instance. + """ return self def __enter__(self): @@ -91,8 +130,12 @@ def __enter__(self): async def __aenter__(self): """ - Entry point for the validator to start running in the background. - Indended to be overwritten by the user, as this is an example. + Asynchronous context manager entry point. + + Creates and starts the background update task for the validator. + + Returns: + BaseValidatorNeuron: The validator instance. """ bt.logging.debug("Starting validator in background thread.") self.loop.create_task(self.async_updater()) @@ -102,15 +145,11 @@ async def __aenter__(self): def __exit__(self, exc_type, exc_value, traceback): """ Stops the validator's background operations upon exiting the context. - This method facilitates the use of the validator in a 'with' statement. Args: exc_type: The type of the exception that caused the context to be exited. - None if the context was exited without an exception. exc_value: The instance of the exception that caused the context to be exited. - None if the context was exited without an exception. traceback: A traceback object encoding the stack trace. - None if the context was exited without an exception. """ if self.is_running: bt.logging.debug("Stopping validator in background thread.") @@ -120,7 +159,16 @@ def __exit__(self, exc_type, exc_value, traceback): bt.logging.debug("Stopped") def resync_metagraph(self): - """Resyncs the metagraph and updates the hotkeys and moving averages based on the new metagraph.""" + """ + Resyncs the metagraph and updates the hotkeys and scores. + + This method: + 1. Creates a copy of the current metagraph state + 2. Syncs with the network to get the latest state + 3. Updates scores for any replaced hotkeys + 4. Adjusts the size of scoring tensors if the network has grown + 5. Updates the local hotkey cache + """ bt.logging.info("resync_metagraph()") # Copies state of metagraph before syncing. @@ -154,7 +202,14 @@ def resync_metagraph(self): self.hotkeys = copy.deepcopy(self.metagraph.hotkeys) def save_state(self): - """Saves the state of the validator to a file.""" + """ + Saves the validator's state to a file. + + Saves the following information: + - Current step + - Validation scores + - Hotkey list + """ bt.logging.info("Saving validator state.") # Save the state of the validator to file. @@ -168,7 +223,16 @@ def save_state(self): ) def load_state(self): - """Loads the state of the validator from a file.""" + """ + Loads the validator's state from a file. + + Attempts to load: + - Step count + - Validation scores + - Hotkey list + + If no state file exists, starts with fresh state. + """ try: state = torch.load(self.config.neuron.full_path + "/state.pt") self.step = state["step"] @@ -182,12 +246,25 @@ def load_state(self): @abstractmethod def set_weights(self): - """Sets the validator weights to the metagraph hotkeys based on the scores it has received from the miners. - The weights determine the trust and incentive level the validator assigns to miner nodes on the network. + """ + Sets the validator weights for the network. + + This abstract method must be implemented by subclasses to define how + the validator assigns trust and incentive weights to miners based on + their performance scores. """ raise NotImplementedError @abstractmethod def update_scores(self, rewards: torch.FloatTensor, uids: List[int]): - """Performs exponential moving average on the scores based on the rewards received from the miners.""" + """ + Updates the scores for miners using exponential moving average. + + Args: + rewards (torch.FloatTensor): The rewards tensor for miners + uids (List[int]): List of miner UIDs corresponding to the rewards + + This abstract method must be implemented by subclasses to define how + the validator updates its scoring mechanism based on miner performance. + """ raise NotImplementedError diff --git a/atom/chain/chain.py b/atom/chain/chain.py index 3f0256d..aab7a9e 100644 --- a/atom/chain/chain.py +++ b/atom/chain/chain.py @@ -1,22 +1,42 @@ -import functools -from typing import Optional +"""Chain module for interacting with the Bittensor blockchain. -from atom.chain.generic import run_in_subprocess +This module provides functionality for storing and retrieving information on the Bittensor +blockchain through the ChainStore class. It handles both reading and writing operations +with appropriate subprocess management and timeout controls. +""" +import functools +from typing import Optional import bittensor as bt from bittensor.extrinsics.serving import publish_metadata +from atom.chain.generic import run_in_subprocess class ChainStore: - """Chain based implementation for storing and retrieving information on chain.""" + """Chain based implementation for storing and retrieving information on chain. + + This class provides methods to read from and write to the Bittensor blockchain, + handling all necessary subprocess management and timeout controls. + + Args: + netuid (int): The network UID to interact with + chain (str, optional): The chain to connect to. Defaults to "finney" + wallet (bt.wallet, optional): The wallet used for chain operations. Required for writing. Defaults to None + """ def __init__( self, netuid: int, chain: str = "finney", - # Wallet is only needed to write to the chain, not to read. wallet: Optional[bt.wallet] = None, ): + """Initialize the ChainStore instance. + + Args: + netuid (int): The network UID to interact with + chain (str, optional): The chain to connect to. Defaults to "finney" + wallet (bt.wallet, optional): The wallet used for chain operations. Required for writing. Defaults to None + """ if wallet is None: bt.logging.warning( "No wallet provided. You will not be able to write to the chain." @@ -32,7 +52,16 @@ async def write( wait_for_inclusion: bool = True, wait_for_finalization: bool = True, ): - """write to the subnet chain for a specific wallet.""" + """Write data to the subnet chain for a specific wallet. + + Args: + data (str): The data to write to the chain + wait_for_inclusion (bool, optional): Whether to wait for the transaction to be included. Defaults to True + wait_for_finalization (bool, optional): Whether to wait for the transaction to be finalized. Defaults to True + + Raises: + ValueError: If no wallet is available or if no data is provided + """ if self.wallet is None: raise ValueError("No wallet available to write to the chain.") if not data: @@ -54,7 +83,14 @@ async def write( run_in_subprocess(partial, 60) async def read(self, hotkey: str) -> str: - """Reads the most recent data from the chain from the specified hotkey.""" + """Read the most recent data from the chain for the specified hotkey. + + Args: + hotkey (str): The hotkey to read data from + + Returns: + str: The decoded data from the chain, or None if no data is found + """ # Wrap calls to the subtensor in a subprocess with a timeout to handle potential hangs. partial = functools.partial( diff --git a/atom/chain/chain_utils.py b/atom/chain/chain_utils.py index d8b67dd..fd5eb2d 100644 --- a/atom/chain/chain_utils.py +++ b/atom/chain/chain_utils.py @@ -1,7 +1,20 @@ +"""Various utility functions to be used for chain-related tasks.""" + + import json +from typing import Union + +def json_reader(filepath: str, encoding: str = "utf-8") -> Union[dict, list]: + """Reads and parses a JSON file into a Python object. + Args: + filepath (str): Path to the JSON file to be read + encoding (str, optional): Character encoding to use when reading the file. Defaults to "utf-8" -def json_reader(filepath: str): - with open(filepath, "r") as file: + Returns: + Union[dict, list]: The parsed JSON content as a Python object - either a dictionary or list + depending on the JSON structure + """ + with open(filepath, "r", encoding=encoding) as file: content = json.load(file) return content diff --git a/atom/epistula/epistula.py b/atom/epistula/epistula.py index c492a7b..993b743 100644 --- a/atom/epistula/epistula.py +++ b/atom/epistula/epistula.py @@ -9,23 +9,46 @@ from .__init__ import EPISTULA_VERSION from pydantic import BaseModel, Field, ValidationError +"""Cryptographic signature management module for secure message handling. + +This module provides a robust framework for generating and verifying cryptographic +signatures for messages in a distributed system. It implements time-based validation, +UUID tracking, and optional recipient-specific signing. + +Key Features: + - Message signature generation and verification + - Time-based signature validation with configurable time windows + - Support for recipient-specific message signing + - Comprehensive input validation using Pydantic + - JSON message body handling +""" + class VerifySignatureRequest(BaseModel): + """Validation model for signature verification requests. + + This Pydantic model enforces strict typing and format validation for all + parameters required in the signature verification process. + + Attributes: + body (bytes): The raw message body to verify + timestamp (int): Unix timestamp in milliseconds when the message was signed + signature (str): Hex-encoded signature with '0x' prefix, must be 64 characters + uuid (str): Unique identifier for the message, must be valid UUID format + signed_by (str): The SS58 address of the signing keypair + signed_for (Optional[str]): The intended recipient's address, if any + now (Optional[int]): Current timestamp for testing purposes """ - Pydantic model for the verify_signature input parameters. - """ - body: bytes # Directly use bytes - timestamp: int - signature: Annotated[str, Field(pattern=r"^0x[a-fA-F0-9]{64}$")] # Ensures signature format - uuid: Annotated[str, Field(min_length=36, max_length=36)] # UUID with constraints - signed_by: str - signed_for: Optional[str] = None - now: Optional[int] = None - class Epistula: - """ - Manages the generation and verification of cryptographic signatures for messages. - Handles both header generation and signature verification in a unified interface. + """Cryptographic signature manager for secure message handling. + + This class provides a comprehensive interface for generating and verifying + cryptographic signatures in a distributed messaging system. It supports + time-based validation windows and recipient-specific signing. + + Attributes: + ALLOWED_DELTA_MS (int): Maximum allowed time difference in milliseconds + between message timestamp and verification time """ def __init__(self, allowed_delta_ms: Optional[int] = None): @@ -37,16 +60,26 @@ def generate_header( body: bytes, signed_for: Optional[str] = None, ) -> Dict[str, Any]: - """ - Generate headers containing signatures and metadata for a message. + """Generate cryptographic headers for a message. + + Creates a complete set of headers including signatures and metadata + required for message verification. Optionally generates additional + time-based signatures for recipient-specific messages. Args: - hotkey: The keypair used for signing - body: The message body in bytes - signed_for: Receiver's address (optional) + hotkey: The keypair used for signing the message + body: Raw message content in bytes + signed_for: Optional recipient SS58 address for targeted messages Returns: - Dictionary containing all necessary headers + Dictionary containing all required headers: + - Epistula-Version: Protocol version + - Epistula-Timestamp: Message timestamp + - Epistula-Uuid: Unique message identifier + - Epistula-Signed-By: Sender's SS58 address + - Epistula-Request-Signature: Primary message signature + - Epistula-Signed-For: (Optional) Recipient's address + - Epistula-Secret-Signature-[0-2]: (Optional) Time-based signatures """ timestamp = round(time.time() * 1000) timestampInterval = ceil(timestamp / 1e4) * 1e4 @@ -88,20 +121,30 @@ def verify_signature( signed_for: Optional[str] = None, now: Optional[int] = None, ) -> Optional[Annotated[str, "Error Message"]]: - """ - Verify the signature of a message. + """Verify the authenticity of a signed message. + + Performs comprehensive validation including: + - Input format validation + - Timestamp freshness check + - Cryptographic signature verification + - Optional recipient validation Args: - signature: The signature to verify - body: Message body in bytes - timestamp: Message timestamp - uuid: Message UUID - signed_by: Sender's address - signed_for: Receiver's address (optional) - now: Current timestamp (defaults to current time if not provided) in seconds + signature: Hex-encoded signature with '0x' prefix + body: Raw message content in bytes + timestamp: Message timestamp in milliseconds + uuid: Unique message identifier + signed_by: Sender's SS58 address + signed_for: Optional recipient's SS58 address + now: Optional timestamp for testing purposes Returns: - None if verification succeeds, error message string if it fails + None if verification succeeds, or an error message string describing + the reason for validation failure + + Note: + The verification will fail if the message is too old (exceeds ALLOWED_DELTA_MS) + or if any of the cryptographic checks fail """ #Pydantic will enforce the validation typing rules @@ -139,5 +182,15 @@ def verify_signature( @staticmethod def create_message_body(data: Dict) -> bytes: - """Utility method to create message body from dictionary data""" + """Convert a dictionary into a deterministic JSON-encoded byte string. + + Creates a consistent byte representation of dictionary data for signing, + ensuring that the same input always produces the same output bytes. + + Args: + data: Dictionary containing message data + + Returns: + UTF-8 encoded bytes of the sorted JSON string representation + """ return json.dumps(data, default=str, sort_keys=True).encode("utf-8") diff --git a/atom/logging/github.py b/atom/logging/github.py index 2e7e7cd..99dfd8d 100644 --- a/atom/logging/github.py +++ b/atom/logging/github.py @@ -1,3 +1,19 @@ +"""GitHub repository interaction module for version control operations. + +This module provides a robust interface for interacting with GitHub repositories, +handling common operations like cloning, fetching, and managing file content across +different commits. It implements safe cleanup and proper error handling. + +Key Features: + - Repository cloning and cleanup + - Commit-specific content retrieval + - File content management + - Automated branch handling + +Use cases include: +- Dynamic Desirability (SN13) +""" + import os import shutil import subprocess @@ -11,16 +27,35 @@ class BaseHandler(ABC): + """Abstract base class for content handlers. + + Defines the interface for content handling operations with get/put operations. + """ + @abstractmethod def get(self): + """Abstract method to retrieve content.""" pass @abstractmethod def put(self): + """Abstract method to store content.""" pass class GithubHandler(BaseHandler): + """Handles GitHub repository operations for content management. + + Manages repository cloning, content retrieval, and content storage operations + while maintaining proper cleanup of temporary files. + + Attributes: + REPO_URL (str): URL of the GitHub repository + original_dir (str): Original working directory path + repo_name (str): Name of the repository + repo_path (str): Local path where repository is cloned + """ + def __init__(self, repo_url: str): self.REPO_URL = repo_url @@ -29,7 +64,11 @@ def __init__(self, repo_url: str): self.repo_path = os.path.join(self.original_dir, self.repo_name) def clone(self): - """Clones the self.REPO_URL repository into the current directory.""" + """Clone the repository to local directory. + + Clones the repository if it doesn't already exist locally. + Logs the operation and handles potential Git errors. + """ if not os.path.exists(self.repo_path): try: bt.logging.info(f"Cloning repository: {self.REPO_URL}") @@ -38,7 +77,11 @@ def clone(self): bt.logging.error(f"An error occurred during Git operations: {e}") def fetch_all(self): - """Fetch all changes from self.REPO_URL repository.""" + """Fetch all changes from the remote repository. + + Updates the local repository with all remote changes. + Handles potential Git operation errors. + """ try: bt.logging.info("Fetching latest changes") run_command(["git", "fetch", "--all"], cwd=self.repo_path) @@ -48,15 +91,19 @@ def fetch_all(self): return None def get(self, commit_sha: str, filepath: str, reader: Callable = json_reader): - """Get content from a specific commit in the repository. + """Retrieve content from a specific commit. Args: - commit_sha (str): The commit hash to checkout. - filepath (str): The path to the file to read. Usually identified through the hotkey, f"{hotkey}.json" - reader (Callable, optional): Function that reads the datatype specified. Defaults to json_reader. + commit_sha (str): Hash of the target commit + filepath (str): Path to the target file within repository + reader (Callable): Function to read and parse the file content. + Defaults to json_reader Returns: - content: The content of the file in the specified commit. + The file content parsed by the reader function, or None if operation fails + + Note: + Automatically handles repository cleanup after operation """ try: @@ -98,17 +145,28 @@ def put( hotkey: str, branch_name: str = "main", ) -> str: - """Put content into the repository. + """Store content in the repository. + + Handles the entire process of adding content to the repository: + 1. Clones/updates the repository + 2. Creates necessary folders + 3. Writes content to file + 4. Commits and pushes changes + 5. Verifies push success + 6. Cleans up local files Args: - content (str): The content to be written into the file. - folder_name (str): Relative or absolute name of the folder to write the file into. - file_ext (str): The datatype of the saved file. E.g. "json" - hotkey (str): Validator hotkey. - branch_name (str): The branch to commit the changes to. E.g. "main" + content (str): Content to store in the file + folder_name (str): Target folder path in repository + file_ext (str): File extension (e.g., "json") + hotkey (str): Validator hotkey used in commit message + branch_name (str): Target branch name, defaults to "main" Returns: - str: _description_ + str: Remote commit hash after successful push + + Note: + Automatically handles repository cleanup after operation """ self.clone() diff --git a/atom/mock/mock.py b/atom/mock/mock.py index aab24a2..9fc7647 100644 --- a/atom/mock/mock.py +++ b/atom/mock/mock.py @@ -1,15 +1,49 @@ +"""Mock module for Bittensor testing environment. + +This module provides mock implementations of core Bittensor components for testing purposes. +It includes mock versions of wallet, subtensor, metagraph, and dendrite classes that simulate +the behavior of their real counterparts without actual blockchain interaction. + +Key Features: + - Mock wallet creation and management + - Simulated subtensor environment + - Mock metagraph for network topology testing + - Mock dendrite for testing network requests +""" + import bittensor as bt def create_wallet(): - """This function creates a wallet for the network.""" + """Creates a mock wallet for testing purposes. + + Creates a new wallet with predefined test keys for consistent testing environment. + + Returns: + bt.wallet: A mock wallet instance with test coldkey and hotkey. + """ wallet = bt.wallet(name="test_coldkey", hotkey="test_hotkey") wallet.create_if_non_existent() return wallet class MockSubtensor(bt.MockSubtensor): + """Mock implementation of the Subtensor network. + + Simulates basic blockchain functionality for testing purposes. + + Args: + netuid (int): Network UID to operate on + n (int, optional): Number of nodes in the network. Defaults to 16 + wallet (bt.wallet, optional): Wallet to use for operations + network (str, optional): Network name. Defaults to "mock" + """ + def __init__(self, netuid, n=16, wallet=None, network="mock"): + """Initialize the mock subtensor instance. + + Creates a new subnet if it doesn't exist for the given netuid. + """ super().__init__(network=network) if not self.subnet_exists(netuid): @@ -17,7 +51,21 @@ def __init__(self, netuid, n=16, wallet=None, network="mock"): class MockMetagraph(bt.metagraph): + """Mock implementation of the Bittensor metagraph. + + Provides a simulated network topology for testing validator and miner interactions. + + Args: + netuid (int, optional): Network UID to operate on. Defaults to 1 + network (str, optional): Network name. Defaults to "mock" + subtensor (MockSubtensor, optional): Subtensor instance to use + """ + def __init__(self, netuid=1, network="mock", subtensor=None): + """Initialize the mock metagraph instance. + + Sets up a basic network topology with mock axons using localhost addresses. + """ super().__init__(netuid=netuid, network=network, sync=False) if subtensor is not None: @@ -33,22 +81,34 @@ def __init__(self, netuid=1, network="mock", subtensor=None): class MockDendrite(bt.dendrite): - """ - Replaces a real bittensor network request with a mock request that just returns some static completion for all axons that are passed and adds some random delay. + """Mock implementation of the Bittensor dendrite. + + Simulates network requests for testing purposes without actual network communication. + + Args: + wallet (bt.wallet): Wallet to use for operations """ def __init__(self, wallet): + """Initialize the mock dendrite instance.""" super().__init__(wallet) def __str__(self) -> str: - """ - Returns a string representation of the Dendrite object. + """Get string representation of the mock dendrite. Returns: - str: The string representation of the Dendrite object in the format "dendrite()". + str: String representation in format "MockDendrite()". """ return "MockDendrite({})".format(self.keypair.ss58_address) async def forward(self): + """Simulate a forward pass through the network. + + Returns: + None: Currently returns None as placeholder. + + Todo: + Implement mock forward functionality. + """ # TODO: Implement this function return None diff --git a/atom/mock/mock_identities.py b/atom/mock/mock_identities.py index 8a43618..2368284 100644 --- a/atom/mock/mock_identities.py +++ b/atom/mock/mock_identities.py @@ -1,3 +1,14 @@ +"""Mock implementation module for testing Bittensor neurons. + +This module provides mock implementations of miner and validator neurons for testing purposes. +It includes basic implementations of required methods while maintaining minimal functionality. + +Classes: + MockMiner: A mock implementation of a miner neuron + MockValidator: A mock implementation of a validator neuron + MockOrganicValidator: A mock implementation of organic validation functionality +""" + import random import asyncio import bittensor as bt @@ -13,6 +24,15 @@ class MockMiner(BaseMinerNeuron): + """Mock implementation of a miner neuron for testing. + + A simplified miner implementation that returns default values for all required methods. + Useful for testing validator behavior without full miner functionality. + + Args: + config: Configuration object for the miner. Defaults to None. + """ + def __init__(self, config=None): config = create_config(self) config.mock = True @@ -20,19 +40,58 @@ def __init__(self, config=None): super().__init__(config) def spec_version(self): + """Get the specification version. + + Returns: + str: The current specification version. + """ return spec_version def forward(self, synapse: bt.Synapse) -> bt.Synapse: + """Mock forward pass implementation. + + Args: + synapse: The input synapse object. + + Returns: + bt.Synapse: Always returns None. + """ return None def blacklist(self, synapse: bt.Synapse) -> Tuple[bool, str]: + """Mock blacklist check implementation. + + Args: + synapse: The synapse to check. + + Returns: + Tuple[bool, str]: Always returns (False, ""). + """ return False, "" def priority(self, synapse: bt.Synapse) -> float: + """Mock priority calculation implementation. + + Args: + synapse: The synapse to evaluate. + + Returns: + float: Always returns 0.0. + """ return 0.0 class MockValidator(BaseValidatorNeuron): + """Mock implementation of a validator neuron for testing. + + A simplified validator implementation that returns default values for all required methods. + Includes a mock organic validator component. + + Args: + config: Configuration object for the validator. Defaults to None. + organic_config (Dict[str, Any]): Configuration for the organic validator component. + """ + def __init__( self, config=None, @@ -46,62 +105,116 @@ def __init__( self.organic_validator = MockOrganicValidator(axon=self.axon, **organic_config) def run(self): + """Mock run implementation. + + Returns: + None: Always returns None. + """ return None def spec_version(self): + """Get the specification version. + + Returns: + str: The current specification version. + """ return spec_version def forward(self, synapse: bt.Synapse) -> bt.Synapse: + """Mock forward pass implementation. + + Args: + synapse: The input synapse object. + + Returns: + bt.Synapse: Always returns None. + """ return None def blacklist(self, synapse: bt.Synapse) -> Tuple[bool, str]: + """Mock blacklist check implementation. + + Args: + synapse: The synapse to check. + + Returns: + Tuple[bool, str]: Always returns (False, ""). + """ return False, "" def priority(self, synapse: bt.Synapse) -> float: + """Mock priority calculation implementation. + + Args: + synapse: The synapse to evaluate. + + Returns: + float: Always returns 0.0. + """ return 0.0 - # The following methods are not implemented in the mock classes, so they should return False. def should_set_weights(self): + """Mock weight setting check. + + Returns: + bool: Always returns False. + """ return False def should_sync_metagraph(self): + """Mock metagraph sync check. + + Returns: + bool: Always returns False. + """ return False def set_weights(self): + """Mock weight setting implementation. + + Returns: + bool: Always returns False. + """ return False def update_scores(self): + """Mock score update implementation. + + Returns: + bool: Always returns False. + """ return False class MockOrganicValidator(OrganicScoringBase): - """Validator class to handle organic entries.""" + """Mock implementation of organic validation functionality. - def __init__( - self, - axon: bt.axon, - trigger_frequency: Union[float, int], - trigger: Literal["seconds", "steps"], - trigger_frequency_min: Union[float, int] = 5, - trigger_scaling_factor: Union[float, int] = 5, - synth_dataset=None, - ): - super().__init__( - axon=axon, - synth_dataset=synth_dataset, - trigger_frequency=trigger_frequency, - trigger=trigger, - trigger_frequency_min=trigger_frequency_min, - trigger_scaling_factor=trigger_scaling_factor, - ) + Provides a basic implementation of organic validation for testing purposes. + + Args: + axon (bt.axon): The axon instance to use. + trigger_frequency (Union[float, int]): Frequency of organic validation triggers. + trigger (Literal["seconds", "steps"]): Type of trigger to use. + trigger_frequency_min (Union[float, int]): Minimum trigger frequency. + trigger_scaling_factor (Union[float, int]): Scaling factor for triggers. + synth_dataset: Optional synthetic dataset for testing. + """ async def _on_organic_entry(self, synapse: bt.Synapse) -> bt.Synapse: + """Mock organic entry handler. + + Args: + synapse: The input synapse object. + + Returns: + bt.Synapse: Returns the input synapse unchanged. + """ return synapse async def start_loop(self): - """ - The main loop for running the organic scoring task, either based on a time interval or steps. - Calls the `sample` method to establish the sampling logic for the organic scoring task. + """Main loop for organic scoring task. + + Implements a basic loop that handles organic scoring based on time or step triggers. """ while not self._should_exit: if self._trigger == "steps": @@ -118,10 +231,10 @@ async def start_loop(self): await asyncio.sleep(0.1) async def sample(self) -> dict[str, Any]: - """Sample data from the organic queue or the synthetic dataset. + """Sample data from organic queue or synthetic dataset. Returns: - dict[str, Any]: dict that contains all the attributes for creating a simulation object. + dict[str, Any]: A sample containing attributes for simulation. """ if not self._organic_queue.is_empty(): # Choose organic sample based on the organic queue logic. @@ -135,11 +248,21 @@ async def sample(self) -> dict[str, Any]: return sample async def forward(self) -> dict[str, Any]: - """The forward method is responsible for sampling data from the organic queue, - and adding it to the local database of the validator. + """Process organic queue entries. + + Returns: + dict[str, Any]: The sampled data. """ sample: dict[str, Any] = await self.sample() return sample def _blacklist_fn(self, synapse: bt.Synapse) -> Tuple[bool, str]: + """Mock blacklist function implementation. + + Args: + synapse: The synapse to check. + + Returns: + Tuple[bool, str]: Always returns (False, ""). + """ return False, "" diff --git a/atom/organic_scoring/organic_queue/organic_queue.py b/atom/organic_scoring/organic_queue/organic_queue.py index 4d971ad..4c973d0 100644 --- a/atom/organic_scoring/organic_queue/organic_queue.py +++ b/atom/organic_scoring/organic_queue/organic_queue.py @@ -1,3 +1,9 @@ +""" +A module implementing a basic organic queue data structure for sample management. + +The organic queue is a fixed-size queue that stores samples and provides a sequential sampler. +""" + import random from typing import Any @@ -5,24 +11,57 @@ class OrganicQueue(OrganicQueueBase): - """Basic organic queue, implemented as a list.""" + """ + A basic organic queue implementation using a list as the underlying data structure. + + The queue maintains a maximum size and implements FIFO behavior when the size limit + is reached. Samples can be randomly retrieved from any position in the queue. + + Args: + max_size (int): Maximum number of samples that can be stored in the queue. + Defaults to 10000. + + Attributes: + max_size (int): Maximum capacity of the queue. + _queue (list): Internal list storing the samples. + """ def __init__(self, max_size: int = 10000): self._queue = [] self.max_size = max_size def add(self, sample: Any): - """Add the sample to the queue""" + """ + Add a sample to the queue. + + If the queue is at maximum capacity, the oldest sample is removed before + adding the new one (FIFO behavior). + + Args: + sample (Any): The sample to be added to the queue. + """ if self.size >= self.max_size: self._queue.pop(0) self._queue.append(sample) def sample(self) -> Any: - """Randomly pop the sample from the queue, if the queue is empty return None.""" + """ + Randomly sample and remove an item from the queue. + + Returns: + Any: A randomly selected sample from the queue. + Returns None if the queue is empty. + """ if self.is_empty(): return None return self._queue.pop(random.randint(0, self.size - 1)) @property def size(self) -> int: + """ + Get the current number of samples in the queue. + + Returns: + int: The current size of the queue. + """ return len(self._queue) diff --git a/atom/organic_scoring/organic_scoring_base.py b/atom/organic_scoring/organic_scoring_base.py index 95ecbaf..75ca9be 100644 --- a/atom/organic_scoring/organic_scoring_base.py +++ b/atom/organic_scoring/organic_scoring_base.py @@ -1,6 +1,6 @@ import asyncio from abc import ABC, abstractmethod -from typing import Any, Literal, Optional, Sequence, Union, Tuple, Callable +from typing import Any, Literal, Optional, Sequence, Union, Tuple import bittensor as bt @@ -9,7 +9,53 @@ from atom.organic_scoring.utils import is_overridden +""" +Base module for organic scoring mechanisms in the Atom framework. + +This module provides the foundation for implementing organic scoring systems, +which combine both synthetic and organic data processing for reward calculation +and weight adjustment in the network. +""" + + class OrganicScoringBase(ABC): + """ + Abstract base class for organic scoring implementations. + + This class provides the framework for processing both organic and synthetic data, + managing scoring frequencies, and handling weight updates in the network. It runs + asynchronously and can be triggered either by time intervals or step counts. + + Args: + axon (bt.axon): The axon instance for network communication. + synth_dataset (Optional[Union[SynthDatasetBase, Sequence[SynthDatasetBase]]]): + Synthetic dataset(s) for training. If None, only organic data will be used. + trigger_frequency (Union[float, int]): Frequency of organic scoring reward steps. + trigger (Literal["seconds", "steps"]): Trigger type for scoring: + - "seconds": Wait specified number of seconds between steps + - "steps": Wait specified number of steps between updates + trigger_frequency_min (Union[float, int], optional): Minimum frequency value. + Defaults to 2. + trigger_scaling_factor (Union[float, int], optional): Scaling factor for + adjusting trigger frequency based on queue size. Higher values mean slower + adjustment. Must be > 0. Defaults to 5. + organic_queue (Optional[OrganicQueueBase], optional): Queue for storing organic + samples. Defaults to OrganicQueue. + + Attributes: + _axon: The axon instance used for network communication. + _should_exit: Flag indicating if the scoring loop should terminate. + _is_running: Flag indicating if the scoring loop is active. + _synth_dataset: Collection of synthetic datasets. + _trigger_frequency: Base frequency for triggering scoring steps. + _trigger: Type of trigger mechanism used. + _trigger_min: Minimum allowed trigger frequency. + _trigger_scaling_factor: Factor for dynamic frequency adjustment. + _organic_queue: Queue storing organic samples. + _step_counter: Counter for step-based triggering. + _step_lock: Lock for thread-safe step counter operations. + """ + def __init__( self, axon: bt.axon, @@ -111,33 +157,78 @@ def set_step(self, step: int): @abstractmethod async def _on_organic_entry(self, synapse: bt.Synapse) -> bt.Synapse: - """Handle an organic entry. + """ + Process an incoming organic sample. - Important: this method must add the required values to the `_organic_queue`. + This abstract method must be implemented by subclasses to handle incoming + organic samples and add them to the organic queue. Args: - synapse: The synapse to handle. + synapse (bt.Synapse): The incoming synapse containing the organic sample. Returns: - bt.StreamingSynapse: The handled synapse. + bt.Synapse: The processed synapse. + + Note: + Implementations MUST add required values to self._organic_queue. """ raise NotImplementedError async def _priority_fn(self, synapse: bt.Synapse) -> float: - """Priority function to sort the organic queue.""" + """ + Calculate priority for organic sample processing. + + Args: + synapse (bt.Synapse): The synapse to evaluate. + + Returns: + float: Priority value, higher values indicate higher priority. + Defaults to 0.0. + """ return 0.0 async def _blacklist_fn(self, synapse: bt.Synapse) -> Tuple[bool, str]: - """Blacklist function for organic handles.""" + """ + Determine if a synapse should be blacklisted. + + Args: + synapse (bt.Synapse): The synapse to evaluate. + + Returns: + Tuple[bool, str]: A tuple containing: + - bool: True if blacklisted, False otherwise + - str: Reason for blacklisting (empty if not blacklisted) + """ return False, "" async def _verify_fn(self, synapse: bt.Synapse) -> bool: - """Function to verify requests for organic handles.""" + """ + Verify if a synapse request is valid. + + Args: + synapse (bt.Synapse): The synapse to verify. + + Returns: + bool: True if the request is valid, False otherwise. + """ return True async def start_loop(self): - """The main loop for running the organic scoring task, either based on a time interval or steps. - Calls the `sample` method to establish the sampling logic for the organic scoring task. + """ + Main execution loop for the organic scoring task. + + This asynchronous loop runs continuously until _should_exit is set to True. + It handles both time-based and step-based triggering mechanisms, executing + the forward pass and managing the waiting period between iterations. + + The loop: + 1. Checks trigger conditions (time or steps) + 2. Executes the forward pass + 3. Calculates the next waiting period + 4. Handles any exceptions during execution + + Raises: + Logs errors that occur during execution but doesn't terminate the loop. """ while not self._should_exit: if self._trigger == "steps": @@ -168,26 +259,22 @@ async def forward(self) -> dict[str, Any]: ... async def wait_until_next(self, timer_elapsed: float = 0): - """Wait until next iteration dynamically based on the size of the organic queue and the elapsed time. + """ + Dynamically adjust and wait for the next iteration based on queue size. - This method implements an annealing sampling rate that adapts to the growth of the organic queue, - ensuring the system can keep up with the data processing demands. + Implements an adaptive waiting mechanism that adjusts the sampling rate + based on the current size of the organic queue. This ensures efficient + processing as the queue size changes. Args: - timer_elapsed: The time elapsed during the current iteration of the processing loop. This is used - to calculate the remaining sleep duration when the trigger is based on seconds. - - Behavior: - - If the trigger is set to "seconds", the method calculates a dynamic frequency based on the current queue - size and the scaling factor, then sleeps for the remaining duration after considering the elapsed time. - - If the trigger is set to "steps", the method adjusts the step counter dynamically based on the current - queue size and the scaling factor, ensuring that the system can keep up with the processing demands. - - Dynamic Adjustment: - - The `dynamic_frequency` is calculated by reducing the original frequency by a value proportional to the - queue size divided by the scaling factor. It ensures the frequency does not drop below `min_seconds`. - - The `dynamic_steps` is calculated similarly, reducing the original step count by a value proportional - to the queue size divided by the scaling factor. It ensures the steps do not drop below `min_steps`. + timer_elapsed (float, optional): Time spent in the current processing + iteration. Used for time-based triggers. Defaults to 0. + + Dynamic Adjustment Formula: + - For time-based triggers: + wait_time = max(base_frequency - (queue_size / scaling_factor), min_frequency) + - For step-based triggers: + steps = int(max(base_steps - (queue_size / scaling_factor), min_steps)) """ # Annealing sampling rate logic. dynamic_unit = self.sample_rate_dynamic() @@ -204,7 +291,17 @@ async def wait_until_next(self, timer_elapsed: float = 0): await asyncio.sleep(1) def sample_rate_dynamic(self) -> float: - """Returns dynamic sampling rate based on the size of the organic queue.""" + """ + Calculate the dynamic sampling rate based on organic queue size. + + Returns: + float: The adjusted sampling rate. For time-based triggers, returns + seconds to wait. For step-based triggers, returns the number of + steps (as an integer). + + Formula: + rate = max(trigger_frequency - (queue_size / scaling_factor), trigger_min) + """ size = self._organic_queue.size delay = max( self._trigger_frequency - (size / self._trigger_scaling_factor), diff --git a/docs/Makefile b/docs/Makefile new file mode 100644 index 0000000..d4bb2cb --- /dev/null +++ b/docs/Makefile @@ -0,0 +1,20 @@ +# Minimal makefile for Sphinx documentation +# + +# You can set these variables from the command line, and also +# from the environment for the first two. +SPHINXOPTS ?= +SPHINXBUILD ?= sphinx-build +SOURCEDIR = . +BUILDDIR = _build + +# Put it first so that "make" without argument is like "make help". +help: + @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) + +.PHONY: help Makefile + +# Catch-all target: route all unknown targets to Sphinx using the new +# "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS). +%: Makefile + @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) diff --git a/docs/atom.base.rst b/docs/atom.base.rst new file mode 100644 index 0000000..6527ed7 --- /dev/null +++ b/docs/atom.base.rst @@ -0,0 +1,61 @@ +atom.base package +================= + +Submodules +---------- + +atom.base.config module +----------------------- + +.. automodule:: atom.base.config + :members: + :undoc-members: + :show-inheritance: + +atom.base.miner module +---------------------- + +.. automodule:: atom.base.miner + :members: + :undoc-members: + :show-inheritance: + +atom.base.neuron module +----------------------- + +.. automodule:: atom.base.neuron + :members: + :undoc-members: + :show-inheritance: + +atom.base.ttl module +-------------------- + +.. automodule:: atom.base.ttl + :members: + :undoc-members: + :show-inheritance: + +atom.base.validator module +-------------------------- + +.. automodule:: atom.base.validator + :members: + :undoc-members: + :show-inheritance: + +atom.base.weights module +------------------------ + +.. automodule:: atom.base.weights + :members: + :undoc-members: + :show-inheritance: + +Module contents +--------------- + +.. automodule:: atom.base + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/atom.chain.rst b/docs/atom.chain.rst new file mode 100644 index 0000000..2d65b6c --- /dev/null +++ b/docs/atom.chain.rst @@ -0,0 +1,37 @@ +atom.chain package +================== + +Submodules +---------- + +atom.chain.chain module +----------------------- + +.. automodule:: atom.chain.chain + :members: + :undoc-members: + :show-inheritance: + +atom.chain.chain\_utils module +------------------------------ + +.. automodule:: atom.chain.chain_utils + :members: + :undoc-members: + :show-inheritance: + +atom.chain.generic module +------------------------- + +.. automodule:: atom.chain.generic + :members: + :undoc-members: + :show-inheritance: + +Module contents +--------------- + +.. automodule:: atom.chain + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/atom.epistula.rst b/docs/atom.epistula.rst new file mode 100644 index 0000000..a062478 --- /dev/null +++ b/docs/atom.epistula.rst @@ -0,0 +1,21 @@ +atom.epistula package +===================== + +Submodules +---------- + +atom.epistula.epistula module +----------------------------- + +.. automodule:: atom.epistula.epistula + :members: + :undoc-members: + :show-inheritance: + +Module contents +--------------- + +.. automodule:: atom.epistula + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/atom.mock.rst b/docs/atom.mock.rst new file mode 100644 index 0000000..2420ded --- /dev/null +++ b/docs/atom.mock.rst @@ -0,0 +1,29 @@ +atom.mock package +================= + +Submodules +---------- + +atom.mock.mock module +--------------------- + +.. automodule:: atom.mock.mock + :members: + :undoc-members: + :show-inheritance: + +atom.mock.mock\_identities module +--------------------------------- + +.. automodule:: atom.mock.mock_identities + :members: + :undoc-members: + :show-inheritance: + +Module contents +--------------- + +.. automodule:: atom.mock + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/atom.organic_scoring.organic_queue.rst b/docs/atom.organic_scoring.organic_queue.rst new file mode 100644 index 0000000..59bc008 --- /dev/null +++ b/docs/atom.organic_scoring.organic_queue.rst @@ -0,0 +1,29 @@ +atom.organic\_scoring.organic\_queue package +============================================ + +Submodules +---------- + +atom.organic\_scoring.organic\_queue.organic\_queue module +---------------------------------------------------------- + +.. automodule:: atom.organic_scoring.organic_queue.organic_queue + :members: + :undoc-members: + :show-inheritance: + +atom.organic\_scoring.organic\_queue.organic\_queue\_base module +---------------------------------------------------------------- + +.. automodule:: atom.organic_scoring.organic_queue.organic_queue_base + :members: + :undoc-members: + :show-inheritance: + +Module contents +--------------- + +.. automodule:: atom.organic_scoring.organic_queue + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/atom.organic_scoring.rst b/docs/atom.organic_scoring.rst new file mode 100644 index 0000000..5f352c2 --- /dev/null +++ b/docs/atom.organic_scoring.rst @@ -0,0 +1,38 @@ +atom.organic\_scoring package +============================= + +Subpackages +----------- + +.. toctree:: + :maxdepth: 4 + + atom.organic_scoring.organic_queue + atom.organic_scoring.synth_dataset + +Submodules +---------- + +atom.organic\_scoring.organic\_scoring\_base module +--------------------------------------------------- + +.. automodule:: atom.organic_scoring.organic_scoring_base + :members: + :undoc-members: + :show-inheritance: + +atom.organic\_scoring.utils module +---------------------------------- + +.. automodule:: atom.organic_scoring.utils + :members: + :undoc-members: + :show-inheritance: + +Module contents +--------------- + +.. automodule:: atom.organic_scoring + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/atom.organic_scoring.synth_dataset.rst b/docs/atom.organic_scoring.synth_dataset.rst new file mode 100644 index 0000000..2b974ad --- /dev/null +++ b/docs/atom.organic_scoring.synth_dataset.rst @@ -0,0 +1,21 @@ +atom.organic\_scoring.synth\_dataset package +============================================ + +Submodules +---------- + +atom.organic\_scoring.synth\_dataset.synth\_dataset\_base module +---------------------------------------------------------------- + +.. automodule:: atom.organic_scoring.synth_dataset.synth_dataset_base + :members: + :undoc-members: + :show-inheritance: + +Module contents +--------------- + +.. automodule:: atom.organic_scoring.synth_dataset + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/atom.rst b/docs/atom.rst new file mode 100644 index 0000000..ad6c4ab --- /dev/null +++ b/docs/atom.rst @@ -0,0 +1,33 @@ +atom package +============ + +Subpackages +----------- + +.. toctree:: + :maxdepth: 4 + + atom.base + atom.chain + atom.epistula + atom.mock + atom.organic_scoring + +Submodules +---------- + +atom.utils module +----------------- + +.. automodule:: atom.utils + :members: + :undoc-members: + :show-inheritance: + +Module contents +--------------- + +.. automodule:: atom + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/conf.py b/docs/conf.py new file mode 100644 index 0000000..730eafa --- /dev/null +++ b/docs/conf.py @@ -0,0 +1,38 @@ +# Configuration file for the Sphinx documentation builder. +# +# For the full list of built-in configuration values, see the documentation: +# https://www.sphinx-doc.org/en/master/usage/configuration.html + +# -- Project information ----------------------------------------------------- +# https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information +import os +import sys + +sys.path.insert(0, os.path.abspath("../atom")) + +project = "atom" +copyright = "2024, Macrocosmos" +author = "Macrocosmos" +release = "1.0.0" + +# -- General configuration --------------------------------------------------- +# https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration + +extensions = [ + "sphinx.ext.autodoc", + "sphinx.ext.todo", + "sphinx.ext.viewcode", + "sphinx.ext.napoleon", + "sphinx.ext.autosummary", + "sphinx_autodoc_typehints", # Render type hints nicely +] + +templates_path = ["_templates"] +exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"] + + +# -- Options for HTML output ------------------------------------------------- +# https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output + +html_theme = "sphinx_book_theme" +html_static_path = ["_static"] diff --git a/docs/index.rst b/docs/index.rst new file mode 100644 index 0000000..5b7f813 --- /dev/null +++ b/docs/index.rst @@ -0,0 +1,27 @@ +.. atom documentation master file, created by + sphinx-quickstart on Mon Dec 16 20:18:20 2024. + You can adapt this file completely to your liking, but it should at least + contain the root `toctree` directive. + +atom documentation +================== + +## This is a comment + +.. toctree:: + :maxdepth: 3 + :caption: Contents: + + atom.base + + atom.chain + + atom.epistula + + atom.mock + + atom.organic_scoring + atom.organic_scoring.organic_queue + atom.organic_scoring.synthetic_dataset + + diff --git a/docs/make.bat b/docs/make.bat new file mode 100644 index 0000000..32bb245 --- /dev/null +++ b/docs/make.bat @@ -0,0 +1,35 @@ +@ECHO OFF + +pushd %~dp0 + +REM Command file for Sphinx documentation + +if "%SPHINXBUILD%" == "" ( + set SPHINXBUILD=sphinx-build +) +set SOURCEDIR=. +set BUILDDIR=_build + +%SPHINXBUILD% >NUL 2>NUL +if errorlevel 9009 ( + echo. + echo.The 'sphinx-build' command was not found. Make sure you have Sphinx + echo.installed, then set the SPHINXBUILD environment variable to point + echo.to the full path of the 'sphinx-build' executable. Alternatively you + echo.may add the Sphinx directory to PATH. + echo. + echo.If you don't have Sphinx installed, grab it from + echo.https://www.sphinx-doc.org/ + exit /b 1 +) + +if "%1" == "" goto help + +%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% +goto end + +:help +%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% + +:end +popd diff --git a/docs/modules.rst b/docs/modules.rst new file mode 100644 index 0000000..63a9e89 --- /dev/null +++ b/docs/modules.rst @@ -0,0 +1,8 @@ +atom +==== + +.. toctree:: + :maxdepth: 4 + + atom + tests diff --git a/docs/tests.rst b/docs/tests.rst new file mode 100644 index 0000000..f29f85a --- /dev/null +++ b/docs/tests.rst @@ -0,0 +1,37 @@ +tests package +============= + +Submodules +---------- + +tests.test\_base module +----------------------- + +.. automodule:: tests.test_base + :members: + :undoc-members: + :show-inheritance: + +tests.test\_epistula module +--------------------------- + +.. automodule:: tests.test_epistula + :members: + :undoc-members: + :show-inheritance: + +tests.test\_organic module +-------------------------- + +.. automodule:: tests.test_organic + :members: + :undoc-members: + :show-inheritance: + +Module contents +--------------- + +.. automodule:: tests + :members: + :undoc-members: + :show-inheritance: diff --git a/poetry.lock b/poetry.lock index 4ea4515..2d1f074 100644 --- a/poetry.lock +++ b/poetry.lock @@ -1,5 +1,23 @@ # This file is automatically @generated by Poetry 1.8.4 and should not be changed by hand. +[[package]] +name = "accessible-pygments" +version = "0.0.5" +description = "A collection of accessible pygments styles" +optional = false +python-versions = ">=3.9" +files = [ + {file = "accessible_pygments-0.0.5-py3-none-any.whl", hash = "sha256:88ae3211e68a1d0b011504b2ffc1691feafce124b845bd072ab6f9f66f34d4b7"}, + {file = "accessible_pygments-0.0.5.tar.gz", hash = "sha256:40918d3e6a2b619ad424cb91e556bd3bd8865443d9f22f1dcdf79e33c8046872"}, +] + +[package.dependencies] +pygments = ">=1.5" + +[package.extras] +dev = ["pillow", "pkginfo (>=1.10)", "playwright", "pre-commit", "setuptools", "twine (>=5.0)"] +tests = ["hypothesis", "pytest"] + [[package]] name = "aiohappyeyeballs" version = "2.4.4" @@ -125,18 +143,29 @@ speedups = ["Brotli", "aiodns (>=3.2.0)", "brotlicffi"] [[package]] name = "aiosignal" -version = "1.3.1" +version = "1.3.2" description = "aiosignal: a list of registered asynchronous callbacks" optional = false -python-versions = ">=3.7" +python-versions = ">=3.9" files = [ - {file = "aiosignal-1.3.1-py3-none-any.whl", hash = "sha256:f8376fb07dd1e86a584e4fcdec80b36b7f81aac666ebc724e2c090300dd83b17"}, - {file = "aiosignal-1.3.1.tar.gz", hash = "sha256:54cd96e15e1649b75d6c87526a6ff0b6c1b0dd3459f43d9ca11d48c339b68cfc"}, + {file = "aiosignal-1.3.2-py2.py3-none-any.whl", hash = "sha256:45cde58e409a301715980c2b01d0c28bdde3770d8290b5eb2173759d9acb31a5"}, + {file = "aiosignal-1.3.2.tar.gz", hash = "sha256:a8c255c66fafb1e499c9351d0bf32ff2d8a0321595ebac3b93713656d2436f54"}, ] [package.dependencies] frozenlist = ">=1.1.0" +[[package]] +name = "alabaster" +version = "1.0.0" +description = "A light, configurable Sphinx theme" +optional = false +python-versions = ">=3.10" +files = [ + {file = "alabaster-1.0.0-py3-none-any.whl", hash = "sha256:fc6786402dc3fcb2de3cabd5fe455a2db534b371124f1f21de8731783dec828b"}, + {file = "alabaster-1.0.0.tar.gz", hash = "sha256:c00dca57bca26fa62a6d7d0a9fcce65f3e026e9bfe33e9c538fd3fbb2144fd9e"}, +] + [[package]] name = "annotated-types" version = "0.7.0" @@ -194,23 +223,37 @@ files = [ [[package]] name = "attrs" -version = "24.2.0" +version = "24.3.0" description = "Classes Without Boilerplate" optional = false -python-versions = ">=3.7" +python-versions = ">=3.8" files = [ - {file = "attrs-24.2.0-py3-none-any.whl", hash = "sha256:81921eb96de3191c8258c199618104dd27ac608d9366f5e35d011eae1867ede2"}, - {file = "attrs-24.2.0.tar.gz", hash = "sha256:5cfb1b9148b5b086569baec03f20d7b6bf3bcacc9a42bebf87ffaaca362f6346"}, + {file = "attrs-24.3.0-py3-none-any.whl", hash = "sha256:ac96cd038792094f438ad1f6ff80837353805ac950cd2aa0e0625ef19850c308"}, + {file = "attrs-24.3.0.tar.gz", hash = "sha256:8f5c07333d543103541ba7be0e2ce16eeee8130cb0b3f9238ab904ce1e85baff"}, ] [package.extras] benchmark = ["cloudpickle", "hypothesis", "mypy (>=1.11.1)", "pympler", "pytest (>=4.3.0)", "pytest-codspeed", "pytest-mypy-plugins", "pytest-xdist[psutil]"] cov = ["cloudpickle", "coverage[toml] (>=5.3)", "hypothesis", "mypy (>=1.11.1)", "pympler", "pytest (>=4.3.0)", "pytest-mypy-plugins", "pytest-xdist[psutil]"] -dev = ["cloudpickle", "hypothesis", "mypy (>=1.11.1)", "pre-commit", "pympler", "pytest (>=4.3.0)", "pytest-mypy-plugins", "pytest-xdist[psutil]"] +dev = ["cloudpickle", "hypothesis", "mypy (>=1.11.1)", "pre-commit-uv", "pympler", "pytest (>=4.3.0)", "pytest-mypy-plugins", "pytest-xdist[psutil]"] docs = ["cogapp", "furo", "myst-parser", "sphinx", "sphinx-notfound-page", "sphinxcontrib-towncrier", "towncrier (<24.7)"] tests = ["cloudpickle", "hypothesis", "mypy (>=1.11.1)", "pympler", "pytest (>=4.3.0)", "pytest-mypy-plugins", "pytest-xdist[psutil]"] tests-mypy = ["mypy (>=1.11.1)", "pytest-mypy-plugins"] +[[package]] +name = "babel" +version = "2.16.0" +description = "Internationalization utilities" +optional = false +python-versions = ">=3.8" +files = [ + {file = "babel-2.16.0-py3-none-any.whl", hash = "sha256:368b5b98b37c06b7daf6696391c3240c938b37767d4584413e8438c5c435fa8b"}, + {file = "babel-2.16.0.tar.gz", hash = "sha256:d1f3554ca26605fe173f3de0c65f750f5a42f924499bf134de6423582298e316"}, +] + +[package.extras] +dev = ["freezegun (>=1.0,<2.0)", "pytest (>=6.0)", "pytest-cov"] + [[package]] name = "backoff" version = "2.2.1" @@ -236,21 +279,43 @@ files = [ [package.extras] tests = ["PyHamcrest (>=2.0.2)", "mypy", "pytest (>=4.6)", "pytest-benchmark", "pytest-cov", "pytest-flake8"] +[[package]] +name = "beautifulsoup4" +version = "4.12.3" +description = "Screen-scraping library" +optional = false +python-versions = ">=3.6.0" +files = [ + {file = "beautifulsoup4-4.12.3-py3-none-any.whl", hash = "sha256:b80878c9f40111313e55da8ba20bdba06d8fa3969fc68304167741bbf9e082ed"}, + {file = "beautifulsoup4-4.12.3.tar.gz", hash = "sha256:74e3d1928edc070d21748185c46e3fb33490f22f52a3addee9aee0f4f7781051"}, +] + +[package.dependencies] +soupsieve = ">1.2" + +[package.extras] +cchardet = ["cchardet"] +chardet = ["chardet"] +charset-normalizer = ["charset-normalizer"] +html5lib = ["html5lib"] +lxml = ["lxml"] + [[package]] name = "bittensor" -version = "8.4.5" +version = "8.5.1" description = "bittensor" optional = false python-versions = ">=3.9" files = [ - {file = "bittensor-8.4.5-py3-none-any.whl", hash = "sha256:8e85327d0552e9839781b31015a1b7e45a092b7cc54cae86a14c2be0b7cb956b"}, - {file = "bittensor-8.4.5.tar.gz", hash = "sha256:93c7573488d88292eb877a54cacad601aab776cd56d500f76054bf9ebd7d9b23"}, + {file = "bittensor-8.5.1-py3-none-any.whl", hash = "sha256:8dbf9c389d10fd043dab5da163377a43ec2ae1b1715e819a3602e07d36304f94"}, + {file = "bittensor-8.5.1.tar.gz", hash = "sha256:f1bb033ba1e2641881d37f9d8cfebdcb7145ae20975861863710bdd17941cce4"}, ] [package.dependencies] aiohttp = ">=3.9,<4.0" async-property = "0.2.2" bittensor-cli = "*" +bittensor-commit-reveal = ">=0.1.0" bittensor-wallet = ">=2.1.3" bt-decode = "0.4.0" colorama = ">=0.4.6,<0.5.0" @@ -282,13 +347,13 @@ torch = ["torch (>=1.13.1)"] [[package]] name = "bittensor-cli" -version = "8.4.1" +version = "8.4.2" description = "Bittensor CLI" optional = false python-versions = ">=3.9" files = [ - {file = "bittensor-cli-8.4.1.tar.gz", hash = "sha256:6d834622382606583660dd51d3ca0d03b9551b9b6a75f1436c5883ba33a1e3c3"}, - {file = "bittensor_cli-8.4.1-py3-none-any.whl", hash = "sha256:3c6de436e16186770ea564f2dafe0eeac89b8fc317ed0b963ea106635900e60d"}, + {file = "bittensor-cli-8.4.2.tar.gz", hash = "sha256:43efc081ed2ecf4357bf5c5322ccd6f7d1a5110eb842cf138c75adb3f21686fd"}, + {file = "bittensor_cli-8.4.2-py3-none-any.whl", hash = "sha256:e7fc5ff510f039fa0cb9c0c701a56c4eb2b644befb019b1cd0fac29546bfb764"}, ] [package.dependencies] @@ -316,6 +381,37 @@ wheel = "*" [package.extras] cuda = ["cubit (>=1.1.0)", "torch"] +[[package]] +name = "bittensor-commit-reveal" +version = "0.1.0" +description = "" +optional = false +python-versions = ">=3.9" +files = [ + {file = "bittensor_commit_reveal-0.1.0-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2e628b052ebdbd6893eb996a0d03b4c5e0823e42ee410ff5066018700a35539a"}, + {file = "bittensor_commit_reveal-0.1.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:245a7e0defb79f6a45c243f72739ee5c58840cba51342d28322c6d7a73f475b9"}, + {file = "bittensor_commit_reveal-0.1.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:2bb23935ac60a981bfb3d83397b83e858c0b69a11806969cf56486f5ebc90943"}, + {file = "bittensor_commit_reveal-0.1.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4917b215c24b10bd80c84db921113b9cd1346ca7dcaca75e286905ede81a3b18"}, + {file = "bittensor_commit_reveal-0.1.0-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c46cee3e5fa5fc9e6f6a444793062855f40495c1a00b52df6508e4449ac5e89f"}, + {file = "bittensor_commit_reveal-0.1.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7d56407b879dcf82bdde5eaefede43c8891e122fefc03a32c77a063dfc52e0c8"}, + {file = "bittensor_commit_reveal-0.1.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:8509250549b6f5c475a9150e941b28fc66e82f30b27fe078fd80fa840943bb7b"}, + {file = "bittensor_commit_reveal-0.1.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:bed04f82f162121747cfd7f51bb5d625dda0bf763a0699054565f255d219a9c2"}, + {file = "bittensor_commit_reveal-0.1.0-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:25af2d9c82cacc4278095460493430d36070cb2843c0aa54b1c563788d0742eb"}, + {file = "bittensor_commit_reveal-0.1.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f8f530793274698aaf4ac7cc8f24e915749d8156df8302c9e1e16446177b429d"}, + {file = "bittensor_commit_reveal-0.1.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:e52955d652b61f091310e2b9b232d26b9e586a928e3b414a09a1b6615e9cc7a0"}, + {file = "bittensor_commit_reveal-0.1.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7be8c8f79dea2e137f5add6ee4711447c4f5d43668be26616ab7c1cacf317e07"}, + {file = "bittensor_commit_reveal-0.1.0-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b88ecb6a0989c2200486e29419a8e7d3b3f7918bdbde4ec04dbb4464abdee08f"}, + {file = "bittensor_commit_reveal-0.1.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4ac015f9eefa9dbddd2875cd7214e3a0bc2e394a2915772e655bdcc5c0af67de"}, + {file = "bittensor_commit_reveal-0.1.0-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:18062ccab9bd8c66eee741bab9c047ec302eede563b16d4a960bcef6ef4ab368"}, + {file = "bittensor_commit_reveal-0.1.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:957eff5b5b760dd8267d5f3c23c1aab4155505aa15bc06e044ffca483979f3d1"}, + {file = "bittensor_commit_reveal-0.1.0-pp310-pypy310_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:df0ef502f07804bff843a7e6318f95b9a9ca5bcc9c75e501040202b38d09d8b5"}, + {file = "bittensor_commit_reveal-0.1.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a8706ae43e3455913d210c7ab5fc0110595e45b8fa3964441e2842fc7975aec3"}, + {file = "bittensor_commit_reveal-0.1.0.tar.gz", hash = "sha256:1c8bb8d77f6279988902c5c28361cc460167829c63ffa8d788209f8810933211"}, +] + +[package.extras] +dev = ["maturin (==1.7.0)"] + [[package]] name = "bittensor-wallet" version = "2.1.3" @@ -512,13 +608,13 @@ test = ["bittensor (==8.2.0)", "ddt (==1.6.0)", "pytest (==7.2.0)", "pytest-asyn [[package]] name = "certifi" -version = "2024.8.30" +version = "2024.12.14" description = "Python package for providing Mozilla's CA Bundle." optional = false python-versions = ">=3.6" files = [ - {file = "certifi-2024.8.30-py3-none-any.whl", hash = "sha256:922820b53db7a7257ffbda3f597266d435245903d80737e34f8a45ff3e3230d8"}, - {file = "certifi-2024.8.30.tar.gz", hash = "sha256:bec941d2aa8195e248a60b31ff9f0558284cf01a52591ceda73ea9afffd69fd9"}, + {file = "certifi-2024.12.14-py3-none-any.whl", hash = "sha256:1275f7a45be9464efc1173084eaa30f866fe2e47d389406136d332ed4967ec56"}, + {file = "certifi-2024.12.14.tar.gz", hash = "sha256:b650d30f370c2b724812bee08008be0c4163b163ddaec3f2546c1caf65f191db"}, ] [[package]] @@ -790,97 +886,111 @@ test-randomorder = ["pytest-randomly"] [[package]] name = "cytoolz" -version = "1.0.0" +version = "1.0.1" description = "Cython implementation of Toolz: High performance functional utilities" optional = false python-versions = ">=3.8" files = [ - {file = "cytoolz-1.0.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:ecf5a887acb8f079ab1b81612b1c889bcbe6611aa7804fd2df46ed310aa5a345"}, - {file = "cytoolz-1.0.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:ef0ef30c1e091d4d59d14d8108a16d50bd227be5d52a47da891da5019ac2f8e4"}, - {file = "cytoolz-1.0.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7df2dfd679f0517a96ced1cdd22f5c6c6aeeed28d928a82a02bf4c3fd6fd7ac4"}, - {file = "cytoolz-1.0.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8c51452c938e610f57551aa96e34924169c9100c0448bac88c2fb395cbd3538c"}, - {file = "cytoolz-1.0.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6433f03910c5e5345d82d6299457c26bf33821224ebb837c6b09d9cdbc414a6c"}, - {file = "cytoolz-1.0.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:389ec328bb535f09e71dfe658bf0041f17194ca4cedaacd39bafe7893497a819"}, - {file = "cytoolz-1.0.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c64658e1209517ce4b54c1c9269a508b289d8d55fc742760e4b8579eacf09a33"}, - {file = "cytoolz-1.0.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:f6039a9bd5bb988762458b9ca82b39e60ca5e5baae2ba93913990dcc5d19fa88"}, - {file = "cytoolz-1.0.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:85c9c8c4465ed1b2c8d67003809aec9627b129cb531d2f6cf0bbfe39952e7e4d"}, - {file = "cytoolz-1.0.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:49375aad431d76650f94877afb92f09f58b6ff9055079ef4f2cd55313f5a1b39"}, - {file = "cytoolz-1.0.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:4c45106171c824a61e755355520b646cb35a1987b34bbf5789443823ee137f63"}, - {file = "cytoolz-1.0.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:3b319a7f0fed5db07d189db4046162ebc183c108df3562a65ba6ebe862d1f634"}, - {file = "cytoolz-1.0.0-cp310-cp310-win32.whl", hash = "sha256:9770e1b09748ad0d751853d994991e2592a9f8c464a87014365f80dac2e83faa"}, - {file = "cytoolz-1.0.0-cp310-cp310-win_amd64.whl", hash = "sha256:20194dd02954c00c1f0755e636be75a20781f91a4ac9270c7f747e82d3c7f5a5"}, - {file = "cytoolz-1.0.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:dffc22fd2c91be64dbdbc462d0786f8e8ac9a275cfa1869a1084d1867d4f67e0"}, - {file = "cytoolz-1.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a99e7e29274e293f4ffe20e07f76c2ac753a78f1b40c1828dfc54b2981b2f6c4"}, - {file = "cytoolz-1.0.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c507a3e0a45c41d66b43f96797290d75d1e7a8549aa03a4a6b8854fdf3f7b8d8"}, - {file = "cytoolz-1.0.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:643a593ec272ef7429099e1182a22f64ec2696c00d295d2a5be390db1b7ff176"}, - {file = "cytoolz-1.0.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6ce38e2e42cbae30446190c59b92a8a9029e1806fd79eaf88f48b0fe33003893"}, - {file = "cytoolz-1.0.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:810a6a168b8c5ecb412fbae3dd6f7ed6c6253a63caf4174ee9794ebd29b2224f"}, - {file = "cytoolz-1.0.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0ce8a2a85c0741c1b19b16e6782c4a5abc54c3caecda66793447112ab2fa9884"}, - {file = "cytoolz-1.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:ea4ac72e6b830861035c4c7999af8e55813f57c6d1913a3d93cc4a6babc27bf7"}, - {file = "cytoolz-1.0.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:a09cdfb21dfb38aa04df43e7546a41f673377eb5485da88ceb784e327ec7603b"}, - {file = "cytoolz-1.0.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:658dd85deb375ff7af990a674e5c9058cef1c9d1f5dc89bc87b77be499348144"}, - {file = "cytoolz-1.0.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:9715d1ff5576919d10b68f17241375f6a1eec8961c25b78a83e6ef1487053f39"}, - {file = "cytoolz-1.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f370a1f1f1afc5c1c8cc5edc1cfe0ba444263a0772af7ce094be8e734f41769d"}, - {file = "cytoolz-1.0.0-cp311-cp311-win32.whl", hash = "sha256:dbb2ec1177dca700f3db2127e572da20de280c214fc587b2a11c717fc421af56"}, - {file = "cytoolz-1.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:0983eee73df86e54bb4a79fcc4996aa8b8368fdbf43897f02f9c3bf39c4dc4fb"}, - {file = "cytoolz-1.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:10e3986066dc379e30e225b230754d9f5996aa8d84c2accc69c473c21d261e46"}, - {file = "cytoolz-1.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:16576f1bb143ee2cb9f719fcc4b845879fb121f9075c7c5e8a5ff4854bd02fc6"}, - {file = "cytoolz-1.0.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3faa25a1840b984315e8b3ae517312375f4273ffc9a2f035f548b7f916884f37"}, - {file = "cytoolz-1.0.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:781fce70a277b20fd95dc66811d1a97bb07b611ceea9bda8b7dd3c6a4b05d59a"}, - {file = "cytoolz-1.0.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7a562c25338eb24d419d1e80a7ae12133844ce6fdeb4ab54459daf250088a1b2"}, - {file = "cytoolz-1.0.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f29d8330aaf070304f7cd5cb7e73e198753624eb0aec278557cccd460c699b5b"}, - {file = "cytoolz-1.0.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:98a96c54aa55ed9c7cdb23c2f0df39a7b4ee518ac54888480b5bdb5ef69c7ef0"}, - {file = "cytoolz-1.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:287d6d7f475882c2ddcbedf8da9a9b37d85b77690779a2d1cdceb5ae3998d52e"}, - {file = "cytoolz-1.0.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:05a871688df749b982839239fcd3f8ec3b3b4853775d575ff9cd335fa7c75035"}, - {file = "cytoolz-1.0.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:28bb88e1e2f7d6d4b8e0890b06d292c568984d717de3e8381f2ca1dd12af6470"}, - {file = "cytoolz-1.0.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:576a4f1fc73d8836b10458b583f915849da6e4f7914f4ecb623ad95c2508cad5"}, - {file = "cytoolz-1.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:509ed3799c47e4ada14f63e41e8f540ac6e2dab97d5d7298934e6abb9d3830ec"}, - {file = "cytoolz-1.0.0-cp312-cp312-win32.whl", hash = "sha256:9ce25f02b910630f6dc2540dd1e26c9326027ddde6c59f8cab07c56acc70714c"}, - {file = "cytoolz-1.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:7e53cfcce87e05b7f0ae2fb2b3e5820048cd0bb7b701e92bd8f75c9fbb7c9ae9"}, - {file = "cytoolz-1.0.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:7d56569dfe67a39ce74ffff0dc12cf0a3d1aae709667a303fe8f2dd5fd004fdf"}, - {file = "cytoolz-1.0.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:035c8bb4706dcf93a89fb35feadff67e9301935bf6bb864cd2366923b69d9a29"}, - {file = "cytoolz-1.0.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:27c684799708bdc7ee7acfaf464836e1b4dec0996815c1d5efd6a92a4356a562"}, - {file = "cytoolz-1.0.0-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:44ab57cfc922b15d94899f980d76759ef9e0256912dfab70bf2561bea9cd5b19"}, - {file = "cytoolz-1.0.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:478af5ecc066da093d7660b23d0b465a7f44179739937afbded8af00af412eb6"}, - {file = "cytoolz-1.0.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:da1f82a7828a42468ea2820a25b6e56461361390c29dcd4d68beccfa1b71066b"}, - {file = "cytoolz-1.0.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6c371b3114d38ee717780b239179e88d5d358fe759a00dcf07691b8922bbc762"}, - {file = "cytoolz-1.0.0-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:90b343b2f3b3e77c3832ba19b0b17e95412a5b2e715b05c23a55ba525d1fca49"}, - {file = "cytoolz-1.0.0-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:89a554a9ba112403232a54e15e46ff218b33020f3f45c4baf6520ab198b7ad93"}, - {file = "cytoolz-1.0.0-cp38-cp38-musllinux_1_2_ppc64le.whl", hash = "sha256:0d603f5e2b1072166745ecdd81384a75757a96a704a5642231eb51969f919d5f"}, - {file = "cytoolz-1.0.0-cp38-cp38-musllinux_1_2_s390x.whl", hash = "sha256:122ef2425bd3c0419e6e5260d0b18cd25cf74de589cd0184e4a63b24a4641e2e"}, - {file = "cytoolz-1.0.0-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:8819f1f97ebe36efcaf4b550e21677c46ac8a41bed482cf66845f377dd20700d"}, - {file = "cytoolz-1.0.0-cp38-cp38-win32.whl", hash = "sha256:fcddbb853770dd6e270d89ea8742f0aa42c255a274b9e1620eb04e019b79785e"}, - {file = "cytoolz-1.0.0-cp38-cp38-win_amd64.whl", hash = "sha256:ca526905a014a38cc23ae78635dc51d0462c5c24425b22c08beed9ff2ee03845"}, - {file = "cytoolz-1.0.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:05df5ff1cdd198fb57e7368623662578c950be0b14883cadfb9ee4098415e1e5"}, - {file = "cytoolz-1.0.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:04a84778f48ebddb26948971dc60948907c876ba33b13f9cbb014fe65b341fc2"}, - {file = "cytoolz-1.0.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f65283b618b4c4df759f57bcf8483865a73f7f268e6d76886c743407c8d26c1c"}, - {file = "cytoolz-1.0.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:388cd07ee9a9e504c735a0a933e53c98586a1c301a64af81f7aa7ff40c747520"}, - {file = "cytoolz-1.0.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:06d09e9569cfdfc5c082806d4b4582db8023a3ce034097008622bcbac7236f38"}, - {file = "cytoolz-1.0.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9502bd9e37779cc9893cbab515a474c2ab6af61ed22ac2f7e16033db18fcaa85"}, - {file = "cytoolz-1.0.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:364c2fda148def38003b2c86e8adde1d2aab12411dd50872c244a815262e2fda"}, - {file = "cytoolz-1.0.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:9b2e945617325242687189966335e785dc0fae316f4c1825baacf56e5a97e65f"}, - {file = "cytoolz-1.0.0-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:0f16907fdc724c55b16776bdb7e629deae81d500fe48cfc3861231753b271355"}, - {file = "cytoolz-1.0.0-cp39-cp39-musllinux_1_2_ppc64le.whl", hash = "sha256:d3206c81ca3ba2d7b8fe78f2e116e3028e721148be753308e88dcbbc370bca52"}, - {file = "cytoolz-1.0.0-cp39-cp39-musllinux_1_2_s390x.whl", hash = "sha256:becce4b13e110b5ac6b23753dcd0c977f4fdccffa31898296e13fd1109e517e3"}, - {file = "cytoolz-1.0.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:69a7e5e98fd446079b8b8ec5987aec9a31ec3570a6f494baefa6800b783eaf22"}, - {file = "cytoolz-1.0.0-cp39-cp39-win32.whl", hash = "sha256:b1707b6c3a91676ac83a28a231a14b337dbb4436b937e6b3e4fd44209852a48b"}, - {file = "cytoolz-1.0.0-cp39-cp39-win_amd64.whl", hash = "sha256:11d48b8521ef5fe92e099f4fc00717b5d0789c3c90d5d84031b6d3b17dee1700"}, - {file = "cytoolz-1.0.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:e672712d5dc3094afc6fb346dd4e9c18c1f3c69608ddb8cf3b9f8428f9c26a5c"}, - {file = "cytoolz-1.0.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:86fb208bfb7420e1d0d20065d661310e4a8a6884851d4044f47d37ed4cd7410e"}, - {file = "cytoolz-1.0.0-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6dbe5fe3b835859fc559eb59bf2775b5a108f7f2cfab0966f3202859d787d8fd"}, - {file = "cytoolz-1.0.0-pp310-pypy310_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0cace092dfda174eed09ed871793beb5b65633963bcda5b1632c73a5aceea1ce"}, - {file = "cytoolz-1.0.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:f7a9d816af3be9725c70efe0a6e4352a45d3877751b395014b8eb2f79d7d8d9d"}, - {file = "cytoolz-1.0.0-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:caa7ef840847a23b379e6146760e3a22f15f445656af97e55a435c592125cfa5"}, - {file = "cytoolz-1.0.0-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:921082fff09ff6e40c12c87b49be044492b2d6bb01d47783995813b76680c7b2"}, - {file = "cytoolz-1.0.0-pp38-pypy38_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a32f1356f3b64dda883583383966948604ac69ca0b7fbcf5f28856e5f9133b4e"}, - {file = "cytoolz-1.0.0-pp38-pypy38_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9af793b1738e4191d15a92e1793f1ffea9f6461022c7b2442f3cb1ea0a4f758a"}, - {file = "cytoolz-1.0.0-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:51dfda3983fcc59075c534ce54ca041bb3c80e827ada5d4f25ff7b4049777f94"}, - {file = "cytoolz-1.0.0-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:acfb8780c04d29423d14aaab74cd1b7b4beaba32f676e7ace02c9acfbf532aba"}, - {file = "cytoolz-1.0.0-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:99f39dcc46416dca3eb23664b73187b77fb52cd8ba2ddd8020a292d8f449db67"}, - {file = "cytoolz-1.0.0-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c0d56b3721977806dcf1a68b0ecd56feb382fdb0f632af1a9fc5ab9b662b32c6"}, - {file = "cytoolz-1.0.0-pp39-pypy39_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:45d346620abc8c83ae634136e700432ad6202faffcc24c5ab70b87392dcda8a1"}, - {file = "cytoolz-1.0.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:df0c81197fc130de94c09fc6f024a6a19c98ba8fe55c17f1e45ebba2e9229079"}, - {file = "cytoolz-1.0.0.tar.gz", hash = "sha256:eb453b30182152f9917a5189b7d99046b6ce90cdf8aeb0feff4b2683e600defd"}, + {file = "cytoolz-1.0.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:cec9af61f71fc3853eb5dca3d42eb07d1f48a4599fa502cbe92adde85f74b042"}, + {file = "cytoolz-1.0.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:140bbd649dbda01e91add7642149a5987a7c3ccc251f2263de894b89f50b6608"}, + {file = "cytoolz-1.0.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e90124bdc42ff58b88cdea1d24a6bc5f776414a314cc4d94f25c88badb3a16d1"}, + {file = "cytoolz-1.0.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e74801b751e28f7c5cc3ad264c123954a051f546f2fdfe089f5aa7a12ccfa6da"}, + {file = "cytoolz-1.0.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:582dad4545ddfb5127494ef23f3fa4855f1673a35d50c66f7638e9fb49805089"}, + {file = "cytoolz-1.0.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dd7bd0618e16efe03bd12f19c2a26a27e6e6b75d7105adb7be1cd2a53fa755d8"}, + {file = "cytoolz-1.0.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d74cca6acf1c4af58b2e4a89cc565ed61c5e201de2e434748c93e5a0f5c541a5"}, + {file = "cytoolz-1.0.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:823a3763828d8d457f542b2a45d75d6b4ced5e470b5c7cf2ed66a02f508ed442"}, + {file = "cytoolz-1.0.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:51633a14e6844c61db1d68c1ffd077cf949f5c99c60ed5f1e265b9e2966f1b52"}, + {file = "cytoolz-1.0.1-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:f3ec9b01c45348f1d0d712507d54c2bfd69c62fbd7c9ef555c9d8298693c2432"}, + {file = "cytoolz-1.0.1-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:1855022b712a9c7a5bce354517ab4727a38095f81e2d23d3eabaf1daeb6a3b3c"}, + {file = "cytoolz-1.0.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:9930f7288c4866a1dc1cc87174f0c6ff4cad1671eb1f6306808aa6c445857d78"}, + {file = "cytoolz-1.0.1-cp310-cp310-win32.whl", hash = "sha256:a9baad795d72fadc3445ccd0f122abfdbdf94269157e6d6d4835636dad318804"}, + {file = "cytoolz-1.0.1-cp310-cp310-win_amd64.whl", hash = "sha256:ad95b386a84e18e1f6136f6d343d2509d4c3aae9f5a536f3dc96808fcc56a8cf"}, + {file = "cytoolz-1.0.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:2d958d4f04d9d7018e5c1850790d9d8e68b31c9a2deebca74b903706fdddd2b6"}, + {file = "cytoolz-1.0.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:0f445b8b731fc0ecb1865b8e68a070084eb95d735d04f5b6c851db2daf3048ab"}, + {file = "cytoolz-1.0.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1f546a96460a7e28eb2ec439f4664fa646c9b3e51c6ebad9a59d3922bbe65e30"}, + {file = "cytoolz-1.0.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0317681dd065532d21836f860b0563b199ee716f55d0c1f10de3ce7100c78a3b"}, + {file = "cytoolz-1.0.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0c0ef52febd5a7821a3fd8d10f21d460d1a3d2992f724ba9c91fbd7a96745d41"}, + {file = "cytoolz-1.0.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f5ebaf419acf2de73b643cf96108702b8aef8e825cf4f63209ceb078d5fbbbfd"}, + {file = "cytoolz-1.0.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5f7f04eeb4088947585c92d6185a618b25ad4a0f8f66ea30c8db83cf94a425e3"}, + {file = "cytoolz-1.0.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:f61928803bb501c17914b82d457c6f50fe838b173fb40d39c38d5961185bd6c7"}, + {file = "cytoolz-1.0.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:d2960cb4fa01ccb985ad1280db41f90dc97a80b397af970a15d5a5de403c8c61"}, + {file = "cytoolz-1.0.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:b2b407cc3e9defa8df5eb46644f6f136586f70ba49eba96f43de67b9a0984fd3"}, + {file = "cytoolz-1.0.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:8245f929144d4d3bd7b972c9593300195c6cea246b81b4c46053c48b3f044580"}, + {file = "cytoolz-1.0.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:e37385db03af65763933befe89fa70faf25301effc3b0485fec1c15d4ce4f052"}, + {file = "cytoolz-1.0.1-cp311-cp311-win32.whl", hash = "sha256:50f9c530f83e3e574fc95c264c3350adde8145f4f8fc8099f65f00cc595e5ead"}, + {file = "cytoolz-1.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:b7f6b617454b4326af7bd3c7c49b0fc80767f134eb9fd6449917a058d17a0e3c"}, + {file = "cytoolz-1.0.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:fcb8f7d0d65db1269022e7e0428471edee8c937bc288ebdcb72f13eaa67c2fe4"}, + {file = "cytoolz-1.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:207d4e4b445e087e65556196ff472ff134370d9a275d591724142e255f384662"}, + {file = "cytoolz-1.0.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:21cdf6bac6fd843f3b20280a66fd8df20dea4c58eb7214a2cd8957ec176f0bb3"}, + {file = "cytoolz-1.0.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4a55ec098036c0dea9f3bdc021f8acd9d105a945227d0811589f0573f21c9ce1"}, + {file = "cytoolz-1.0.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a13ab79ff4ce202e03ab646a2134696988b554b6dc4b71451e948403db1331d8"}, + {file = "cytoolz-1.0.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4e2d944799026e1ff08a83241f1027a2d9276c41f7a74224cd98b7df6e03957d"}, + {file = "cytoolz-1.0.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:88ba85834cd523b91fdf10325e1e6d71c798de36ea9bdc187ca7bd146420de6f"}, + {file = "cytoolz-1.0.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:5a750b1af7e8bf6727f588940b690d69e25dc47cce5ce467925a76561317eaf7"}, + {file = "cytoolz-1.0.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:44a71870f7eae31d263d08b87da7c2bf1176f78892ed8bdade2c2850478cb126"}, + {file = "cytoolz-1.0.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:c8231b9abbd8e368e036f4cc2e16902c9482d4cf9e02a6147ed0e9a3cd4a9ab0"}, + {file = "cytoolz-1.0.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:aa87599ccc755de5a096a4d6c34984de6cd9dc928a0c5eaa7607457317aeaf9b"}, + {file = "cytoolz-1.0.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:67cd16537df51baabde3baa770ab7b8d16839c4d21219d5b96ac59fb012ebd2d"}, + {file = "cytoolz-1.0.1-cp312-cp312-win32.whl", hash = "sha256:fb988c333f05ee30ad4693fe4da55d95ec0bb05775d2b60191236493ea2e01f9"}, + {file = "cytoolz-1.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:8f89c48d8e5aec55ffd566a8ec858706d70ed0c6a50228eca30986bfa5b4da8b"}, + {file = "cytoolz-1.0.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:6944bb93b287032a4c5ca6879b69bcd07df46f3079cf8393958cf0b0454f50c0"}, + {file = "cytoolz-1.0.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:e027260fd2fc5cb041277158ac294fc13dca640714527219f702fb459a59823a"}, + {file = "cytoolz-1.0.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:88662c0e07250d26f5af9bc95911e6137e124a5c1ec2ce4a5d74de96718ab242"}, + {file = "cytoolz-1.0.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:309dffa78b0961b4c0cf55674b828fbbc793cf2d816277a5c8293c0c16155296"}, + {file = "cytoolz-1.0.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:edb34246e6eb40343c5860fc51b24937698e4fa1ee415917a73ad772a9a1746b"}, + {file = "cytoolz-1.0.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0a54da7a8e4348a18d45d4d5bc84af6c716d7f131113a4f1cc45569d37edff1b"}, + {file = "cytoolz-1.0.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:241c679c3b1913c0f7259cf1d9639bed5084c86d0051641d537a0980548aa266"}, + {file = "cytoolz-1.0.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5bfc860251a8f280ac79696fc3343cfc3a7c30b94199e0240b6c9e5b6b01a2a5"}, + {file = "cytoolz-1.0.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:c8edd1547014050c1bdad3ff85d25c82bd1c2a3c96830c6181521eb78b9a42b3"}, + {file = "cytoolz-1.0.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:b349bf6162e8de215403d7f35f8a9b4b1853dc2a48e6e1a609a5b1a16868b296"}, + {file = "cytoolz-1.0.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:1b18b35256219b6c3dd0fa037741b85d0bea39c552eab0775816e85a52834140"}, + {file = "cytoolz-1.0.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:738b2350f340ff8af883eb301054eb724997f795d20d90daec7911c389d61581"}, + {file = "cytoolz-1.0.1-cp313-cp313-win32.whl", hash = "sha256:9cbd9c103df54fcca42be55ef40e7baea624ac30ee0b8bf1149f21146d1078d9"}, + {file = "cytoolz-1.0.1-cp313-cp313-win_amd64.whl", hash = "sha256:90e577e08d3a4308186d9e1ec06876d4756b1e8164b92971c69739ea17e15297"}, + {file = "cytoolz-1.0.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:f3a509e4ac8e711703c368476b9bbce921fcef6ebb87fa3501525f7000e44185"}, + {file = "cytoolz-1.0.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:a7eecab6373e933dfbf4fdc0601d8fd7614f8de76793912a103b5fccf98170cd"}, + {file = "cytoolz-1.0.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e55ed62087f6e3e30917b5f55350c3b6be6470b849c6566018419cd159d2cebc"}, + {file = "cytoolz-1.0.1-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:43de33d99a4ccc07234cecd81f385456b55b0ea9c39c9eebf42f024c313728a5"}, + {file = "cytoolz-1.0.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:139bed875828e1727018aa0982aa140e055cbafccb7fd89faf45cbb4f2a21514"}, + {file = "cytoolz-1.0.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:22c12671194b518aa8ce2f4422bd5064f25ab57f410ba0b78705d0a219f4a97a"}, + {file = "cytoolz-1.0.1-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:79888f2f7dc25709cd5d37b032a8833741e6a3692c8823be181d542b5999128e"}, + {file = "cytoolz-1.0.1-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:51628b4eb41fa25bd428f8f7b5b74fbb05f3ae65fbd265019a0dd1ded4fdf12a"}, + {file = "cytoolz-1.0.1-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:1db9eb7179285403d2fb56ba1ff6ec35a44921b5e2fa5ca19d69f3f9f0285ea5"}, + {file = "cytoolz-1.0.1-cp38-cp38-musllinux_1_2_ppc64le.whl", hash = "sha256:08ab7efae08e55812340bfd1b3f09f63848fe291675e2105eab1aa5327d3a16e"}, + {file = "cytoolz-1.0.1-cp38-cp38-musllinux_1_2_s390x.whl", hash = "sha256:e5fdc5264f884e7c0a1711a81dff112708a64b9c8561654ee578bfdccec6be09"}, + {file = "cytoolz-1.0.1-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:90d6a2e6ab891043ee655ec99d5e77455a9bee9e1131bdfcfb745edde81200dd"}, + {file = "cytoolz-1.0.1-cp38-cp38-win32.whl", hash = "sha256:08946e083faa5147751b34fbf78ab931f149ef758af5c1092932b459e18dcf5c"}, + {file = "cytoolz-1.0.1-cp38-cp38-win_amd64.whl", hash = "sha256:a91b4e10a9c03796c0dc93e47ebe25bb41ecc6fafc3cf5197c603cf767a3d44d"}, + {file = "cytoolz-1.0.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:980c323e626ba298b77ae62871b2de7c50b9d7219e2ddf706f52dd34b8be7349"}, + {file = "cytoolz-1.0.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:45f6fa1b512bc2a0f2de5123db932df06c7f69d12874fe06d67772b2828e2c8b"}, + {file = "cytoolz-1.0.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f93f42d9100c415155ad1f71b0de362541afd4ac95e3153467c4c79972521b6b"}, + {file = "cytoolz-1.0.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a76d20dec9c090cdf4746255bbf06a762e8cc29b5c9c1d138c380bbdb3122ade"}, + {file = "cytoolz-1.0.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:239039585487c69aa50c5b78f6a422016297e9dea39755761202fb9f0530fe87"}, + {file = "cytoolz-1.0.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c28307640ca2ab57b9fbf0a834b9bf563958cd9e038378c3a559f45f13c3c541"}, + {file = "cytoolz-1.0.1-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:454880477bb901cee3a60f6324ec48c95d45acc7fecbaa9d49a5af737ded0595"}, + {file = "cytoolz-1.0.1-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:902115d1b1f360fd81e44def30ac309b8641661150fcbdde18ead446982ada6a"}, + {file = "cytoolz-1.0.1-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:e68e6b38473a3a79cee431baa22be31cac39f7df1bf23eaa737eaff42e213883"}, + {file = "cytoolz-1.0.1-cp39-cp39-musllinux_1_2_ppc64le.whl", hash = "sha256:32fba3f63fcb76095b0a22f4bdcc22bc62a2bd2d28d58bf02fd21754c155a3ec"}, + {file = "cytoolz-1.0.1-cp39-cp39-musllinux_1_2_s390x.whl", hash = "sha256:0724ba4cf41eb40b6cf75250820ab069e44bdf4183ff78857aaf4f0061551075"}, + {file = "cytoolz-1.0.1-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:c42420e0686f887040d5230420ed44f0e960ccbfa29a0d65a3acd9ca52459209"}, + {file = "cytoolz-1.0.1-cp39-cp39-win32.whl", hash = "sha256:4ba8b16358ea56b1fe8e637ec421e36580866f2e787910bac1cf0a6997424a34"}, + {file = "cytoolz-1.0.1-cp39-cp39-win_amd64.whl", hash = "sha256:92d27f84bf44586853d9562bfa3610ecec000149d030f793b4cb614fd9da1813"}, + {file = "cytoolz-1.0.1-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:83d19d55738ad9c60763b94f3f6d3c6e4de979aeb8d76841c1401081e0e58d96"}, + {file = "cytoolz-1.0.1-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f112a71fad6ea824578e6393765ce5c054603afe1471a5c753ff6c67fd872d10"}, + {file = "cytoolz-1.0.1-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5a515df8f8aa6e1eaaf397761a6e4aff2eef73b5f920aedf271416d5471ae5ee"}, + {file = "cytoolz-1.0.1-pp310-pypy310_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:92c398e7b7023460bea2edffe5fcd0a76029580f06c3f6938ac3d198b47156f3"}, + {file = "cytoolz-1.0.1-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:3237e56211e03b13df47435b2369f5df281e02b04ad80a948ebd199b7bc10a47"}, + {file = "cytoolz-1.0.1-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:ba0d1da50aab1909b165f615ba1125c8b01fcc30d606c42a61c42ea0269b5e2c"}, + {file = "cytoolz-1.0.1-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:25b6e8dec29aa5a390092d193abd673e027d2c0b50774ae816a31454286c45c7"}, + {file = "cytoolz-1.0.1-pp38-pypy38_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:36cd6989ebb2f18fe9af8f13e3c61064b9f741a40d83dc5afeb0322338ad25f2"}, + {file = "cytoolz-1.0.1-pp38-pypy38_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a47394f8ab7fca3201f40de61fdeea20a2baffb101485ae14901ea89c3f6c95d"}, + {file = "cytoolz-1.0.1-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:d00ac423542af944302e034e618fb055a0c4e87ba704cd6a79eacfa6ac83a3c9"}, + {file = "cytoolz-1.0.1-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:a5ca923d1fa632f7a4fb33c0766c6fba7f87141a055c305c3e47e256fb99c413"}, + {file = "cytoolz-1.0.1-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:058bf996bcae9aad3acaeeb937d42e0c77c081081e67e24e9578a6a353cb7fb2"}, + {file = "cytoolz-1.0.1-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:69e2a1f41a3dad94a17aef4a5cc003323359b9f0a9d63d4cc867cb5690a2551d"}, + {file = "cytoolz-1.0.1-pp39-pypy39_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:67daeeeadb012ec2b59d63cb29c4f2a2023b0c4957c3342d354b8bb44b209e9a"}, + {file = "cytoolz-1.0.1-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:54d3d36bbf0d4344d1afa22c58725d1668e30ff9de3a8f56b03db1a6da0acb11"}, + {file = "cytoolz-1.0.1.tar.gz", hash = "sha256:89cc3161b89e1bb3ed7636f74ed2e55984fd35516904fc878cae216e42b2c7d6"}, ] [package.dependencies] @@ -891,13 +1001,13 @@ cython = ["cython"] [[package]] name = "datasets" -version = "3.1.0" +version = "3.2.0" description = "HuggingFace community-driven open-source library of datasets" optional = false -python-versions = ">=3.8.0" +python-versions = ">=3.9.0" files = [ - {file = "datasets-3.1.0-py3-none-any.whl", hash = "sha256:dc8808a6d17838fe05e13b39aa7ac3ea0fd0806ed7004eaf4d4eb2c2a356bc61"}, - {file = "datasets-3.1.0.tar.gz", hash = "sha256:c92cac049e0f9f85b0dd63739c68e564c657b1624bc2b66b1e13489062832e27"}, + {file = "datasets-3.2.0-py3-none-any.whl", hash = "sha256:f3d2ba2698b7284a4518019658596a6a8bc79f31e51516524249d6c59cf0fe2a"}, + {file = "datasets-3.2.0.tar.gz", hash = "sha256:9a6e1a356052866b5dbdd9c9eedb000bf3fc43d986e3584d9b028f4976937229"}, ] [package.dependencies] @@ -919,15 +1029,15 @@ xxhash = "*" [package.extras] audio = ["librosa", "soundfile (>=0.12.1)", "soxr (>=0.4.0)"] benchmarks = ["tensorflow (==2.12.0)", "torch (==2.0.1)", "transformers (==4.30.1)"] -dev = ["Pillow (>=9.4.0)", "absl-py", "decorator", "decord (==0.6.0)", "elasticsearch (<8.0.0)", "faiss-cpu (>=1.8.0.post1)", "jax (>=0.3.14)", "jaxlib (>=0.3.14)", "joblib (<1.3.0)", "joblibspark", "librosa", "lz4", "moto[server]", "polars[timezone] (>=0.20.0)", "protobuf (<4.0.0)", "py7zr", "pyspark (>=3.4)", "pytest", "pytest-datadir", "pytest-xdist", "rarfile (>=4.0)", "ruff (>=0.3.0)", "s3fs", "s3fs (>=2021.11.1)", "soundfile (>=0.12.1)", "soxr (>=0.4.0)", "sqlalchemy", "tensorflow (>=2.16.0)", "tensorflow (>=2.6.0)", "tensorflow (>=2.6.0)", "tiktoken", "torch", "torch (>=2.0.0)", "torchdata", "transformers", "transformers (>=4.42.0)", "zstandard"] +dev = ["Pillow (>=9.4.0)", "absl-py", "decorator", "decord (==0.6.0)", "elasticsearch (>=7.17.12,<8.0.0)", "faiss-cpu (>=1.8.0.post1)", "jax (>=0.3.14)", "jaxlib (>=0.3.14)", "joblib (<1.3.0)", "joblibspark", "librosa", "lz4", "moto[server]", "polars[timezone] (>=0.20.0)", "protobuf (<4.0.0)", "py7zr", "pyspark (>=3.4)", "pytest", "pytest-datadir", "pytest-xdist", "rarfile (>=4.0)", "ruff (>=0.3.0)", "s3fs", "s3fs (>=2021.11.1)", "soundfile (>=0.12.1)", "soxr (>=0.4.0)", "sqlalchemy", "tensorflow (>=2.16.0)", "tensorflow (>=2.6.0)", "tensorflow (>=2.6.0)", "tiktoken", "torch", "torch (>=2.0.0)", "torchdata", "transformers", "transformers (>=4.42.0)", "zstandard"] docs = ["s3fs", "tensorflow (>=2.6.0)", "torch", "transformers"] jax = ["jax (>=0.3.14)", "jaxlib (>=0.3.14)"] quality = ["ruff (>=0.3.0)"] s3 = ["s3fs"] tensorflow = ["tensorflow (>=2.6.0)"] tensorflow-gpu = ["tensorflow (>=2.6.0)"] -tests = ["Pillow (>=9.4.0)", "absl-py", "decorator", "decord (==0.6.0)", "elasticsearch (<8.0.0)", "faiss-cpu (>=1.8.0.post1)", "jax (>=0.3.14)", "jaxlib (>=0.3.14)", "joblib (<1.3.0)", "joblibspark", "librosa", "lz4", "moto[server]", "polars[timezone] (>=0.20.0)", "protobuf (<4.0.0)", "py7zr", "pyspark (>=3.4)", "pytest", "pytest-datadir", "pytest-xdist", "rarfile (>=4.0)", "s3fs (>=2021.11.1)", "soundfile (>=0.12.1)", "soxr (>=0.4.0)", "sqlalchemy", "tensorflow (>=2.16.0)", "tensorflow (>=2.6.0)", "tiktoken", "torch (>=2.0.0)", "torchdata", "transformers (>=4.42.0)", "zstandard"] -tests-numpy2 = ["Pillow (>=9.4.0)", "absl-py", "decorator", "decord (==0.6.0)", "elasticsearch (<8.0.0)", "jax (>=0.3.14)", "jaxlib (>=0.3.14)", "joblib (<1.3.0)", "joblibspark", "lz4", "moto[server]", "polars[timezone] (>=0.20.0)", "protobuf (<4.0.0)", "py7zr", "pyspark (>=3.4)", "pytest", "pytest-datadir", "pytest-xdist", "rarfile (>=4.0)", "s3fs (>=2021.11.1)", "soundfile (>=0.12.1)", "soxr (>=0.4.0)", "sqlalchemy", "tiktoken", "torch (>=2.0.0)", "torchdata", "transformers (>=4.42.0)", "zstandard"] +tests = ["Pillow (>=9.4.0)", "absl-py", "decorator", "decord (==0.6.0)", "elasticsearch (>=7.17.12,<8.0.0)", "faiss-cpu (>=1.8.0.post1)", "jax (>=0.3.14)", "jaxlib (>=0.3.14)", "joblib (<1.3.0)", "joblibspark", "librosa", "lz4", "moto[server]", "polars[timezone] (>=0.20.0)", "protobuf (<4.0.0)", "py7zr", "pyspark (>=3.4)", "pytest", "pytest-datadir", "pytest-xdist", "rarfile (>=4.0)", "s3fs (>=2021.11.1)", "soundfile (>=0.12.1)", "soxr (>=0.4.0)", "sqlalchemy", "tensorflow (>=2.16.0)", "tensorflow (>=2.6.0)", "tiktoken", "torch (>=2.0.0)", "torchdata", "transformers (>=4.42.0)", "zstandard"] +tests-numpy2 = ["Pillow (>=9.4.0)", "absl-py", "decorator", "decord (==0.6.0)", "elasticsearch (>=7.17.12,<8.0.0)", "jax (>=0.3.14)", "jaxlib (>=0.3.14)", "joblib (<1.3.0)", "joblibspark", "lz4", "moto[server]", "polars[timezone] (>=0.20.0)", "protobuf (<4.0.0)", "py7zr", "pyspark (>=3.4)", "pytest", "pytest-datadir", "pytest-xdist", "rarfile (>=4.0)", "s3fs (>=2021.11.1)", "soundfile (>=0.12.1)", "soxr (>=0.4.0)", "sqlalchemy", "tiktoken", "torch (>=2.0.0)", "torchdata", "transformers (>=4.42.0)", "zstandard"] torch = ["torch"] vision = ["Pillow (>=9.4.0)"] @@ -957,6 +1067,17 @@ files = [ graph = ["objgraph (>=1.7.2)"] profile = ["gprof2dot (>=2022.7.29)"] +[[package]] +name = "docutils" +version = "0.21.2" +description = "Docutils -- Python Documentation Utilities" +optional = false +python-versions = ">=3.9" +files = [ + {file = "docutils-0.21.2-py3-none-any.whl", hash = "sha256:dafca5b9e384f0e419294eb4d2ff9fa826435bf15f15b7bd45723e8ad76811b2"}, + {file = "docutils-0.21.2.tar.gz", hash = "sha256:3a6b18732edf182daa3cd12775bbb338cf5691468f91eeeb109deff6ebfa986f"}, +] + [[package]] name = "ecdsa" version = "0.19.0" @@ -1262,6 +1383,23 @@ files = [ [package.extras] speedup = ["python-levenshtein (>=0.12)"] +[[package]] +name = "ghp-import" +version = "2.1.0" +description = "Copy your docs directly to the gh-pages branch." +optional = false +python-versions = "*" +files = [ + {file = "ghp-import-2.1.0.tar.gz", hash = "sha256:9c535c4c61193c2df8871222567d7fd7e5014d835f97dc7b7439069e2413d343"}, + {file = "ghp_import-2.1.0-py3-none-any.whl", hash = "sha256:8337dd7b50877f163d4c0289bc1f1c7f127550241988d568c1db512c4324a619"}, +] + +[package.dependencies] +python-dateutil = ">=2.8.1" + +[package.extras] +dev = ["flake8", "markdown", "twine", "wheel"] + [[package]] name = "gitdb" version = "4.0.11" @@ -1307,13 +1445,13 @@ files = [ [[package]] name = "huggingface-hub" -version = "0.26.3" +version = "0.27.0" description = "Client library to download and publish models, datasets and other repos on the huggingface.co hub" optional = false python-versions = ">=3.8.0" files = [ - {file = "huggingface_hub-0.26.3-py3-none-any.whl", hash = "sha256:e66aa99e569c2d5419240a9e553ad07245a5b1300350bfbc5a4945cf7432991b"}, - {file = "huggingface_hub-0.26.3.tar.gz", hash = "sha256:90e1fe62ffc26757a073aaad618422b899ccf9447c2bba8c902a90bef5b42e1d"}, + {file = "huggingface_hub-0.27.0-py3-none-any.whl", hash = "sha256:8f2e834517f1f1ddf1ecc716f91b120d7333011b7485f665a9a412eacb1a2a81"}, + {file = "huggingface_hub-0.27.0.tar.gz", hash = "sha256:902cce1a1be5739f5589e560198a65a8edcfd3b830b1666f36e4b961f0454fac"}, ] [package.dependencies] @@ -1353,6 +1491,17 @@ files = [ [package.extras] all = ["flake8 (>=7.1.1)", "mypy (>=1.11.2)", "pytest (>=8.3.2)", "ruff (>=0.6.2)"] +[[package]] +name = "imagesize" +version = "1.4.1" +description = "Getting image size from png/jpeg/jpeg2000/gif file" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +files = [ + {file = "imagesize-1.4.1-py2.py3-none-any.whl", hash = "sha256:0d8d18d08f840c19d0ee7ca1fd82490fdc3729b7ac93f49870406ddde8ef8d8b"}, + {file = "imagesize-1.4.1.tar.gz", hash = "sha256:69150444affb9cb0d5cc5a92b3676f0b2fb7cd9ae39e947a5e11a36b4497cd4a"}, +] + [[package]] name = "iniconfig" version = "2.0.0" @@ -1947,20 +2096,21 @@ nicer-shell = ["ipython"] [[package]] name = "networkx" -version = "3.2.1" +version = "3.4.2" description = "Python package for creating and manipulating graphs and networks" optional = false -python-versions = ">=3.9" +python-versions = ">=3.10" files = [ - {file = "networkx-3.2.1-py3-none-any.whl", hash = "sha256:f18c69adc97877c42332c170849c96cefa91881c99a7cb3e95b7c659ebdc1ec2"}, - {file = "networkx-3.2.1.tar.gz", hash = "sha256:9f1bb5cf3409bf324e0a722c20bdb4c20ee39bf1c30ce8ae499c8502b0b5e0c6"}, + {file = "networkx-3.4.2-py3-none-any.whl", hash = "sha256:df5d4365b724cf81b8c6a7312509d0c22386097011ad1abe274afd5e9d3bbc5f"}, + {file = "networkx-3.4.2.tar.gz", hash = "sha256:307c3669428c5362aab27c8a1260aa8f47c4e91d3891f48be0141738d8d053e1"}, ] [package.extras] -default = ["matplotlib (>=3.5)", "numpy (>=1.22)", "pandas (>=1.4)", "scipy (>=1.9,!=1.11.0,!=1.11.1)"] -developer = ["changelist (==0.4)", "mypy (>=1.1)", "pre-commit (>=3.2)", "rtoml"] -doc = ["nb2plots (>=0.7)", "nbconvert (<7.9)", "numpydoc (>=1.6)", "pillow (>=9.4)", "pydata-sphinx-theme (>=0.14)", "sphinx (>=7)", "sphinx-gallery (>=0.14)", "texext (>=0.6.7)"] -extra = ["lxml (>=4.6)", "pydot (>=1.4.2)", "pygraphviz (>=1.11)", "sympy (>=1.10)"] +default = ["matplotlib (>=3.7)", "numpy (>=1.24)", "pandas (>=2.0)", "scipy (>=1.10,!=1.11.0,!=1.11.1)"] +developer = ["changelist (==0.5)", "mypy (>=1.1)", "pre-commit (>=3.2)", "rtoml"] +doc = ["intersphinx-registry", "myst-nb (>=1.1)", "numpydoc (>=1.8.0)", "pillow (>=9.4)", "pydata-sphinx-theme (>=0.15)", "sphinx (>=7.3)", "sphinx-gallery (>=0.16)", "texext (>=0.6.7)"] +example = ["cairocffi (>=1.7)", "contextily (>=1.6)", "igraph (>=0.11)", "momepy (>=0.7.2)", "osmnx (>=1.9)", "scikit-learn (>=1.5)", "seaborn (>=0.13)"] +extra = ["lxml (>=4.6)", "pydot (>=3.0.1)", "pygraphviz (>=1.14)", "sympy (>=1.10)"] test = ["pytest (>=7.2)", "pytest-cov (>=4.0)"] [[package]] @@ -2510,82 +2660,94 @@ files = [ [[package]] name = "py-ed25519-zebra-bindings" -version = "1.1.0" +version = "1.2.0" description = "Python bindings for the ed25519-zebra RUST crate" optional = false python-versions = ">=3.9" files = [ - {file = "py_ed25519_zebra_bindings-1.1.0-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:f0634c6b56cd81ce8bc10c322c14a7cd2a72f3742572c0dec332979df36e7cf5"}, - {file = "py_ed25519_zebra_bindings-1.1.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:cc91befe939088aedd176e46f1316b46b4c5dd8f44a14d309e49a634fd65dbe7"}, - {file = "py_ed25519_zebra_bindings-1.1.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:70cc6b1d460608b23e7a0f91ecb0cd4d8ed54762fc9035cc7d5d6a22358d5679"}, - {file = "py_ed25519_zebra_bindings-1.1.0-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:045396583efc93f16ee80df7739040a66cc7f8e048e9aec60d19e4cd2afaafb8"}, - {file = "py_ed25519_zebra_bindings-1.1.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:838ea2bb3f27907ec7a07aff6b267646b7c0c010f506673cbbc0d911e57cdfb8"}, - {file = "py_ed25519_zebra_bindings-1.1.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:716f090ab1564c9bf13e790b6f8bdea5ae40b68082def48f91023a8e12e38cf1"}, - {file = "py_ed25519_zebra_bindings-1.1.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2ebf8935bf1a856d9283916cfa62083b5cdfb24f7b772f42276fbf5b5af0f1f6"}, - {file = "py_ed25519_zebra_bindings-1.1.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:7a9e5652d3bc2e4e5ef7c12ba6767800b49f9504207e4210ac4bac9c2e31efa9"}, - {file = "py_ed25519_zebra_bindings-1.1.0-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:b846ffdfd035206e16e76026bc1f4cb45964068a929b76b2ec3289fef3ee420b"}, - {file = "py_ed25519_zebra_bindings-1.1.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:c97c0d04be12b299581daba0296bd522460a0f7001b9340d1551c0e2daea18a4"}, - {file = "py_ed25519_zebra_bindings-1.1.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:b1d8f8b04c2b3372ef33554d62fec44db28517dea1986944fc65ce3b35341800"}, - {file = "py_ed25519_zebra_bindings-1.1.0-cp310-none-win32.whl", hash = "sha256:3243cdaad41406c21e3840630ca46a997f30644a7b3c4aa7fe54c930d0ad66af"}, - {file = "py_ed25519_zebra_bindings-1.1.0-cp310-none-win_amd64.whl", hash = "sha256:278481a18225dc74e4292980c1859b1774b9e86da2d9a4cd63988717d24d421c"}, - {file = "py_ed25519_zebra_bindings-1.1.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:048e84121007b6ced32b70086e9bd710a825920f0715d73be4760c45f61847be"}, - {file = "py_ed25519_zebra_bindings-1.1.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:8200479a222da9bab0abbe35d9a60e4f658a4039054c3b9f2e58a102a393a658"}, - {file = "py_ed25519_zebra_bindings-1.1.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8ef039b7a7e4f1653e7f0c467d136a7e135061e53fdc74934d36489a8859f9e4"}, - {file = "py_ed25519_zebra_bindings-1.1.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d6d035b7bd3dd998ef6030666e69cde95c34225187f53ebb9c2fa7298a65ffde"}, - {file = "py_ed25519_zebra_bindings-1.1.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8f4a7bb72294f7f1f560a464832c0fc32bc0a20cf4d3b638f2428bf3dde6ebda"}, - {file = "py_ed25519_zebra_bindings-1.1.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:89735c2623bcf02177004eaa895250a3115214cd51df2ab561863f565aa06b1b"}, - {file = "py_ed25519_zebra_bindings-1.1.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:4a7cccd8ab3156d1f397c6476583e78427e93cd01fa82173df78b96e15eb9f4d"}, - {file = "py_ed25519_zebra_bindings-1.1.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:27483aa9262d0952e886d01ec174056503238064ce1f08a3fb17752db18071dd"}, - {file = "py_ed25519_zebra_bindings-1.1.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:b461baeb4adb5c5d916f8cf31651142744f29b90f010a71bb22beafe0d803f40"}, - {file = "py_ed25519_zebra_bindings-1.1.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:1b79af368be80b5cd32b2a678c775f113c1d76c6f0e1ea5e66586c81c9e0ab5b"}, - {file = "py_ed25519_zebra_bindings-1.1.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9555ccf645374e5282103416fe5cba60937d7bf12af676980bd4e18cfa2fab48"}, - {file = "py_ed25519_zebra_bindings-1.1.0-cp311-none-win32.whl", hash = "sha256:1c55a32c2070aa68e0ed5a2930ba547fbf47617fd279462171d5c0f87b00df6d"}, - {file = "py_ed25519_zebra_bindings-1.1.0-cp311-none-win_amd64.whl", hash = "sha256:c4a4dedb1b8edf7f68dd8015f9d8a20f2f0ecca90fac4432e5cbabfcc16ab13d"}, - {file = "py_ed25519_zebra_bindings-1.1.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:3ee9a0b7eb896547e539a27c4286461d58c6a99952ea27fa1b5f5e39e63019dc"}, - {file = "py_ed25519_zebra_bindings-1.1.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:93e2a12d0bbf58f4d1e5ae2a1c352e43302cadd747a1a5e88fea03ce7a78a562"}, - {file = "py_ed25519_zebra_bindings-1.1.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a33673e6047eba0a0a28e818fa0b36b703986347fc98e6f0f96e36af68756787"}, - {file = "py_ed25519_zebra_bindings-1.1.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:14399e6e8c5b9c193256a1b9aec16b9de719691de84ab23a690056cfe011d13b"}, - {file = "py_ed25519_zebra_bindings-1.1.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:85ea7a5632a1bf6713518bb56d4c8abe5128aee173a3c498b3a564cfb346ca72"}, - {file = "py_ed25519_zebra_bindings-1.1.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2a01f58a1c980df68c8efd43892562b3224507bab83d880910fbb4a3c84fc965"}, - {file = "py_ed25519_zebra_bindings-1.1.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:655360cd74718d4efb8fbaf7afb2e4ce459af5f1d399479f577a63bd9177aa3b"}, - {file = "py_ed25519_zebra_bindings-1.1.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:650081644c6613fdf658456ed4b2a6580ec1b54084f318a31a924ce5cf536bb9"}, - {file = "py_ed25519_zebra_bindings-1.1.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:5d56b81186fc75cbcf80d0549f83e98c62c4359460e512f9fb8d6c7be2a158dd"}, - {file = "py_ed25519_zebra_bindings-1.1.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:072bf62421ad890c1849aaa19c7b6e6a890d337f0622e9bd09161b180a10496c"}, - {file = "py_ed25519_zebra_bindings-1.1.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e09830c3672699f5f1f164fe92b102254ef68300ceaddc847d9a35bf4a2ec270"}, - {file = "py_ed25519_zebra_bindings-1.1.0-cp312-none-win32.whl", hash = "sha256:33ca2a7ad10846c281a73450316b390c7343e62e40516389fc1b580241f3907f"}, - {file = "py_ed25519_zebra_bindings-1.1.0-cp312-none-win_amd64.whl", hash = "sha256:4ba042528ddb81f8f025b1987bf8f19547f188efb7aa4c95d1a4e3e7f968e991"}, - {file = "py_ed25519_zebra_bindings-1.1.0-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:d75a61407651174841051d59ebcee5716207371999bef78055193e96b6dec546"}, - {file = "py_ed25519_zebra_bindings-1.1.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:b5afba0bd4ae86f06b278698d24acebe2d4b912e0490c94ee550a859377e5c05"}, - {file = "py_ed25519_zebra_bindings-1.1.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d977fb8d7f5594278ea3eb8283dac811cc35c925176454ccbb3ddf0110e194fa"}, - {file = "py_ed25519_zebra_bindings-1.1.0-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:83aa29a0d0df233591da3118142c818adc3f697143d655378ee076e6f091be7e"}, - {file = "py_ed25519_zebra_bindings-1.1.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:01f2952e5c7082dc9266d668528b27711874d0f5d2aa2e85994a46643b12686e"}, - {file = "py_ed25519_zebra_bindings-1.1.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f0db1e886f65a439fe9641196e05229715701df572a92b41428ad097d4889c5b"}, - {file = "py_ed25519_zebra_bindings-1.1.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:dada974b078204d1591851d0e5958824569900be3ea53676b84165ba16283641"}, - {file = "py_ed25519_zebra_bindings-1.1.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:c0f7aa0056c7af9df6c580880948cce42f779951e3e551573acf9b30462d9ca9"}, - {file = "py_ed25519_zebra_bindings-1.1.0-cp39-cp39-musllinux_1_2_armv7l.whl", hash = "sha256:2176111de560441caaf72f09da77a1d4f8eacbb34245e2531c7243ee4070829f"}, - {file = "py_ed25519_zebra_bindings-1.1.0-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:6f8686f160c4e7e928c79ad33919817b9eb608e5808154311a933078bad243b4"}, - {file = "py_ed25519_zebra_bindings-1.1.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:09b089af355cb0815cca4796407f89aaf08aceb5d39c5b7de087533319e3673e"}, - {file = "py_ed25519_zebra_bindings-1.1.0-cp39-none-win32.whl", hash = "sha256:12e5f602897c1c95217e406d80f2e7901c90b9345011c147c36989bfb7c3bb49"}, - {file = "py_ed25519_zebra_bindings-1.1.0-cp39-none-win_amd64.whl", hash = "sha256:119c3ca0c23570ead0a3ea9e8b7fb9716bf3675229562a7dadd815009cecf3eb"}, - {file = "py_ed25519_zebra_bindings-1.1.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ded8debbcffc756214cd55ebefff44fb23640c9f54edf34c0e43b371e2d2b42d"}, - {file = "py_ed25519_zebra_bindings-1.1.0-pp310-pypy310_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:db18ef79ea6dc0bc42e28cd46eb442d8e84c0c9c8b2809babd63608efe015ec9"}, - {file = "py_ed25519_zebra_bindings-1.1.0-pp310-pypy310_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:875bba860c5ce874e33e6d04c4804c8e4149754720bf47bd66c068a61c2ed3cc"}, - {file = "py_ed25519_zebra_bindings-1.1.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:de987c5c8b3a69504f82adc4d3b70aa322315550f945684111d8bfe40288517b"}, - {file = "py_ed25519_zebra_bindings-1.1.0-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:9721c029279a6e074d4a69a8ca2ee5da6264efda052fe07afcae6ca04e340805"}, - {file = "py_ed25519_zebra_bindings-1.1.0-pp310-pypy310_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:b8843fe090b793449fc8b581ff5d55c03ae9bb18ecd4943ef27c51751df9e5e8"}, - {file = "py_ed25519_zebra_bindings-1.1.0-pp310-pypy310_pp73-musllinux_1_2_armv7l.whl", hash = "sha256:b8da29729eb83c1aeeb80f0a60ceb30f6c00ba9c2c208548f6628b8f4764eccd"}, - {file = "py_ed25519_zebra_bindings-1.1.0-pp310-pypy310_pp73-musllinux_1_2_i686.whl", hash = "sha256:a99ab59da361a9834c0019954e72a7687fa19a3380c5acc3274452c26af3b791"}, - {file = "py_ed25519_zebra_bindings-1.1.0-pp310-pypy310_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:4b40b19b0259412171a36f51778bc9d8e92f21baea469549a03ff99318bc640e"}, - {file = "py_ed25519_zebra_bindings-1.1.0-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0b7c389eee3f99c1ad3b3fa32fc53914dda22876f8e2918b5b564b98f029dd92"}, - {file = "py_ed25519_zebra_bindings-1.1.0-pp39-pypy39_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f13dffb7875eea6b2bd8f9b1165e29d9cd3df2c919c2f2db0f164926c99393e8"}, - {file = "py_ed25519_zebra_bindings-1.1.0-pp39-pypy39_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a55f043d87e00e7d68fed03d02ac0725acd2dff9a03e61388285d6d920f6850f"}, - {file = "py_ed25519_zebra_bindings-1.1.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e48f09c403c58245cc6712ce34ba3cab91705c901a6c4bb1e865847f46b26ec9"}, - {file = "py_ed25519_zebra_bindings-1.1.0-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:17694b0afce037860043cf8237a990e8df9c307b4decb73028d794ae56733875"}, - {file = "py_ed25519_zebra_bindings-1.1.0-pp39-pypy39_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:c80f339abfc522248c749323b2cd6d555c3095128b01d845eb48a746318553da"}, - {file = "py_ed25519_zebra_bindings-1.1.0-pp39-pypy39_pp73-musllinux_1_2_armv7l.whl", hash = "sha256:89222bb4e16d1e222a95c622630f3380fe1896ab7d0cd145da39f3aa8888ed64"}, - {file = "py_ed25519_zebra_bindings-1.1.0-pp39-pypy39_pp73-musllinux_1_2_i686.whl", hash = "sha256:85904f3b4e11d2fc7358686e15c1e0e3707b4e1846e82d49d764c9c44881f2a3"}, - {file = "py_ed25519_zebra_bindings-1.1.0-pp39-pypy39_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:b4452e9ed752db2c1ed2b7c74e1d589dfa68101b04c3304ba87a3cb843d34306"}, - {file = "py_ed25519_zebra_bindings-1.1.0.tar.gz", hash = "sha256:2977603b59cfc593fb01284465fe41062d6929b0d09edf0e1ade40709977014f"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d488bf0ac70424514fddb3cf9cca6166ad149b7655970719e9bbef398054e6ad"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:7c3f97af9b0db7fe2bba1b1ac8d684711fc33e6383c067e1a1fc642e1595282a"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9798a82efe73cfff02eb4c09576af0dc0ca3b41cc3e17cf469179add708c8b40"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0837d10e19e72bb4665c584c89f207bad8b3d29cf2410c0f9ea310c6698f4b26"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:8bb278da1728db5259d5c29dcc95717336a69fc6e6159cb7400ac262ee8a96ca"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:5a739e82c82a1f62de54cc0482e9d007b961c84220849ffd86924e34f8db5c9e"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:d311a44ae162da4b391eb4d47675709b5044b925bef20e4e2209cdfa28ccc1ee"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:c4a30a6a22f28173de66634294824455ae683163be32565f36fbfa27b8a76495"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:325eb5d0c7a406fd6abbd5b2daeb6d16e4c161a86909bf11a34a3a2c351e7fa0"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp310-cp310-win32.whl", hash = "sha256:dcd8f8ecbc3593c54fb3fcc1d0d847d2fdf86c8d2e6840d319d152f4efdef498"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp310-cp310-win_amd64.whl", hash = "sha256:b762e13f1e2cedfac4be954a70a75330a5368e2c0ecd64db7ce1e2e9672ed4da"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:dbfe655442b73d49c1ac740f87a480cfee4c013fcb0ba2b639290b20f8dc9bb5"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:b03308c3eb2311b5d308c3df22dbf244073e4c014cda5da2609a562adb4121fc"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1828031f38f246d35c7c7b427c17a3525fc311c0402d3b32572510977b9d0f67"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f88238cf167ba5681e74a556b1e6ce825cb157825ce40c7f757b7d02a7c47dfb"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:2b25ca1596ae3be7e6ce6e78252ce7efa570000f9ba5b39cfe8dd10e79f73d50"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:68a33b1d8af961d28831caf2d481879bb1592f700da79aa5613d845ae6b8153a"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:41ee171c18852f6db4a86e68c4fbd622f5415f15c0ab9b40ac1fe66a8ddc3844"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:58623ff56bf1da2581a7d52507d9757ec3b03d49879fc8611646faf666bd0120"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:3fdd9cc305dd88562b9fe4d27762070bfdaa1e88647a1509a22fe252e17148d7"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:911f068d15159798309dc1895ce156b1bca2f91e34446be3ac5f54f2d3418979"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9d0fc9c1afbf4b5ff0bc03accf5f07bf53971839eb373d1139eb3bb5a02b3bd0"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp311-cp311-win32.whl", hash = "sha256:256b96fdf0e264a348bf4176c0fb180a0efc6627ac312cb5e71ec95b347d1ff5"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp311-cp311-win_amd64.whl", hash = "sha256:efa06b8a0e11c62c10fdf576679ab3039aa6a7254e6cfa4d2d230941799fef5b"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:8d63a447d3adac9b431fecd886cf711a6d44200d8b2497598a8ab44ac897f1fb"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a5b1c32414a6da709e84d0614e1ed153a5e1dbcbf6d4d17baa31c493fdbd4da4"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:780073555571390c4b355b5646c0b59c2a90d3393e354d58c4ad904121a2aee2"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:677ade8ab3348604a9e4176b068ff19707cf205fd8ee4f1781614b085628fa45"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c19c0cc491bc4999245f9d2e904f611354f442710b6dae6d1d6ebc81666124cc"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1317a8af53c658f1e89b346d361edaf10eccd428c937a17d0684b2192fa77c40"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:cdc05ade2608707f6c54701e7425d9c00751ccffa57533a48f68f61b0aada9f1"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ec1965ed54fd162da564cc33676377888bd1ad14c15680465463d06e14aac74d"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:7386e7cec522ac50e7d81cfc8488e463fe93902d6ba0f7c79d6f6db0fcf71111"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:b06102b2be52da075f29f0db907bb5a03af942e2f6fb558065ea5717aa567d32"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:4237cf821f74126077220d5826448c0b68c8807f40db961b1335bb6a66a83af8"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp312-cp312-win32.whl", hash = "sha256:fe11223695c94040f31b48a2128f1642a1b689aaaa91b5f8ae018d53b1497409"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:87654379855152770974c045099e488b577d86429af609524903b8029b276417"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:2e10a578c1297a9b12a818c5b874d9830afba1592e8cb9df3a44b2afbc241cf0"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7f0edbed9d94f5295c4f360baa38e124626296e36f315d6a19bc91f7d8a61627"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fe2d0db5c2d4c0575b91373eb0c33b1d222fbb38664e17d807c8845eab268c16"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:4b371742adbd9be4a5a813e5d920a1a057fe9013620681651a3e7c84fd1f8d8b"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f82a6ae05ac4feb16d077ce1b4a48396c9685bc2b37d3a1ffbcd16023a4f3b8a"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:446f26b62311db93205507fedb3fa07dae786ae75822182d44dadd28984d7768"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:f76ccb64577bbdfdacc543298355747dca9684e74262f844c3d892bd583e023b"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c5c95587f93f9cbf73e3609e8befe2b36c488bcf96ccc1c8c63b257212e1b9df"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:3f157f87844d5e395380eaf03d9baa2108126ad276088c7edb55869683cc2cfc"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:022499a21096d03d90654af2203a5475f6c3c5572245b7bc6a1bbeeb4e42c319"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:7b466ec2de929e38e6f441156a3e108a3c090dbc6b624864f6c1b300cc329f8d"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:998b5d9c4db1053156a55e8edf06a5dce68ddaa3e928e2861f8ba9a5fe5b6119"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3a0fe34c20032f406a78c865c308b49fe3c79c9e1642f6471228cfbc6c513348"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f7e3273d73148d983a5e7f9ed3e8b53824dcb7833393aa09dd969dd3e7a1f3c1"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:cb5858f54ebd7d37c9d21c6dd80367d0031dbda7bd91b333018c0f243e1284f5"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:4fd00c8686b17e31ec29d8e4e7ce97f465fe26227f12c9e111e012b9d0dff4b9"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:e4e55fc5be4ba0c723d424cefdbb8d863e74d2ff25fbeadca9539ca60d78cc0f"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:91816ed4cef90d4d08fa9f55fa0c5687c5eba601dc1a44f211adcf1c20d96cc3"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:da78de274a8276ba8127cd1a0c8dc7889162703d0f21b8ca136587a40ab911fb"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:acc66206412d2abbfb088bd4027c7e21949975cc66f5ccd6249b8937a3cf315d"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:71f36c2465d808149604e536e50e3d6038c5bc83165df3b71a78345a66437819"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7c8ff027c9363f9c52ee36967b74e948f583e90a5bcbc24b31831a5ce9a25173"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:161f5996ac22ba224e3c1026fef7992a7f2be71685f7dc3208b2f94039a680cc"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:eeec2b39546ebea93f96cfd8c7984e1d5489c4767f053225b1b71da1aba60273"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp39-cp39-musllinux_1_2_armv7l.whl", hash = "sha256:4524e3a900d6f11daa12185ee0d96c11f215ddf714b697599d8f0ec99d03275a"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:0614733ed55ad8bd80a4a3a8abf21d26e39678c6fe31ee164388c7dc543e070d"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:aa9a2a610ffe5b576513ff4d6bd77b79e1c818c1a11df51522e7a82c9c299059"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp39-cp39-win32.whl", hash = "sha256:81b2dac4669d2935edf5953eb53c2507023774d2fa6e3a51743e8e3757f28e1a"}, + {file = "py_ed25519_zebra_bindings-1.2.0-cp39-cp39-win_amd64.whl", hash = "sha256:3503a179561ada2ac456351e211a28b433083d5fa48ff605e9670ae51797ea12"}, + {file = "py_ed25519_zebra_bindings-1.2.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3f76228db22d018a66e858b27d4c074a0111438919a45276ac1a00d397d6daca"}, + {file = "py_ed25519_zebra_bindings-1.2.0-pp310-pypy310_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:4f7c0875eda221bfdc1029207d7807c2ae5446bf4aaf5d34def94b8fa2abeace"}, + {file = "py_ed25519_zebra_bindings-1.2.0-pp310-pypy310_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0c713b7dba676380e2a1c3208667a71bf4bcc02a67b487894cda35c6103079e9"}, + {file = "py_ed25519_zebra_bindings-1.2.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1fe2882a1377199cdb656e42adf5e97869d1b04af1f66a7300179f95692603c2"}, + {file = "py_ed25519_zebra_bindings-1.2.0-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c6afd09a1b831444a5107ca8e48f14db837a2351cac25e70e71f80f976c76ca2"}, + {file = "py_ed25519_zebra_bindings-1.2.0-pp310-pypy310_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:91c0627efe7048ce552be5db08c11a99d532b2e115316daed3b53e52ba9f383b"}, + {file = "py_ed25519_zebra_bindings-1.2.0-pp310-pypy310_pp73-musllinux_1_2_armv7l.whl", hash = "sha256:d6efc48c7c26838044c7f58ba2e7944776ef6eaef21c962a528ddffd3943e1b4"}, + {file = "py_ed25519_zebra_bindings-1.2.0-pp310-pypy310_pp73-musllinux_1_2_i686.whl", hash = "sha256:7cb8befc4c52c681c4e2f5994adeff28f529f767c979921faaa1fbb84a52afae"}, + {file = "py_ed25519_zebra_bindings-1.2.0-pp310-pypy310_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:3b976f2c6053011c08dcde2f5805e285a8ff53eec5a42be0cc24ce93bc5729ac"}, + {file = "py_ed25519_zebra_bindings-1.2.0-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5f7ac9e2f0856b2ce3db7bfb6bb1b750e2533846b8aaf6106d5edc4fca33d4e2"}, + {file = "py_ed25519_zebra_bindings-1.2.0-pp39-pypy39_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e97df330d22c671e4e494b4e4f85ab06a4b067f38201430d8d08e687c6c1ef25"}, + {file = "py_ed25519_zebra_bindings-1.2.0-pp39-pypy39_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ac83999ed7ef81a64830495ad356e587ff89bdc20c79ad81d2baf8e38c707d76"}, + {file = "py_ed25519_zebra_bindings-1.2.0-pp39-pypy39_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:78c23fe0e20159268ee343110a9afe58813691c9fe94bfb3525efcd23af97b81"}, + {file = "py_ed25519_zebra_bindings-1.2.0-pp39-pypy39_pp73-musllinux_1_2_armv7l.whl", hash = "sha256:900e1fd3d1474b02342d5e388fe874b2b71d1c87e4e652ed5b7773ca25c34754"}, + {file = "py_ed25519_zebra_bindings-1.2.0-pp39-pypy39_pp73-musllinux_1_2_i686.whl", hash = "sha256:c11f644619ca166fb62b6ec4586d53fc74e1bc3a5345e9b84af6baca7b5ca6b1"}, + {file = "py_ed25519_zebra_bindings-1.2.0-pp39-pypy39_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:f03a9514c7e763367128a7e6be529fe8417775f72d5d717c0c3004047f188596"}, + {file = "py_ed25519_zebra_bindings-1.2.0.tar.gz", hash = "sha256:d9ec63d54b1801d5b5bdef0b3096ed94e2e1a7c870c937682afc7b8b25ffc2fc"}, ] [[package]] @@ -2940,6 +3102,33 @@ files = [ [package.dependencies] typing-extensions = ">=4.6.0,<4.7.0 || >4.7.0" +[[package]] +name = "pydata-sphinx-theme" +version = "0.16.0" +description = "Bootstrap-based Sphinx theme from the PyData community" +optional = false +python-versions = ">=3.9" +files = [ + {file = "pydata_sphinx_theme-0.16.0-py3-none-any.whl", hash = "sha256:18c810ee4e67e05281e371e156c1fb5bb0fa1f2747240461b225272f7d8d57d8"}, + {file = "pydata_sphinx_theme-0.16.0.tar.gz", hash = "sha256:721dd26e05fa8b992d66ef545536e6cbe0110afb9865820a08894af1ad6f7707"}, +] + +[package.dependencies] +accessible-pygments = "*" +Babel = "*" +beautifulsoup4 = "*" +docutils = "!=0.17.0" +pygments = ">=2.7" +sphinx = ">=6.1" +typing-extensions = "*" + +[package.extras] +a11y = ["pytest-playwright"] +dev = ["pandoc", "pre-commit", "pydata-sphinx-theme[doc,test]", "pyyaml", "sphinx-theme-builder[cli]", "tox"] +doc = ["ablog (>=0.11.8)", "colorama", "graphviz", "ipykernel", "ipyleaflet", "ipywidgets", "jupyter_sphinx", "jupyterlite-sphinx", "linkify-it-py", "matplotlib", "myst-parser", "nbsphinx", "numpy", "numpydoc", "pandas", "plotly", "rich", "sphinx-autoapi (>=3.0.0)", "sphinx-copybutton", "sphinx-design", "sphinx-favicon (>=1.0.1)", "sphinx-sitemap", "sphinx-togglebutton", "sphinxcontrib-youtube (>=1.4.1)", "sphinxext-rediraffe", "xarray"] +i18n = ["Babel", "jinja2"] +test = ["pytest", "pytest-cov", "pytest-regressions", "sphinx[test]"] + [[package]] name = "pygments" version = "2.18.0" @@ -3453,6 +3642,196 @@ files = [ {file = "sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc"}, ] +[[package]] +name = "snowballstemmer" +version = "2.2.0" +description = "This package provides 29 stemmers for 28 languages generated from Snowball algorithms." +optional = false +python-versions = "*" +files = [ + {file = "snowballstemmer-2.2.0-py2.py3-none-any.whl", hash = "sha256:c8e1716e83cc398ae16824e5572ae04e0d9fc2c6b985fb0f900f5f0c96ecba1a"}, + {file = "snowballstemmer-2.2.0.tar.gz", hash = "sha256:09b16deb8547d3412ad7b590689584cd0fe25ec8db3be37788be3810cbf19cb1"}, +] + +[[package]] +name = "soupsieve" +version = "2.6" +description = "A modern CSS selector implementation for Beautiful Soup." +optional = false +python-versions = ">=3.8" +files = [ + {file = "soupsieve-2.6-py3-none-any.whl", hash = "sha256:e72c4ff06e4fb6e4b5a9f0f55fe6e81514581fca1515028625d0f299c602ccc9"}, + {file = "soupsieve-2.6.tar.gz", hash = "sha256:e2e68417777af359ec65daac1057404a3c8a5455bb8abc36f1a9866ab1a51abb"}, +] + +[[package]] +name = "sphinx" +version = "8.1.3" +description = "Python documentation generator" +optional = false +python-versions = ">=3.10" +files = [ + {file = "sphinx-8.1.3-py3-none-any.whl", hash = "sha256:09719015511837b76bf6e03e42eb7595ac8c2e41eeb9c29c5b755c6b677992a2"}, + {file = "sphinx-8.1.3.tar.gz", hash = "sha256:43c1911eecb0d3e161ad78611bc905d1ad0e523e4ddc202a58a821773dc4c927"}, +] + +[package.dependencies] +alabaster = ">=0.7.14" +babel = ">=2.13" +colorama = {version = ">=0.4.6", markers = "sys_platform == \"win32\""} +docutils = ">=0.20,<0.22" +imagesize = ">=1.3" +Jinja2 = ">=3.1" +packaging = ">=23.0" +Pygments = ">=2.17" +requests = ">=2.30.0" +snowballstemmer = ">=2.2" +sphinxcontrib-applehelp = ">=1.0.7" +sphinxcontrib-devhelp = ">=1.0.6" +sphinxcontrib-htmlhelp = ">=2.0.6" +sphinxcontrib-jsmath = ">=1.0.1" +sphinxcontrib-qthelp = ">=1.0.6" +sphinxcontrib-serializinghtml = ">=1.1.9" +tomli = {version = ">=2", markers = "python_version < \"3.11\""} + +[package.extras] +docs = ["sphinxcontrib-websupport"] +lint = ["flake8 (>=6.0)", "mypy (==1.11.1)", "pyright (==1.1.384)", "pytest (>=6.0)", "ruff (==0.6.9)", "sphinx-lint (>=0.9)", "tomli (>=2)", "types-Pillow (==10.2.0.20240822)", "types-Pygments (==2.18.0.20240506)", "types-colorama (==0.4.15.20240311)", "types-defusedxml (==0.7.0.20240218)", "types-docutils (==0.21.0.20241005)", "types-requests (==2.32.0.20240914)", "types-urllib3 (==1.26.25.14)"] +test = ["cython (>=3.0)", "defusedxml (>=0.7.1)", "pytest (>=8.0)", "setuptools (>=70.0)", "typing_extensions (>=4.9)"] + +[[package]] +name = "sphinx-autodoc-typehints" +version = "2.5.0" +description = "Type hints (PEP 484) support for the Sphinx autodoc extension" +optional = false +python-versions = ">=3.10" +files = [ + {file = "sphinx_autodoc_typehints-2.5.0-py3-none-any.whl", hash = "sha256:53def4753239683835b19bfa8b68c021388bd48a096efcb02cdab508ece27363"}, + {file = "sphinx_autodoc_typehints-2.5.0.tar.gz", hash = "sha256:259e1026b218d563d72743f417fcc25906a9614897fe37f91bd8d7d58f748c3b"}, +] + +[package.dependencies] +sphinx = ">=8.0.2" + +[package.extras] +docs = ["furo (>=2024.8.6)"] +numpy = ["nptyping (>=2.5)"] +testing = ["covdefaults (>=2.3)", "coverage (>=7.6.1)", "defusedxml (>=0.7.1)", "diff-cover (>=9.1.1)", "pytest (>=8.3.2)", "pytest-cov (>=5)", "sphobjinv (>=2.3.1.1)", "typing-extensions (>=4.12.2)"] + +[[package]] +name = "sphinx-book-theme" +version = "1.1.3" +description = "A clean book theme for scientific explanations and documentation with Sphinx" +optional = false +python-versions = ">=3.9" +files = [ + {file = "sphinx_book_theme-1.1.3-py3-none-any.whl", hash = "sha256:a554a9a7ac3881979a87a2b10f633aa2a5706e72218a10f71be38b3c9e831ae9"}, + {file = "sphinx_book_theme-1.1.3.tar.gz", hash = "sha256:1f25483b1846cb3d353a6bc61b3b45b031f4acf845665d7da90e01ae0aef5b4d"}, +] + +[package.dependencies] +pydata-sphinx-theme = ">=0.15.2" +sphinx = ">=5" + +[package.extras] +code-style = ["pre-commit"] +doc = ["ablog", "folium", "ipywidgets", "matplotlib", "myst-nb", "nbclient", "numpy", "numpydoc", "pandas", "plotly", "sphinx-copybutton", "sphinx-design", "sphinx-examples", "sphinx-tabs", "sphinx-thebe", "sphinx-togglebutton", "sphinxcontrib-bibtex", "sphinxcontrib-youtube", "sphinxext-opengraph"] +test = ["beautifulsoup4", "coverage", "defusedxml", "myst-nb", "pytest", "pytest-cov", "pytest-regressions", "sphinx_thebe"] + +[[package]] +name = "sphinxcontrib-applehelp" +version = "2.0.0" +description = "sphinxcontrib-applehelp is a Sphinx extension which outputs Apple help books" +optional = false +python-versions = ">=3.9" +files = [ + {file = "sphinxcontrib_applehelp-2.0.0-py3-none-any.whl", hash = "sha256:4cd3f0ec4ac5dd9c17ec65e9ab272c9b867ea77425228e68ecf08d6b28ddbdb5"}, + {file = "sphinxcontrib_applehelp-2.0.0.tar.gz", hash = "sha256:2f29ef331735ce958efa4734873f084941970894c6090408b079c61b2e1c06d1"}, +] + +[package.extras] +lint = ["mypy", "ruff (==0.5.5)", "types-docutils"] +standalone = ["Sphinx (>=5)"] +test = ["pytest"] + +[[package]] +name = "sphinxcontrib-devhelp" +version = "2.0.0" +description = "sphinxcontrib-devhelp is a sphinx extension which outputs Devhelp documents" +optional = false +python-versions = ">=3.9" +files = [ + {file = "sphinxcontrib_devhelp-2.0.0-py3-none-any.whl", hash = "sha256:aefb8b83854e4b0998877524d1029fd3e6879210422ee3780459e28a1f03a8a2"}, + {file = "sphinxcontrib_devhelp-2.0.0.tar.gz", hash = "sha256:411f5d96d445d1d73bb5d52133377b4248ec79db5c793ce7dbe59e074b4dd1ad"}, +] + +[package.extras] +lint = ["mypy", "ruff (==0.5.5)", "types-docutils"] +standalone = ["Sphinx (>=5)"] +test = ["pytest"] + +[[package]] +name = "sphinxcontrib-htmlhelp" +version = "2.1.0" +description = "sphinxcontrib-htmlhelp is a sphinx extension which renders HTML help files" +optional = false +python-versions = ">=3.9" +files = [ + {file = "sphinxcontrib_htmlhelp-2.1.0-py3-none-any.whl", hash = "sha256:166759820b47002d22914d64a075ce08f4c46818e17cfc9470a9786b759b19f8"}, + {file = "sphinxcontrib_htmlhelp-2.1.0.tar.gz", hash = "sha256:c9e2916ace8aad64cc13a0d233ee22317f2b9025b9cf3295249fa985cc7082e9"}, +] + +[package.extras] +lint = ["mypy", "ruff (==0.5.5)", "types-docutils"] +standalone = ["Sphinx (>=5)"] +test = ["html5lib", "pytest"] + +[[package]] +name = "sphinxcontrib-jsmath" +version = "1.0.1" +description = "A sphinx extension which renders display math in HTML via JavaScript" +optional = false +python-versions = ">=3.5" +files = [ + {file = "sphinxcontrib-jsmath-1.0.1.tar.gz", hash = "sha256:a9925e4a4587247ed2191a22df5f6970656cb8ca2bd6284309578f2153e0c4b8"}, + {file = "sphinxcontrib_jsmath-1.0.1-py2.py3-none-any.whl", hash = "sha256:2ec2eaebfb78f3f2078e73666b1415417a116cc848b72e5172e596c871103178"}, +] + +[package.extras] +test = ["flake8", "mypy", "pytest"] + +[[package]] +name = "sphinxcontrib-qthelp" +version = "2.0.0" +description = "sphinxcontrib-qthelp is a sphinx extension which outputs QtHelp documents" +optional = false +python-versions = ">=3.9" +files = [ + {file = "sphinxcontrib_qthelp-2.0.0-py3-none-any.whl", hash = "sha256:b18a828cdba941ccd6ee8445dbe72ffa3ef8cbe7505d8cd1fa0d42d3f2d5f3eb"}, + {file = "sphinxcontrib_qthelp-2.0.0.tar.gz", hash = "sha256:4fe7d0ac8fc171045be623aba3e2a8f613f8682731f9153bb2e40ece16b9bbab"}, +] + +[package.extras] +lint = ["mypy", "ruff (==0.5.5)", "types-docutils"] +standalone = ["Sphinx (>=5)"] +test = ["defusedxml (>=0.7.1)", "pytest"] + +[[package]] +name = "sphinxcontrib-serializinghtml" +version = "2.0.0" +description = "sphinxcontrib-serializinghtml is a sphinx extension which outputs \"serialized\" HTML files (json and pickle)" +optional = false +python-versions = ">=3.9" +files = [ + {file = "sphinxcontrib_serializinghtml-2.0.0-py3-none-any.whl", hash = "sha256:6e2cb0eef194e10c27ec0023bfeb25badbbb5868244cf5bc5bdc04e4464bf331"}, + {file = "sphinxcontrib_serializinghtml-2.0.0.tar.gz", hash = "sha256:e9d912827f872c029017a53f0ef2180b327c3f7fd23c87229f7a8e8b70031d4d"}, +] + +[package.extras] +lint = ["mypy", "ruff (==0.5.5)", "types-docutils"] +standalone = ["Sphinx (>=5)"] +test = ["pytest"] + [[package]] name = "starlette" version = "0.37.2" @@ -3466,7 +3845,6 @@ files = [ [package.dependencies] anyio = ">=3.4.0,<5" -typing-extensions = {version = ">=3.10.0", markers = "python_version < \"3.10\""} [package.extras] full = ["httpx (>=0.22.0)", "itsdangerous", "jinja2", "python-multipart (>=0.0.7)", "pyyaml"] @@ -3765,13 +4143,13 @@ zstd = ["zstandard (>=0.18.0)"] [[package]] name = "uvicorn" -version = "0.32.1" +version = "0.34.0" description = "The lightning-fast ASGI server." optional = false -python-versions = ">=3.8" +python-versions = ">=3.9" files = [ - {file = "uvicorn-0.32.1-py3-none-any.whl", hash = "sha256:82ad92fd58da0d12af7482ecdb5f2470a04c9c9a53ced65b9bbb4a205377602e"}, - {file = "uvicorn-0.32.1.tar.gz", hash = "sha256:ee9519c246a72b1c084cea8d3b44ed6026e78a4a309cbedae9c37e4cb9fbb175"}, + {file = "uvicorn-0.34.0-py3-none-any.whl", hash = "sha256:023dc038422502fa28a09c7a30bf2b6991512da7dcdb8fd35fe57cfc154126f4"}, + {file = "uvicorn-0.34.0.tar.gz", hash = "sha256:404051050cd7e905de2c9a7e61790943440b3416f49cb409f965d9dcd0fa73e9"}, ] [package.dependencies] @@ -3892,13 +4270,13 @@ test = ["pytest (>=6.0.0)", "setuptools (>=65)"] [[package]] name = "win32-setctime" -version = "1.1.0" +version = "1.2.0" description = "A small Python utility to set file creation time on Windows" optional = false python-versions = ">=3.5" files = [ - {file = "win32_setctime-1.1.0-py3-none-any.whl", hash = "sha256:231db239e959c2fe7eb1d7dc129f11172354f98361c4fa2d6d2d7e278baa8aad"}, - {file = "win32_setctime-1.1.0.tar.gz", hash = "sha256:15cf5750465118d6929ae4de4eb46e8edae9a5634350c01ba582df868e932cb2"}, + {file = "win32_setctime-1.2.0-py3-none-any.whl", hash = "sha256:95d644c4e708aba81dc3704a116d8cbc974d70b3bdb8be1d150e36be6e9d1390"}, + {file = "win32_setctime-1.2.0.tar.gz", hash = "sha256:ae1fdf948f5640aae05c511ade119313fb6a30d7eabe25fef9764dca5873c4c0"}, ] [package.extras] @@ -4134,5 +4512,5 @@ propcache = ">=0.2.0" [metadata] lock-version = "2.0" -python-versions = ">=3.9,<3.13" -content-hash = "fbb98a9a62425d6be233083ab21bae8b00041c0e83f6de7940c9d78aca1b663f" +python-versions = ">=3.10,<3.13" +content-hash = "ae3a63ef620d5fdfa8c6876ab324befa2f4791162dc59930506cb819a66b96d1" diff --git a/pyproject.toml b/pyproject.toml index 617a78c..7c35bd0 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,11 +1,11 @@ [tool.poetry] name = "atom" -version = "0.1.0" +version = "1.0.0" description = "macrocosmos-sdk" authors = ["Brian McCrindle "] [tool.poetry.dependencies] -python = ">=3.9,<3.13" # Adjust based on your Python version +python = ">=3.10,<3.13" # Adjust based on your Python version bittensor = ">=8.3.1" pydantic = ">=2.3,<3" datasets = ">=2.14.6" @@ -16,6 +16,10 @@ substrate-interface = "^1.7.11" [tool.poetry.dev-dependencies] black = "^23.9.1" +sphinx = "8.1.3" +sphinx-book-theme = "1.1.3" +sphinx-autodoc-typehints = "2.5.0" +ghp-import = "2.1.0" [build-system] requires = ["poetry-core>=1.0.0"]