fixed CheckTrainingStatus to match python and js (#43)

* update the thresholdl for quickflow auto train

* new dataset

* update test

* test(quick_flow): tolerance on exhaustive recall instead of bit-exact 1.0

n_probes==n_lists exhaustive search should recover the ground truth, but
JSON->float32 rounding of query vectors differs slightly across SDKs and can
flip a few tie-broken neighbors at the top_k boundary. Assert recall within
0.01 of 1.0 rather than exact equality so the check is portable.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* renamed CheckTrainingStatus

---------

Co-authored-by: “Truman <“trumanngny@yahoo.com”>
Co-authored-by: ahellegit <ah.secured@gmail.com>
Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>

Author: 4 people

encrypted_index.go

@@ -170,15 +170,14 @@ func (e *EncryptedIndex) IsTrained(ctx context.Context) (bool, error) {
 	return resp.GetIsTrained(), nil
 }
 
-// CheckTrainingStatus queries the server to check whether this index is
-// currently being trained (e.g. by an auto-training trigger). It reflects live
-// server state on every call and holds no cached status, matching the Python
-// SDK's is_training.
+// IsTraining queries the server to check whether this index is currently being
+// trained (e.g. by an auto-training trigger). It reflects live server state on
+// every call and holds no cached status, matching the Python SDK's is_training.
 //
 // Returns:
 //   - bool: true if the index is currently being trained, false otherwise
 //   - error: Any error encountered during the status check
-func (e *EncryptedIndex) CheckTrainingStatus(ctx context.Context) (bool, error) {
+func (e *EncryptedIndex) IsTraining(ctx context.Context) (bool, error) {
 	result, _, err := e.client.APIClient.DefaultAPI.GetTrainingStatusV1IndexesTrainingStatusGet(ctx).Execute()
 	if err != nil {
 		return false, fmt.Errorf("failed to get training status: %w", err)
@@ -607,7 +606,7 @@ func (e *EncryptedIndex) Delete(ctx context.Context, ids []string) error {
 // be suboptimal until training completes.
 //
 // All parameters are optional with sensible defaults. Use IsTrained or
-// CheckTrainingStatus to observe training state, which is read live from the
+// IsTraining to observe training state, which is read live from the
 // server.
 //
 // Parameters:

test/api_contract_test.go

@@ -510,11 +510,11 @@ func TestClientIsTraining(t *testing.T) {
 	defer cancel()
 
 	t.Run("ReturnTrainingStatusWithCorrectSchema", func(t *testing.T) {
-		// Note: In Go SDK, this is CheckTrainingStatus on the index, not client
+		// Note: In Go SDK, this is IsTraining on the index, not client
 		// But we can verify the behavior exists
-		isTraining, err := testIndex.CheckTrainingStatus(ctx)
+		isTraining, err := testIndex.IsTraining(ctx)
 		if err != nil {
-			t.Fatalf("CheckTrainingStatus failed: %v", err)
+			t.Fatalf("IsTraining failed: %v", err)
 		}
 
 		if reflect.TypeOf(isTraining).Kind() != reflect.Bool {

test/kms_byok_test.go

@@ -210,8 +210,8 @@ func runKMSRoundTrip(t *testing.T, cfg kmsBYOKConfig, kmsName string) {
 	if _, err := loaded.IsTrained(ctx); err != nil {
 		t.Errorf("IsTrained: %v", err)
 	}
-	if _, err := loaded.CheckTrainingStatus(ctx); err != nil {
-		t.Errorf("CheckTrainingStatus: %v", err)
+	if _, err := loaded.IsTraining(ctx); err != nil {
+		t.Errorf("IsTraining: %v", err)
 	}
 
 	if err := loaded.Delete(ctx, []string{"0"}); err != nil {

test/quick_flow_test.go

@@ -651,7 +651,7 @@ func TestUnitFlow(t *testing.T) {
 		for attempt := 0; attempt < numRetries; attempt++ {
 			time.Sleep(2 * time.Second)
 
-			isTraining, checkErr := index.CheckTrainingStatus(ctx)
+			isTraining, checkErr := index.IsTraining(ctx)
 			if checkErr != nil {
 				fmt.Printf("Error checking training status: %v, retrying... (%d/%d)\n", checkErr, attempt+1, numRetries)
 				continue