Seer is a lightweight, semantically rich wrapper for the Google Visualization API. It allows you to easily create a visualization of data in a variety of formats, including area charts, bar charts, column charts, gauges, line charts, and pie charts.
A quick and easy way to visually test out your application's API.
Google Visualization API Query Language written in Ruby.
Use this SDK to access the Looker API. The Looker API provides functions to perform administrative tasks such as provisioning users, configuring database connections, and so on. It also enables you to leverage the Looker data analytics engine to fetch data or render visualizations defined in your Looker data models. For more information, see https://looker.com.
Ruby/SDL2 is an extension library to use SDL 2.x (Simple DirectMedia Layer). SDL 2.x is quite refined from SDL 1.x and API is changed. This library enables you to control audio, keyboard, mouse, joystick, 3D hardware via OpenGL, and 2D video using opengl or Direct3D. Ruby/SDL is used for games and visual demos.
Easily embed charts with Google Visualization API, using ruby formatted options in your view files
Work In Progress - Clarifai is a visual recognition API. Clarifai's algorithms enable fine grained classification, localization of objects in images and similarity search based on the combination of semantic and visual properties.
Using the provided API, record metrics (such as number of hits to a particular controller, bytes in/out, compression ratio) within your system. Visualization is NOT provided within this gem.
Kaitai Struct is a declarative language used for describe various binary data structures, laid out in files or in memory: i.e. binary file formats, network stream packet formats, etc. The main idea is that a particular format is described in Kaitai Struct language (.ksy file) and then can be compiled with ksc into source files in one of the supported programming languages. These modules will include a generated code for a parser that can read described data structure from a file / stream and give access to it in a nice, easy-to-comprehend API. This package is a visualizer tool for .ksy files. Given a particular binary file and .ksy file(s) that describe its format, it can visualize internal data structures in a tree form and a multi-level highlight hex viewer.
Seer is a lightweight, semantically rich wrapper for the Google Visualization API. It allows you to easily create a visualization of data in a variety of formats, including area charts, bar charts, column charts, gauges, line charts, and pie charts.
Simple Ruby library for interfacing with Google's Visualization API, specifically their Image Chart capability.
Seer is a lightweight, semantically rich wrapper for the Google Visualization API. It allows you to easily create a visualization of data in a variety of formats, including area charts, bar charts, column charts, gauges, line charts, and pie charts.
A rest API fronted database and web based front-end around a event database. Useful for visualizing and tracking events in a time-stream style format.
Visualization of your Github activity over the past year via Github API with visualizations like table, graph, stacked graph and pie chart.
A Ruby client for the Google Visualization API.
An enterprise-grade Database is provided as a Service (DBaaS) solution that can be managed through a browser-based "Data Center Designer" (DCD) tool or via an easy to use API. The API allows you to create additional PostgreSQL database clusters or modify existing ones. It is designed to allow users to leverage the same power and flexibility found within the DCD visual tool. Both tools are consistent with their concepts and lend well to making the experience smooth and intuitive.
Seer is a lightweight, semantically rich wrapper for the Google Visualization API. It allows you to easily create a visualization of data in a variety of formats, including area charts, bar charts, column charts, gauges, line charts, and pie charts.
Turnitin Core API (TCA) provides direct API access to the core functionality provided by Turnitin. TCA supports file submission, similarity report generation, group management, and visualization of report matches via Cloud Viewer or PDF download. Below is the full flow to successfully set up an integration scope, an API Key, and make calls to TCA. Integration Scope and API Key management is done via the Admin Console UI by logging in as an admin user. For more details, go to our [developer portal documentation page](https://developers.turnitin.com/docs). ## Integration Scope and API Key Management TCA API calls must provide an API Key for authentication, so you must first have at least one integration scope associated with at least one API Key to use TCA. ### Admin Console UI First, login to Admin Console UI as an *Admin* user with permission to create Integration Scopes, under a tenant that is licensed to use the TCA product Integration Scopes (you can create a new one, or add keys to existing) * Click `Integrations` in the side bar --> `+ Add Integration` at top the top of the page --> Enter a name --> `Add` Button API Keys * Click `Integrations` in the side bar --> `Create API Key` Button next to a given Integration Scope --> Enter a name --> click `Create and View button` * Copy/Save the key manually or click save to clipboard button to copy it (this is the only time it will show) ## TCA Flow * Register a webhook * Create a submission * Upload a file for the submission * Wait for the submission upload to process * If you registered a webhook, a callback will be sent to it when upload is complete * The status of the *submission* will also update to `COMPLETE` * Request a Similarity Report * Wait for similarity report to process * If you registered a webhook, a callback will be sent to it when report is complete * The status of the *report* will also be updated to `COMPLETE` * Request a URL with parameters to view the Similarity Report
A ruby client to integrate visual recommendation feature from Artifacia API
Google Visualization API Ruby Client
Simple object oriented API for opening a window and drawing in it. Based on gosu. It's meant to teach beginners programming as a visualization of code can help.
Generates server side renderings of D3 visualizations for a nodejs backend
An API client to the Microsoft Visual Studio online Rest APIs. It can connect to VSTS via the public API and query VSTS with a personal access token. May also work with TFS.
Ruby/SDL2 is an extension library to use SDL 2.x (Simple DirectMedia Layer). SDL 2.x is quite refined from SDL 1.x and API is changed. This library enables you to control audio, keyboard, mouse, joystick, 3D hardware via OpenGL, and 2D video using opengl or Direct3D. Ruby/SDL is used for games and visual demos.
Ruby client for the ShotWolf API - capture screenshots, render device mockups, generate Open Graph cards, convert HTML to PDF, and run pixel-level visual regression diffs through a single JSON HTTP API. Zero dependencies.
Ask an AI coding agent to move a button 10 pixels left, and watch it struggle. CSS gives it five or six different ways to control position: margin, padding, a flex order, a grid column, a transform. Nothing says which one is actually in charge on this particular page, so the agent guesses, edits the wrong one, and something else quietly shifts. It reports the change as done. The page is now broken. QSS removes the guessing by removing the choice. Every element's position and size is one explicit number, not a tug-of-war between properties. Those numbers are written in a single unit, a "qnt" (1/1000th of the layout's own width), so the same edit holds its exact proportion at any screen size -- a phone, a laptop, a 4K display -- with no breakpoints, no media queries, and no separate rules to keep in sync. Move something once and it stays put, everywhere. That is the whole idea, and it helps humans exactly as much as it helps agents: fewer rules to maintain, one obvious place to make a change, and layouts that stay consistent across devices by construction instead of by discipline. QSS backs that up with two automatic auditors that catch mistakes a human reviewer might miss (a RED finding is a broken rule, ORANGE is a judgment call) and a real-browser render check, because a passing lint rule is not proof a page actually displays correctly -- only watching it render is. It ships compiled, ready-to-use CSS plus its SCSS source, works with zero JavaScript, and offers an optional JS engine for a few conveniences on top. It stays out of the way of whatever you use for colors, type and visual polish (Tailwind or anything else) -- QSS only ever owns position, size and structure. QSS was extracted from a real Rails development tool that still runs on it today, not built as a theoretical exercise. See docs/HOWTO.md to get started and docs/DESIGN_HISTORY.md for the full story of what was tried, what broke, and why each decision landed where it did. Status: 0.x. Expect names and APIs to change before 1.0.
Send an image or a PDF, describe the fields you want in plain language, and get structured JSON back with a confidence level on every value. Presets for invoices, receipts, IDs and 25 more; custom schemas; visual Q&A; async tasks and signed webhooks.
Agricultural intelligence and soil analysis API with tier-based access control. ## What's New in 1.2.0 - **Consumer Plant Care APIs**: Three new endpoints addressing top pain points in plant ID apps: - `/safe-identification`: Toxic lookalike warnings and environmental context - `/dynamic-care`: Hyper-localized, real-time care recommendations - `/beginner-guidance`: Judgment-free, jargon-free plant guidance ## Authentication All endpoints require an API key passed via the `x-api-key` header: ``` x-api-key: ak_your_api_key_here ``` API keys are generated through the dashboard and use the `ak_*` format. ## Rate Limiting Rate limits are enforced based on your subscription tier: - **Free**: 10 req/min, 100 req/hour, 1,000 req/day - **Starter**: 30 req/min, 500 req/hour, 5,000 req/day - **Pro**: 100 req/min, 2,000 req/hour, 25,000 req/day - **Enterprise**: 500 req/min, 10,000 req/hour, 100,000 req/day Rate limit information is returned in response headers: - `X-RateLimit-Limit`: Maximum requests in window - `X-RateLimit-Remaining`: Remaining requests in window - `X-RateLimit-Reset`: Unix timestamp when limit resets ## Response Time SLAs All endpoints return response time headers for performance monitoring: - `X-Response-Time`: Human-readable response time (e.g., "245ms") - `X-Response-Time-Ms`: Response time in milliseconds - `X-Response-Time-Target`: Target response time for this endpoint - `X-Response-Time-Max`: Maximum acceptable response time - `X-Response-Time-Status`: Performance status (`optimal`, `acceptable`, `exceeded`) ### Response Time Targets by Category | Category | Target | Maximum | Endpoints | |----------|--------|---------|-----------| | **Fast** | 200ms | 500ms | county-lookup, check-subscription | | **Standard** | 500ms | 1,500ms | get-soil-data, territorial-water-quality | | **Complex** | 2,000ms | 5,000ms | agricultural-intelligence, gpt5-chat, visual-crop-analysis | | **Heavy** | 5,000ms | 15,000ms | live-agricultural-data, generate-vrt-prescription |
vcvars locates a Visual Studio / Build Tools install via vswhere and loads the MSVC toolchain (vcvars*.bat) into the current process, so C extensions build under an mswin Ruby without first opening a "Developer Command Prompt". It provides a library API (Vcvars.activate!), a Rake integration (require "vcvars/rake"), a `vcvars exec -- <cmd>` runner, a `vcvars doctor` that diagnoses the classic MSVC extension-build failures, a `vcvars env` shell-env emitter, and a `vcvars new` scaffolder for MSVC-ready extension gems. It is "ridk enable", but for MSVC. Pure Ruby, no compiler required to install.
REST API for electronic invoicing in France: Factur-X (CII), UBL 2.1, AFNOR PDP/PA, electronic signatures. ## 🎯 Main Features ### 📄 Invoice Generation - **Formats**: CII XML, UBL 2.1 XML, or Factur-X PDF/A-3 - **Profiles** (CII/PDF): MINIMUM, BASIC, EN16931, EXTENDED - **UBL**: Always EN16931 compliant - **Standards**: EN 16931 (EU directive 2014/55), ISO 19005-3 (PDF/A-3), CII (UN/CEFACT), UBL 2.1 (OASIS) - **Simplified Format**: Generation from SIRET + auto-enrichment (Chorus Pro API + Business Search) ### ✅ Factur-X - Validation - **XML Validation**: Schematron (45 to 210+ rules depending on profile) - **PDF Validation**: PDF/A-3, Factur-X XMP metadata - **VeraPDF**: Strict PDF/A validation (146+ ISO 19005-3 rules) ### ✍️ Electronic Signature - **Standards**: PAdES-B-B, PAdES-B-T (RFC 3161 timestamping), PAdES-B-LT (long-term archival) - **eIDAS Levels**: SES (self-signed), AdES (commercial CA), QES (QTSP) - **Validation**: Cryptographic integrity and certificate verification ### 📋 Flux 6 - Invoice Lifecycle (CDAR) - **CDAR Messages**: Acknowledgements, invoice statuses - **PPF Statuses**: REFUSED (210), PAID (212) ### 📊 Flux 10 - E-Reporting - **Tax Declarations**: International B2B, B2C - **Flow Types**: 10.1 (B2B transactions), 10.2 (B2B payments), 10.3 (B2C transactions), 10.4 (B2C payments) ### 📡 AFNOR PDP/PA (XP Z12-013) - **Flow Service**: Submit and search flows to PDPs - **Directory Service**: Company search (SIREN/SIRET) - **Multi-client**: Support for multiple PDP configs per user ### 🏛️ Chorus Pro - **Public Sector Invoicing**: Complete API for Chorus Pro ### ⏳ Async Tasks - **Celery**: Asynchronous generation, validation and signing - **Polling**: Status tracking via `/tasks/{task_id}/status` - **Webhooks**: Automatic notifications when tasks complete ## 🔒 Authentication All requests require a **JWT token** in the Authorization header: ``` Authorization: Bearer YOUR_JWT_TOKEN ``` ### How to obtain a JWT token? #### 🔑 Method 1: `/api/token/` API (Recommended) **URL:** `https://factpulse.fr/api/token/` This method is **recommended** for integration in your applications and CI/CD workflows. **Prerequisites:** Having set a password on your account **For users registered via email/password:** - You already have a password, use it directly **For users registered via OAuth (Google/GitHub):** - You must first set a password at: https://factpulse.fr/accounts/password/set/ - Once the password is created, you can use the API **Request example:** ```bash curl -X POST https://factpulse.fr/api/token/ \ -H "Content-Type: application/json" \ -d '{ "username": "your_email@example.com", "password": "your_password" }' ``` **Optional `client_uid` parameter:** To select credentials for a specific client (PA/PDP, Chorus Pro, signing certificates), add `client_uid`: ```bash curl -X POST https://factpulse.fr/api/token/ \ -H "Content-Type: application/json" \ -d '{ "username": "your_email@example.com", "password": "your_password", "client_uid": "550e8400-e29b-41d4-a716-446655440000" }' ``` The `client_uid` will be included in the JWT and allow the API to automatically use: - AFNOR/PDP credentials configured for this client - Chorus Pro credentials configured for this client - Electronic signature certificates configured for this client **Response:** ```json { "access": "eyJ0eXAiOiJKV1QiLCJhbGc...", // Access token (validity: 30 min) "refresh": "eyJ0eXAiOiJKV1QiLCJhbGc..." // Refresh token (validity: 7 days) } ``` **Advantages:** - ✅ Full automation (CI/CD, scripts) - ✅ Programmatic token management - ✅ Refresh token support for automatic access renewal - ✅ Easy integration in any language/tool #### 🖥️ Method 2: Dashboard Generation (Alternative) **URL:** https://factpulse.fr/api/dashboard/ This method is suitable for quick tests or occasional use via the graphical interface. **How it works:** - Log in to the dashboard - Use the "Generate Test Token" or "Generate Production Token" buttons - Works for **all** users (OAuth and email/password), without requiring a password **Token types:** - **Test Token**: 24h validity, 1000 calls/day quota (free) - **Production Token**: 7 days validity, quota based on your plan **Advantages:** - ✅ Quick for API testing - ✅ No password required - ✅ Simple visual interface **Disadvantages:** - ❌ Requires manual action - ❌ No refresh token - ❌ Less suited for automation ### 📚 Full Documentation For more information on authentication and API usage: https://factpulse.fr/documentation-api/
GRYDRA v2.0 is a complete, modular Ruby library for building, training, and deploying neural networks. NEW in v2.0: - Complete modular architecture with 29 organized files - Keyword arguments API for better readability - Full implementations (no more "simplified" versions) - 8 loss functions (MSE, MAE, Huber, Cross-Entropy, Hinge, Log-Cosh, Quantile) - 5 optimizers (Adam, SGD, RMSprop, AdaGrad, AdamW) - 6 training callbacks (EarlyStopping, LearningRateScheduler, ReduceLROnPlateau, ModelCheckpoint, CSVLogger, ProgressBar) - Complete LSTM implementation with backpropagation - Complete 2D Convolutional layer with padding and stride - Real PCA with eigenvalue decomposition using Power Iteration - Multiple activation functions (Tanh, ReLU, Leaky ReLU, Sigmoid, Swish, GELU, Softmax) - Regularization (Dropout, L1, L2) - Weight initialization (Xavier, He) - Data normalization (Z-Score, Min-Max) - Comprehensive metrics (MSE, MAE, Accuracy, Precision, Recall, F1, Confusion Matrix, AUC-ROC) - Advanced training (mini-batch, early stopping, learning rate decay, validation split) - Cross-validation and hyperparameter search - Text processing (vocabulary, binary vectorization, TF-IDF) - Model persistence (save/load with Marshal) - Network visualization and gradient analysis - Simplified EasyNetwork interface - 100% backward compatibility with v1.x Perfect for machine learning projects, research, and education in Ruby.
easy way of accessing a postgres database, both visually and via api