firecloud-devnet 0.1.0__py3-none-any.whl

firecloud/transport.py

@@ -0,0 +1,387 @@
+"""FireCloud Transport Engine.
+
+Handles secure peer-to-peer communication using asyncio TCP over TLS,
+implementing a custom binary protocol, handshake, multiplexed chunk transfer,
+manifest synchronization, and heartbeat monitoring.
+"""
+
+import asyncio
+from datetime import datetime, timezone, timedelta
+import json
+import logging
+from pathlib import Path
+import ssl
+import struct
+import tempfile
+
+from cryptography import x509
+from cryptography.x509.oid import NameOID
+from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.primitives.asymmetric import rsa
+from cryptography.hazmat.primitives import serialization
+
+from firecloud.exceptions import TransportError, NodeAuthError, ChunkNotFoundError
+
+logger = logging.getLogger("firecloud.transport")
+
+# Protocol constants
+MSG_AUTH = 0x01
+MSG_AUTH_OK = 0x02
+MSG_STORE_CHUNK = 0x10
+MSG_RETRIEVE_CHUNK = 0x11
+MSG_CHUNK_DATA = 0x12
+MSG_CHUNK_NOT_FOUND = 0x13
+MSG_SYNC_MANIFEST = 0x20
+MSG_HEARTBEAT = 0x30
+MSG_PEER_LIST = 0x40
+
+# ---------------------------------------------------------------------------
+# TLS & Certificate Helpers
+# ---------------------------------------------------------------------------
+
+
+def generate_self_signed_cert() -> tuple[bytes, bytes]:
+    """Generate a self-signed cert and key for TLS node authentication."""
+    private_key = rsa.generate_private_key(
+        public_exponent=65537,
+        key_size=2048,
+    )
+    subject = issuer = x509.Name([
+        x509.NameAttribute(NameOID.COMMON_NAME, "firecloud-node"),
+    ])
+    cert = (
+        x509.CertificateBuilder()
+        .subject_name(subject)
+        .issuer_name(issuer)
+        .public_key(private_key.public_key())
+        .serial_number(x509.random_serial_number())
+        .not_valid_before(datetime.now(timezone.utc) - timedelta(days=1))
+        .not_valid_after(datetime.now(timezone.utc) + timedelta(days=365))
+        .sign(private_key, hashes.SHA256())
+    )
+    cert_bytes = cert.public_bytes(serialization.Encoding.PEM)
+    key_bytes = private_key.private_bytes(
+        encoding=serialization.Encoding.PEM,
+        format=serialization.PrivateFormat.TraditionalOpenSSL,
+        encryption_algorithm=serialization.NoEncryption(),
+    )
+    return cert_bytes, key_bytes
+
+
+def get_ssl_context(is_server: bool, node_dir: Path | None = None) -> ssl.SSLContext:
+    """Get or create the SSLContext for secure connections."""
+    if node_dir is None:
+        node_dir = Path(tempfile.gettempdir()) / "firecloud_ssl"
+    node_dir.mkdir(parents=True, exist_ok=True)
+    
+    cert_path = node_dir / "node.crt"
+    key_path = node_dir / "node.key"
+    
+    if not cert_path.exists() or not key_path.exists():
+        cert_bytes, key_bytes = generate_self_signed_cert()
+        cert_path.write_bytes(cert_bytes)
+        key_path.write_bytes(key_bytes)
+        
+    if is_server:
+        context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
+        context.load_cert_chain(certfile=str(cert_path), keyfile=str(key_path))
+    else:
+        context = ssl.create_default_context(ssl.Purpose.SERVER_AUTH)
+        context.check_hostname = False
+        context.verify_mode = ssl.CERT_NONE
+        
+    return context
+
+
+# ---------------------------------------------------------------------------
+# Binary framing helpers
+# ---------------------------------------------------------------------------
+
+
+async def read_msg(reader: asyncio.StreamReader) -> tuple[int, bytes]:
+    """Read a structured message from the stream.
+
+    Format: [4 bytes length][1 byte type][payload]
+    """
+    try:
+        header = await reader.readexactly(4)
+        length = struct.unpack("!I", header)[0]
+        msg_type_byte = await reader.readexactly(1)
+        msg_type = msg_type_byte[0]
+        payload = await reader.readexactly(length)
+        return msg_type, payload
+    except asyncio.IncompleteReadError as exc:
+        raise TransportError("Connection closed prematurely during read") from exc
+    except Exception as exc:
+        raise TransportError(f"Error reading message from socket: {exc}") from exc
+
+
+async def write_msg(writer: asyncio.StreamWriter, msg_type: int, payload: bytes) -> None:
+    """Write a structured message to the stream."""
+    try:
+        header = struct.pack("!IB", len(payload), msg_type)
+        writer.write(header + payload)
+        await writer.drain()
+    except Exception as exc:
+        raise TransportError(f"Error writing message to socket: {exc}") from exc
+
+
+# ---------------------------------------------------------------------------
+# Peer Connection Handler
+# ---------------------------------------------------------------------------
+
+
+class PeerConnection:
+    """Handles an active bidirectional connection with a remote peer."""
+
+    def __init__(
+        self,
+        reader: asyncio.StreamReader,
+        writer: asyncio.StreamWriter,
+        peer_node_id: str,
+        node,
+    ) -> None:
+        self.reader = reader
+        self.writer = writer
+        self.peer_node_id = peer_node_id
+        self.node = node
+        self.write_lock = asyncio.Lock()
+        self.retrieve_lock = asyncio.Lock()
+        self.pending_retrieve: asyncio.Future[bytes | None] | None = None
+        self.last_seen = datetime.now(timezone.utc)
+        self.read_task = asyncio.create_task(self._read_loop())
+
+    async def send_message(self, msg_type: int, payload: bytes) -> None:
+        """Send a message to the peer."""
+        async with self.write_lock:
+            await write_msg(self.writer, msg_type, payload)
+
+    async def retrieve_chunk(self, chunk_id: str) -> bytes | None:
+        """Request and retrieve a chunk from this peer."""
+        async with self.retrieve_lock:
+            loop = asyncio.get_running_loop()
+            self.pending_retrieve = loop.create_future()
+            try:
+                await self.send_message(MSG_RETRIEVE_CHUNK, chunk_id.encode("utf-8"))
+                # Wait for the background loop to resolve the future
+                return await self.pending_retrieve
+            finally:
+                self.pending_retrieve = None
+
+    async def _read_loop(self) -> None:
+        """Background loop that processes incoming messages from the peer."""
+        try:
+            while True:
+                msg_type, payload = await read_msg(self.reader)
+                self.last_seen = datetime.now(timezone.utc)
+
+                if msg_type == MSG_HEARTBEAT:
+                    # Heartbeat received, last_seen is updated.
+                    pass
+
+                elif msg_type == MSG_CHUNK_DATA:
+                    if self.pending_retrieve and not self.pending_retrieve.done():
+                        self.pending_retrieve.set_result(payload)
+
+                elif msg_type == MSG_CHUNK_NOT_FOUND:
+                    if self.pending_retrieve and not self.pending_retrieve.done():
+                        self.pending_retrieve.set_result(None)
+
+                elif msg_type == MSG_STORE_CHUNK:
+                    if len(payload) < 64:
+                        continue
+                    chunk_id = payload[:64].decode("utf-8")
+                    chunk_data = payload[64:]
+                    try:
+                        self.node.chunk_store.store(chunk_id, chunk_data)
+                    except Exception as e:
+                        logger.error(f"Failed to store chunk {chunk_id}: {e}")
+
+                elif msg_type == MSG_RETRIEVE_CHUNK:
+                    chunk_id = payload.decode("utf-8")
+                    try:
+                        chunk_data = self.node.chunk_store.retrieve(chunk_id)
+                        await self.send_message(MSG_CHUNK_DATA, chunk_data)
+                    except ChunkNotFoundError:
+                        await self.send_message(
+                            MSG_CHUNK_NOT_FOUND, chunk_id.encode("utf-8")
+                        )
+                    except Exception as e:
+                        logger.error(f"Failed to retrieve chunk {chunk_id}: {e}")
+                        await self.send_message(
+                            MSG_CHUNK_NOT_FOUND, chunk_id.encode("utf-8")
+                        )
+
+                elif msg_type == MSG_SYNC_MANIFEST:
+                    try:
+                        remote_entries_dicts = json.loads(payload.decode("utf-8"))
+                        from firecloud.manifest import FileEntry, ChunkInfo
+                        remote_entries = []
+                        for edict in remote_entries_dicts:
+                            d = dict(edict)
+                            chunks = [ChunkInfo(**ci) for ci in d.pop("chunks", [])]
+                            remote_entries.append(FileEntry(**d, chunks=chunks))
+                        self.node.manifest.merge(remote_entries)
+                    except Exception as e:
+                        logger.error(f"Failed to merge remote manifest: {e}")
+
+                elif msg_type == MSG_PEER_LIST:
+                    try:
+                        peers = json.loads(payload.decode("utf-8"))
+                        for p in peers:
+                            if p["node_id"] != self.node.node_id:
+                                self.node.add_peer_discovered(
+                                    p["node_id"], p["host"], p["port"]
+                                )
+                    except Exception as e:
+                        logger.error(f"Failed to process peer list: {e}")
+
+        except asyncio.CancelledError:
+            pass
+        except Exception as e:
+            logger.debug(f"Connection with peer {self.peer_node_id} dropped: {e}")
+        finally:
+            await self.close()
+
+    async def close(self) -> None:
+        """Close the connection."""
+        self.read_task.cancel()
+        if self.pending_retrieve and not self.pending_retrieve.done():
+            self.pending_retrieve.set_exception(
+                TransportError("Connection closed while waiting for chunk retrieval")
+            )
+        try:
+            self.writer.close()
+            await asyncio.wait_for(self.writer.wait_closed(), timeout=0.5)
+        except (Exception, asyncio.CancelledError):
+            pass
+        self.node.on_connection_closed(self.peer_node_id)
+
+
+# ---------------------------------------------------------------------------
+# Node Server
+# ---------------------------------------------------------------------------
+
+
+class NodeServer:
+    """Listens for secure TCP connections from remote peers."""
+
+    def __init__(self, node, host: str, port: int) -> None:
+        self.node = node
+        self.host = host
+        self.port = port
+        self.server: asyncio.AbstractServer | None = None
+
+    async def start(self) -> None:
+        """Start the TCP server."""
+        ssl_context = get_ssl_context(is_server=True, node_dir=self.node.storage_path / "ssl")
+        self.server = await asyncio.start_server(
+            self._handle_connection,
+            self.host,
+            self.port,
+            ssl=ssl_context,
+        )
+        logger.info(f"Node server listening on {self.host}:{self.port}")
+
+    async def stop(self) -> None:
+        """Stop the TCP server."""
+        if self.server:
+            self.server.close()
+            # Close all active connections on the node to unblock wait_closed
+            if hasattr(self.node, "connections"):
+                for conn in list(self.node.connections.values()):
+                    await conn.close()
+            try:
+                await asyncio.wait_for(self.server.wait_closed(), timeout=1.0)
+            except Exception:
+                pass
+            self.server = None
+            logger.info("Node server stopped")
+
+    async def _handle_connection(
+        self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter
+    ) -> None:
+        """Handle an incoming connection from a peer."""
+        try:
+            # Perform server handshake
+            msg_type, payload = await read_msg(reader)
+            if msg_type != MSG_AUTH:
+                writer.close()
+                await writer.wait_closed()
+                return
+
+            if len(payload) < 32:
+                writer.close()
+                await writer.wait_closed()
+                return
+
+            token = payload[:32]
+            peer_node_id = payload[32:].decode("utf-8")
+
+            if token != self.node.network.auth_token:
+                writer.close()
+                await writer.wait_closed()
+                raise NodeAuthError("Peer authentication failed: invalid token")
+
+            # Authentication successful. Send AUTH_OK with our node ID.
+            await write_msg(writer, MSG_AUTH_OK, self.node.node_id.encode("utf-8"))
+
+            conn = PeerConnection(reader, writer, peer_node_id, self.node)
+            self.node.register_connection(peer_node_id, conn)
+
+        except Exception as e:
+            logger.debug(f"Error handling incoming connection: {e}")
+            try:
+                writer.close()
+                await writer.wait_closed()
+            except Exception:
+                pass
+
+
+# ---------------------------------------------------------------------------
+# Node Client
+# ---------------------------------------------------------------------------
+
+
+class NodeClient:
+    """Establishes secure TCP connections to remote peers."""
+
+    def __init__(self, node) -> None:
+        self.node = node
+
+    async def connect(self, host: str, port: int) -> str:
+        """Connect to a peer, authenticate, and register the connection."""
+        ssl_context = get_ssl_context(is_server=False, node_dir=self.node.storage_path / "ssl")
+        try:
+            reader, writer = await asyncio.open_connection(host, port, ssl=ssl_context)
+        except Exception as exc:
+            raise TransportError(f"Failed to connect to {host}:{port}: {exc}") from exc
+
+        try:
+            # Send AUTH message: auth_token (32 bytes) + our node_id (UTF-8 bytes)
+            auth_payload = self.node.network.auth_token + self.node.node_id.encode("utf-8")
+            await write_msg(writer, MSG_AUTH, auth_payload)
+
+            # Receive AUTH_OK
+            msg_type, payload = await read_msg(reader)
+            if msg_type != MSG_AUTH_OK:
+                writer.close()
+                await writer.wait_closed()
+                raise NodeAuthError("Handshake failed: expected AUTH_OK")
+
+            peer_node_id = payload.decode("utf-8")
+            conn = PeerConnection(reader, writer, peer_node_id, self.node)
+            self.node.register_connection(peer_node_id, conn)
+            return peer_node_id
+
+        except Exception as e:
+            writer.close()
+            try:
+                await writer.wait_closed()
+            except Exception:
+                pass
+            if isinstance(e, NodeAuthError):
+                raise e
+            if isinstance(e, TransportError):
+                raise NodeAuthError("Handshake failed: peer rejected connection or auth token mismatch") from e
+            raise TransportError(f"Handshake failed with {host}:{port}: {e}") from e

firecloud_devnet-0.1.0.dist-info/METADATA

@@ -0,0 +1,158 @@
+Metadata-Version: 2.4
+Name: firecloud-devnet
+Version: 0.1.0
+Summary: Private, encrypted, distributed storage across your own machines
+Project-URL: Homepage, https://github.com/rajashekharsunkara/firecloud
+Project-URL: Repository, https://github.com/rajashekharsunkara/firecloud
+Project-URL: Issues, https://github.com/rajashekharsunkara/firecloud/issues
+Project-URL: Changelog, https://github.com/rajashekharsunkara/firecloud/blob/main/CHANGELOG.md
+Author: Rajashekhar Sunkara
+License-Expression: MIT
+License-File: LICENSE
+Keywords: chunking,distributed,encryption,p2p,storage
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Security :: Cryptography
+Classifier: Topic :: System :: Distributed Computing
+Requires-Python: >=3.10
+Requires-Dist: aiofiles>=23.0.0
+Requires-Dist: click>=8.0.0
+Requires-Dist: cryptography>=41.0.0
+Requires-Dist: fastcdc>=1.5.0
+Requires-Dist: pycryptodome>=3.20.0
+Requires-Dist: watchdog>=3.0.0
+Requires-Dist: zeroconf>=0.80.0
+Requires-Dist: zfec>=1.5.0
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.21.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0.0; extra == 'dev'
+Requires-Dist: pytest>=7.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.4.0; extra == 'dev'
+Provides-Extra: mlops
+Requires-Dist: fastapi>=0.100.0; extra == 'mlops'
+Requires-Dist: numpy>=1.24.0; extra == 'mlops'
+Requires-Dist: psutil>=5.9.0; extra == 'mlops'
+Requires-Dist: pydantic>=2.0; extra == 'mlops'
+Requires-Dist: rich>=13.0.0; extra == 'mlops'
+Requires-Dist: scikit-learn>=1.3.0; extra == 'mlops'
+Requires-Dist: uvicorn>=0.20.0; extra == 'mlops'
+Provides-Extra: rag
+Requires-Dist: fastembed>=0.2.0; extra == 'rag'
+Requires-Dist: ollama>=0.1.0; extra == 'rag'
+Requires-Dist: pydantic>=2.0; extra == 'rag'
+Requires-Dist: qdrant-client>=1.8.0; extra == 'rag'
+Requires-Dist: rich>=13.0.0; extra == 'rag'
+Description-Content-Type: text/markdown
+
+![CI](https://github.com/rajashekharsunkara/firecloud/actions/workflows/ci.yml/badge.svg)
+
+# FireCloud
+
+Private, encrypted, distributed storage across machines you own.
+
+Unlike S3 (vendor lock-in), Syncthing (no erasure coding), or IPFS (public DHT), FireCloud gives you zero-knowledge peer-to-peer storage where data is encrypted locally before it leaves your machine. Every chunk stored on the network is ciphertext — nodes can't read it.
+
+---
+
+## Install
+
+```bash
+# from GitHub (recommended for now)
+pip install git+https://github.com/rajashekharsunkara/firecloud.git
+
+# with RAG extensions
+pip install "firecloud-devnet[rag]"
+
+# with MLOps extensions
+pip install "firecloud-devnet[mlops]"
+```
+
+## Quickstart
+
+```bash
+# 1. Start a 4-node network via Docker Compose
+git clone https://github.com/rajashekharsunkara/firecloud.git
+cd firecloud
+cp .env.example .env          # set FIRECLOUD_PASSPHRASE in .env
+docker compose up -d           # starts bootstrap + 3 storage nodes
+
+# 2. Upload a file
+docker exec firecloud-bootstrap firecloud upload /data/my-file.zip
+
+# 3. Download from any node
+docker exec firecloud-node-1 firecloud download <file_id> /data/restored.zip
+```
+
+---
+
+## Architecture
+
+```
+┌─────────────────────────────────────────┐
+│  fc-rag (Private RAG — opt-in)          │  LLMOps
+│  fc-mlops (Artifact Store — opt-in)     │  MLOps
+│  Docker + GitHub Actions                │  DevOps
+│  FireCloud Core (storage, crypto, P2P)  │  Distributed Systems
+└─────────────────────────────────────────┘
+```
+
+**Distributed Systems** — XChaCha20-Poly1305 encryption, FastCDC content-defined chunking, zfec erasure coding, mDNS peer discovery. Manifest consistency uses Lamport timestamps with last-writer-wins semantics. Node communication runs over TLS-protected binary RPC.
+
+**DevOps** — Multi-node Docker Compose setup with health checks. GitHub Actions CI pipeline (lint → test → build) gates every merge.
+
+**MLOps** — `fc-mlops` provides version-tracked ML artifact storage via FireCloud's `Node` API, a FastAPI telemetry endpoint with psutil system metrics, and IsolationForest-based anomaly detection on telemetry readings.
+
+**LLMOps** — `fc-rag` is a fully local RAG pipeline using fastembed for embeddings, Qdrant (embedded mode) for vector search, and Ollama for local LLM inference — no text ever leaves your machine.
+
+---
+
+## Security
+
+FireCloud uses **HMAC-SHA-256 with a network-derived key** for chunk addressing instead of plain SHA-256. This raises the cost of confirmation-of-file attacks — an attacker who suspects a specific file is stored cannot verify its presence by computing chunk hashes from the plaintext, because valid chunk IDs require the network key. This protection holds as long as the network key remains confidential.
+
+---
+
+## AI/ML Extensions
+
+FireCloud stores and retrieves encrypted content. The RAG and artifact layers run entirely on the client — nothing in plaintext crosses the server boundary.
+
+### Private RAG (`fc-rag`)
+
+Index your docs locally and query with a private LLM — no data leaves your machine.
+
+```bash
+pip install "firecloud-devnet[rag]"
+fc-rag index ./docs
+fc-rag query "How does FireCloud handle node departure?"
+```
+
+### MLOps Artifact Store (`fc-mlops`)
+
+Version-track ML models, datasets, and checkpoints using FireCloud as the storage backend.
+
+```bash
+pip install "firecloud-devnet[mlops]"
+fc-ml save ./model.pt --name resnet --version 1.0.0 --type model --metric accuracy=0.94
+fc-ml simulate-failure
+```
+
+---
+
+## Development
+
+```bash
+git clone https://github.com/rajashekharsunkara/firecloud.git
+cd firecloud
+pip install -e ".[dev]"
+pytest tests/ -v
+```
+
+## License
+
+MIT — see [LICENSE](LICENSE).

firecloud_devnet-0.1.0.dist-info/RECORD

@@ -0,0 +1,34 @@
+fc_mlops/__init__.py,sha256=BaZAx9-tFMUWeBR-ltdL9a3XfxyDbbONKbhTMPURiN4,61
+fc_mlops/__main__.py,sha256=90NkmknSUTGhdGhiSVswLJJEkDNS0G5pmc6eyS_DTRQ,128
+fc_mlops/anomaly.py,sha256=bej4RTVjWneaCB3ckLm5dBe3njetPv6C7PPn2JCPNE0,3237
+fc_mlops/artifact_store.py,sha256=3qgynHVB28H8yF-iLmQl3n7JllWI3YipZSjdlF0mM2Y,3006
+fc_mlops/cli.py,sha256=waWnKRqu1HXbFQxCmWLuiTI263tLDZCjVFyAbNkxjtc,5732
+fc_mlops/simulate_failure.py,sha256=716JhAFBiS4GdmTyT7AP7mnCtTEP9lz-M5zU5oXXQ4o,3480
+fc_mlops/telemetry.py,sha256=znynDV9UJqQf3JpaNuTJsTmG0uo_nbnV2xw1sByr1XI,2146
+fc_rag/__init__.py,sha256=1tLueyQGaIgv7WPvIrji_RxUr9wa3arAwpj6nTiDCZc,97
+fc_rag/cli.py,sha256=uzvh7ccMGtj6iKAqoY3XEqqzy2r1vdFOCJI3rda4ePU,1278
+fc_rag/config.py,sha256=-SFjQE2Z0SuC2znorrv7GpctKZ33exlStlz6Ue8Yodw,675
+fc_rag/embedder.py,sha256=9l25UcKaCHJPbV6r6Bf3mvaiGs_lNl7-o3M6SO9QppM,1845
+fc_rag/indexer.py,sha256=pkRuDwu8-xjwQY5q410o-KWTY3mGCltLYnrSetwL5pk,4041
+fc_rag/query_engine.py,sha256=U31UBS6O-4nRibtJX1ZXWy9CslIzzEmUK4WyAD2iPL0,2377
+fc_rag/requirements.txt,sha256=PjVjcp3ovoo_XNJ6o0v2nJHQDhkcB9MtUKCQ4TgQBTo,56
+fc_rag/retriever.py,sha256=yUR9Kdq38I9q9co3emi12r5POwNyWBlGOYcRW5NBoek,1225
+firecloud/__init__.py,sha256=VUgE4uVUyHObBHQYG5rDjcBp3Sdsp9XfV43N16yeVCs,415
+firecloud/chunker.py,sha256=fuVfnabHzPuzQy9VhHMJzIWZlTOWnLsSgB5cR4Gzhno,3213
+firecloud/cli.py,sha256=NdMevf1LnMAKJ09ryUwgQ5VeYy0U5J4d0PsWSKR3wkY,18774
+firecloud/crypto.py,sha256=9-M2MxH-xhHWHrVm_tSYKURUOKVG25K3bpeCthi8Z4c,8301
+firecloud/discovery.py,sha256=rs0zg-bFZwBVJ6FJNENA68gX3EHHUyEISNELLtSj2eU,5638
+firecloud/distributor.py,sha256=QGeq6vS8C3aR_8OL9QsTc5ayJqiohNj-tFWaeltK3i8,10224
+firecloud/exceptions.py,sha256=otDFDr-AbSHCpTt8eb40kMRYkoFh6ngpO7H92LpcO1M,1170
+firecloud/fec.py,sha256=q30tH2p4R1vTgtHVR_ZBEh6Nq5BuSW2sp3KJLglfpvU,2713
+firecloud/manifest.py,sha256=Tw2sxY08ITF1QfFUcW42X7lQ2fx5LWTjRy80o60krPY,8893
+firecloud/network.py,sha256=-C6naE3ZcDEHoDCMw9T-03rqRUvyFkxdWtJCF58OcRU,2951
+firecloud/node.py,sha256=V2OzqOkbd7cqQysCH3nH6LSH5vaSxHsTthIscUI0Fvw,21728
+firecloud/storage.py,sha256=ZZwR5ZOWHLvK0aVj6-tKyT9D2t7ZMrqTgdLzYAWjFzs,4971
+firecloud/sync.py,sha256=-oOCxvkkXVWZXBoVbv-1RW4RVaGCHV8yfjCd9V_ra6w,10875
+firecloud/transport.py,sha256=qSCy_P3rywko-qNATlXwuRMEB2JWnKXvboIaX-DN-Ig,14986
+firecloud_devnet-0.1.0.dist-info/METADATA,sha256=wgAi-YLWC2E16jW_MVD7Q9sPGHTS3nx94DnAhts37fg,6091
+firecloud_devnet-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+firecloud_devnet-0.1.0.dist-info/entry_points.txt,sha256=aNR4TWzUB6IWq1CppyIVGmqrANwmQA9LKr4CQsVVeio,97
+firecloud_devnet-0.1.0.dist-info/licenses/LICENSE,sha256=enPSqS9BWWItID5gIsaicRl5K2YdWhaq9WnoQnWynMM,1081
+firecloud_devnet-0.1.0.dist-info/RECORD,,

firecloud_devnet-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

firecloud_devnet-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+fc-ml = fc_mlops.cli:cli
+fc-rag = fc_rag.cli:cli
+firecloud = firecloud.cli:cli

firecloud_devnet-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-2025 Rajashekhar Sunkara
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.