refactor: align structure more closely with rust library (#167)

* refactor: align structure more closely with rust library

- divide structures, `fn blob_` is now `blobs().` etc
- workarounds for python reserved names `del` and `import`

* update kotlin

* update swift

* python: apply ruff fixes

Author: dignifiedquire

Iroh.xcframework/ios-arm64/Iroh.framework/Headers/iroh_ffiFFI.h

@@ -3,8 +3,8 @@ import XCTest
 
 final class IrohLibTests: XCTestCase {
     func testNodeId() async throws {
-        let node = try await IrohLib.IrohNode.memory()
-        let nodeId = try await node.nodeId()
+        let node = try await IrohLib.Iroh.memory()
+        let nodeId = try await node.node().nodeId()
         print(nodeId)
 
         XCTAssertEqual(true, true)

Iroh.xcframework/ios-arm64_x86_64-simulator/Iroh.framework/Headers/iroh_ffiFFI.h

@@ -3,30 +3,30 @@ import iroh.*
 
 kotlinx.coroutines.runBlocking {
     // create node
-    val node = IrohNode.memory()
+    val node = Iroh.memory()
 
     // creating a node also creates an author
-    assert(node.authorList().size == 1)
+    assert(node.authors().list().size == 1)
 
     // create
-    val authorId = node.authorCreate()
+    val authorId = node.authors().create()
 
     // list all authors on the node
-    assert(node.authorList().size == 2)
+    assert(node.authors().list().size == 2)
 
     // export the author
-    val author = node.authorExport(authorId)
+    val author = node.authors().export(authorId)
     assert(authorId.equal(author.id()))
 
     // remove that author from the node
-    node.authorDelete(authorId)
+    node.authors().delete(authorId)
 
     // check there are 1 authors on the node
-    assert(node.authorList().size == 1)
+    assert(node.authors().list().size == 1)
 
     // import the author back into the node
-    node.authorImport(author)
+    node.authors().import(author)
 
     // check there is 1 author on the node
-    assert(node.authorList().size == 2)
+    assert(node.authors().list().size == 2)
 }

Iroh.xcframework/macos-arm64/Iroh.framework/Headers/iroh_ffiFFI.h

@@ -92,34 +92,34 @@ runBlocking {
 runBlocking {
     // create node
     val irohDir = kotlin.io.path.createTempDirectory("doc-test")
-    val node = IrohNode.persistent(irohDir.toString())
+    val node = Iroh.persistent(irohDir.toString())
 
     // create bytes
     val blobSize = 100
     val bytes = generateRandomByteArray(blobSize)
 
     // add blob
-    val addOutcome = node.blobsAddBytes(bytes)
+    val addOutcome = node.blobs().addBytes(bytes)
 
     // check outcome info is as expected
     assert(addOutcome.format == BlobFormat.RAW)
     assert(addOutcome.size == blobSize.toULong())
 
     // check we get the expected size from the hash
     val hash = addOutcome.hash
-    val gotSize = node.blobsSize(hash)
+    val gotSize = node.blobs().size(hash)
     assert(gotSize == blobSize.toULong())
 
     // get bytes
-    val gotBytes = node.blobsReadToBytes(hash)
+    val gotBytes = node.blobs().readToBytes(hash)
     assert(gotBytes.size == blobSize)
     assert(gotBytes contentEquals bytes)
 }
 
 // test functionality between reading bytes from a path and writing bytes to a path
 runBlocking {
     val irohDir = kotlin.io.path.createTempDirectory("doc-test-read-bytes")
-    val node = IrohNode.persistent(irohDir.toString())
+    val node = Iroh.persistent(irohDir.toString())
 
     // create bytes
     val blobSize = 100
@@ -154,24 +154,24 @@ runBlocking {
         }
     }
     val cb = Handler()
-    node.blobsAddFromPath(path, false, tag, wrap, cb)
+    node.blobs().addFromPath(path, false, tag, wrap, cb)
 
     // check outcome info is as expected
     assert(cb.format == BlobFormat.RAW)
     assert(cb.hash != null)
 
     // check we get the expected size from the hash
-    val gotSize = node.blobsSize(cb.hash!!)
+    val gotSize = node.blobs().size(cb.hash!!)
     assert(gotSize == blobSize.toULong())
 
     // get bytes
-    val gotBytes = node.blobsReadToBytes(cb.hash!!)
+    val gotBytes = node.blobs().readToBytes(cb.hash!!)
     assert(gotBytes.size == blobSize)
     assert(gotBytes contentEquals bytes)
 
     // write to file
     val outPath = dir.toString() + "out"
-    node.blobsWriteToPath(cb.hash!!, outPath)
+    node.blobs().writeToPath(cb.hash!!, outPath)
 
     // open file
     val gotBytesFile = java.io.File(outPath).readBytes()
@@ -192,10 +192,10 @@ runBlocking {
     }
     // make node
     val irohDir = kotlin.io.path.createTempDirectory("doc-test-collection")
-    val node = IrohNode.persistent(irohDir.toString())
+    val node = Iroh.persistent(irohDir.toString())
 
     // ensure zero blobs
-    val blobs = node.blobsList()
+    val blobs = node.blobs().list()
     assert(blobs.size == 0)
 
     // create callback to get blobs and collection hash
@@ -226,13 +226,13 @@ runBlocking {
     val tag = SetTagOption.auto()
     val wrap = WrapOption.noWrap()
     // add from path
-    node.blobsAddFromPath(collectionDir.toString(), false, tag, wrap, cb)
+    node.blobs().addFromPath(collectionDir.toString(), false, tag, wrap, cb)
 
     assert(cb.collectionHash != null)
     assert(cb.format == BlobFormat.HASH_SEQ)
 
     // list collections
-    val collections = node.blobsListCollections()
+    val collections = node.blobs().listCollections()
     println("collection hash " + collections[0].hash)
     assert(collections.size == 1)
     assert(collections[0].hash.equal(cb.collectionHash!!))
@@ -241,9 +241,9 @@ runBlocking {
     // list blobs
     val collectionHashes = cb.blobHashes!!
     collectionHashes.add(cb.collectionHash!!)
-    val gotHashes = node.blobsList()
+    val gotHashes = node.blobs().list()
     for (hash in gotHashes) {
-        val blob = node.blobsReadToBytes(hash)
+        val blob = node.blobs().readToBytes(hash)
         println("hash " + hash + " has size " + blob.size)
     }
     hashesExist(collectionHashes, gotHashes)
@@ -256,7 +256,7 @@ runBlocking {
 runBlocking {
     val irohDir = kotlin.io.path.createTempDirectory("doc-test-list-del")
     val opts = NodeOptions(100UL)
-    val node = IrohNode.persistentWithOptions(irohDir.toString(), opts)
+    val node = Iroh.persistentWithOptions(irohDir.toString(), opts)
 
     // create bytes
     val blobSize = 100
@@ -272,23 +272,23 @@ runBlocking {
     val hashes: MutableList<Hash> = arrayListOf()
     val tags: MutableList<ByteArray> = arrayListOf()
     for (blob in blobs) {
-        val output = node.blobsAddBytes(blob)
+        val output = node.blobs().addBytes(blob)
         hashes.add(output.hash)
         tags.add(output.tag)
     }
 
-    val gotHashes = node.blobsList()
+    val gotHashes = node.blobs().list()
     assert(gotHashes.size == numBlobs)
     hashesExist(hashes, gotHashes)
 
     val removeHash = hashes.removeAt(0)
     val removeTag = tags.removeAt(0)
     // delete the tag for the first blob
-    node.tagsDelete(removeTag)
+    node.tags().delete(removeTag)
     // wait for GC to clear the blob
     java.lang.Thread.sleep(250)
 
-    val clearedHashes = node.blobsList()
+    val clearedHashes = node.blobs().list()
     assert(clearedHashes.size == numBlobs - 1)
     hashesExist(hashes, clearedHashes)
 

IrohLib/Sources/IrohLib/IrohLib.swift

@@ -85,11 +85,11 @@ runBlocking {
 runBlocking {
     // create node
     val irohDir = kotlin.io.path.createTempDirectory("doc-test")
-    val node = IrohNode.persistent(irohDir.toString())
+    val node = Iroh.persistent(irohDir.toString())
 
     // create doc and author
-    val doc = node.docCreate()
-    val author = node.authorCreate()
+    val doc = node.docs().create()
+    val author = node.authors().create()
 
     // create entry
     val v = "hello world!".toByteArray()

IrohLib/Tests/IrohLibTests/IrohLibTests.swift

@@ -16,29 +16,29 @@ class Callback: GossipMessageCallback {
 runBlocking {
     setLogLevel(LogLevel.DEBUG)
 
-    val n0 = IrohNode.memory()
-    val n1 = IrohNode.memory()
+    val n0 = Iroh.memory()
+    val n1 = Iroh.memory()
 
     // Create a topic
     val topic = ByteArray(32) { i -> 1 }
 
     // Setup gossip on node 0
     val cb0 = Callback()
-    val n1Id = n1.nodeId()
-    val n1Addr = n1.nodeAddr()
-    n0.addNodeAddr(n1Addr)
+    val n1Id = n1.node().nodeId()
+    val n1Addr = n1.node().nodeAddr()
+    n0.node().addNodeAddr(n1Addr)
 
     println("subscribe n0")
-    val sink0 = n0.gossipSubscribe(topic, listOf(n1Id), cb0)
+    val sink0 = n0.gossip().subscribe(topic, listOf(n1Id), cb0)
 
     // Setup gossip on node 1
     val cb1 = Callback()
-    val n0Id = n0.nodeId()
-    val n0Addr = n0.nodeAddr()
-    n1.addNodeAddr(n0Addr)
+    val n0Id = n0.node().nodeId()
+    val n0Addr = n0.node().nodeAddr()
+    n1.node().addNodeAddr(n0Addr)
 
     println("subscribe n1")
-    val sink1 = n1.gossipSubscribe(topic, listOf(n0Id), cb1)
+    val sink1 = n1.gossip().subscribe(topic, listOf(n0Id), cb1)
 
     // Wait for n1 to show up for n0
     while (true) {