near-jsonrpc-client 1.0.21__tar.gz → 1.0.23__tar.gz

{near_jsonrpc_client-1.0.21 → near_jsonrpc_client-1.0.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: near-jsonrpc-client
-Version: 1.0.21
+Version: 1.0.23
 Summary: A typed Python client for the NEAR JSON-RPC API with Pydantic models and async HTTP support
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
@@ -174,24 +174,24 @@ print(response)
 The client raises structured exceptions:
 
 * `RpcError` – returned from NEAR JSON-RPC
-* `HttpError` – HTTP errors with status code and body
-* `RequestTimeoutError` – request timeout
-* `ClientError` – unexpected or invalid responses
+* `RpcHttpError` – HTTP errors with status code and body
+* `RpcTimeoutError` – request timeout
+* `RpcClientError` – unexpected or invalid responses
 
 Example:
 
 ```python
-from near_jsonrpc_client import RpcError, HttpError, RequestTimeoutError, ClientError
+from near_jsonrpc_client import RpcError, RpcHttpError, RpcTimeoutError, RpcClientError
 
 try:
     block = client.block(params=params)
 except RpcError as e:
     print(f"RPC error: {e.error}")
-except HttpError as e:
+except RpcHttpError as e:
     print(f"HTTP error: {e.status_code}, {e.body}")
-except RequestTimeoutError as e:
+except RpcTimeoutError as e:
     print("Request timed out")
-except ClientError as e:
+except RpcClientError as e:
     print("Invalid response", e)
 ```
 

{near_jsonrpc_client-1.0.21 → near_jsonrpc_client-1.0.23}/README.md

@@ -162,24 +162,24 @@ print(response)
 The client raises structured exceptions:
 
 * `RpcError` – returned from NEAR JSON-RPC
-* `HttpError` – HTTP errors with status code and body
-* `RequestTimeoutError` – request timeout
-* `ClientError` – unexpected or invalid responses
+* `RpcHttpError` – HTTP errors with status code and body
+* `RpcTimeoutError` – request timeout
+* `RpcClientError` – unexpected or invalid responses
 
 Example:
 
 ```python
-from near_jsonrpc_client import RpcError, HttpError, RequestTimeoutError, ClientError
+from near_jsonrpc_client import RpcError, RpcHttpError, RpcTimeoutError, RpcClientError
 
 try:
     block = client.block(params=params)
 except RpcError as e:
     print(f"RPC error: {e.error}")
-except HttpError as e:
+except RpcHttpError as e:
     print(f"HTTP error: {e.status_code}, {e.body}")
-except RequestTimeoutError as e:
+except RpcTimeoutError as e:
     print("Request timed out")
-except ClientError as e:
+except RpcClientError as e:
     print("Invalid response", e)
 ```
 

{near_jsonrpc_client-1.0.21 → near_jsonrpc_client-1.0.23}/near_jsonrpc_client/__init__.py

@@ -1,9 +1,9 @@
 from .client import NearClientAsync, NearClientSync
 from .transport import HttpTransportAsync, HttpTransportSync
 from .errors import (
-    ClientError,
-    TransportError,
-    HttpError,
+    RpcClientError,
+    RpcTransportError,
+    RpcHttpError,
     RpcError,
     RpcTimeoutError
 )
@@ -19,9 +19,9 @@ __all__ = [
     "HttpTransportSync",
 
     # Errors
-    "ClientError",
-    "TransportError",
-    "HttpError",
+    "RpcClientError",
+    "RpcTransportError",
+    "RpcHttpError",
     "RpcError",
     "RpcTimeoutError"
 ]

{near_jsonrpc_client-1.0.21 → near_jsonrpc_client-1.0.23}/near_jsonrpc_client/base_client.py

@@ -7,11 +7,11 @@ from pydantic import BaseModel
 from typing import get_args
 
 from .errors import (
-    ClientError,
-    TransportError,
-    HttpError,
+    RpcClientError,
+    RpcTransportError,
+    RpcHttpError,
     RpcError,
-    RequestTimeoutError,
+    RpcTimeoutError,
 )
 from .transport import HttpTransportAsync, HttpTransportSync
 
@@ -19,13 +19,13 @@ from .transport import HttpTransportAsync, HttpTransportSync
 def _extract_method(request_model: Type[BaseModel]) -> str:
     field = request_model.model_fields.get("method")
     if field is None:
-        raise ClientError(
+        raise RpcClientError(
             f"{request_model.__name__} does not define a 'method' field"
         )
 
     args = get_args(field.annotation)
     if len(args) != 1 or not isinstance(args[0], str):
-        raise ClientError(
+        raise RpcClientError(
             f"Invalid JSON-RPC method definition in {request_model.__name__}"
         )
 
@@ -39,9 +39,9 @@ def _parse_response(response_model: Type[BaseModel], response_json: dict):
     except Exception as e:
 
         if response_json["result"]["error"] is not None:
-            raise ClientError(response_json["result"]["error"]) from e
+            raise RpcClientError(response_json["result"]["error"]) from e
 
-        raise ClientError("Invalid response format") from e
+        raise RpcClientError("Invalid response format") from e
 
     inner = parsed.root
     if hasattr(inner, "error") and inner.error is not None:
@@ -87,12 +87,12 @@ class NearBaseClientAsync:
                 print("⬅️ JSON-RPC Raw Response:", response.text)
 
         except httpx.TimeoutException as e:
-            raise RequestTimeoutError() from e
+            raise RpcTimeoutError() from e
         except httpx.RequestError as e:
-            raise TransportError(str(e)) from e
+            raise RpcTransportError(str(e)) from e
 
         if 500 <= response.status_code < 600:
-            raise HttpError(status_code=response.status_code, body=response.text)
+            raise RpcHttpError(status_code=response.status_code, body=response.text)
 
         return _parse_response(response_model, response.json())
 
@@ -139,12 +139,12 @@ class NearBaseClientSync:
 
         # handle sync transport exceptions (requests or httpx sync)
         except requests.Timeout as e:
-            raise RequestTimeoutError() from e
+            raise RpcTimeoutError() from e
         except requests.RequestException as e:
-            raise TransportError(str(e)) from e
+            raise RpcTransportError(str(e)) from e
 
         if 500 <= response.status_code < 600:
-            raise HttpError(status_code=response.status_code, body=response.text)
+            raise RpcHttpError(status_code=response.status_code, body=response.text)
 
         return _parse_response(response_model, response.json())
 

{near_jsonrpc_client-1.0.21 → near_jsonrpc_client-1.0.23}/near_jsonrpc_client/errors.py

@@ -1,17 +1,17 @@
 from pydantic import BaseModel
 
 
-class ClientError(Exception):
+class RpcClientError(Exception):
     """Base error for all NEAR client related failures."""
     pass
 
 
-class TransportError(ClientError):
+class RpcTransportError(RpcClientError):
     """Network-level errors (timeout, DNS, connection, etc)."""
     pass
 
 
-class HttpError(ClientError):
+class RpcHttpError(RpcClientError):
     """Non-200 HTTP responses."""
 
     def __init__(self, status_code: int, body: str | None = None):
@@ -20,7 +20,7 @@ class HttpError(ClientError):
         super().__init__(f"HTTP error {status_code}")
 
 
-class RpcError(ClientError):
+class RpcError(RpcClientError):
     """JSON-RPC error object wrapping the Pydantic error model."""
 
     def __init__(self, error: BaseModel | str):
@@ -32,7 +32,7 @@ class RpcError(ClientError):
             super().__init__(error)
 
 
-class RpcTimeoutError(ClientError):
+class RpcTimeoutError(RpcClientError):
     """Timeout Error"""
 
     def __init__(self):

{near_jsonrpc_client-1.0.21 → near_jsonrpc_client-1.0.23}/near_jsonrpc_client.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: near-jsonrpc-client
-Version: 1.0.21
+Version: 1.0.23
 Summary: A typed Python client for the NEAR JSON-RPC API with Pydantic models and async HTTP support
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
@@ -174,24 +174,24 @@ print(response)
 The client raises structured exceptions:
 
 * `RpcError` – returned from NEAR JSON-RPC
-* `HttpError` – HTTP errors with status code and body
-* `RequestTimeoutError` – request timeout
-* `ClientError` – unexpected or invalid responses
+* `RpcHttpError` – HTTP errors with status code and body
+* `RpcTimeoutError` – request timeout
+* `RpcClientError` – unexpected or invalid responses
 
 Example:
 
 ```python
-from near_jsonrpc_client import RpcError, HttpError, RequestTimeoutError, ClientError
+from near_jsonrpc_client import RpcError, RpcHttpError, RpcTimeoutError, RpcClientError
 
 try:
     block = client.block(params=params)
 except RpcError as e:
     print(f"RPC error: {e.error}")
-except HttpError as e:
+except RpcHttpError as e:
     print(f"HTTP error: {e.status_code}, {e.body}")
-except RequestTimeoutError as e:
+except RpcTimeoutError as e:
     print("Request timed out")
-except ClientError as e:
+except RpcClientError as e:
     print("Invalid response", e)
 ```
 

{near_jsonrpc_client-1.0.21 → near_jsonrpc_client-1.0.23}/near_jsonrpc_models/dynamic_resharding_config_view.py

@@ -1,23 +1,22 @@
-"""Configuration for dynamic resharding feature"""
+"""Configuration for dynamic resharding feature
+See [`DynamicReshardingConfig`] for more details."""
 
+from near_jsonrpc_models.shard_id import ShardId
 from pydantic import BaseModel
 from pydantic import conint
+from typing import List
 
 
 class DynamicReshardingConfigView(BaseModel):
+    # Shards that should **not** be split even when they meet the regular split criteria.
+    block_split_shards: List[ShardId]
+    # Shards that should be split even when they don't meet the regular split criteria.
+    force_split_shards: List[ShardId]
     # Maximum number of shards in the network.
-    # 
-    # See [`CongestionControlConfig`] for more details.
     max_number_of_shards: conint(ge=0, le=18446744073709551615)
     # Memory threshold over which a shard is marked for a split.
-    # 
-    # See [`CongestionControlConfig`] for more details.
     memory_usage_threshold: conint(ge=0, le=18446744073709551615)
     # Minimum memory usage of a child shard.
-    # 
-    # See [`CongestionControlConfig`] for more details.
     min_child_memory_usage: conint(ge=0, le=18446744073709551615)
     # Minimum number of epochs until next resharding can be scheduled.
-    # 
-    # See [`CongestionControlConfig`] for more details.
     min_epochs_between_resharding: conint(ge=0, le=18446744073709551615)

{near_jsonrpc_client-1.0.21 → near_jsonrpc_client-1.0.23}/near_jsonrpc_models/runtime_config_view.py

@@ -17,7 +17,7 @@ class RuntimeConfigView(BaseModel):
     # The configuration for congestion control.
     congestion_control_config: CongestionControlConfigView = None
     # Configuration for dynamic resharding feature.
-    dynamic_resharding_config: DynamicReshardingConfigView = Field(default_factory=lambda: DynamicReshardingConfigView(**{'max_number_of_shards': 999999999999999, 'memory_usage_threshold': 999999999999999, 'min_child_memory_usage': 999999999999999, 'min_epochs_between_resharding': 999999999999999}))
+    dynamic_resharding_config: DynamicReshardingConfigView = Field(default_factory=lambda: DynamicReshardingConfigView(**{'block_split_shards': [], 'force_split_shards': [], 'max_number_of_shards': 999999999999999, 'memory_usage_threshold': 999999999999999, 'min_child_memory_usage': 999999999999999, 'min_epochs_between_resharding': 999999999999999}))
     # Amount of yN per byte required to have on the account.  See
     # <https://nomicon.io/Economics/Economics.html#state-stake> for details.
     storage_amount_per_byte: NearToken = None

{near_jsonrpc_client-1.0.21 → near_jsonrpc_client-1.0.23}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "near-jsonrpc-client"
-version = "1.0.21"
+version = "1.0.23"
 description = "A typed Python client for the NEAR JSON-RPC API with Pydantic models and async HTTP support"
 readme = "README.md"
 requires-python = ">=3.9"