*: upgrade eslint

Author: tharvik

.eslintrc.js

@@ -7,7 +7,7 @@
     "watch": "nodemon --ext ts --ignore dist --watch ../discojs/discojs-node/dist --watch ../server/dist --watch . --exec npm run",
     "start": "npm run build && node dist/cli.js",
     "build": "tsc",
-    "lint": "npx eslint --ext ts --max-warnings 0 .",
+    "lint": "npx eslint .",
     "test": ": nothing"
   },
   "author": "",

cli/.eslintrc.json

@@ -32,7 +32,7 @@ async function simplefaceData (task: Task): Promise<data.DataSplit> {
 
   const filesPerFolder = [youngFiles, oldFiles]
 
-  const labels = filesPerFolder.flatMap((files, index) => Array(files.length).fill(index))
+  const labels = filesPerFolder.flatMap((files, index) => Array<string>(files.length).fill(`${index}`))
   const files = filesPerFolder.flat()
 
   return await new NodeImageLoader(task).loadAll(files, { labels })

cli/package.json

@@ -7,7 +7,7 @@
   "scripts": {
     "watch": "nodemon --ext ts --ignore dist --exec npm run",
     "build": "tsc",
-    "lint": "npx eslint --ext ts --max-warnings 0 .",
+    "lint": "npx eslint .",
     "test": "mocha",
     "docs": "typedoc ./src/index.ts --theme oxide"
   },

cli/src/data.ts

@@ -1,3 +1,5 @@
+// TODO remove as nothing is implemented
+
 import { Base as Aggregator } from './base.js'
 import type { client, Model, WeightsContainer } from '../index.js'
 
@@ -8,11 +10,8 @@ export type Momentum = WeightsContainer
 // TODO @s314cy: store previous round contributions + be able to access own previous contribution
 // for computing the momentum
 export class RobustAggregator extends Aggregator<WeightsContainer> {
-  // TODO @s314y: move to task definition
-  private readonly beta = 1
-
   constructor (
-    private readonly tauPercentile: number,
+    _tauPercentile: number,
     model?: Model,
     roundCutoff?: number,
     communicationRounds?: number
@@ -35,19 +34,15 @@ export class RobustAggregator extends Aggregator<WeightsContainer> {
     return false
   }
 
-  aggregate (): void {
+  override aggregate (): void {
     throw new Error('not implemented')
   }
 
-  makePayloads (weights: WeightsContainer): Map<client.NodeID, WeightsContainer> {
-    return undefined as any
+  override makePayloads (): Map<client.NodeID, WeightsContainer> {
+    throw new Error('not implemented')
   }
 
   isFull (): boolean {
     return true
   }
-
-  private computeMomentum (a: WeightsContainer, b: WeightsContainer): WeightsContainer {
-    return a.sub(b).mul(1 - this.beta).add(a.mul(this.beta))
-  }
 }

discojs/discojs-core/package.json

@@ -67,46 +67,46 @@ export abstract class Base {
 
   /**
    * Communication callback called once at the beginning of the training instance.
-   * @param weights The initial model weights
-   * @param trainingInformant The training informant
+   * @param _weights The initial model weights
+   * @param _trainingInformant The training informant
    */
   async onTrainBeginCommunication (
-    weights: WeightsContainer,
-    trainingInformant: TrainingInformant
+    _weights: WeightsContainer,
+    _trainingInformant: TrainingInformant
   ): Promise<void> {}
 
   /**
    * Communication callback called once at the end of the training instance.
-   * @param weights The final model weights
-   * @param trainingInformant The training informant
+   * @param _weights The final model weights
+   * @param _trainingInformant The training informant
    */
   async onTrainEndCommunication (
-    weights: WeightsContainer,
-    trainingInformant: TrainingInformant
+    _weights: WeightsContainer,
+    _trainingInformant: TrainingInformant
   ): Promise<void> {}
 
   /**
    * Communication callback called at the beginning of every training round.
-   * @param weights The most recent local weight updates
-   * @param round The current training round
-   * @param trainingInformant The training informant
+   * @param _weights The most recent local weight updates
+   * @param _round The current training round
+   * @param _trainingInformant The training informant
    */
   async onRoundBeginCommunication (
-    weights: WeightsContainer,
-    round: number,
-    trainingInformant: TrainingInformant
+    _weights: WeightsContainer,
+    _round: number,
+    _trainingInformant: TrainingInformant
   ): Promise<void> {}
 
   /**
    * Communication callback called the end of every training round.
-   * @param weights The most recent local weight updates
-   * @param round The current training round
-   * @param trainingInformant The training informant
+   * @param _weights The most recent local weight updates
+   * @param _round The current training round
+   * @param _trainingInformant The training informant
    */
   async onRoundEndCommunication (
-    weights: WeightsContainer,
-    round: number,
-    trainingInformant: TrainingInformant
+    _weights: WeightsContainer,
+    _round: number,
+    _trainingInformant: TrainingInformant
   ): Promise<void> {}
 
   get nodes (): Set<NodeID> {

discojs/discojs-core/src/aggregator/robust.ts

@@ -1,6 +1,6 @@
 import { Map, Set } from 'immutable'
 
-import { type TrainingInformant, type WeightsContainer, serialization } from '../../index.js'
+import { type WeightsContainer, serialization } from '../../index.js'
 import { Client, type NodeID } from '../index.js'
 import { type, type ClientConnected } from '../messages.js'
 import { timeout } from '../utils.js'
@@ -125,7 +125,7 @@ export class Base extends Client {
     this.pool = new PeerPool(peerIdMsg.id)
   }
 
-  async disconnect (): Promise<void> {
+  disconnect (): Promise<void> {
     // Disconnect from peers
     this.pool?.shutdown()
     this.pool = undefined
@@ -139,12 +139,13 @@ export class Base extends Client {
     this.server?.disconnect()
     this._server = undefined
     this._ownId = undefined
+
+    return Promise.resolve()
   }
 
-  async onRoundBeginCommunication (
-    weights: WeightsContainer,
+  override async onRoundBeginCommunication (
+    _: WeightsContainer,
     round: number,
-    trainingInformant: TrainingInformant
   ): Promise<void> {
     // Reset peers list at each round of training to make sure client works with an updated peers
     // list, maintained by the server. Adds any received weights to the aggregator.
@@ -153,10 +154,9 @@ export class Base extends Client {
     this.aggregationResult = this.aggregator.receiveResult()
   }
 
-  async onRoundEndCommunication (
+  override async onRoundEndCommunication (
     weights: WeightsContainer,
     round: number,
-    trainingInformant: TrainingInformant
   ): Promise<void> {
     let result = weights
 

discojs/discojs-core/src/client/base.ts

@@ -12,7 +12,7 @@ describe('peer pool', function () {
 
   let pools: Map<NodeID, PeerPool>
 
-  beforeEach(async () => {
+  beforeEach(() => {
     const count = 3
 
     pools = Map(Range(1, count + 1).map(String).map((id) =>
@@ -26,8 +26,8 @@ describe('peer pool', function () {
 
   function mockServer (poolId: string): EventConnection {
     return {
-      send: (msg: any): void => {
-        const signal: messages.SignalForPeer = msg
+      send: (msg): void => {
+        const signal = msg as messages.SignalForPeer
         const otherPool = pools.get(signal.peer)
         if (otherPool === undefined) {
           throw new Error(`signal for unknown pool: ${signal.peer}`)
@@ -71,7 +71,7 @@ describe('peer pool', function () {
     const messages =
       peersSets
         .entrySeq()
-        .map(([poolID, peers]) =>
+        .map(([_, peers]) =>
           peers
             .keySeq().map((id) => mockWeights(id))
             .toArray())
@@ -81,7 +81,7 @@ describe('peer pool', function () {
     peersSets
       .entrySeq()
       .forEach(([poolID, peers]) =>
-        peers.forEach((peer, id) => { peer.send(mockWeights(poolID)) }))
+        peers.forEach((peer) => { peer.send(mockWeights(poolID)) }))
 
     const exchanged = (await Promise.all(
       peersSets
@@ -106,7 +106,7 @@ describe('peer pool', function () {
     await assertCanSendMessagesToEach(poolsPeers)
   })
 
-  it('doesn\'t reconnect known peers', async () => {
+  it("doesn't reconnect known peers", async () => {
     const poolsPeersFirst = await getAllPeers(pools)
     await assertCanSendMessagesToEach(poolsPeersFirst)
 

discojs/discojs-core/src/client/decentralized/base.ts

@@ -51,7 +51,7 @@ export class PeerPool {
     ))
 
     console.info(`[${this.id}] asked to connect new peers:`, newPeers.keySeq().toJS())
-    const newPeersConnections = newPeers.map((peer, id) => new PeerConnection(this.id, peer, signallingServer))
+    const newPeersConnections = newPeers.map((peer) => new PeerConnection(this.id, peer, signallingServer))
 
     // adding peers to pool before connecting them because they must be set to call signal on them
     this.peers = this.peers.merge(newPeersConnections)

discojs/discojs-core/src/client/decentralized/peer_pool.spec.ts

@@ -30,7 +30,7 @@ export async function waitMessageWithTimeout<T extends type> (connection: EventC
 
 export class PeerConnection extends EventEmitter<{ [K in type]: NarrowMessage<K> }> implements EventConnection {
   constructor (
-    private readonly ownId: NodeID,
+    private readonly _ownId: NodeID,
     private readonly peer: Peer,
     private readonly signallingServer: EventConnection
   ) {
@@ -48,7 +48,7 @@ export class PeerConnection extends EventEmitter<{ [K in type]: NarrowMessage<K>
     })
 
     this.peer.on('data', (data) => {
-      const msg = msgpack.decode(data)
+      const msg: unknown = msgpack.decode(data)
 
       if (!decentralizedMessages.isPeerMessage(msg)) {
         throw new Error(`invalid message received: ${JSON.stringify(msg)}`)
@@ -83,27 +83,26 @@ export class PeerConnection extends EventEmitter<{ [K in type]: NarrowMessage<K>
 export class WebSocketServer extends EventEmitter<{ [K in type]: NarrowMessage<K> }> implements EventConnection {
   private constructor (
     private readonly socket: isomorphic.WebSocket,
-    private readonly validateReceived?: (msg: any) => boolean,
-    private readonly validateSent?: (msg: any) => boolean
+    private readonly validateSent?: (msg: Message) => boolean
   ) { super() }
 
   static async connect (url: URL,
-    validateReceived?: (msg: any) => boolean,
-    validateSent?: (msg: any) => boolean): Promise<WebSocketServer> {
+    validateReceived: (msg: unknown) => msg is Message,
+    validateSent: (msg: Message) => boolean): Promise<WebSocketServer> {
     const ws = new isomorphic.WebSocket(url)
     ws.binaryType = 'arraybuffer'
 
-    const server: WebSocketServer = new WebSocketServer(ws, validateReceived, validateSent)
+    const server: WebSocketServer = new WebSocketServer(ws, validateSent)
 
     ws.onmessage = (event: isomorphic.MessageEvent) => {
       if (!(event.data instanceof ArrayBuffer)) {
         throw new Error('server did not send an ArrayBuffer')
       }
 
-      const msg = msgpack.decode(new Uint8Array(event.data))
+      const msg: unknown = msgpack.decode(new Uint8Array(event.data))
 
       // Validate message format
-      if (validateReceived !== undefined && !validateReceived(msg)) {
+      if (!validateReceived(msg)) {
         throw new Error(`invalid message received: ${JSON.stringify(msg)}`)
       }