amadeus-java

Java library for the Amadeus Self-Service travel APIs

Stars: 87

Visit

Amadeus Java SDK provides a rich set of APIs for the travel industry, allowing developers to access various functionalities such as flight search, booking, airport information, and more. The SDK simplifies interaction with the Amadeus API by providing self-contained code examples and detailed documentation. Developers can easily make API calls, handle responses, and utilize features like pagination and logging. The SDK supports various endpoints for tasks like flight search, booking management, airport information retrieval, and travel analytics. It also offers functionalities for hotel search, booking, and sentiment analysis. Overall, the Amadeus Java SDK is a comprehensive tool for integrating Amadeus APIs into Java applications.

README:

Amadeus Java SDK

Amadeus provides a rich set of APIs for the travel industry. For more details, check out the Amadeus for Developers Portal or the SDK class reference.

Installation

This library requires Java 1.7+ and the Gson library. You can install the SDK via Maven or Gradle:

Maven

<dependency>
  <groupId>com.amadeus</groupId>
  <artifactId>amadeus-java</artifactId>
  <version>9.1.0</version>
</dependency>

Gradle

compile "com.amadeus:amadeus-java:9.1.0"

Getting Started

To make your first API call, you will need to register for an Amadeus Developer Account and set up your first application.

import com.amadeus.Amadeus;
import com.amadeus.Params;

import com.amadeus.exceptions.ResponseException;
import com.amadeus.referenceData.Locations;
import com.amadeus.resources.Location;

public class AmadeusExample {
  public static void main(String[] args) throws ResponseException {
    Amadeus amadeus = Amadeus
            .builder("REPLACE_BY_YOUR_API_KEY", "REPLACE_BY_YOUR_API_SECRET")
            .build();

    Location[] locations = amadeus.referenceData.locations.get(Params
      .with("keyword", "LON")
      .and("subType", Locations.ANY));

    System.out.println(locations);
  }
}

Examples

You can find all the endpoints in self-contained code examples.

Initialization

The client can be initialized directly:

//Initialize using parameters
Amadeus amadeus = Amadeus
        .builder("REPLACE_BY_YOUR_API_KEY", "REPLACE_BY_YOUR_API_SECRET")
        .build();

Alternatively, it can be initialized without any parameters if the environment variables AMADEUS_CLIENT_ID and AMADEUS_CLIENT_SECRET are present.

Amadeus amadeus = Amadeus
        .builder(System.getenv())
        .build();

Your credentials can be found on the Amadeus dashboard.

By default the SDK is set to test environment. To switch to a production (pay-as-you-go) environment, please switch the hostname as follows:

Amadeus amadeus = Amadeus
        .builder(System.getenv())
        .setHostname("production")
        .build();

Documentation

Amadeus has a large set of APIs, and our documentation is here to get you started. Head over to our reference documentation for in-depth information about every SDK method, its arguments and return types.

Making API calls

This library conveniently maps every API path to a similar path. For example, GET /v2/reference-data/urls/checkin-links?airlineCode=BA would be:

amadeus.referenceData.urls.checkinLinks.get(Params.with("airlineCode", "BA"));

Similarly, to select a resource by ID, you can pass in the ID to the singular path. For example, GET v1/reference-data/locations/pois would be:

amadeus.referenceData.locations.pointOfInterest("9CB40CB5D0").get();

You can make any arbitrary API call as well directly with the .get method. Keep in mind, this returns a raw Resource.

Response response = amadeus.get("/v2/reference-data/urls/checkin-links", Params.with("airlineCode", "BA"));

response.getResult();

Or, with POST method:

Response response = amadeus.post("/v1/shopping/availability/flight-availabilities", body);

Response

Every successful API call returns a Resource object. The Resource object has the raw response body (in string format) available:

Location[] locations = amadeus.referenceData.locations.get(Params
  .with("keyword", "LON")
  .and("subType", Locations.ANY));

 // The raw response, as a string
locations[0].getResponse().getBody();

Pagination

If an API endpoint supports pagination, the other pages are available under the .next, .previous, .last and .first methods.

Location[] locations = amadeus.referenceData.locations.get(Params
  .with("keyword", "LON")
  .and("subType", Locations.ANY));

// Fetches the next page
Location[] locations = (Location[]) amadeus.next(locations[0]);

If a page is not available, the method will return null.

Logging & Debugging

The SDK makes it easy to add your own logger.

import java.util.logging.Logger;

// Assumes the current class is called MyLogger
private final static Logger LOGGER = Logger.getLogger(MyLogger.class.getName());

...

Amadeus amadeus = Amadeus
        .builder("REPLACE_BY_YOUR_API_KEY", "REPLACE_BY_YOUR_API_SECRET")
        .setLogger(LOGGER)
        .build();
)

Additionally, to enable more verbose logging, you can set the appropriate level on your own logger. The easiest way would be to enable debugging via a parameter during initialization, or using the AMADEUS_LOG_LEVEL environment variable.

Amadeus amadeus = Amadeus
        .builder("REPLACE_BY_YOUR_API_KEY", "REPLACE_BY_YOUR_API_SECRET")
        .setLogLevel("debug") // or warn
        .build();

List of supported endpoints

// Flight Inspiration Search
FlightDestination[] flightDestinations = amadeus.shopping.flightDestinations.get(Params
  .with("origin", "MAD"));

// Flight Cheapest Date Search
FlightDate[] flightDates = amadeus.shopping.flightDates.get(Params
  .with("origin", "MAD")
  .and("destination", "MUC"));

// Flight Offers Search v2 GET
FlightOfferSearch[] flightOffersSearches = amadeus.shopping.flightOffersSearch.get(
              Params.with("originLocationCode", "SYD")
                      .and("destinationLocationCode", "BKK")
                      .and("departureDate", "2023-11-01")
                      .and("returnDate", "2023-11-08")
                      .and("adults", 2)
                      .and("max", 3));

// Flight Offers Search v2 POST
// body can be a String version of your JSON or a JsonObject
FlightOfferSearch[] flightOffersSearches = amadeus.shopping.flightOffersSearch.post(body);

// Flight Order Management
// The flightOrderID comes from the Flight Create Orders (in test environment it's temporary)
// Retrieve a flight order
FlightOrder order = amadeus.booking.flightOrder("eJzTd9f3NjIJdzUGAAp%2fAiY=").get();
// Cancel a flight order
Response order = amadeus.booking.flightOrder("eJzTd9f3NjIJdzUGAAp%2fAiY=").delete();

// Flight Offers price
FlightPrice[] flightPricing = amadeus.shopping.flightOffersSearch.pricing.post(
                    body,
                    Params.with("include", "other-services")
                          .and("forceClass", "false"));

// Flight Choice Prediction
// Note that the example calls 2 APIs: Flight Offers Search & Flight Choice Prediction
FlightOfferSearch[] flightOffers = amadeus.shopping.flightOffersSearch.get(
              Params.with("originLocationCode", "NYC")
                      .and("destinationLocationCode", "MAD")
                      .and("departureDate", "2024-04-01")
                      .and("returnDate", "2024-04-08")
                      .and("adults", 1));

// Using a JSonObject
JsonObject result = flightOffers[0].getResponse().getResult();
FlightOfferSearch[] flightOffersPrediction = amadeus.shopping.flightOffers.prediction.post(result);

// Using a String
String body = flightOffers[0].getResponse().getBody();
FlightOfferSearch[] flightOffersPrediction = amadeus.shopping.flightOffers.prediction.post(body);

// Flight Check-in Links
CheckinLink[] checkinLinks = amadeus.referenceData.urls.checkinLinks.get(Params
  .with("airlineCode", "BA"));

// Airline Code LookUp
Airline[] airlines = amadeus.referenceData.airlines.get(Params
  .with("airlineCodes", "BA"));

// Airport & City Search (autocomplete)
// Find all the cities and airports starting by the keyword 'LON'
Location[] locations = amadeus.referenceData.locations.get(Params
  .with("keyword", "LON")
  .and("subType", Locations.ANY));
// Get a specific city or airport based on its id
Location location = amadeus.referenceData
  .location("ALHR").get();

// Airport Nearest Relevant (for London)
Location[] locations = amadeus.referenceData.locations.airports.get(Params
  .with("latitude", 0.1278)
  .and("longitude", 51.5074));

// City Search
City[] cities = amadeus.referenceData.locations.cities.get(Params
  .with("keyword","PARIS"));

// Flight Most Booked Destinations
AirTraffic[] airTraffics = amadeus.travel.analytics.airTraffic.booked.get(Params
  .with("originCityCode", "MAD")
  .and("period", "2017-08"));

// Flight Most Traveled Destinations
AirTraffic[] airTraffics = amadeus.travel.analytics.airTraffic.traveled.get(Params
  .with("originCityCode", "MAD")
  .and("period", "2017-01"));

// Flight Busiest Traveling Period
Period[] busiestPeriods = amadeus.travel.analytics.airTraffic.busiestPeriod.get(Params
  .with("cityCode", "MAD")
  .and("period", "2017")
  .and("direction", BusiestPeriod.ARRIVING));

// Points of Interest
// What are the popular places in Barcelona (based a geo location and a radius)
PointOfInterest[] pointsOfInterest = amadeus.referenceData.locations.pointsOfInterest.get(Params
   .with("latitude", "41.39715")
   .and("longitude", "2.160873"));

// What are the popular places in Barcelona? (based on a square)
PointOfInterest[] pointsOfInterest = amadeus.referenceData.locations.pointsOfInterest.bySquare.get(Params
    .with("north", "41.397158")
    .and("west", "2.160873")
    .and("south", "41.394582")
    .and("east", "2.177181"));

// Returns a single Point of Interest from a given id
PointOfInterest pointOfInterest = amadeus.referenceData.locations.pointOfInterest("9CB40CB5D0").get();

// Tours and Activities
// What are the popular activities in Barcelona (based a geo location and a radius)
Activity[] activities = amadeus.shopping.activities.get(Params
   .with("latitude", "41.39715")
   .and("longitude", "2.160873"));

// What are the popular activities in Barcelona? (based on a square)
Activity[] activities = amadeus.shopping.activities.bySquare.get(Params
    .with("north", "41.397158")
    .and("west", "2.160873")
    .and("south", "41.394582")
    .and("east", "2.177181"));

// Returns a single activity from a given id
Activity activity = amadeus.shopping.activity("4615").get();

// What's the likelihood flights from this airport will leave on time?
Prediction AirportOnTime = amadeus.airport.predictions.onTime.get(Params
    .with("airportCode", "NCE")
    .and("date", "2024-04-01"));

// What's the likelihood of a given flight to be delayed?
Prediction[] flightDelay = amadeus.travel.predictions.flightDelay.get(Params
    .with("originLocationCode", "NCE")
    .and("destinationLocationCode", "IST")
    .and("departureDate", "2020-08-01")
    .and("departureTime", "18:20:00")
    .and("arrivalDate", "2020-08-01")
    .and("arrivalTime", "22:15:00")
    .and("aircraftCode", "321")
    .and("carrierCode", "TK")
    .and("flightNumber", "1816")
    .and("duration", "PT31H10M"));

// Flight Create Orders to book a flight
// Using a JSonObject or String
FlightOrder createdOrder = amadeus.booking.flightOrders.post(body);

// Using a JsonObject for flight offer and Traveler[] as traveler information
// see example at src/main/java/examples/flight/createorders/FlightCreateOrders.java
FlightOrder createdOrder = amadeus.booking.flightOrders.post(flightOffersSearches, travelerArray);

// What is the the seat map of a given flight?
SeatMap[] seatmap = amadeus.shopping.seatMaps.get(Params
    .with("flight-orderId", "eJzTd9f3NjIJdzUGAAp%2fAiY="));

// What is the the seat map of a given flight?
// The body can be a String version of your JSON or a JsonObject
SeatMap[] seatmap = amadeus.shopping.seatMaps.post(body);

// Trip Purpose Prediction
Prediction tripPurpose = amadeus.travel.predictions.tripPurpose.get(Params
    .with("originLocationCode", "NYC")
    .and("destinationLocationCode", "MAD")
    .and("departureDate", "2024-04-01")
    .and("returnDate", "2024-04-08"));

// Travel Recommendations
Location destinations = amadeus.referenceData.recommendedLocations.get(Params
    .with("cityCodes", "PAR")
    .and("travelerCountryCode", "FR"));

// On Demand Flight Status
DatedFlight[] flightStatus = amadeus.schedule.flights.get(Params
    .with("carrierCode", "AZ")
    .and("flightNumber", "319")
    .and("scheduledDepartureDate", "2024-03-13"));

// Flight Price Analysis
ItineraryPriceMetric[] metrics = amadeus.analytics.itineraryPriceMetrics.get(Params
    .with("originIataCode", "MAD")
    .and("destinationIataCode", "CDG")
    .and("departureDate", "2024-03-21"));

// Airport Routes
Destination[] directDestinations = amadeus.airport.directDestinations.get(Params
    .with("departureAirportCode","MAD")
    .and("max","2"));

// Flight Availabilites Search POST
// body can be a String version of your JSON or a JsonObject
FlightAvailability[] flightAvailabilities
  = amadeus.shopping.availability.flightAvailabilities.post(body);


// Location Score GET
ScoredLocation[] scoredLocations
  = amadeus.location.analytics.categoryRatedAreas.get(Params
      .with("latitude", "41.397158")
      .and("longitude", "2.160873"));

// Branded Fares Upsell Post
// body can be a String version of your JSON or a JsonObject
FlightOfferSearch[] upsellFlightOffers
  = amadeus.shopping.flightOffers.upselling.post(body);

// Hotel List
// Get list of hotels by hotel id
Hotel[] hotels = amadeus.referenceData.locations.hotels.byHotels.get(Params
  .with("hotelIds", "ADPAR001"));
// Get list of hotels by city code
Hotel[] hotels = amadeus.referenceData.locations.hotels.byCity.get(Params
  .with("cityCode", "PAR"));
// Get list of hotels by a geocode
Hotel[] hotels = amadeus.referenceData.locations.hotels.byGeocode.get(Params
  .with("longitude", 2.160873)
  .and("latitude", 41.397158));

// Hotel autocomplete names
Hotel[] result = amadeus.referenceData.locations.hotel.get(Params
  .with("keyword", "PARI")
  .and("subType", "HOTEL_GDS")
  .and("countryCode", "FR")
  .and("lang", "EN")
  .and("max", "20"));

// Hotel Offers Search API v3
// Get multiple hotel offers
HotelOfferSearch[] offers = amadeus.shopping.hotelOffersSearch.get(Params
  .with("hotelIds", "MCLONGHM")
  .and("adults", 1)
  .and("checkInDate", "2023-11-22")
  .and("roomQuantity", 1)
  .and("paymentPolicy", "NONE")
  .and("bestRateOnly", true));
// Get hotel offer pricing by offer id
HotelOfferSearch offer = amadeus.shopping.hotelOfferSearch("QF3MNOBDQ8").get();

// Hotel Booking
// The body can be a String version of your JSON or a JsonObject
HotelBooking[] hotel = amadeus.booking.hotelBookings.post(body);

// Hotel Booking v2
HotelOrder hotel = amadeus.booking.hotelOrders.post(body);

// Hotel Ratings / Sentiments
HotelSentiment[] hotelSentiments = amadeus.ereputation.hotelSentiments.get(Params.with("hotelIds", "ELONMFS,ADNYCCTB"));

// Airline Routes
// Get airline destinations
Destination[] destinations = amadeus.airline.destinations.get(Params
  .with("airlineCode", "BA")
  .and("max", 2));

// Transfer Search
TransferOffersPost[] transfers = amadeus.shopping.transferOffers.post(body);

// Transfer Booking
TransferOrder transfers = amadeus.ordering.transferOrders.post(body, params);

// Transfer Management
TransferCancellation transfers = amadeus.ordering.transferOrder("123456").transfers.cancellation.post(params);

Development & Contributing

Want to contribute? Read our Contributors Guide for guidance on installing and running this code in a development environment.

License

This library is released under the MIT License.

Help

You can find us on StackOverflow or join our developer community on Discord.

For Tasks:

Click tags to check more tools for each tasks

search flights book hotels retrieve airport info analyze hotel sentiments manage flight bookings

For Jobs:

software developer travel consultant api integration specialist backend engineer data analyst

Alternative AI tools for amadeus-java

Similar Open Source Tools

amadeus-java

github

: 87

dynamiq

Dynamiq is an orchestration framework designed to streamline the development of AI-powered applications, specializing in orchestrating retrieval-augmented generation (RAG) and large language model (LLM) agents. It provides an all-in-one Gen AI framework for agentic AI and LLM applications, offering tools for multi-agent orchestration, document indexing, and retrieval flows. With Dynamiq, users can easily build and deploy AI solutions for various tasks.

github

: 671

orch

orch is a library for building language model powered applications and agents for the Rust programming language. It can be used for tasks such as text generation, streaming text generation, structured data generation, and embedding generation. The library provides functionalities for executing various language model tasks and can be integrated into different applications and contexts. It offers flexibility for developers to create language model-powered features and applications in Rust.

github

: 178

ai-no-jimaku-gumi

AI no jimaku gumi is a command-line utility designed to assist in video translation. It supports translating subtitles using AI models and provides options for different translation and subtitle sources. Users can easily set up the tool by following the installation steps and use it to translate videos to different languages with customizable settings. The tool currently supports DeepL and llm translation backends and SRT subtitle export. It aims to simplify the process of adding subtitles to videos by leveraging AI technology.

github

: 130

openapi

The `@samchon/openapi` repository is a collection of OpenAPI types and converters for various versions of OpenAPI specifications. It includes an 'emended' OpenAPI v3.1 specification that enhances clarity by removing ambiguous and duplicated expressions. The repository also provides an application composer for LLM (Large Language Model) function calling from OpenAPI documents, allowing users to easily perform LLM function calls based on the Swagger document. Conversions to different versions of OpenAPI documents are also supported, all based on the emended OpenAPI v3.1 specification. Users can validate their OpenAPI documents using the `typia` library with `@samchon/openapi` types, ensuring compliance with standard specifications.

github

: 51

python-genai

The Google Gen AI SDK is a Python library that provides access to Google AI and Vertex AI services. It allows users to create clients for different services, work with parameter types, models, generate content, call functions, handle JSON response schemas, stream text and image content, perform async operations, count and compute tokens, embed content, generate and upscale images, edit images, work with files, create and get cached content, tune models, distill models, perform batch predictions, and more. The SDK supports various features like automatic function support, manual function declaration, JSON response schema support, streaming for text and image content, async methods, tuning job APIs, distillation, batch prediction, and more.

github

: 701

RagaAI-Catalyst

RagaAI Catalyst is a comprehensive platform designed to enhance the management and optimization of LLM projects. It offers features such as project management, dataset management, evaluation management, trace management, prompt management, synthetic data generation, and guardrail management. These functionalities enable efficient evaluation and safeguarding of LLM applications.

github

: 7.0k

AIGODLIKE-ComfyUI-Translation

A plugin for multilingual translation of ComfyUI, This plugin implements translation of resident menu bar/search bar/right-click context menu/node, etc

github

: 1.3k

blendsql

BlendSQL is a superset of SQLite designed for problem decomposition and hybrid question-answering with Large Language Models (LLMs). It allows users to blend operations over heterogeneous data sources like tables, text, and images, combining the structured and interpretable reasoning of SQL with the generalizable reasoning of LLMs. Users can oversee all calls (LLM + SQL) within a unified query language, enabling tasks such as building LLM chatbots for travel planning and answering complex questions by injecting 'ingredients' as callable functions.

github

: 66

go-anthropic

Go-anthropic is an unofficial API wrapper for Anthropic Claude in Go. It supports completions, streaming completions, messages, streaming messages, vision, and tool use. Users can interact with the Anthropic Claude API to generate text completions, analyze messages, process images, and utilize specific tools for various tasks.

github

: 130

byzer-llm

Easy, fast, and cheap pretrain, finetune, serving for everyone

github

: 254

Janus

Janus is a series of unified multimodal understanding and generation models, including Janus-Pro, Janus, and JanusFlow. Janus-Pro is an advanced version that improves both multimodal understanding and visual generation significantly. Janus decouples visual encoding for unified multimodal understanding and generation, surpassing previous models. JanusFlow harmonizes autoregression and rectified flow for unified multimodal understanding and generation, achieving comparable or superior performance to specialized models. The models are available for download and usage, supporting a broad range of research in academic and commercial communities.

github

: 1.4k

langchain-swift

LangChain for Swift. Optimized for iOS, macOS, watchOS (part) and visionOS.(beta) This is a pure client library, no server required

github

: 261

gp.nvim

Gp.nvim (GPT prompt) Neovim AI plugin provides a seamless integration of GPT models into Neovim, offering features like streaming responses, extensibility via hook functions, minimal dependencies, ChatGPT-like sessions, instructable text/code operations, speech-to-text support, and image generation directly within Neovim. The plugin aims to enhance the Neovim experience by leveraging the power of AI models in a user-friendly and native way.

github

: 762

llama_ros

This repository provides a set of ROS 2 packages to integrate llama.cpp into ROS 2. By using the llama_ros packages, you can easily incorporate the powerful optimization capabilities of llama.cpp into your ROS 2 projects by running GGUF-based LLMs and VLMs.

github

: 175

functionary

Functionary is a language model that interprets and executes functions/plugins. It determines when to execute functions, whether in parallel or serially, and understands their outputs. Function definitions are given as JSON Schema Objects, similar to OpenAI GPT function calls. It offers documentation and examples on functionary.meetkai.com. The newest model, meetkai/functionary-medium-v3.1, is ranked 2nd in the Berkeley Function-Calling Leaderboard. Functionary supports models with different context lengths and capabilities for function calling and code interpretation. It also provides grammar sampling for accurate function and parameter names. Users can deploy Functionary models serverlessly using Modal.com.

github

: 1.5k

For similar tasks

amadeus-java

github

: 87

amadeus-node

Amadeus Node SDK provides a rich set of APIs for the travel industry. It allows developers to interact with various endpoints related to flights, hotels, activities, and more. The SDK simplifies making API calls, handling promises, pagination, logging, and debugging. It supports a wide range of functionalities such as flight search, booking, seat maps, flight status, points of interest, hotel search, sentiment analysis, trip predictions, and more. Developers can easily integrate the SDK into their Node.js applications to access Amadeus APIs and build travel-related applications.

github

: 186

awesome-crewai

Awesome CrewAI is a curated collection of open-source projects built by the CrewAI community, aimed at unlocking the full potential of AI agents for supercharging business processes and decision-making. It includes integrations, tutorials, and tools that showcase the capabilities of CrewAI in various domains.

github

: 221

notte

Notte is a web browser designed specifically for LLM agents, providing a language-first web navigation experience without the need for DOM/HTML parsing. It transforms websites into structured, navigable maps described in natural language, enabling users to interact with the web using natural language commands. By simplifying browser complexity, Notte allows LLM policies to focus on conversational reasoning and planning, reducing token usage, costs, and latency. The tool supports various language model providers and offers a reinforcement learning style action space and controls for full navigation control.

github

: 163

For similar jobs

EDDI

E.D.D.I (Enhanced Dialog Driven Interface) is an enterprise-certified chatbot middleware that offers advanced prompt and conversation management for Conversational AI APIs. Developed in Java using Quarkus, it is lean, RESTful, scalable, and cloud-native. E.D.D.I is highly scalable and designed to efficiently manage conversations in AI-driven applications, with seamless API integration capabilities. Notable features include configurable NLP and Behavior rules, support for multiple chatbots running concurrently, and integration with MongoDB, OAuth 2.0, and HTML/CSS/JavaScript for UI. The project requires Java 21, Maven 3.8.4, and MongoDB >= 5.0 to run. It can be built as a Docker image and deployed using Docker or Kubernetes, with additional support for integration testing and monitoring through Prometheus and Kubernetes endpoints.

github

: 259

empower-functions

Empower Functions is a family of large language models (LLMs) that provide GPT-4 level capabilities for real-world 'tool using' use cases. These models offer compatibility support to be used as drop-in replacements, enabling interactions with external APIs by recognizing when a function needs to be called and generating JSON containing necessary arguments based on user inputs. This capability is crucial for building conversational agents and applications that convert natural language into API calls, facilitating tasks such as weather inquiries, data extraction, and interactions with knowledge bases. The models can handle multi-turn conversations, choose between tools or standard dialogue, ask for clarification on missing parameters, integrate responses with tool outputs in a streaming fashion, and efficiently execute multiple functions either in parallel or sequentially with dependencies.

github

: 202

aiotdlib

aiotdlib is a Python asyncio Telegram client based on TDLib. It provides automatic generation of types and functions from tl schema, validation, good IDE type hinting, and high-level API methods for simpler work with tdlib. The package includes prebuilt TDLib binaries for macOS (arm64) and Debian Bullseye (amd64). Users can use their own binary by passing `library_path` argument to `Client` class constructor. Compatibility with other versions of the library is not guaranteed. The tool requires Python 3.9+ and users need to get their `api_id` and `api_hash` from Telegram docs for installation and usage.

github

: 96

amadeus-java

github

: 87

aiomcache

aiomcache is a Python library that provides an asyncio (PEP 3156) interface to work with memcached. It allows users to interact with memcached servers asynchronously, making it suitable for high-performance applications that require non-blocking I/O operations. The library offers similar functionality to other memcache clients and includes features like setting and getting values, multi-get operations, and deleting keys. Version 0.8 introduces the `FlagClient` class, which enables users to register callbacks for setting or processing flags, providing additional flexibility and customization options for working with memcached servers.

github

: 141

aiolimiter

An efficient implementation of a rate limiter for asyncio using the Leaky bucket algorithm, providing precise control over the rate a code section can be entered. It allows for limiting the number of concurrent entries within a specified time window, ensuring that a section of code is executed a maximum number of times in that period.

github

: 474

bee

Bee is an easy and high efficiency ORM framework that simplifies database operations by providing a simple interface and eliminating the need to write separate DAO code. It supports various features such as automatic filtering of properties, partial field queries, native statement pagination, JSON format results, sharding, multiple database support, and more. Bee also offers powerful functionalities like dynamic query conditions, transactions, complex queries, MongoDB ORM, cache management, and additional tools for generating distributed primary keys, reading Excel files, and more. The newest versions introduce enhancements like placeholder precompilation, default date sharding, ElasticSearch ORM support, and improved query capabilities.

github

: 610

claude-api

claude-api is a web conversation library for ClaudeAI implemented in GoLang. It provides functionalities to interact with ClaudeAI for web-based conversations. Users can easily integrate this library into their Go projects to enable chatbot capabilities and handle conversations with ClaudeAI. The library includes features for sending messages, receiving responses, and managing chat sessions, making it a valuable tool for developers looking to incorporate AI-powered chatbots into their applications.

github

: 164