import requests
						class SpeechAnalysisAPI:
						def 	init	(self, base_url="http://localhost:5000"): 
							self.base_url = base_url
						def transcribe(self, audio_file_path):
						"""
						Transcribe a single audio file 
						"""
							with open(audio_file_path, 'rb') as audio_file: 
							files = {'audio': audio_file}
							response = requests.post(f"{self.base_url}/ transcript", files=files)
							return response.json()
						
						def evaluate(self, audio_file_paths):
							"""
							Evaluate one or multiple audio files 
							"""
							files = []
							for path in audio_file_paths: files.append(('audio', open(path, 'rb')))
						
							response = requests.post(f"{self.base_url}/evaluate", files=files)
							return response.json()
						
						# Usage example
						api = SpeechAnalysisAPI()
						 
						# Transcribe single file
						result = api.transcribe('path/to/audio.wav') print("Transcription:", result['transcription'])
						
						# Evaluate multiple files
						results = api.evaluate(['audio1.wav', 'audio2.wav'])
						for result in results['results']:
						print(f"IELTS Score: {result['ielts_score']}") print(f"PTE Score: {result['pte_score']}")					  
  

					import java.io.File; 
					import java.nio.file.Files; 
					import okhttp3.*;
					public class SpeechAnalysisAPI { 
						private final String baseUrl; 
						private final OkHttpClient client;

						public SpeechAnalysisAPI(String baseUrl) {
							this.baseUrl = baseUrl;
							this.client = new OkHttpClient();
						}

						public String transcribe(String audioFilePath) throws IOException {
							File audioFile = new File(audioFilePath); RequestBody  requestBody = new MultipartBody.Builder()
								.setType(MultipartBody.FORM)
								.addFormDataPart("audio", audioFile.getName(), RequestBody.create(MediaType.parse("audio/wav"), audioFile))
								.build();

							Request request = new Request.Builder()
								.url(baseUrl + "/transcript")
								.post(requestBody)
								.build();
							try (Response response = 
							client.newCall(request).execute()) {
								return response.body().string();
							}
						}
					public String evaluate(String[] audioFilePaths) throws IOException { 		
						MultipartBody.Builder builder = new MultipartBody.Builder()
							.setType(MultipartBody.FORM);
						for (String path : audioFilePaths) { 
							File audioFile = new File(path);
							builder.addFormDataPart("audio", audioFile.getName(), RequestBody.create(MediaType.parse("audio/wav"),
							audioFile));
						}
					Request request = new Request.Builder()
					.url(baseUrl + "/evaluate")
					.post(builder.build())
					.build();
				try (Response response = client.newCall(request).execute()) {
					return response.body().string();
				}
			}
			// Usage example
			public static void main(String[] args) { 
				SpeechAnalysisAPI api = new SpeechAnalysisAPI("http:// localhost:5000");
			try {
			// Transcribe single file
			String transcription = api.transcribe("audio.wav"); System.out.println("Transcription: " + transcription);
			// Evaluate multiple files
			String[] files = {"audio1.wav", "audio2.wav"}; 
			String evaluation = api.evaluate(files); 
			System.out.println("Evaluation: " + evaluation);
		}
		catch (IOException e) { 
			e.printStackTrace();
		}
	}
}				

const axios = require('axios');
const FormData = require('form-data');
const fs = require('fs');

class SpeechAnalysisAPI {
  constructor(baseUrl = 'http://localhost:5000') {
    this.baseUrl = baseUrl;
  }

  async transcribe(audioFilePath) {
    try {
      const formData = new FormData();
      formData.append('audio', fs.createReadStream(audioFilePath));

      const response = await axios.post(`${this.baseUrl}/transcript`, formData, {
        headers: formData.getHeaders(),
      });

      return response.data;
    } catch (error) {
      throw new Error(`Transcription failed: ${error.message}`);
    }
  }

  async evaluate(audioFilePaths) {
    try {
      const formData = new FormData();

      audioFilePaths.forEach((path) => {
        formData.append('audio', fs.createReadStream(path));
      });

      const response = await axios.post(`${this.baseUrl}/evaluate`, formData, {
        headers: formData.getHeaders(),
      });

      return response.data;
    } catch (error) {
      throw new Error(`Evaluation failed: ${error.message}`);
    }
  }
}

// Usage example
async function main() {
  const api = new SpeechAnalysisAPI();

  try {
    // Transcribe single file
    const transcription = await api.transcribe('audio.wav');
    console.log('Transcription:', transcription);

    // Evaluate multiple files
    const evaluation = await api.evaluate(['audio1.wav', 'audio2.wav']);
    console.log('Evaluation:', evaluation);
  } catch (error) {
    console.error('Error:', error.message);
  }
}
main();