This repository is the official gRPC implementation for .NET (grpc-dotnet), providing a comprehensive set of libraries for building gRPC services and clients on ASP.NET Core. It includes server-side integration via `Grpc.AspNetCore.Server` with full support for unary, server-streaming, client-streaming, and duplex streaming calls, as well as client-side libraries (`Grpc.Net.Client`, `Grpc.Net.ClientFactory`) that leverage `HttpClient` and DI. The codebase also covers gRPC-Web (both server middleware and client handler), health checks, server reflection, load balancing, retry/hedging policies, compression, interceptors, and a CLI tool (`dotnet-grpc`) for managing protobuf references. The architecture is modular, with clear separation of concerns: core abstractions in `Grpc.Core.Api`, shared utilities in `Grpc.Net.Common`, and platform-specific implementations. Extensive unit and functional tests, performance benchmarks, and interop test assets ensure correctness and performance across .NET versions and platforms.
This is the Supabase JavaScript SDK monorepo, providing isomorphic client libraries for Supabase backend services. It is a well-structured TypeScript monorepo managed with pnpm and Nx, containing six core packages: auth-js (authentication), postgrest-js (database queries via PostgREST), realtime-js (WebSocket-based realtime subscriptions), storage-js (file storage and vector index API), functions-js (edge function invocation), and the umbrella supabase-js package that combines them into a single `createClient()` entry point. The SDK supports multiple runtimes (Node.js, Deno, browsers, Bun, React Native, Cloudflare Workers) and includes optional OpenTelemetry tracing support. The codebase demonstrates high craftsmanship with extensive TypeScript generics for type-safe query building, fluent builder patterns, robust error handling hierarchies, and comprehensive integration tests against local Supabase infrastructure. It is actively maintained with frequent releases, automated CI/CD, and a strong focus on backward compatibility.
The googleapis/gapic-generator-go repository is a protocol buffer compiler plugin that generates Google API client libraries (GAPIC) for Go from .proto files. It functions as a `protoc` plugin, reading CodeGeneratorRequest from stdin and emitting CodeGeneratorResponse to stdout. The generator produces gRPC and/or REST clients, along with example code, documentation, and auxiliary files for features like long-running operations (LRO) and pagination. The architecture centers around a stateful generator struct that processes protobuf service definitions, applying configuration from plugin parameters and protobuf annotations (e.g., google.api.http, google.longrunning.operation_info). Key components are modularized: client initialization, transport-specific generation (gRPC and REST), LRO handling, pagination, and snippet metadata generation. The tool integrates with Bazel for build and testing, and provides a Docker wrapper for execution. Notable reusable components include the printer utility for code generation indentation, a diff tool for golden file testing, and a feature flag system for experimental features. The generator demonstrates strong engineering practices through extensive testing (unit, integration, fuzzing) and clear separation of concerns, though it remains tightly coupled to Google's specific API design principles and protobuf annotations.
MSAL Python is a production-grade OAuth2/OIDC client library for the Microsoft identity platform (Entra ID / Azure AD, ADFS, MSA). It implements the full token acquisition lifecycle: authorization code, client credentials, device code, ROPC, on-behalf-of, and managed identity flows, plus WS-Trust for legacy ADFS federation. The library exposes two primary application classes — PublicClientApplication (desktop/mobile) and ConfidentialClientApplication (web apps/daemons) — built on a shared ClientApplication base with an embedded oauth2cli sub-package for low-level OAuth2 protocol handling. It also supports broker integration via pymsalruntime, proof-of-possession tokens, and regional endpoints.
This is the LINE Messaging API SDK for Ruby (gem `line-bot-api`), a client library for building LINE bot applications. It provides auto-generated Ruby clients for LINE's various APIs (Messaging API, Webhook, Channel Access Token, Insight, LIFF, Manage Audience, Shop, Module, and Module Attach) from OpenAPI specifications. The library includes a webhook parser with constant-time signature verification, typed model classes with dynamic attribute support, and comprehensive RBS type signatures for static type checking. It is not a data research repository; it is a production-quality SDK maintained by LINE Corporation with active development, CI/CD pipelines, and example Sinatra applications.
This is a .NET client library for Google Maps Platform web services. It provides a strongly-typed, async-first wrapper around 15+ Google Maps APIs, including Geocoding, Directions, Distance Matrix, Places (New), Routes, Address Validation, Elevation, Time Zone, Roads, Solar, Aerial View, Air Quality, Pollen, and Static Maps. The library is published as a NuGet package (over 2M downloads) and targets multiple .NET frameworks (netstandard2.0, net8.0, net10.0). It follows a consistent request/response pattern with generic constraints for compile-time safety, and includes a built-in engine that handles HTTP serialization, API key injection, error handling, and OpenTelemetry diagnostics (tracing and metrics). An optional dependency injection extension package registers `IGoogleMapsClient` with `IHttpClientFactory`. The repository also contains a comprehensive test suite with a VCR (record/replay) system, benchmarks, mutation testing, and sample applications (Blazor, Console, Minimal API, Generic Host) demonstrating usage.
This repository is a mature, production-grade WAMP v2 client library for Node.js and browsers. The actual code implements the Web Application Messaging Protocol with full pub/sub and RPC support over WebSocket, including auto-reconnect, multiple serializers (JSON, CBOR, MsgPack), and authentication methods (ticket, WAMP-CRA, cryptosign). The architecture is modular: a core Wampy class in `src/wampy.ts` accepts pluggable serializers via a common interface, and authentication plugins are registered in a hashmap. The library also includes a CLI tool (`cmd/cli.ts`) for rapid WAMP API debugging. External dependencies are minimal (WebSocket, Node.js crypto for cryptosign). The codebase is written in TypeScript with strict mode, dual ESM/CJS builds, and a comprehensive test suite covering connectivity, PubSub, RPC, and advanced features like progressive calls and Payload PassThru Mode. Despite large test files and some legacy patterns, the code is well-structured and follows promises/async-await throughout.
This repository is a multi-language collection of client libraries, code examples, and integration wrappers for the Trading Economics API — a service providing global economic indicators, financial market data, calendar events, forecasts, and specialized datasets (World Bank, Comtrade, Eurostat, Federal Reserve). The code spans 10+ programming languages (Python, R, Ruby, Go, Java, C#, PHP, Rust, TypeScript, Google Apps Script, Tableau WDC, MATLAB, MetaTrader) and demonstrates how to authenticate, request, parse, and display data from the API. The architecture is not a single application but a set of independent, language-specific examples and lightweight SDKs. Entry points include interactive CLIs (Ruby, Python), a Google Sheets add-on, a Tableau Web Data Connector, and standalone scripts for each data endpoint. The primary data flow is HTTP GET requests to api.tradingeconomics.com with an API key, parsing JSON or XML responses. External dependencies are minimal per language (e.g., httr for R, requests for Python, HTTParty for Ruby). The repository serves as both documentation and reusable boilerplate for integrating Trading Economics data into various platforms.