blaxel 0.2.2rc79__py3-none-any.whl → 0.2.3__py3-none-any.whl

blaxel/core/sandbox/sandbox.py

@@ -77,7 +77,7 @@ class SandboxInstance:
         default_image = "blaxel/prod-base:latest"
         default_memory = 4096
 
-        # Handle SandboxCreateConfiguration or simple dict with name/image/memory/ports keys
+        # Handle SandboxCreateConfiguration or simple dict with name/image/memory/ports/envs keys
         if (
             sandbox is None
             or isinstance(sandbox, SandboxCreateConfiguration | dict)
@@ -89,6 +89,7 @@ class SandboxInstance:
                     or "image" in (sandbox if isinstance(sandbox, dict) else sandbox.__dict__)
                     or "memory" in (sandbox if isinstance(sandbox, dict) else sandbox.__dict__)
                     or "ports" in (sandbox if isinstance(sandbox, dict) else sandbox.__dict__)
+                    or "envs" in (sandbox if isinstance(sandbox, dict) else sandbox.__dict__)
                 )
             )
         ):
@@ -102,12 +103,13 @@ class SandboxInstance:
             image = sandbox.image or default_image
             memory = sandbox.memory or default_memory
             ports = sandbox._normalize_ports() or UNSET
+            envs = sandbox._normalize_envs() or UNSET
 
             # Create full Sandbox object
             sandbox = Sandbox(
                 metadata=Metadata(name=name),
                 spec=SandboxSpec(
-                    runtime=Runtime(image=image, memory=memory, ports=ports, generation="mk3")
+                    runtime=Runtime(image=image, memory=memory, ports=ports, envs=envs, generation="mk3")
                 ),
             )
         else:

blaxel/core/sandbox/types.py

@@ -113,11 +113,13 @@ class SandboxCreateConfiguration:
         image: Optional[str] = None,
         memory: Optional[int] = None,
         ports: Optional[Union[List[Port], List[Dict[str, Any]]]] = None,
+        envs: Optional[List[Dict[str, str]]] = None,
     ):
         self.name = name
         self.image = image
         self.memory = memory
         self.ports = ports
+        self.envs = envs
 
     @classmethod
     def from_dict(cls, data: Dict[str, Any]) -> "SandboxCreateConfiguration":
@@ -126,6 +128,7 @@ class SandboxCreateConfiguration:
             image=data.get("image"),
             memory=data.get("memory"),
             ports=data.get("ports"),
+            envs=data.get("envs"),
         )
 
     def _normalize_ports(self) -> Optional[List[Port]]:
@@ -150,3 +153,20 @@ class SandboxCreateConfiguration:
                 raise ValueError(f"Invalid port type: {type(port)}. Expected Port object or dict.")
 
         return port_objects
+
+    def _normalize_envs(self) -> Optional[List[Dict[str, str]]]:
+        """Convert envs to list of dicts with name and value keys."""
+        if not self.envs:
+            return None
+
+        env_objects = []
+        for env in self.envs:
+            if isinstance(env, dict):
+                # Validate that the dict has the required keys
+                if "name" not in env or "value" not in env:
+                    raise ValueError(f"Environment variable dict must have 'name' and 'value' keys: {env}")
+                env_objects.append({"name": env["name"], "value": env["value"]})
+            else:
+                raise ValueError(f"Invalid env type: {type(env)}. Expected dict with 'name' and 'value' keys.")
+
+        return env_objects

blaxel/core/tools/__init__.py

@@ -22,12 +22,15 @@ if os.getenv("BL_SERVER_PORT"):
 
 
 class PersistentWebSocket:
-    def __init__(
-        self, url: str, name: str, timeout: int = DEFAULT_TIMEOUT, timeout_enabled: bool = True
-    ):
-        self.url = url
+    def __init__(self, name: str, timeout: int = DEFAULT_TIMEOUT, timeout_enabled: bool = True):
         self.name = name
         self.timeout = timeout
+        self.type = "function"
+        self.pluralType = "functions"
+        if name.startswith("sandbox/") or name.startswith("sandboxes/"):
+            self.name = name.split("/")[1]
+            self.type = "sandbox"
+            self.pluralType = "sandboxes"
         self.session_exit_stack = AsyncExitStack()
         self.client_exit_stack = AsyncExitStack()
         self.session: ClientSession = None
@@ -37,6 +40,42 @@ class PersistentWebSocket:
             self.timeout_enabled = False
         else:
             self.timeout_enabled = timeout_enabled
+        self.use_fallback_url = False
+
+    @property
+    def _internal_url(self):
+        """Get the internal URL for the agent using a hash of workspace and agent name."""
+        hash = get_global_unique_hash(settings.workspace, self.type, self.name)
+        return f"{settings.run_internal_protocol}://bl-{settings.env}-{hash}.{settings.run_internal_hostname}"
+
+    @property
+    def _forced_url(self):
+        """Get the forced URL from environment variables if set."""
+        return get_forced_url(self.type, self.name)
+
+    @property
+    def _external_url(self):
+        return f"{settings.run_url}/{settings.workspace}/{self.pluralType}/{self.name}"
+
+    @property
+    def _fallback_url(self):
+        if self._external_url != self._url:
+            return self._external_url
+        return None
+
+    @property
+    def _url(self):
+        if self.use_fallback_url:
+            return self._fallback_url
+        logger.debug(f"Getting URL for {self.name}")
+        if self._forced_url:
+            logger.debug(f"Forced URL found for {self.name}: {self._forced_url}")
+            return self._forced_url
+        if settings.run_internal_hostname:
+            logger.debug(f"Internal hostname found for {self.name}: {self._internal_url}")
+            return self._internal_url
+        logger.debug(f"No URL found for {self.name}, using external URL")
+        return self._external_url
 
     def with_metas(self, metas: dict[str, Any]):
         self.metas = metas
@@ -44,7 +83,7 @@ class PersistentWebSocket:
 
     async def call_tool(self, tool_name: str, arguments: dict[str, Any]) -> CallToolResult:
         try:
-            await self._initialize()
+            await self.initialize()
             if self.timeout_enabled:
                 self._remove_timer()
             logger.debug(f"Calling tool {tool_name} with arguments {arguments}")
@@ -70,7 +109,7 @@ class PersistentWebSocket:
 
     async def list_tools(self):
         logger.debug(f"Listing tools for {self.name}")
-        await self._initialize()
+        await self.initialize()
         logger.debug(f"Initialized websocket for {self.name}")
         if self.timeout_enabled:
             self._remove_timer()
@@ -87,17 +126,23 @@ class PersistentWebSocket:
     def get_tools(self):
         return self.tools_cache
 
-    async def _initialize(self):
+    async def initialize(self, fallback: bool = False):
         if not self.session:
-            logger.debug(f"Initializing websocket client for {self.url}")
-            read, write = await self.client_exit_stack.enter_async_context(
-                websocket_client(self.url, settings.headers)
-            )
-            self.session = cast(
-                ClientSession,
-                await self.session_exit_stack.enter_async_context(ClientSession(read, write)),
-            )
-            await self.session.initialize()
+            try:
+                logger.debug(f"Initializing websocket client for {self._url}")
+                read, write = await self.client_exit_stack.enter_async_context(
+                    websocket_client(self._url, settings.headers)
+                )
+                self.session = cast(
+                    ClientSession,
+                    await self.session_exit_stack.enter_async_context(ClientSession(read, write)),
+                )
+                await self.session.initialize()
+            except Exception as e:
+                if not fallback:
+                    self.use_fallback_url = True
+                    return await self.initialize(fallback=True)
+                raise e
 
     def _reset_timer(self):
         self._remove_timer()
@@ -113,7 +158,7 @@ class PersistentWebSocket:
         self.session = None
 
     async def _close(self):
-        logger.debug(f"Closing websocket client {self.url}")
+        logger.debug(f"Closing websocket client {self._url}")
         if self.session:
             self.session = None
             try:
@@ -129,8 +174,6 @@ class PersistentWebSocket:
 
 def convert_mcp_tool_to_blaxel_tool(
     websocket_client: PersistentWebSocket,
-    name: str,
-    url: str,
     tool: MCPTool,
 ) -> Tool:
     """Convert an MCP tool to a blaxel tool.
@@ -193,34 +236,6 @@ class BlTools:
         self.timeout = timeout
         self.timeout_enabled = timeout_enabled
 
-    def _internal_url(self, name: str):
-        """Get the internal URL for the agent using a hash of workspace and agent name."""
-        hash = get_global_unique_hash(settings.workspace, "function", name)
-        return f"{settings.run_internal_protocol}://bl-{settings.env}-{hash}.{settings.run_internal_hostname}"
-
-    def _forced_url(self, name: str):
-        """Get the forced URL from environment variables if set."""
-        return get_forced_url("function", name)
-
-    def _external_url(self, name: str):
-        return f"{settings.run_url}/{settings.workspace}/functions/{name}"
-
-    def _fallback_url(self, name: str):
-        if self._external_url(name) != self._url(name):
-            return self._external_url(name)
-        return None
-
-    def _url(self, name: str):
-        logger.debug(f"Getting URL for {name}")
-        if self._forced_url(name):
-            logger.debug(f"Forced URL found for {name}: {self._forced_url(name)}")
-            return self._forced_url(name)
-        if settings.run_internal_hostname:
-            logger.debug(f"Internal hostname found for {name}: {self._internal_url(name)}")
-            return self._internal_url(name)
-        logger.debug(f"No URL found for {name}, using external URL")
-        return self._external_url(name)
-
     def get_tools(self) -> list[Tool]:
         """Get a list of all tools from all connected servers."""
         all_tools: list[Tool] = []
@@ -228,47 +243,21 @@ class BlTools:
             toolPersistances.get(name).with_metas(self.metas)
             websocket = toolPersistances.get(name)
             tools = websocket.get_tools()
-            converted_tools = [
-                convert_mcp_tool_to_blaxel_tool(websocket, name, self._url(name), tool)
-                for tool in tools
-            ]
+            converted_tools = [convert_mcp_tool_to_blaxel_tool(websocket, tool) for tool in tools]
             all_tools.extend(converted_tools)
         return all_tools
 
     async def connect(self, name: str):
         # Create and store the connection
-        try:
-            url = self._url(name)
-            await self.connect_with_url(name, url)
-        except Exception as e:
-            if not self._fallback_url(name):
-                raise e
-            logger.warning(f"Error connecting to {name}: {e}\n{traceback.format_exc()}")
-            url = self._fallback_url(name)
-            try:
-                await self.connect_with_url(name, url)
-            except Exception as e:
-                logger.error(
-                    f"Error connecting to {name} with fallback URL: {e}\n{traceback.format_exc()}"
-                )
-                raise e
-
-    async def connect_with_url(self, name: str, url: str) -> None:
-        """Initialize a session and load tools from it.
-
-        Args:
-            name: Name to identify this server connection
-            url: The URL to connect to
-        """
-        logger.debug(f"Initializing session and loading tools from {url}")
+        logger.debug("Initializing session and loading tools")
 
         if not toolPersistances.get(name):
             logger.debug(f"Creating new persistent websocket for {name}")
             toolPersistances[name] = PersistentWebSocket(
-                url, name, timeout=self.timeout, timeout_enabled=self.timeout_enabled
+                name, timeout=self.timeout, timeout_enabled=self.timeout_enabled
             )
             await toolPersistances[name].list_tools()
-        logger.debug(f"Loaded {len(toolPersistances[name].get_tools())} tools from {url}")
+        logger.debug(f"Loaded {len(toolPersistances[name].get_tools())} tools")
         return toolPersistances[name].with_metas(self.metas)
 
     async def initialize(self) -> "BlTools":

blaxel/crewai/tools.py

@@ -19,8 +19,8 @@ class CrewAITool(BaseTool):
     def _run(self, *args, **kwargs):
         return self._tool.sync_coroutine(**kwargs)
 
+
 async def bl_tools(tools_names: list[str], **kwargs) -> list[BaseTool]:
     tools = bl_tools_core(tools_names, **kwargs)
     await tools.initialize()
     return [CrewAITool(tool) for tool in tools.get_tools()]
-    return [CrewAITool(tool) for tool in tools.get_tools()]

blaxel/livekit/tools.py

@@ -8,23 +8,27 @@ def livekit_coroutine(tool: Tool):
     async def livekit_coroutine_wrapper(raw_arguments: dict[str, object]):
         result = await tool.coroutine(**raw_arguments)
         return result.model_dump_json()
+
     return livekit_coroutine_wrapper
 
+
 def get_livekit_tools(tools: list[Tool]) -> list[llm.FunctionTool]:
     livekit_tools = []
     for tool in tools:
-        livekit_tools.append(function_tool(
-            livekit_coroutine(tool),
-            raw_schema={
-                "name": tool.name,
-                "description": tool.description,
-                "parameters": tool.input_schema,
-            },
-        ))
+        livekit_tools.append(
+            function_tool(
+                livekit_coroutine(tool),
+                raw_schema={
+                    "name": tool.name,
+                    "description": tool.description,
+                    "parameters": tool.input_schema,
+                },
+            )
+        )
     return livekit_tools
 
+
 async def bl_tools(tools_names: list[str], **kwargs) -> list[llm.FunctionTool]:
     tools = bl_tools_core(tools_names, **kwargs)
     await tools.initialize()
     return get_livekit_tools(tools.get_tools())
-    return get_livekit_tools(tools.get_tools())

blaxel/openai/tools.py

@@ -9,8 +9,8 @@ from blaxel.core.tools.types import Tool
 
 def get_openai_tool(tool: Tool) -> FunctionTool:
     async def openai_coroutine(
-      _: RunContextWrapper,
-      arguments: dict[str, Any],
+        _: RunContextWrapper,
+        arguments: dict[str, Any],
     ) -> Any:
         result = await tool.coroutine(**json.loads(arguments))
         return result
@@ -22,8 +22,8 @@ def get_openai_tool(tool: Tool) -> FunctionTool:
         on_invoke_tool=openai_coroutine,
     )
 
+
 async def bl_tools(tools_names: list[str], **kwargs) -> list[FunctionTool]:
     tools = bl_tools_core(tools_names, **kwargs)
     await tools.initialize()
     return [get_openai_tool(tool) for tool in tools.get_tools()]
-    return [get_openai_tool(tool) for tool in tools.get_tools()]

{blaxel-0.2.2rc79.dist-info → blaxel-0.2.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: blaxel
-Version: 0.2.2rc79
+Version: 0.2.3
 Summary: Blaxel - AI development platform SDK
 Project-URL: Homepage, https://blaxel.ai
 Project-URL: Documentation, https://docs.blaxel.ai
@@ -42,7 +42,7 @@ Requires-Dist: llama-index-llms-google-genai>=0.1.13; extra == 'all'
 Requires-Dist: llama-index-llms-groq>=0.3.1; extra == 'all'
 Requires-Dist: llama-index-llms-mistralai>=0.4.0; extra == 'all'
 Requires-Dist: llama-index-llms-openai>=0.3.42; extra == 'all'
-Requires-Dist: llama-index>=0.12.37; extra == 'all'
+Requires-Dist: llama-index>=0.12.46; extra == 'all'
 Requires-Dist: openai-agents>=0.0.19; extra == 'all'
 Requires-Dist: opentelemetry-exporter-otlp>=1.28.0; extra == 'all'
 Requires-Dist: opentelemetry-instrumentation-anthropic==0.40.6; extra == 'all'
@@ -92,7 +92,7 @@ Requires-Dist: llama-index-llms-google-genai>=0.1.13; extra == 'llamaindex'
 Requires-Dist: llama-index-llms-groq>=0.3.1; extra == 'llamaindex'
 Requires-Dist: llama-index-llms-mistralai>=0.4.0; extra == 'llamaindex'
 Requires-Dist: llama-index-llms-openai>=0.3.42; extra == 'llamaindex'
-Requires-Dist: llama-index>=0.12.37; extra == 'llamaindex'
+Requires-Dist: llama-index>=0.12.46; extra == 'llamaindex'
 Requires-Dist: opentelemetry-instrumentation-llamaindex>=0.40.7; extra == 'llamaindex'
 Provides-Extra: openai
 Requires-Dist: openai-agents>=0.0.19; extra == 'openai'

{blaxel-0.2.2rc79.dist-info → blaxel-0.2.3.dist-info}/RECORD

@@ -310,9 +310,9 @@ blaxel/core/sandbox/filesystem.py,sha256=dyIvDdlPZO0ijD6mXXX8Yl0t75VijQ6_uMz_9rJ
 blaxel/core/sandbox/network.py,sha256=P5jLd4AAg1zgyIK4qGWvZaDZ5BzIcxRx2ffz_JLsLMI,357
 blaxel/core/sandbox/preview.py,sha256=M6FulOxPghUBpb5fLxu1Rd3ekLeCbZ_dgt4s1X2Cneo,5354
 blaxel/core/sandbox/process.py,sha256=7zEngDTs2XiNsMm9TZ4lEDUiRpS3af8dw60pEvRuHDY,8357
-blaxel/core/sandbox/sandbox.py,sha256=3eJSWG0Y0jJsi1B5PK8BIvAEw-p0kP03vfUruYqAP14,8484
+blaxel/core/sandbox/sandbox.py,sha256=y6mV2-i6TsSZGQsvBBGptR514OfgvhV0hXBMEsOBcsY,8648
 blaxel/core/sandbox/session.py,sha256=4SH1tyXcQ9UqJx4lMwxAlp7x9Te_anDrdSEG6AlNkvU,4496
-blaxel/core/sandbox/types.py,sha256=ylvwCnqNXMtCrGaJ-saMwi1Tz9ky_5phnpwmx4HNwOI,4775
+blaxel/core/sandbox/types.py,sha256=nsbvZLUxvDZkg2oExE3HdXx2qIpPaaoa7_lGYBzQ8Xk,5638
 blaxel/core/sandbox/client/__init__.py,sha256=N26bD5o1jsTb48oExow6Rgivd8ylaU9jaWZfZsVilP8,128
 blaxel/core/sandbox/client/client.py,sha256=tcP8cJ4Q3dV9aB3yQ01dDXO-ekfsa3WGGFz4DQAEf8I,7079
 blaxel/core/sandbox/client/errors.py,sha256=gO8GBmKqmSNgAg-E5oT-oOyxztvp7V_6XG7OUTT15q0,546
@@ -355,13 +355,13 @@ blaxel/core/sandbox/client/models/process_response.py,sha256=vXHK6NBnuf0KYVzpkaA
 blaxel/core/sandbox/client/models/process_response_status.py,sha256=hCE1gCtheV83T6PYURG3k-rPZSauvyTFhsxLEtudgYE,246
 blaxel/core/sandbox/client/models/subdirectory.py,sha256=obztIgi_XjT4pPoT1-dyOX6O8k0e4ERZUTiI9qgkhJM,1593
 blaxel/core/sandbox/client/models/success_response.py,sha256=ksioQ0qNV7yhXlySY3_3EycsJ1ec7LSxBMwIq4HnfVQ,1703
-blaxel/core/tools/__init__.py,sha256=9_pgKEU5GbPfqfGN4aZTkthnaV4AVYf63jIZw44peBQ,10167
+blaxel/core/tools/__init__.py,sha256=OCZExds99o_j_GvAywaWFIGfY12abNZHcaiGOmAyh8o,9793
 blaxel/core/tools/common.py,sha256=JGK052v_fvwWBFYnIArlBnFFViYyFrqdDn3gdVf53EU,1332
 blaxel/core/tools/types.py,sha256=YPCGJ4vZDhqR0X2H_TWtc5chQScsC32nGTQdRKJlO8Y,707
 blaxel/crewai/__init__.py,sha256=HdAZxRDgC2zW-O5xYzb_Xuysb66_fMykNJVPxlTmFnY,123
 blaxel/crewai/model.py,sha256=VOLUE5tpz9tmYl7KU9L1kNUJ5uTci2rhRfPQ8HyCfWI,1785
 blaxel/crewai/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-blaxel/crewai/tools.py,sha256=wMMZvSrmhuoFRFux2j31PeSVMbElhs5e49jtvRNxZxY,848
+blaxel/crewai/tools.py,sha256=HVMSRTVrc0ygiCCNkL6xa3i31IWwFlGKB6oC-6iWrK8,789
 blaxel/googleadk/__init__.py,sha256=WfYZvtkh5IF042qWLaiWjbDarJZCX9ghHGiTrat8eps,127
 blaxel/googleadk/model.py,sha256=ZSBGapgcrhRogc1kBFKfuLS36UUkcQL6nZD22yVUEJM,2236
 blaxel/googleadk/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -374,7 +374,7 @@ blaxel/langgraph/custom/gemini.py,sha256=AkhpuVMXnh1CyJ0zR2NMTtxQFPPHtAdHf_cyNzV
 blaxel/livekit/__init__.py,sha256=byUwOJ6MHeSXOYXmaVoHnC3ZUmpkqJ55u5mQglXX-SQ,124
 blaxel/livekit/model.py,sha256=4HA6Jn4_jQ5QeH5mWMeopWybQDeiJcDRyh5kX5O9LHE,961
 blaxel/livekit/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-blaxel/livekit/tools.py,sha256=-TnlCRB1toKNJi6ix2HvteQ4TWMtxU_99hS8R7Xjvek,1048
+blaxel/livekit/tools.py,sha256=QipxGDnKqma_ktzTUpKgzdp5x4bvpQnxEVoqSTBesu8,1053
 blaxel/llamaindex/__init__.py,sha256=iZ3QbZhlwKvP91ChcqSXVkpRrzurMxJoQfKdZFzE2AA,127
 blaxel/llamaindex/model.py,sha256=FYUCTA80LKC4-UfESh43htoHrsoZjwwVaxXD51T0IuE,2557
 blaxel/llamaindex/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -383,7 +383,7 @@ blaxel/llamaindex/custom/cohere.py,sha256=zoUv4NWwMZLZEynYTC3JuOvtinguRgtuRwS31w
 blaxel/openai/__init__.py,sha256=YkizVtcYL2m9v-z5B1EReYVu9n9V-DCxJhSB2mvqOs0,123
 blaxel/openai/model.py,sha256=lGz4zrV4sURPb6aLtroMRV5-CgfQUq15PeTgjc7QkTI,600
 blaxel/openai/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-blaxel/openai/tools.py,sha256=De6Gjiu9pnX-jVUiueCWvUl8hXcnLgrqcWjAIMDEbIo,894
+blaxel/openai/tools.py,sha256=XnbQt8AvvmCHjoQIe3AhylmGi3bwTJIrdmXm--sldLg,834
 blaxel/pydantic/__init__.py,sha256=-UDZ5VSrlgfqErJuiuphcAFwesijzXxYLeyC7yHEDrE,128
 blaxel/pydantic/model.py,sha256=1oPf1EH01wvbgBS-w89L73nQrII6VNkZiRIuJYmrMms,3396
 blaxel/pydantic/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -402,7 +402,7 @@ blaxel/telemetry/instrumentation/map.py,sha256=PCzZJj39yiYVYJrxLBNP-NW-tjjYyTijw
 blaxel/telemetry/instrumentation/utils.py,sha256=KInMYZH-mu9_wvetmf0EmgrfN3Sw8IWk2Y95v2u90_U,1901
 blaxel/telemetry/log/log.py,sha256=RvQByRjZMoP_dRaAZu8oK6DTegsHs-xV4W-UIqis6CA,2461
 blaxel/telemetry/log/logger.py,sha256=NPAS3g82ryROjvc_DEZaTIfrcehoLEZoP-JkLxADxc0,4113
-blaxel-0.2.2rc79.dist-info/METADATA,sha256=Riq57nznlw3GBF4YKj_dpKtKdKbYg9jXxVR07J85SXE,9879
-blaxel-0.2.2rc79.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-blaxel-0.2.2rc79.dist-info/licenses/LICENSE,sha256=p5PNQvpvyDT_0aYBDgmV1fFI_vAD2aSV0wWG7VTgRis,1069
-blaxel-0.2.2rc79.dist-info/RECORD,,
+blaxel-0.2.3.dist-info/METADATA,sha256=QgO7ehwf9t_mx9IdU9orVDZIlufpL2pgIXkGWRzKKyg,9875
+blaxel-0.2.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+blaxel-0.2.3.dist-info/licenses/LICENSE,sha256=p5PNQvpvyDT_0aYBDgmV1fFI_vAD2aSV0wWG7VTgRis,1069
+blaxel-0.2.3.dist-info/RECORD,,