GitHub 1C Enterprise Daily Trending

tmc/langchaingo

2024-11-23T01:28:27Z

Official inference repo for FLUX.1 models

FLUX

by Black Forest Labs: https://blackforestlabs.ai. Documentation for our API can be found here: docs.bfl.ml.

This repo contains minimal inference code to run image generation & editing with our Flux models.

Local installation

cd $HOME && git clone https://github.com/black-forest-labs/flux
cd $HOME/flux
python3.10 -m venv .venv
source .venv/bin/activate
pip install -e ".[all]"

Models

We are offering an extensive suite of models. For more information about the invidual models, please refer to the link under Usage.

Name	Usage	HuggingFace repo	License
`FLUX.1 [schnell]`	Text to Image	https://huggingface.co/black-forest-labs/FLUX.1-schnell	apache-2.0
`FLUX.1 [dev]`	Text to Image	https://huggingface.co/black-forest-labs/FLUX.1-dev	FLUX.1-dev Non-Commercial License
`FLUX.1 Fill [dev]`	In/Out-painting	https://huggingface.co/black-forest-labs/FLUX.1-Fill-dev	FLUX.1-dev Non-Commercial License
`FLUX.1 Canny [dev]`	Structural Conditioning	https://huggingface.co/black-forest-labs/FLUX.1-Canny-dev	FLUX.1-dev Non-Commercial License
`FLUX.1 Depth [dev]`	Structural Conditioning	https://huggingface.co/black-forest-labs/FLUX.1-Depth-dev	FLUX.1-dev Non-Commercial License
`FLUX.1 Canny [dev] LoRA`	Structural Conditioning	https://huggingface.co/black-forest-labs/FLUX.1-Canny-dev-lora	FLUX.1-dev Non-Commercial License
`FLUX.1 Depth [dev] LoRA`	Structural Conditioning	https://huggingface.co/black-forest-labs/FLUX.1-Depth-dev-lora	FLUX.1-dev Non-Commercial License
`FLUX.1 Redux [dev]`	Image variation	https://huggingface.co/black-forest-labs/FLUX.1-Redux-dev	FLUX.1-dev Non-Commercial License
`FLUX.1 [pro]`	Text to Image	Available in our API.
`FLUX1.1 [pro]`	Text to Image	Available in our API.
`FLUX1.1 [pro] Ultra/raw`	Text to Image	Available in our API.
`FLUX.1 Fill [pro]`	In/Out-painting	Available in our API.
`FLUX.1 Canny [pro]`	Structural Conditioning	Available in our API.
`FLUX.1 Depth [pro]`	Structural Conditioning	Available in our API.
`FLUX1.1 Redux [pro]`	Image variation	Available in our API.
`FLUX1.1 Redux [pro] Ultra`	Image variation	Available in our API.

The weights of the autoencoder are also released under apache-2.0 and can be found in the HuggingFace repos above.

API usage

Our API offers access to our models. It is documented here: docs.bfl.ml.

In this repository we also offer an easy python interface. To use this, you first need to register with the API on api.bfl.ml, and create a new API key.

To use the API key either run export BFL_API_KEY=<your_key_here> or provide it via the api_key=<your_key_here> parameter. It is also expected that you have installed the package as above.

Usage from python:

from flux.api import ImageRequest

# this will create an api request directly but not block until the generation is finished
request = ImageRequest("A beautiful beach", name="flux.1.1-pro")
# or: request = ImageRequest("A beautiful beach", name="flux.1.1-pro", api_key="your_key_here")

# any of the following will block until the generation is finished
request.url
# -> https:<...>/sample.jpg
request.bytes
# -> b"..." bytes for the generated image
request.save("outputs/api.jpg")
# saves the sample to local storage
request.image
# -> a PIL image

Usage from the command line:

$ python -m flux.api --prompt="A beautiful beach" url
https:<...>/sample.jpg

# generate and save the result
$ python -m flux.api --prompt="A beautiful beach" save outputs/api

# open the image directly
$ python -m flux.api --prompt="A beautiful beach" image show

primefaces/primevue

2024-11-24T01:28:50Z

Next Generation Vue UI Component Library

PrimeVue MonoRepo

PrimeVue is a rich set of open source UI Components for Vue. See PrimeVue homepage for live showcase and documentation.

Packages

Name	Version
primevue
@primevue/core
@primevue/icons
@primevue/themes
@primevue/nuxt-module
@primevue/auto-import-resolver
@primevue/metadata

Contributors

shader-slang/slang

2024-11-24T01:28:50Z

Making it easier to work with shaders

Slang

Slang is a shading language that makes it easier to build and maintain large shader codebases in a modular and extensible fashion, while also maintaining the highest possible performance on modern GPUs and graphics APIs. Slang is based on years of collaboration between researchers at NVIDIA, Carnegie Mellon University, Stanford, MIT, UCSD and the University of Washington.

Why Slang?

The Slang shading language is designed to enable real-time graphics developers to work with large-scale, high-performance shader code.

Write Shaders Once, Run Anywhere

The Slang compiler can generate code for a wide variety of targets: D3D12, Vulkan, Metal, D3D11, OpenGL, CUDA, and even generate code to run on a CPU. For textual targets, such as Metal Shading Language (MSL) and CUDA, Slang produces readable code that preserves original identifier names, as well as the type and call structure, making it easier to debug.

Access the Latest GPU Features

Slang code is highly portable, but can still leverage unique platform capabilities, including the latest features in Direct3D and Vulkan. For example, developers can make full use of pointers when generating SPIR-V. Slang's capability system helps applications manage feature set differences across target platforms by ensuring code only uses available features during the type-checking step, before generating final code. Additionally, Slang provides flexible interop features to enable directly embedding target code or SPIR-V into generated shaders.

Leverage Neural Graphics with Automatic Differentiation

Slang can automatically generate both forward and backward derivative propagation code for complex functions that involve arbitrary control flow and dynamic dispatch. This allows existing rendering codebases to easily become differentiable, or for Slang to serve as the kernel language in a PyTorch-driven machine learning framework via slangtorch.

Scalable Software Development with Modules

Slang provides a module system that enables logical organization of code for separate compilation. Slang modules can be independently compiled offline to a custom IR (with optional obfuscation) and then linked at runtime to generate code in formats such as DXIL or SPIR-V.

Code Specialization that Works with Modules

Slang supports generics and interfaces (a.k.a. type traits/protocols), allowing for clear expression of shader specialization without the need for preprocessor techniques or string-pasting. Unlike C++ templates, Slang's generics are pre-checked and don't produce cascading error messages that are difficult to diagnose. The same generic shader can be specialized for a variety of different types to produce specialized code ahead of time, or on the fly, entirely under application control.

Easy On-ramp for HLSL and GLSL Codebases

Slang's syntax is similar to HLSL, and most existing HLSL code can be compiled with the Slang compiler out-of-the-box, or with just minor modifications. This allows existing shader codebases to immediately benefit from Slang without requiring a complete rewrite or port.

Slang provides a compatibility module that enables the use of most GLSL intrinsic functions and GLSL's parameter binding syntax.

Comprehensive Tooling Support

Slang comes with full support of IntelliSense editing features in Visual Studio Code and Visual Studio through the Language Server Protocol. Full debugging capabilities are also available through RenderDoc and SPIR-V based tools.

Getting Started

The fastest way to get started using Slang in your own development is to use a pre-built binary package, available through GitHub releases. Slang binaries are also included in the Vulkan SDK since version 1.3.296.0.

There are packages built for 32- and 64-bit Windows, as well as 64-bit Ubuntu. Each binary release includes the command-line slangc compiler, a shared library for the compiler, and the slang.h header.

See the user-guide for info on using the slangc command-line tool: Slang Command Line Usage.

If you want to try out the Slang language without installing anything, a fast and simple way is to use the Slang Playground. The playground allows you to compile Slang code to a variety of targets, and even run some simple shaders directly within the browser. The playground loads Slang compiler to your browser and runs all compilation locally. No data will be sent to any servers.

If you would like to build Slang from source, please consult the build instructions.

Documentation

The Slang project provides a variety of different documentation, but most users would be well served starting with the User's Guide.

For developers writing Slang code, the Slang Core Module Reference provides detailed documentation on Slang's built-in types and functions.

We also provide a few examples of how to integrate Slang into a rendering application.

These examples use a graphics layer that we include with Slang called "GFX" which is an abstraction library of various graphics APIs (D3D11, D2D12, OpenGL, Vulkan, CUDA, and the CPU) to support cross-platform applications using GPU graphics and compute capabilities. If you'd like to learn more about GFX, see the GFX User Guide.

Additionally, we recommend checking out Vulkan Mini Examples for more examples of using Slang's language features available on Vulkan, such as pointers and the ray tracing intrinsics.

Contributing

If you'd like to contribute to the project, we are excited to have your input. The following guidelines should be observed by contributors:

Please follow the contributor Code of Conduct.
Bugs reports and feature requests should go through the GitHub issue tracker
Changes should ideally come in as small pull requests on top of master, coming from your own personal fork of the project
Large features that will involve multiple contributors or a long development time should be discussed in issues, and broken down into smaller pieces that can be implemented and checked in in stages

Contribution guide describes the workflow for contributors at more detail.

Limitations and Support

Platform support

The Slang compiler and libraries can be built on the following platforms:

Windows	Linux	MacOS	WebAssembly
supported	supported	supported	experimental

Both x86_64 and aarch64 architectures are supported on Windows, Linux and MacOS platforms.

Target support

Slang can compile shader code to the following targets:

Target	Status	Output Formats
Direct3D 11	supported	HLSL
Direct3D 12	supported	HLSL
Vulkan	supported	SPIRV, GLSL
Metal	experimental*	Metal Shading Language
WebGPU	experimental**	WGSL
CUDA	supported	C++ (compute only)
Optix	experimental	C++ (WIP)
CPU	experimental	C++ (kernel), C++ (host), standalone executable, dynamic library

*Slang currently supports generating vertex, fragment, compute, task and mesh shaders for Metal.

**WGSL support is still work in-progress.

For greater detail, see the Supported Compilation Targets section of the User Guide

The Slang project has been used for production applications and large shader codebases, but it is still under active development. Support is currently focused on the platforms (Windows, Linux) and target APIs (Direct3D 12, Vulkan) where Slang is used most heavily. Users who are looking for support on other platforms or APIs should coordinate with the development team via the issue tracker to make sure that their use cases can be supported.

License

The Slang code itself is under the Apache 2.0 with LLVM Exception license (see LICENSE).

Builds of the core Slang tools depend on the following projects, either automatically or optionally, which may have their own licenses:

glslang (BSD)
lz4 (BSD)
miniz (MIT)
spirv-headers (Modified MIT)
spirv-tools (Apache 2.0)
ankerl::unordered_dense::{map, set} (MIT)

Slang releases may include slang-llvm which includes LLVM under the license:

llvm (Apache 2.0 License with LLVM exceptions)

Some of the tests and example programs that build with Slang use the following projects, which may have their own licenses:

glm (MIT)
stb_image and stb_image_write from the stb collection of single-file libraries (Public Domain)
tinyobjloader (MIT)

twentyhq/twenty

2024-11-24T01:36:35Z

Building a modern alternative to Salesforce, powered by the community.

The #1 Open-Source CRM

Tailored to your unique business needs

🌐 Website · 📚 Documentation · Discord · Figma

We’ve spent thousands of hours grappling with traditional CRMs like Pipedrive and Salesforce to align them with our business needs, only to end up frustrated — customizations are complex and the closed ecosystems of these platforms can feel restrictive.

We felt the need for a CRM platform that empowers rather than constrains. We believe the next great CRM will come from the open-source community. We’ve packed Twenty with powerful features to give you full control and help you run your business efficiently.

Demo

Go to demo.twenty.com and login with the following credentials:

email: tim@apple.dev
password: Applecar2025

See also:
🚀 Self-hosting
🖥️ Local Setup

Why Choose Twenty?

We understand that the CRM landscape is vast. So why should you choose us?

⛓️ Full control, Full Freedom: Contribute, self-host, fork. Break free from vendor lock-in and join us in shaping the open future of CRM.

📊 Data, Your Way: The days when the role of CRM platforms was to shift manual data entries to a database are over. Now, the data is already there. CRM 2.0 should be built around your data, allowing you to access and visualize any existing sources, not forcing you to retrofit your data into predefined objects on a remote cloud.

🎨 Effortlessly Intuitive: We set out to create something that we ourselves would always enjoy using. The main application draws inspiration from Notion, a tool known for its user-friendly interface and customization capabilities.

What You Can Do With Twenty

We're currently in the development phase of Twenty's alpha version.

Please feel free to flag any specific needs you have by creating an issue.

Below are some features we have implemented to date:

Add, filter, sort, edit, and track customers:

Create one or several opportunities for each company:

Track deals effortlessly with the email integration:

Tailor your data model to meet business needs:

See rich notes displayed in a timeline:

Create tasks on records

Navigate quickly through the app using keyboard shortcuts and search:

Connect your CRM to all your tools through our APIs and Webhooks.

What's In Store

Here’s what you can look forward to:

⏳ Frequent updates: We’re shipping fast! Expect regular updates and new features that enhance your experience.

🔗 Extensibility: We’re putting the power in your hands. Soon, you’ll have the tools to extend and customize Twenty with plugins and more.

Join the Community

Star the repo
Join discussions and track issues
Follow us on Twitter or LinkedIn
Join our Discord
Contributions are, of course, most welcome!

Bin-Huang/chatbox

2024-11-24T01:36:35Z

User-friendly Desktop Client App for AI Models/LLMs (GPT, Claude, Gemini, Ollama...)

English | 简体中文

This is the repository for the Chatbox Community Edition, open-sourced under the GPLv3 license. For most users, I recommend using the Chatbox Official Edition (closed-source). It's still completely free, easy to install, and supports more of the latest features. You can get it below:

Download for Desktop

Windows	MacOS	Linux
Setup.exe	Intel	M1/M2	AppImage

Download for iOS/Android

.APK

For more information: chatboxai.app

Chatbox (Community Edition)

Your Ultimate AI Copilot on the Desktop.
Chatbox is a desktop client for ChatGPT, Claude and other LLMs, available on Windows, Mac, Linux

Features

Local Data Storage
💾 Your data remains on your device, ensuring it never gets lost and maintains your privacy.
No-Deployment Installation Packages
📦 Get started quickly with downloadable installation packages. No complex setup necessary!
Support for Multiple LLM Providers
⚙ Seamlessly integrate with a variety of cutting-edge language models:
- OpenAI (ChatGPT)
- Azure OpenAI
- Claude
- Google Gemini Pro
- Ollama (enable access to local models like llama2, Mistral, Mixtral, codellama, vicuna, yi, and solar)
- ChatGLM-6B
Image Generation with Dall-E-3
🎨 Create the images of your imagination with Dall-E-3.
Enhanced Prompting
💬 Advanced prompting features to refine and focus your queries for better responses.
Keyboard Shortcuts
⌨ Stay productive with shortcuts that speed up your workflow.
Markdown, Latex & Code Highlighting
📜 Generate messages with the full power of Markdown and Latex formatting, coupled with syntax highlighting for various programming languages, enhancing readability and presentation.
Prompt Library & Message Quoting
📚 Save and organize prompts for reuse, and quote messages for context in discussions.
Streaming Reply
▶ Provide rapid responses to your interactions with immediate, progressive replies.
Ergonomic UI & Dark Theme
🌑 A user-friendly interface with a night mode option for reduced eye strain during extended use.
Team Collaboration
👥 Collaborate with ease and share OpenAI API resources among your team. Learn More
Cross-Platform Availability
💻 Chatbox is ready for Windows, Mac, Linux users.
Access Anywhere with the Web Version
🌐 Use the web application on any device with a browser, anywhere.
iOS & Android
☎ Use the mobile applications that will bring this power to your fingertips on the go.
Multilingual Support
🌎 Catering to a global audience by offering support in multiple languages:
- English
- 简体中文 (Simplified Chinese)
- 繁體中文 (Traditional Chinese)
- 日本語 (Japanese)
- 한국어 (Korean)
- Français (French)
- Deutsch (German)
- Русский (Russian)
And More...
✨ Constantly enhancing the experience with new features!

FAQ

Frequently Asked Questions

Why I made Chatbox?

I developed Chatbox initially because I was debugging some prompts and found myself in need of a simple and easy-to-use prompt and API debugging tool. I thought there might be more people who needed such a tool, so I open-sourced it.

At first, I didn't know that it would be so popular. I listened to the feedback from the open-source community and continued to develop and improve it. Now, it has become a very useful AI desktop application. There are many users who love Chatbox, and they not only use it for developing and debugging prompts, but also for daily chatting, and even to do some more interesting things like using well-designed prompts to make AI play various professional roles to assist them in everyday work...

How to Contribute

Any form of contribution is welcome, including but not limited to:

Submitting issues
Submitting pull requests
Submitting feature requests
Submitting bug reports
Submitting documentation revisions
Submitting translations
Submitting any other forms of contribution

Build Instructions

Clone the repository from Github

git clone https://github.com/Bin-Huang/chatbox.git

Install the required dependencies

npm install

Start the application (in development mode)

npm run dev

Build the application, package the installer for current platform

npm run package

Build the application, package the installer for all platforms

npm run package:all

Buy Me a Coffee

Paypal	Wechat Pay	Ali Pay
`Paypal`

Star History

Contact

Twitter | Email | Blog

License

LICENSE

NASA-SW-VnV/ikos

2024-11-24T01:36:35Z

Static analyzer for C/C++ based on the theory of Abstract Interpretation.

IKOS

IKOS (Inference Kernel for Open Static Analyzers) is a static analyzer for C/C++ based on the theory of Abstract Interpretation.

Introduction

IKOS started as a C++ library designed to facilitate the development of sound static analyzers based on Abstract Interpretation. Specialization of a static analyzer for an application or family of applications is critical for achieving both precision and scalability. Developing such an analyzer is arduous and requires significant expertise in Abstract Interpretation.

IKOS provides a generic and efficient implementation of state-of-the-art Abstract Interpretation data structures and algorithms, such as control-flow graphs, fixpoint iterators, numerical abstract domains, etc. IKOS is independent of a particular programming language.

IKOS also provides a C and C++ static analyzer based on LLVM. It implements scalable analyses for detecting and proving the absence of runtime errors in C and C++ programs.

License

IKOS has been released under the NASA Open Source Agreement version 1.3, see LICENSE.pdf

Contact

ikos@lists.nasa.gov

Release notes

See Releases.

Troubleshooting

See TROUBLESHOOTING.md

Installation

To install IKOS on Linux or macOS, we recommend to use Homebrew.

First, install Homebrew by following these instructions.

Then, simply run:

$ brew install nasa-sw-vnv/core/ikos

For Windows, consider using Windows Subsystem for Linux.

How to run IKOS

Suppose we want to analyze the following C program in a file, called loop.c:

 1: #include <stdio.h>
 2: int a[10];
 3: int main(int argc, char *argv[]) {
 4:     size_t i = 0;
 5:     for (;i < 10; i++) {
 6:         a[i] = i;
 7:     }
 8:     a[i] = i;
 9:     printf("%i", a[i]);
10: }

To analyze this program with IKOS, simply run:

$ ikos loop.c

You shall see the following output. IKOS reports two occurrences of buffer overflow at line 8 and 9.

[*] Compiling loop.c
[*] Running ikos preprocessor
[*] Running ikos analyzer
[*] Translating LLVM bitcode to AR
[*] Running liveness analysis
[*] Running widening hint analysis
[*] Running interprocedural value analysis
[*] Analyzing entry point 'main'
[*] Checking properties for entry point 'main'

# Time stats:
clang        : 0.037 sec
ikos-analyzer: 0.023 sec
ikos-pp      : 0.007 sec

# Summary:
Total number of checks                : 7
Total number of unreachable checks    : 0
Total number of safe checks           : 5
Total number of definite unsafe checks: 2
Total number of warnings              : 0

The program is definitely UNSAFE

# Results
loop.c: In function 'main':
loop.c:8:10: error: buffer overflow, trying to access index 10 of global variable 'a' of 10 elements
    a[i] = i;
         ^
loop.c: In function 'main':
loop.c:9:18: error: buffer overflow, trying to access index 10 of global variable 'a' of 10 elements
    printf("%i", a[i]);
                 ^

The ikos command takes a source file (.c, .cpp) or a LLVM bitcode file (.bc) as input, analyzes it to find runtime errors (also called undefined behaviors), creates a result database output.db in the current working directory and prints a report.

In the report, each line has one of the following status:

safe: the statement is proven safe;
error: the statement always results into an error (or is unreachable);
unreachable: the statement is never executed;
warning may mean three things:
1. the statement results into an error for some executions, or
2. the static analyzer did not have enough information to conclude (check dependent on an external input, for instance), or
3. the static analyzer was not powerful enough to prove the absence of errors;

By default, ikos shows warnings and errors directly in your terminal, like a compiler would do.

If the analysis report is too big, you shall use:

ikos-report output.db to examine the report in your terminal
ikos-view output.db to examine the report in a web interface

Further information:

Build from source

Below are instructions to build IKOS from source. This is only for advanced users that want to either package IKOS for an operating system or to experiment with the codebase. Otherwise, please follow the instructions above.

Dependencies

To build and run the analyzer, you will need the following dependencies:

A C++ compiler that supports C++14 (gcc >= 4.9.2 or clang >= 3.4)
CMake >= 3.4.3
GMP >= 4.3.1
Boost >= 1.55
Python >= 3.3
SQLite >= 3.6.20
TBB >= 2
LLVM and Clang 14.0.x
(Optional) APRON >= 0.9.10

Most of them can be installed using your package manager.

Note: If you build LLVM from source, you need to enable run-time type information (RTTI).

Build and Install

Now that you have all the dependencies on your system, you can build and install IKOS.

As you open the IKOS distribution, you shall see the following directory structure:

.
├── CMakeLists.txt
├── LICENSE.pdf
├── README.md
├── RELEASE_NOTES.md
├── TROUBLESHOOTING.md
├── analyzer
├── ar
├── cmake
├── core
├── doc
├── frontend
├── script
└── test

IKOS uses the CMake build system. You will need to specify an installation directory that will contain all the binaries, libraries and headers after installation. If you do not specify this directory, CMake will install everything under install in the root directory of the distribution. In the following steps, we will install IKOS under /path/to/ikos-install-directory.

Here are the steps to build and install IKOS:

$ mkdir build
$ cd build
$ cmake -DCMAKE_INSTALL_PREFIX=/path/to/ikos-install-directory ..
$ make
$ make install

Then, add IKOS in your PATH (consider adding this in your .bashrc):

$ PATH="/path/to/ikos-install-directory/bin:$PATH"

Tests

To build and run the tests, simply type:

$ make check

Contributors

See CONTRIBUTORS.md

Publications

Sung Kook Kim, Arnaud J. Venet, Aditya V. Thakur. Deterministic Parallel Fixpoint Computation. In Principles of Programming Languages (POPL 2020), New Orleans, Louisiana (PDF).
Guillaume Brat, Jorge Navas, Nija Shi and Arnaud Venet. IKOS: a Framework for Static Analysis based on Abstract Interpretation. In Proceedings of the International Conference on Software Engineering and Formal Methods (SEFM 2014), Grenoble, France (PDF).
Arnaud Venet. The Gauge Domain: Scalable Analysis of Linear Inequality Invariants. In Proceedings of Computer Aided Verification (CAV 2012), Berkeley, California, USA 2012. Lecture Notes in Computer Science, pages 139-154, volume 7358, Springer 2012 (PDF).

Coding Standards

See doc/CODING_STANDARDS.md

Overview of the source code

See doc/OVERVIEW.md

kyokakawaii/DoroHelper

2024-11-24T01:36:57Z

Nikke日常任务脚本。A Time-Saving Script for Goddess of Victory: Nikke.

Azure-Samples/contoso-chat

2024-11-24T01:37:02Z

This sample has the full End2End process of creating RAG application with Prompty and AI Studio. It includes GPT 3.5 Turbo LLM application code, evaluations, deployment automation with AZD CLI, GitHub actions for evaluation and deployment and intent mapping for multiple LLM task mapping.

dotnet/Scaffolding

2024-11-23T01:29:14Z

Code generators to speed up development.

Scaffolding

This repository contains the code for the following features.

ASP.NET Scaffolding

ASP.NET scaffolding: this can be used to generate boilerplate code for web apps to improve developer productivity

For more info on ASP.NET scaffolding, see the scaffolding readme here at README

`dotnet msidentity`

This is a .NET tool which can be used to configure ASP.NET Core projects to use the Microsoft identity platform. The tool can be used to configure ASP.NET Core projects to authenticate with the Microsoft identity platform.

For more info on the dotnet msidentity tool, see the readme here at README

Reporting security issues and bugs

Security issues and bugs should be reported privately, via email, to the Microsoft Security Response Center (MSRC) secure@microsoft.com. You should receive a response within 24 hours. If for some reason you do not, please follow up via email to ensure we received your original message. Further information, including the MSRC PGP key, can be found in the Security TechCenter.

Related projects

These are some other repos for related projects:

Microsoft Identity Web - is a library which contains a set of reusable classes used in conjunction with ASP.NET Core for integrating with the Microsoft identity platform (formerly Azure AD v2.0 endpoint) and AAD B2C.
EF Core - source for Entity Framework Core

Code of conduct

See CODE-OF-CONDUCT

evolutionary-architecture/evolutionary-architecture-by-example

2024-11-24T01:37:20Z

Navigate the complex landscape of .NET software architecture with our step-by-step, story-like guide. Unpack the interplay between modular monoliths, microservices, domain-driven design, and various architectural patterns. Go beyond the one-size-fits-all solutions and understand how to blend these approaches based on your unique needs.

Evolutionary Architecture

Table of Contents

Objective

Problem

There are many repositories that describe software and solution architecture in .NET. As there is no single definition of software architecture, they combine several topics:

Deployment strategies like Modular Monolith and Microservices
Domain-Driven Design
Clean, Onion, Hexagonal Architecture
Infrastructure

as if each of the above were the only possible solution. And that is the problem - it is very rare that any single material shows you a concrete decision path or mix of the above approaches.

Often the examples you find are either too trivial or too complex. Sometimes they are harmful because they misunderstand different concepts. As a result, it is very difficult to take just one and follow some patterns for your own application.

It depends - one of the most overused phrases. Well, it always depends on something, but there are always heuristics to help you decide.

In summary, if you are looking for a journey - not just a single article describing a solution - look no further. It starts here, in this repo.

Proposed Solution

Our solution should be read like a story and is divided into 4 chapters:

Chapter 1: Initial Architecture: Focus On Simplicity

Chapter 2: Modules Separation: Focus On Maintainability

Chapter 3: Microservice Extraction: Focus On Growth

Chapter 4: Applying Tactical Domain-Driven Design: Focus On Complexity

In each chapter we describe the evolution of the architecture of a selected domain:

Starting with a simple solution architecture that meets early production needs, where business processes are separated in namespaces and communication is handled by an in-memory queue
Moving to module separation with the structure of multiple projects associated with each module (including CQRS)
Continue with the single module extraction to a microservice and add the message queue component
Tackling the complexity of one of the modules using tactical Domain-Driven Design

We apply everything we have learned over many years of software development - our aim is to help you avoid making the same mistakes we have. This way you can be sure that your architecture will not be too trivial for too long, or too complex from the start. Treat it as a guide, something you can refer to at any time.

What we focus on:

Selected business domain analysis
Split the domain into subdomains (Core and Supportive)
Choice of architectural pattern
Evolution from monolithic to modular
Evolution to a mix of modular monolith and microservices
Applying Domain-Driven Design to a Core module
Backend (.NET) with minimal API
Loose coupling
Architecture decision log
Good coding practices

What we do not focus on:

Frontend (you can use React, Vue, Angular, Svelte or anything else)
Logging (you can use Serilog)
Contract testing (you can use Pact Net)

so that you get the gist of what we have to share with you. Additionally, static code analysis is enabled in all chapters to help us to keep the code base as clean as possible. It is strongly suggested to use it as well in your production code.

Note	Keep in mind that these are our suggestions. In the end you will have to decide for yourself which chapters fit your needs or combine them into one solution.

Domain

Overview

The chosen domain for analysis and implementation is a Fitness Studio. It is an area that most of people have an idea of how it works. You can:

Get an offer
Request for a contract
Sign the contract
Receive a pass (to be able to enter the fitness studio)
Attend to fitness classes

and many more.

However, in order to identify the above processes, you usually need to analyse the domain with Domain Experts and break it down into smaller pieces called Subdomains. Otherwise, there is a high risk of falling into a big ball of mud (or distributed mud) where everything is tightly coupled.

At first glance, the domain seems small and problems of oversimplification of initial assumptions usually arise from this interpretation. There are dozens of processes related to expired passes and renewals, discount policies, VIP access, negative cases (e.g. rejection of the access). We often tend to underestimate the problem.

Important

Remember that what we want to show you in this repository is how to handle a domain split into a few example subdomains, and how to prepare building blocks that will allow you to easily extend them to cover all processes. We are not able to cover the entire Fitness Studio domain, as that would probably take us a year (or more) of work. Do not worry - we try to show ideas here that are complex enough to be applied to your application.

Subdomains

Now that you understand which business domain we are focusing on, it is time to break it down into smaller pieces called Subdomains.

There are many ways to do this. Our 3 favourites are:

In general, the idea is to find processes by discovering the flow. Based on different heuristics you are able to define the smaller blocks.

After a round of analysis, we decided to choose the following areas for implementation to show you the idea of Evolutionary Architecture:

As you can imagine, each subdomain covers a lot of different processes. Again, due to time constraints, we cannot focus on every single aspect. Therefore, we have chosen the following actions for each subdomain:

There are 6 different processes in 4 different subdomains. There is a problem here - these subdomains do not communicate with each other and this is one of the most common problems we have in our applications. So we decided to complicate things a bit and add some communication:

There are 2 triggers:

when the contract is signed by you (a customer), then the new pass is registered to allow you to enter the fitness studio
when the pass expires, then the new offer is prepared (which will be sent to you as a customer)

This way we are almost ready to start the implementation.

One more thing to mention - in our example, each subdomain is a separate Bounded Context.

Important

It is worth mentioning that there may be a situation where multiple subdomains create a single Bounded Context. An example of this in Fitness Studio domain can be: Assessments, Progress Tracking and Virtual Coaching that creates 1 Bounded Context called Personalised Training.

Potential Patterns

Before you decide to start coding, it is worth to look at your analysis and division one more time and check the complexity of each (it will be mainly defined by the amount of processes and its business rules/policies). Let’s take a look at below examples.

Passes

There is no business logic:

in the pass registration process, it is only informed that the contract has been signed
In the pass expiry process, it is only informed that the pass expiry date has been reached.

In addition, the potential for new business rules to be applied to the above processes or other actions is rather low. As it looks like a perfect candidate for CRUD operations, we want to mark it as a candidate to become an Active Record pattern.

Note	Active Record is an pattern that rationalises the persistence layer in an application. It encapsulates the idea that a database record is an object in the application, with properties that map to the columns of the database table and the behaviour (domain logic) of that object.

Offers

The story here is similar to Passes. There is no business logic, only the fact that the pass is expiring.

Contracts

This is the place where the fun begins. There are 3 business rules:

in the process of contract preparation, it is only allowed if the customer is an adult AND smaller than the maximum height allowed (210 cm)
in the contract signing process, it is only allowed if it is signed within 30 days of the contract being created, otherwise the contract has to be created from scratch

In addition, the potential for new business rules being applied to the above processes or other actions is quite high. Here the warning bell should go off - this has a really high potential to become more and more complex, so it might be a good candidate for a Domain Model.

Note

Domain Model is a widely used pattern in software engineering that encapsulates the concepts and behaviours of a particular problem domain. This representation is designed to mimic the structure and functionality of the real-world system. The domain model pattern is particularly well known for its ability to handle complex business logic by providing a rich, object-oriented representation of the problem domain.

Reports

This case is really simple. The only thing that we want to achieve is to get the information about new passes that have been registered in each month.

There is no business logic and there is also no need to have an object representation of the data retrieved. This is a perfect candidate for a Transaction Script.

Note

Transaction Script is a pattern commonly used in software engineering that organises business logic into procedures, where each procedure handles a single request from the presentation. Each transaction script is a series of procedural steps that represent a sequence of tasks performed as part of a transaction, similar to a script in a play.

Summary

After deeper thinking about our subdomains, we decided for following patterns that will be applied in one of 4 chapters:

Chapters

In the beginning of every greenfield project we need to make a lot of decisions and we lack of knowledge. It is called The Project Paradox:

Quite often we are biased by conferences, meetups, friends and colleagues. As a result we decide for too complex architecture.

This means starting with:

microservices (where we do not yet know the traffic, scale and other factors)
orchestrators
data streaming
NoSQL
cache

and many more. In the end, we have a lot of problems of our own making, and the barrier to entry for any team member is extremely high. In fact, after release, we do not know if we need this or that block. We are also not optimised from a cost perspective and it is very difficult to find bottlenecks.

Another problem is choosing an architecture that is too trivial for too long (this happens less often than "overcomplicated"). This means that we just add code to a monolith, new features flood our codebase and then it becomes a big ball of mud.

What we want to show you in our story is the evolutionary approach that will tackle most of the applications you work with.

Chapter 1: Initial Architecture: Focus On Simplicity

In this chapter we will show you how to start your solution architecture. We start with modularisation from day one of the application, but modules are only separated by namespaces (there is only one project for the production code called Fitnet). Each process that occurs in each module is sliced vertically - all the code is covered in each process namespace. This gives us several advantages:

better productivity - when we start a new design, we are not distracted by creating namespaces, renaming, moving things around
all the code for each process is in just one namespace, so there is no need to look around in folders like Controllers, Entities, Commands, Queries etc. Everything is just in e.g. SignContract
deleting or extracting the process is simple - you just drop or extract a namespace

Modules communicate with the in-memory queue.

Interactive diagram

Chapter 2: Modules Separation: Focus On Maintainability

This chapter focuses on the second step you can take in your application. After some time, you will find that your assumptions about modules were wrong - they grow fast, the business logic becomes more complex. You may have to decide to use a different type of database (e.g. key-value). Or the other way around - something you thought was going to be complex is actually quite simple and there is not a lot of business logic involved. Also, the team has grown and it is quite difficult to work on one project - lots of conflict and merging hell.

With this in mind, you can now start thinking to split your single Fitnet project into several ones:

for one module it will be just Fitnet.Reports - there is only a transaction script, no business logic
for another, it will be Fitnet.Passes.Api, Fitnet.Passes.DataAccess to build around the active record
for the complex one it will be Fitnet.Contracts.Api, Fitnet.Contracts.Application, Fitnet.Contracts.Core, Fitnet.Contracts.Infrastructure

and so on. The modules still communicate with the in-memory queue (alternatives described in the chapter’s own README).

Chapter 3: Microservice Extraction: Focus On Growth

Over time, you may need to extract a microservice from one of your application modules. In this chapter, you will identify the most common disintegrators (decision drivers for extracting a microservice).

We will also add a message queue component to replace the in-memory queue. This way, we will improve the exchange of messages between the modules themselves and the microservice.

Here you will learn about various concepts that are important from a microservices architecture perspective.

Interactive diagram

Chapter 4: Applying Tactical Domain-Driven Design: Focus On Complexity

At the end of the story, we want to show you that it is possible to evolve to a domain model for one of your modules at some point.

You do not have to start from scratch if you do not know your business domain. And you do not need to apply all the concepts of Domain-Driven Design to get good results.

Interesting fact - if you have done a proper analysis of your business domain in the beginning and have already broken it down into different subdomains (and combined them into e.g. a module), then you are almost done from a strategic Domain-Driven Design perspective. Now you just need to make some adjustments and do some tactical DDD. Cool? Absolutely cool!

Here we focus mainly on tactical DDD and describe

value objects
entities
aggregates

You will also find some tips for the next steps.

Repository Structure

Overview

We are trying to keep this repository as simple as possible, so that you can read it like a book. It contains chapters, where each chapter is an extension of the previous one, read like a story.

How To Navigate?

In the root folder of this repository you will find only this README, the assets (images & diagrams) used in it, and 4 folders containing the content for each chapter.

In each folder you will find the same root solution, but expanded:

Chapter 1 - Initial state of the application
Chapter 2 - Extraction into separate projects
Chapter 3 - Extracting a module to a microservice and using the message queue
Chapter 4 - Applying Tactical Domain-Driven Design to one of the modules

Another important thing to note is that the detailed description of each chapter is in its own README folder. There you will find the information on how to run the solution, what solution structure is used, and other important things that are only relevant to that particular chapter.

We are not repeating the information covered in the previous chapter, we are just extending it with the decision we have made.

Important

If you want to get the most out of this repository, we recommend that you read the first chapter, understand the code and description, and then navigate to another folder. Of course you can go through the folders in your own way but you might miss some concepts.

Libraries and Platforms Used

The entire application is developed using C# and .NET 8.

In each chapter we use libraries and platforms that simplify the development process (no need to create them yourself). We try to keep it to a minimum. The certain disadvantage is that we do not have full control over it (trade-off we accept). Here is the list of the most important ones:

Application:

Testing:

Videos 🎥

You can learn the essentials of Evolutionary Architecture from these videos:

Webinar from Architecture Weekly 🇬🇧

In this webinar, Maciej "MJ" Jedrzejewski gives a detailed talk on Evolutionary Architecture. You can watch the recorded webinar here.

Presentation at Programistok 2023 Conference 🇵🇱

This is a recorded presentation from the Programistok 2023 Conference, where Evolutionary Architecture was extensively explained. You can watch it on YouTube here.

Evolutionary Architecture Visualized Through NDepend 🇬🇧

Explore Evolutionary Architecture visualized through NDepend, featuring comprehensive dependency and code analysis in the form of an interview led by Ferry de Boer with Kamil. Watch it on YouTube here.

Authors ✍️

Maciej Jedrzejewski	Kamil Baczek
Software architect, tech lead and facilitator of modern software development practices that allow shortening the feedback loop in every area of a lifecycle e.g. trunk-based development, short-living branches, vertical slices, canary releases, CI/CD, and more. Blog Linkedin YouTube	.NET Engineer, Software Architect who empowers teams to build better software through solid software architecture, utilising techniques such as Event Storming, Domain Driven Design and various architecture styles and design patterns. Blog Linkedin Github

Maciej Jedrzejewski

Kamil Baczek

Software architect, tech lead and facilitator of modern software development practices that allow shortening the feedback loop in every area of a lifecycle e.g. trunk-based development, short-living branches, vertical slices, canary releases, CI/CD, and more.

Blog Linkedin YouTube

.NET Engineer, Software Architect who empowers teams to build better software through solid software architecture, utilising techniques such as Event Storming, Domain Driven Design and various architecture styles and design patterns.

Blog Linkedin Github

👩‍💻👨‍💻 What Software Engeeniers Say

👨‍💼 Chief Software Architect

Really appreciate the repository and the content you are sharing. I think it is really valuable to see the evolutionary approach in practice, and focus on simplicity and pragmatic reasoning and making decisions in software design.

👨‍💻 .NET Developer

Your work has been super helpful as I dive deeper into this field. Evolutionary Architecture, in particular, is incredible and has really clicked for me thanks to your examples and insights.

👨‍💻 .NET Developer

I was always concerned about what architecture to use on a project. Sometimes, spending time on researching what’s right affects my motivation. Your approach which focuses on creating a project with an architecture that evolves resonates perfectly with me. Your efforts in creating such a wonderful resource is greatly appreciated.

💬 Join our Community

Join the "Evolutionary Architecture Community" on Discord (https://discord.gg/BGxYkHFCCF) to engage with fellow architects and enthusiasts who share a fervor for pushing boundaries and crafting high-quality software systems. Whether you have questions, suggestions, or feedback for our repository, we’re excited to hear from you and collaborate towards continuous improvement.

⭐ Say thanks

Feel free to give a ⭐ to this repository if you like it. Your support is greatly appreciated!

rl-tools/rl-tools

2024-11-24T01:29:27Z

The Fastest Deep Reinforcement Learning Library

RLtools: The Fastest Deep Reinforcement Learning Library

Paper on arXiv | Live demo (browser) | Documentation | Zoo | Studio

Trained on a 2020 MacBook Pro (M1) using RLtools SAC and TD3 (respectively)

Trained on a 2020 MacBook Pro (M1) using RLtools PPO/Multi-Agent PPO

Trained in 18s on a 2020 MacBook Pro (M1) using RLtools TD3

Benchmarks

Benchmarks of training the Pendulum swing-up using different RL libraries (PPO and SAC respectively)

Benchmarks of training the Pendulum swing-up on different devices (SAC, RLtools)

Benchmarks of the inference frequency for a two-layer [64, 64] fully-connected neural network across different microcontrollers (types and architectures).

Quick Start

Clone this repo, then build a Zoo example:

g++ -std=c++17 -Ofast -I include src/rl/zoo/l2f/sac.cpp

Run it ./a.out 1337 (number = seed) then run python3 -m http.server to visualize the results. Open http://localhost:8000 and navigate to the ExTrack UI to watch the quadrotor flying.

macOS: Append -framework Accelerate -DRL_TOOLS_BACKEND_ENABLE_ACCELERATE for fast training (~4s on M3)
Ubuntu: Use apt install libopenblas-dev and append -lopenblas -DRL_TOOLS_BACKEND_ENABLE_OPENBLAS (~6s on Zen 5).

Algorithms

Algorithm	Example
TD3	Pendulum, Racing Car, MuJoCo Ant-v4, Acrobot
PPO	Pendulum, Racing Car, MuJoCo Ant-v4 (CPU), MuJoCo Ant-v4 (CUDA)
Multi-Agent PPO	Bottleneck
SAC	Pendulum (CPU), Pendulum (CUDA), Acrobot

Projects Based on RLtools

Learning to Fly in Seconds: GitHub / arXiv / YouTube / IEEE Spectrum
Data-Driven System Identification of Quadrotors Subject to Motor Delays GitHub / arXiv / YouTube / Project Page

Getting Started

Simple example on how to implement your own environment and train a policy using PPO:

Clone and checkout:

git clone https://github.com/rl-tools/example
cd example
git submodule update --init external/rl_tools

build and run:

mkdir build
cd build
cmake .. -DCMAKE_BUILD_TYPE=Release
cmake --build .
./my_pendulum

Note this example does not have dependencies and should work on any system with CMake and a C++ 17 compiler.

Documentation

The documentation is available at docs.rl.tools and consists of C++ notebooks. You can also run them locally to tinker around:

docker run -p 8888:8888 rltools/documentation

After running the Docker container, open the link that is displayed in the CLI (http://127.0.0.1:8888/...) in your browser and enjoy tinkering!

Chapter	Documentation	Interactive Notebook
0	Overview	-
1	Containers
2	Multiple Dispatch
3	Deep Learning
4	CPU Acceleration
5	MNIST Classification
6	Deep Reinforcement Learning
7	The Loop Interface
8	Custom Environment
9	Python Interface

Repository Structure

To build the examples from source (either in Docker or natively), first the repository should be cloned. Instead of cloning all submodules using git clone --recursive which takes a lot of space and bandwidth we recommend cloning the main repo containing all the standalone code for RLtools and then cloning the required sets of submodules later:

git clone https://github.com/rl-tools/rl-tools.git rl_tools

Cloning submodules

There are three classes of submodules:

External dependencies (in external/)
- E.g. HDF5 for checkpointing, Tensorboard for logging, or MuJoCo for the simulation of contact dynamics
Examples/Code for embedded platforms (in embedded_platforms/)
Redistributable dependencies (in redistributable/)
Test dependencies (in tests/lib)
Test data (in tests/data)

These sets of submodules can be cloned incrementally/independent of each other. For most use-cases (like e.g. most of the Docker examples) you should clone the submodules for external dependencies:

cd rl_tools

git submodule update --init --recursive -- external

The submodules for the embedded platforms, the redistributable binaries and test dependencies/data can be cloned in the same fashion (by replacing external with the appropriate folder from the enumeration above). Note: Make sure that for the redistributable dependencies and test data git-lfs is installed (e.g. sudo apt install git-lfs on Ubuntu) and activated (git lfs install) otherwise only the metadata of the blobs is downloaded.

Docker

If you would like to take advantage of the features that require additional dependencies, but don't want to install them on your machine yet, you can use Docker. In our experiments on Linux using the NVIDIA container runtime we were able to achieve close to native performance. Docker instructions & examples While it depends on personal preferences, we believe that there are good reasons (ease of debugging, usage of IDEs etc.) to run everything natively when developing. We make sure that the additional dependencies requried for the full feature set are not invasive and usually available through your systems package manager. We believe sudo ./setup.sh is harmful and should not exist. Instead we make the setup explicit so that users maintain agency over their systems.

Native

For maximum performance and malleability for research and development we recommend to run RLtools natively. Since RLtools itself is dependency free the most basic examples don't need any platform setup. However, for an improved experience, we support HDF5 checkpointing and Tensorboard logging as well as optimized BLAS libraries which comes with some system-dependent requirements.

Unix (Linux and macOS) instructions & examples

Windows instructions & examples

Pro tip: Enable lldb data formatters to get nicely formatted, human- (and machine-) readable outputs for rl_tools::Matrix and rl_tools::Tensor while debugging. Instructions to use .lldbinit for CLion & VS Code

Python Interface

We provide Python bindings that available as rltools through PyPI (the pip package index). Note that using Python Gym environments can slow down the trianing significantly compared to native RLtools environments.

pip install rltools gymnasium

Usage:

from rltools import SAC
import gymnasium as gym
from gymnasium.wrappers import RescaleAction

seed = 0xf00d
def env_factory():
    env = gym.make("Pendulum-v1")
    env = RescaleAction(env, -1, 1)
    env.reset(seed=seed)
    return env

sac = SAC(env_factory)
state = sac.State(seed)

finished = False
while not finished:
    finished = state.step()

You can find more details in the Python Interface documentation and from the repository rl-tools/python-interface.

Embedded Platforms

Inference & Training

iOS
teensy

Inference

Naming Convention

We use snake_case for variables/instances, functions as well as namespaces and PascalCase for structs/classes. Furthermore, we use upper case SNAKE_CASE for compile-time constants.

Citing

When using RLtools in an academic work please cite our publication using the following Bibtex citation:

@article{eschmann_rltools_2024,
  author  = {Jonas Eschmann and Dario Albani and Giuseppe Loianno},
  title   = {RLtools: A Fast, Portable Deep Reinforcement Learning Library for Continuous Control},
  journal = {Journal of Machine Learning Research},
  year    = {2024},
  volume  = {25},
  number  = {301},
  pages   = {1--19},
  url     = {http://jmlr.org/papers/v25/24-0248.html}
}

NASA-SW-VnV/ikos

2024-11-24T01:37:15Z

Static analyzer for C/C++ based on the theory of Abstract Interpretation.

IKOS

IKOS (Inference Kernel for Open Static Analyzers) is a static analyzer for C/C++ based on the theory of Abstract Interpretation.

Introduction

IKOS also provides a C and C++ static analyzer based on LLVM. It implements scalable analyses for detecting and proving the absence of runtime errors in C and C++ programs.

License

IKOS has been released under the NASA Open Source Agreement version 1.3, see LICENSE.pdf

Contact

ikos@lists.nasa.gov

Release notes

See Releases.

Troubleshooting

See TROUBLESHOOTING.md

Installation

To install IKOS on Linux or macOS, we recommend to use Homebrew.

First, install Homebrew by following these instructions.

Then, simply run:

$ brew install nasa-sw-vnv/core/ikos

For Windows, consider using Windows Subsystem for Linux.

How to run IKOS

Suppose we want to analyze the following C program in a file, called loop.c:

 1: #include <stdio.h>
 2: int a[10];
 3: int main(int argc, char *argv[]) {
 4:     size_t i = 0;
 5:     for (;i < 10; i++) {
 6:         a[i] = i;
 7:     }
 8:     a[i] = i;
 9:     printf("%i", a[i]);
10: }

To analyze this program with IKOS, simply run:

$ ikos loop.c

You shall see the following output. IKOS reports two occurrences of buffer overflow at line 8 and 9.

[*] Compiling loop.c
[*] Running ikos preprocessor
[*] Running ikos analyzer
[*] Translating LLVM bitcode to AR
[*] Running liveness analysis
[*] Running widening hint analysis
[*] Running interprocedural value analysis
[*] Analyzing entry point 'main'
[*] Checking properties for entry point 'main'

# Time stats:
clang        : 0.037 sec
ikos-analyzer: 0.023 sec
ikos-pp      : 0.007 sec

# Summary:
Total number of checks                : 7
Total number of unreachable checks    : 0
Total number of safe checks           : 5
Total number of definite unsafe checks: 2
Total number of warnings              : 0

The program is definitely UNSAFE

# Results
loop.c: In function 'main':
loop.c:8:10: error: buffer overflow, trying to access index 10 of global variable 'a' of 10 elements
    a[i] = i;
         ^
loop.c: In function 'main':
loop.c:9:18: error: buffer overflow, trying to access index 10 of global variable 'a' of 10 elements
    printf("%i", a[i]);
                 ^

In the report, each line has one of the following status:

safe: the statement is proven safe;
error: the statement always results into an error (or is unreachable);
unreachable: the statement is never executed;
warning may mean three things:
1. the statement results into an error for some executions, or
2. the static analyzer did not have enough information to conclude (check dependent on an external input, for instance), or
3. the static analyzer was not powerful enough to prove the absence of errors;

By default, ikos shows warnings and errors directly in your terminal, like a compiler would do.

If the analysis report is too big, you shall use:

ikos-report output.db to examine the report in your terminal
ikos-view output.db to examine the report in a web interface

Further information:

Build from source

Dependencies

To build and run the analyzer, you will need the following dependencies:

A C++ compiler that supports C++14 (gcc >= 4.9.2 or clang >= 3.4)
CMake >= 3.4.3
GMP >= 4.3.1
Boost >= 1.55
Python >= 3.3
SQLite >= 3.6.20
TBB >= 2
LLVM and Clang 14.0.x
(Optional) APRON >= 0.9.10

Most of them can be installed using your package manager.

Note: If you build LLVM from source, you need to enable run-time type information (RTTI).

Build and Install

Now that you have all the dependencies on your system, you can build and install IKOS.

As you open the IKOS distribution, you shall see the following directory structure:

.
├── CMakeLists.txt
├── LICENSE.pdf
├── README.md
├── RELEASE_NOTES.md
├── TROUBLESHOOTING.md
├── analyzer
├── ar
├── cmake
├── core
├── doc
├── frontend
├── script
└── test

Here are the steps to build and install IKOS:

$ mkdir build
$ cd build
$ cmake -DCMAKE_INSTALL_PREFIX=/path/to/ikos-install-directory ..
$ make
$ make install

Then, add IKOS in your PATH (consider adding this in your .bashrc):

$ PATH="/path/to/ikos-install-directory/bin:$PATH"

Tests

To build and run the tests, simply type:

$ make check

Contributors

See CONTRIBUTORS.md

Publications

Sung Kook Kim, Arnaud J. Venet, Aditya V. Thakur. Deterministic Parallel Fixpoint Computation. In Principles of Programming Languages (POPL 2020), New Orleans, Louisiana (PDF).
Guillaume Brat, Jorge Navas, Nija Shi and Arnaud Venet. IKOS: a Framework for Static Analysis based on Abstract Interpretation. In Proceedings of the International Conference on Software Engineering and Formal Methods (SEFM 2014), Grenoble, France (PDF).
Arnaud Venet. The Gauge Domain: Scalable Analysis of Linear Inequality Invariants. In Proceedings of Computer Aided Verification (CAV 2012), Berkeley, California, USA 2012. Lecture Notes in Computer Science, pages 139-154, volume 7358, Springer 2012 (PDF).

Coding Standards

See doc/CODING_STANDARDS.md

Overview of the source code

See doc/OVERVIEW.md

shader-slang/slang

2024-11-24T01:37:15Z

Making it easier to work with shaders

Slang

Why Slang?

The Slang shading language is designed to enable real-time graphics developers to work with large-scale, high-performance shader code.

Write Shaders Once, Run Anywhere

Access the Latest GPU Features

Leverage Neural Graphics with Automatic Differentiation

Scalable Software Development with Modules

Code Specialization that Works with Modules

Easy On-ramp for HLSL and GLSL Codebases

Slang provides a compatibility module that enables the use of most GLSL intrinsic functions and GLSL's parameter binding syntax.

Comprehensive Tooling Support

Getting Started

See the user-guide for info on using the slangc command-line tool: Slang Command Line Usage.

If you would like to build Slang from source, please consult the build instructions.

Documentation

The Slang project provides a variety of different documentation, but most users would be well served starting with the User's Guide.

For developers writing Slang code, the Slang Core Module Reference provides detailed documentation on Slang's built-in types and functions.

We also provide a few examples of how to integrate Slang into a rendering application.

Additionally, we recommend checking out Vulkan Mini Examples for more examples of using Slang's language features available on Vulkan, such as pointers and the ray tracing intrinsics.

Contributing

If you'd like to contribute to the project, we are excited to have your input. The following guidelines should be observed by contributors:

Please follow the contributor Code of Conduct.
Bugs reports and feature requests should go through the GitHub issue tracker
Changes should ideally come in as small pull requests on top of master, coming from your own personal fork of the project
Large features that will involve multiple contributors or a long development time should be discussed in issues, and broken down into smaller pieces that can be implemented and checked in in stages

Contribution guide describes the workflow for contributors at more detail.

Limitations and Support

Platform support

The Slang compiler and libraries can be built on the following platforms:

Windows	Linux	MacOS	WebAssembly
supported	supported	supported	experimental

Both x86_64 and aarch64 architectures are supported on Windows, Linux and MacOS platforms.

Target support

Slang can compile shader code to the following targets:

Target	Status	Output Formats
Direct3D 11	supported	HLSL
Direct3D 12	supported	HLSL
Vulkan	supported	SPIRV, GLSL
Metal	experimental*	Metal Shading Language
WebGPU	experimental**	WGSL
CUDA	supported	C++ (compute only)
Optix	experimental	C++ (WIP)
CPU	experimental	C++ (kernel), C++ (host), standalone executable, dynamic library

*Slang currently supports generating vertex, fragment, compute, task and mesh shaders for Metal.

**WGSL support is still work in-progress.

For greater detail, see the Supported Compilation Targets section of the User Guide

License

The Slang code itself is under the Apache 2.0 with LLVM Exception license (see LICENSE).

Builds of the core Slang tools depend on the following projects, either automatically or optionally, which may have their own licenses:

glslang (BSD)
lz4 (BSD)
miniz (MIT)
spirv-headers (Modified MIT)
spirv-tools (Apache 2.0)
ankerl::unordered_dense::{map, set} (MIT)

Slang releases may include slang-llvm which includes LLVM under the license:

llvm (Apache 2.0 License with LLVM exceptions)

Some of the tests and example programs that build with Slang use the following projects, which may have their own licenses:

glm (MIT)
stb_image and stb_image_write from the stb collection of single-file libraries (Public Domain)
tinyobjloader (MIT)

daijro/camoufox

2024-11-24T01:37:15Z

🦊 Anti-detect browser

Camoufox

A stealthy, minimalistic, custom build of Firefox for web scraping 🦊

Camoufox is an open source anti-detect browser for robust fingerprint injection & anti-bot evasion.

[!NOTE] All of the latest documentation is avaliable at camoufox.com.

Camoufox is the most modern, effective & future-proof open source solution for avoiding bot detection and intelligent fingerprint rotation. It outperforms most commercial anti-bot browsers.

Scrapfly is an enterprise-grade solution providing Web Scraping API that aims to simplify the scraping process by managing everything: real browser rendering, rotating proxies, and fingerprints (TLS, HTTP, browser) to bypass all major anti-bots. Scrapfly also unlocks the observability by providing an analytical dashboard and measuring the success rate/block rate in detail.

Features

Invisible to all anti-bot systems 🎭
- Camoufox performs better than most commerical anti-bot browsers.

Fingerprint injection & rotation (without JS injection!)
- All navigator properties (device, OS, hardware, browser, etc.) ✅
- Screen size, resolution, window, & viewport properties ✅
- Geolocation, timezone, & locale spoofing ✅
- Font spoofing & anti-fingerprinting ✅
- WebGL parameters, supported extensions, context attributes, & shader precision formats ✅
- WebRTC IP spoofing at the protocol level ✅
- Media devices, voices, speech playback rate, etc. ✅
- And much, much more!

Quality of life features
- Human-like mouse movement 🖱️
- Blocks & circumvents ads 🛡️
- No CSS animations 💨

Debloated & optimized for memory efficiency ⚡
PyPi package for updates & auto fingerprint injection 📦
Stays up to date with the latest Firefox version 🕓

Fingerprint Injection

In Camoufox, data is intercepted at the C++ implementation level, making the changes undetectable through JavaScript inspection.

To spoof fingerprint properties, pass a JSON containing properties to spoof to the Python interface:

>>> with Camoufox(config={"property": "value"}) as browser:

Config data not set by the user will be automatically populated using BrowserForge fingerprints, which mimic the statistical distribution of device characteristics in real-world traffic.

Legacy documentation

The following properties can be spoofed:

Navigator

Navigator properties can be fully spoofed to other Firefox fingerprints, and it is completely safe! However, there are some issues when spoofing Chrome (leaks noted).

Property	Notes
navigator.userAgent	✅
navigator.doNotTrack	✅
navigator.appCodeName	✅
navigator.appName	✅
navigator.appVersion	✅
navigator.oscpu	✅
navigator.language	✅
navigator.languages	✅
navigator.platform	✅
navigator.hardwareConcurrency	✅
navigator.product	✅
navigator.productSub	✅
navigator.maxTouchPoints	✅
navigator.cookieEnabled	✅
navigator.globalPrivacyControl	✅
navigator.appVersion	✅
navigator.buildID	✅
navigator.doNotTrack	✅

Camoufox will automatically add the following default fonts associated your spoofed User-Agent OS (the value passed in navigator.userAgent).

Notes:

navigator.webdriver is set to false at all times.
navigator.language & navigator.languages will fall back to the locale:language/locale:region values if not set.
When spoofing Chrome fingerprints, the following may leak:
- navigator.userAgentData missing.
- navigator.deviceMemory missing.
Changing the presented Firefox version can be detected by some testing websites, but typically will not flag production WAFs.

Cursor movement

Human-like Cursor movement

Camoufox has built-in support for human-like cursor movement. The natural motion algorithm was originally from rifosnake's HumanCursor, but has been rewritten in C++ and modified for more distance-aware trajectories.

Demo

Properties

Property	Supported	Description
humanize	✅	Enable/disable human-like cursor movement. Defaults to False.
humanize:maxTime	✅	Maximum time in seconds for the cursor movement. Defaults to `1.5`.
showcursor	✅	Toggles the cursor highlighter. Defaults to True.

Notes:

The cursor highlighter is not ran in the page context. It will not be visible to the page. You don't have to worry about it leaking.

Fonts

Adding Fonts

Fonts can be passed to be used in Camoufox through the fonts config property.

By default, Camoufox is bundled with the default Windows 11 22H2 fonts, macOS Sonma fonts, and Linux fonts used in the TOR bundle.

Camoufox will automatically add the default fonts associated your spoofed User-Agent OS (the value passed in navigator.userAgent):

Mac OS fonts (from macOS Sonma):

[".Al Bayan PUA", ".Al Nile PUA", ".Al Tarikh PUA", ".Apple Color Emoji UI", ".Apple SD Gothic NeoI", ".Aqua Kana", ".Aqua Kana Bold", ".Aqua かな", ".Aqua かな ボールド", ".Arial Hebrew Desk Interface", ".Baghdad PUA", ".Beirut PUA", ".Damascus PUA", ".DecoType Naskh PUA", ".Diwan Kufi PUA", ".Farah PUA", ".Geeza Pro Interface", ".Geeza Pro PUA", ".Helvetica LT MM", ".Hiragino Kaku Gothic Interface", ".Hiragino Sans GB Interface", ".Keyboard", ".KufiStandardGK PUA", ".LastResort", ".Lucida Grande UI", ".Muna PUA", ".Nadeem PUA", ".New York", ".Noto Nastaliq Urdu UI", ".PingFang HK", ".PingFang SC", ".PingFang TC", ".SF Arabic", ".SF Arabic Rounded", ".SF Compact", ".SF Compact Rounded", ".SF NS", ".SF NS Mono", ".SF NS Rounded", ".Sana PUA", ".Savoye LET CC.", ".ThonburiUI", ".ThonburiUIWatch", ".苹方-港", ".苹方-简", ".苹方-繁", ".蘋方-港", ".蘋方-簡", ".蘋方-繁", "Academy Engraved LET", "Al Bayan", "Al Nile", "Al Tarikh", "American Typewriter", "Andale Mono", "Apple Braille", "Apple Chancery", "Apple Color Emoji", "Apple SD Gothic Neo", "Apple SD 산돌고딕 Neo", "Apple Symbols", "AppleGothic", "AppleMyungjo", "Arial", "Arial Black", "Arial Hebrew", "Arial Hebrew Scholar", "Arial Narrow", "Arial Rounded MT Bold", "Arial Unicode MS", "Athelas", "Avenir", "Avenir Black", "Avenir Black Oblique", "Avenir Book", "Avenir Heavy", "Avenir Light", "Avenir Medium", "Avenir Next", "Avenir Next Condensed", "Avenir Next Condensed Demi Bold", "Avenir Next Condensed Heavy", "Avenir Next Condensed Medium", "Avenir Next Condensed Ultra Light", "Avenir Next Demi Bold", "Avenir Next Heavy", "Avenir Next Medium", "Avenir Next Ultra Light", "Ayuthaya", "Baghdad", "Bangla MN", "Bangla Sangam MN", "Baskerville", "Beirut", "Big Caslon", "Bodoni 72", "Bodoni 72 Oldstyle", "Bodoni 72 Smallcaps", "Bodoni Ornaments", "Bradley Hand", "Brush Script MT", "Chalkboard", "Chalkboard SE", "Chalkduster", "Charter", "Charter Black", "Cochin", "Comic Sans MS", "Copperplate", "Corsiva Hebrew", "Courier", "Courier New", "Czcionka systemowa", "DIN Alternate", "DIN Condensed", "Damascus", "DecoType Naskh", "Devanagari MT", "Devanagari Sangam MN", "Didot", "Diwan Kufi", "Diwan Thuluth", "Euphemia UCAS", "Farah", "Farisi", "Font Sistem", "Font de sistem", "Font di sistema", "Font sustava", "Fonte do Sistema", "Futura", "GB18030 Bitmap", "Galvji", "Geeza Pro", "Geneva", "Georgia", "Gill Sans", "Grantha Sangam MN", "Gujarati MT", "Gujarati Sangam MN", "Gurmukhi MN", "Gurmukhi MT", "Gurmukhi Sangam MN", "Heiti SC", "Heiti TC", "Heiti-간체", "Heiti-번체", "Helvetica", "Helvetica Neue", "Herculanum", "Hiragino Kaku Gothic Pro", "Hiragino Kaku Gothic Pro W3", "Hiragino Kaku Gothic Pro W6", "Hiragino Kaku Gothic ProN", "Hiragino Kaku Gothic ProN W3", "Hiragino Kaku Gothic ProN W6", "Hiragino Kaku Gothic Std", "Hiragino Kaku Gothic Std W8", "Hiragino Kaku Gothic StdN", "Hiragino Kaku Gothic StdN W8", "Hiragino Maru Gothic Pro", "Hiragino Maru Gothic Pro W4", "Hiragino Maru Gothic ProN", "Hiragino Maru Gothic ProN W4", "Hiragino Mincho Pro", "Hiragino Mincho Pro W3", "Hiragino Mincho Pro W6", "Hiragino Mincho ProN", "Hiragino Mincho ProN W3", "Hiragino Mincho ProN W6", "Hiragino Sans", "Hiragino Sans GB", "Hiragino Sans GB W3", "Hiragino Sans GB W6", "Hiragino Sans W0", "Hiragino Sans W1", "Hiragino Sans W2", "Hiragino Sans W3", "Hiragino Sans W4", "Hiragino Sans W5", "Hiragino Sans W6", "Hiragino Sans W7", "Hiragino Sans W8", "Hiragino Sans W9", "Hoefler Text", "Hoefler Text Ornaments", "ITF Devanagari", "ITF Devanagari Marathi", "Impact", "InaiMathi", "Iowan Old Style", "Iowan Old Style Black", "Järjestelmäfontti", "Kailasa", "Kannada MN", "Kannada Sangam MN", "Kefa", "Khmer MN", "Khmer Sangam MN", "Kohinoor Bangla", "Kohinoor Devanagari", "Kohinoor Gujarati", "Kohinoor Telugu", "Kokonor", "Krungthep", "KufiStandardGK", "Lao MN", "Lao Sangam MN", "Lucida Grande", "Luminari", "Malayalam MN", "Malayalam Sangam MN", "Marion", "Marker Felt", "Menlo", "Microsoft Sans Serif", "Mishafi", "Mishafi Gold", "Monaco", "Mshtakan", "Mukta Mahee", "MuktaMahee Bold", "MuktaMahee ExtraBold", "MuktaMahee ExtraLight", "MuktaMahee Light", "MuktaMahee Medium", "MuktaMahee Regular", "MuktaMahee SemiBold", "Muna", "Myanmar MN", "Myanmar Sangam MN", "Nadeem", "New Peninim MT", "Noteworthy", "Noto Nastaliq Urdu", "Noto Sans Adlam", "Noto Sans Armenian", "Noto Sans Armenian Blk", "Noto Sans Armenian ExtBd", "Noto Sans Armenian ExtLt", "Noto Sans Armenian Light", "Noto Sans Armenian Med", "Noto Sans Armenian SemBd", "Noto Sans Armenian Thin", "Noto Sans Avestan", "Noto Sans Bamum", "Noto Sans Bassa Vah", "Noto Sans Batak", "Noto Sans Bhaiksuki", "Noto Sans Brahmi", "Noto Sans Buginese", "Noto Sans Buhid", "Noto Sans CanAborig", "Noto Sans Canadian Aboriginal", "Noto Sans Carian", "Noto Sans CaucAlban", "Noto Sans Caucasian Albanian", "Noto Sans Chakma", "Noto Sans Cham", "Noto Sans Coptic", "Noto Sans Cuneiform", "Noto Sans Cypriot", "Noto Sans Duployan", "Noto Sans EgyptHiero", "Noto Sans Egyptian Hieroglyphs", "Noto Sans Elbasan", "Noto Sans Glagolitic", "Noto Sans Gothic", "Noto Sans Gunjala Gondi", "Noto Sans Hanifi Rohingya", "Noto Sans HanifiRohg", "Noto Sans Hanunoo", "Noto Sans Hatran", "Noto Sans ImpAramaic", "Noto Sans Imperial Aramaic", "Noto Sans InsPahlavi", "Noto Sans InsParthi", "Noto Sans Inscriptional Pahlavi", "Noto Sans Inscriptional Parthian", "Noto Sans Javanese", "Noto Sans Kaithi", "Noto Sans Kannada", "Noto Sans Kannada Black", "Noto Sans Kannada ExtraBold", "Noto Sans Kannada ExtraLight", "Noto Sans Kannada Light", "Noto Sans Kannada Medium", "Noto Sans Kannada SemiBold", "Noto Sans Kannada Thin", "Noto Sans Kayah Li", "Noto Sans Kharoshthi", "Noto Sans Khojki", "Noto Sans Khudawadi", "Noto Sans Lepcha", "Noto Sans Limbu", "Noto Sans Linear A", "Noto Sans Linear B", "Noto Sans Lisu", "Noto Sans Lycian", "Noto Sans Lydian", "Noto Sans Mahajani", "Noto Sans Mandaic", "Noto Sans Manichaean", "Noto Sans Marchen", "Noto Sans Masaram Gondi", "Noto Sans Meetei Mayek", "Noto Sans Mende Kikakui", "Noto Sans Meroitic", "Noto Sans Miao", "Noto Sans Modi", "Noto Sans Mongolian", "Noto Sans Mro", "Noto Sans Multani", "Noto Sans Myanmar", "Noto Sans Myanmar Blk", "Noto Sans Myanmar ExtBd", "Noto Sans Myanmar ExtLt", "Noto Sans Myanmar Light", "Noto Sans Myanmar Med", "Noto Sans Myanmar SemBd", "Noto Sans Myanmar Thin", "Noto Sans NKo", "Noto Sans Nabataean", "Noto Sans New Tai Lue", "Noto Sans Newa", "Noto Sans Ol Chiki", "Noto Sans Old Hungarian", "Noto Sans Old Italic", "Noto Sans Old North Arabian", "Noto Sans Old Permic", "Noto Sans Old Persian", "Noto Sans Old South Arabian", "Noto Sans Old Turkic", "Noto Sans OldHung", "Noto Sans OldNorArab", "Noto Sans OldSouArab", "Noto Sans Oriya", "Noto Sans Osage", "Noto Sans Osmanya", "Noto Sans Pahawh Hmong", "Noto Sans Palmyrene", "Noto Sans Pau Cin Hau", "Noto Sans PhagsPa", "Noto Sans Phoenician", "Noto Sans PsaPahlavi", "Noto Sans Psalter Pahlavi", "Noto Sans Rejang", "Noto Sans Samaritan", "Noto Sans Saurashtra", "Noto Sans Sharada", "Noto Sans Siddham", "Noto Sans Sora Sompeng", "Noto Sans SoraSomp", "Noto Sans Sundanese", "Noto Sans Syloti Nagri", "Noto Sans Syriac", "Noto Sans Tagalog", "Noto Sans Tagbanwa", "Noto Sans Tai Le", "Noto Sans Tai Tham", "Noto Sans Tai Viet", "Noto Sans Takri", "Noto Sans Thaana", "Noto Sans Tifinagh", "Noto Sans Tirhuta", "Noto Sans Ugaritic", "Noto Sans Vai", "Noto Sans Wancho", "Noto Sans Warang Citi", "Noto Sans Yi", "Noto Sans Zawgyi", "Noto Sans Zawgyi Blk", "Noto Sans Zawgyi ExtBd", "Noto Sans Zawgyi ExtLt", "Noto Sans Zawgyi Light", "Noto Sans Zawgyi Med", "Noto Sans Zawgyi SemBd", "Noto Sans Zawgyi Thin", "Noto Serif Ahom", "Noto Serif Balinese", "Noto Serif Hmong Nyiakeng", "Noto Serif Myanmar", "Noto Serif Myanmar Blk", "Noto Serif Myanmar ExtBd", "Noto Serif Myanmar ExtLt", "Noto Serif Myanmar Light", "Noto Serif Myanmar Med", "Noto Serif Myanmar SemBd", "Noto Serif Myanmar Thin", "Noto Serif Yezidi", "Optima", "Oriya MN", "Oriya Sangam MN", "PT Mono", "PT Sans", "PT Sans Caption", "PT Sans Narrow", "PT Serif", "PT Serif Caption", "Palatino", "Papyrus", "Party LET", "Phosphate", "Phông chữ Hệ thống", "PingFang HK", "PingFang SC", "PingFang TC", "Plantagenet Cherokee", "Police système", "Raanana", "Rendszerbetűtípus", "Rockwell", "STIX Two Math", "STIX Two Text", "STIXGeneral", "STIXIntegralsD", "STIXIntegralsSm", "STIXIntegralsUp", "STIXIntegralsUpD", "STIXIntegralsUpSm", "STIXNonUnicode", "STIXSizeFiveSym", "STIXSizeFourSym", "STIXSizeOneSym", "STIXSizeThreeSym", "STIXSizeTwoSym", "STIXVariants", "STSong", "Sana", "Sathu", "Savoye LET", "Seravek", "Seravek ExtraLight", "Seravek Light", "Seravek Medium", "Shree Devanagari 714", "SignPainter", "SignPainter-HouseScript", "Silom", "Sinhala MN", "Sinhala Sangam MN", "Sistem Fontu", "Skia", "Snell Roundhand", "Songti SC", "Songti TC", "Sukhumvit Set", "Superclarendon", "Symbol", "Systeemlettertype", "System Font", "Systemschrift", "Systemskrift", "Systemtypsnitt", "Systémové písmo", "Tahoma", "Tamil MN", "Tamil Sangam MN", "Telugu MN", "Telugu Sangam MN", "Thonburi", "Times", "Times New Roman", "Tipo de letra del sistema", "Tipo de letra do sistema", "Tipus de lletra del sistema", "Trattatello", "Trebuchet MS", "Verdana", "Waseem", "Webdings", "Wingdings", "Wingdings 2", "Wingdings 3", "Zapf Dingbats", "Zapfino", "Γραμματοσειρά συστήματος", "Системний шрифт", "Системный шрифт", "גופן מערכת", "البيان", "التاريخ", "النيل", "بغداد", "بيروت", "جيزة", "خط النظام", "دمشق", "ديوان ثلث", "ديوان كوفي", "صنعاء", "فارسي", "فرح", "كوفي", "منى", "مِصحفي", "مِصحفي ذهبي", "نديم", "نسخ", "وسيم", "आई॰टी॰एफ़॰ देवनागरी", "आई॰टी॰एफ़॰ देवनागरी मराठी", "कोहिनूर देवनागरी", "देवनागरी एम॰टी॰", "देवनागरी संगम एम॰एन॰", "श्री देवनागरी ७१४", "แบบอักษรระบบ", "⹁煵愠芩苈", "システムフォント", "ヒラギノ丸ゴ Pro", "ヒラギノ丸ゴ Pro W4", "ヒラギノ丸ゴ ProN", "ヒラギノ丸ゴ ProN W4", "ヒラギノ明朝 Pro", "ヒラギノ明朝 Pro W3", "ヒラギノ明朝 Pro W6", "ヒラギノ明朝 ProN", "ヒラギノ明朝 ProN W3", "ヒラギノ明朝 ProN W6", "ヒラギノ角ゴ Pro", "ヒラギノ角ゴ Pro W3", "ヒラギノ角ゴ Pro W6", "ヒラギノ角ゴ ProN", "ヒラギノ角ゴ ProN W3", "ヒラギノ角ゴ ProN W6", "ヒラギノ角ゴ Std", "ヒラギノ角ゴ Std W8", "ヒラギノ角ゴ StdN", "ヒラギノ角ゴ StdN W8", "ヒラギノ角ゴ 簡体中文", "ヒラギノ角ゴ 簡体中文 W3", "ヒラギノ角ゴ 簡体中文 W6", "ヒラギノ角ゴシック", "ヒラギノ角ゴシック W0", "ヒラギノ角ゴシック W1", "ヒラギノ角ゴシック W2", "ヒラギノ角ゴシック W3", "ヒラギノ角ゴシック W4", "ヒラギノ角ゴシック W5", "ヒラギノ角ゴシック W6", "ヒラギノ角 ゴシック W7", "ヒラギノ角ゴシック W8", "ヒラギノ角ゴシック W9", "冬青黑体简体中文", "冬青黑体简体中文 W3", "冬青黑体简体中文 W6", "冬青黑體簡體中文", "冬青黑體簡體中文 W3", "冬青黑體簡體中文 W6", "宋体-简", "宋体-繁", "宋體-簡", "宋體-繁", "系統字體", "系统字体", "苹方-港", "苹方-简", "苹方-繁", "荱莉荍荭詰荓⁐牯", "荱莉荍荭詰荓⁓瑤", "荱莉荍荭詰荓荖荢荎", "荱莉荍荭諛荓⁐牯", "荱莉荍荭难銩⁐牯", "蘋方-港", "蘋方-簡", "蘋方-繁", "黑体-简", "黑体-繁", "黑體-簡", "黑體-繁", "黒体-簡", "黒体-繁", "시스템 서체"]

Windows fonts (from Windows 11 22H2):

["Arial", "Arial Black", "Bahnschrift", "Calibri", "Calibri Light", "Cambria", "Cambria Math", "Candara", "Candara Light", "Comic Sans MS", "Consolas", "Constantia", "Corbel", "Corbel Light", "Courier New", "Ebrima", "Franklin Gothic Medium", "Gabriola", "Gadugi", "Georgia", "HoloLens MDL2 Assets", "Impact", "Ink Free", "Javanese Text", "Leelawadee UI", "Leelawadee UI Semilight", "Lucida Console", "Lucida Sans Unicode", "MS Gothic", "MS PGothic", "MS UI Gothic", "MV Boli", "Malgun Gothic", "Malgun Gothic Semilight", "Marlett", "Microsoft Himalaya", "Microsoft JhengHei", "Microsoft JhengHei Light", "Microsoft JhengHei UI", "Microsoft JhengHei UI Light", "Microsoft New Tai Lue", "Microsoft PhagsPa", "Microsoft Sans Serif", "Microsoft Tai Le", "Microsoft YaHei", "Microsoft YaHei Light", "Microsoft YaHei UI", "Microsoft YaHei UI Light", "Microsoft Yi Baiti", "MingLiU-ExtB", "MingLiU_HKSCS-ExtB", "Mongolian Baiti", "Myanmar Text", "NSimSun", "Nirmala UI", "Nirmala UI Semilight", "PMingLiU-ExtB", "Palatino Linotype", "Segoe Fluent Icons", "Segoe MDL2 Assets", "Segoe Print", "Segoe Script", "Segoe UI", "Segoe UI Black", "Segoe UI Emoji", "Segoe UI Historic", "Segoe UI Light", "Segoe UI Semibold", "Segoe UI Semilight", "Segoe UI Symbol", "Segoe UI Variable", "SimSun", "SimSun-ExtB", "Sitka", "Sitka Text", "Sylfaen", "Symbol", "Tahoma", "Times New Roman", "Trebuchet MS", "Twemoji Mozilla", "Verdana", "Webdings", "Wingdings", "Yu Gothic", "Yu Gothic Light", "Yu Gothic Medium", "Yu Gothic UI", "Yu Gothic UI Light", "Yu Gothic UI Semibold", "Yu Gothic UI Semilight", "宋体", "微軟正黑體", "微軟正黑體 Light", "微软雅黑", "微软雅黑 Light", "新宋体", "新細明體-ExtB", "游ゴシック", "游ゴシック Light", "游ゴシック Medium", "細明體-ExtB", "細明體_HKSCS-ExtB", "맑은 고딕", "맑은 고딕 Semilight", "ＭＳ ゴシック", "ＭＳ Ｐゴシック"]

Linux fonts (from TOR Browser):

["Arimo", "Cousine", "Noto Naskh Arabic", "Noto Sans Adlam", "Noto Sans Armenian", "Noto Sans Balinese", "Noto Sans Bamum", "Noto Sans Bassa Vah", "Noto Sans Batak", "Noto Sans Bengali", "Noto Sans Buginese", "Noto Sans Buhid", "Noto Sans Canadian Aboriginal", "Noto Sans Chakma", "Noto Sans Cham", "Noto Sans Cherokee", "Noto Sans Coptic", "Noto Sans Deseret", "Noto Sans Devanagari", "Noto Sans Elbasan", "Noto Sans Ethiopic", "Noto Sans Georgian", "Noto Sans Grantha", "Noto Sans Gujarati", "Noto Sans Gunjala Gondi", "Noto Sans Gurmukhi", "Noto Sans Hanifi Rohingya", "Noto Sans Hanunoo", "Noto Sans Hebrew", "Noto Sans JP", "Noto Sans Javanese", "Noto Sans KR", "Noto Sans Kannada", "Noto Sans Kayah Li", "Noto Sans Khmer", "Noto Sans Khojki", "Noto Sans Khudawadi", "Noto Sans Lao", "Noto Sans Lepcha", "Noto Sans Limbu", "Noto Sans Lisu", "Noto Sans Mahajani", "Noto Sans Malayalam", "Noto Sans Mandaic", "Noto Sans Masaram Gondi", "Noto Sans Medefaidrin", "Noto Sans Meetei Mayek", "Noto Sans Mende Kikakui", "Noto Sans Miao", "Noto Sans Modi", "Noto Sans Mongolian", "Noto Sans Mro", "Noto Sans Multani", "Noto Sans Myanmar", "Noto Sans NKo", "Noto Sans New Tai Lue", "Noto Sans Newa", "Noto Sans Ol Chiki", "Noto Sans Oriya", "Noto Sans Osage", "Noto Sans Osmanya", "Noto Sans Pahawh Hmong", "Noto Sans Pau Cin Hau", "Noto Sans Rejang", "Noto Sans Runic", "Noto Sans SC", "Noto Sans Samaritan", "Noto Sans Saurashtra", "Noto Sans Sharada", "Noto Sans Shavian", "Noto Sans Sinhala", "Noto Sans Sora Sompeng", "Noto Sans Soyombo", "Noto Sans Sundanese", "Noto Sans Syloti Nagri", "Noto Sans Symbols", "Noto Sans Symbols 2", "Noto Sans Syriac", "Noto Sans TC", "Noto Sans Tagalog", "Noto Sans Tagbanwa", "Noto Sans Tai Le", "Noto Sans Tai Tham", "Noto Sans Tai Viet", "Noto Sans Takri", "Noto Sans Tamil", "Noto Sans Telugu", "Noto Sans Thaana", "Noto Sans Thai", "Noto Sans Tifinagh", "Noto Sans Tifinagh APT", "Noto Sans Tifinagh Adrar", "Noto Sans Tifinagh Agraw Imazighen", "Noto Sans Tifinagh Ahaggar", "Noto Sans Tifinagh Air", "Noto Sans Tifinagh Azawagh", "Noto Sans Tifinagh Ghat", "Noto Sans Tifinagh Hawad", "Noto Sans Tifinagh Rhissa Ixa", "Noto Sans Tifinagh SIL", "Noto Sans Tifinagh Tawellemmet", "Noto Sans Tirhuta", "Noto Sans Vai", "Noto Sans Wancho", "Noto Sans Warang Citi", "Noto Sans Yi", "Noto Sans Zanabazar Square", "Noto Serif Armenian", "Noto Serif Balinese", "Noto Serif Bengali", "Noto Serif Devanagari", "Noto Serif Dogra", "Noto Serif Ethiopic", "Noto Serif Georgian", "Noto Serif Grantha", "Noto Serif Gujarati", "Noto Serif Gurmukhi", "Noto Serif Hebrew", "Noto Serif Kannada", "Noto Serif Khmer", "Noto Serif Khojki", "Noto Serif Lao", "Noto Serif Malayalam", "Noto Serif Myanmar", "Noto Serif NP Hmong", "Noto Serif Sinhala", "Noto Serif Tamil", "Noto Serif Telugu", "Noto Serif Thai", "Noto Serif Tibetan", "Noto Serif Yezidi", "STIX Two Math", "Tinos", "Twemoji Mozilla"]

Other fonts can be added by copying them into the fonts/ directory in Camoufox, or by installing them on your system.

Note: It is highly recommended that you randomly pass custom fonts to the fonts config property to avoid font fingerprinting!

Font Metrics

Camoufox has a built in mechanism to prevent fingerprinting by font metrics & unicode glyphs:

This works by shifting the spacing of each letter by a random value between 0-0.1px.

Screen

Property	Status
screen.availHeight	✅
screen.availWidth	✅
screen.availTop	✅
screen.availLeft	✅
screen.height	✅
screen.width	✅
screen.colorDepth	✅
screen.pixelDepth	✅
screen.pageXOffset	✅
screen.pageYOffset	✅

Notes:

screen.colorDepth and screen.pixelDepth are synonymous.

Window

Property	Status	Notes
window.scrollMinX	✅
window.scrollMinY	✅
window.scrollMaxX	✅
window.scrollMaxY	✅
window.outerHeight	✅	Sets the window height.
window.outerWidth	✅	Sets the window width.
window.innerHeight	✅	Sets the inner viewport height.
window.innerWidth	✅	Sets the inner viewport width.
window.screenX	✅
window.screenY	✅
window.history.length	✅
window.devicePixelRatio	✅	Works, but not recommended.

Notes:

Setting the outer window viewport will cause some cosmetic defects to the Camoufox window if the user attempts to manually resize it. Under no circumstances will Camoufox allow the outer window viewport to be resized.

Document

Spoofing document.body has been implemented, but it is more advicable to set window.innerWidth and window.innerHeight instead.

Property	Status
document.body.clientWidth	✅
document.body.clientHeight	✅
document.body.clientTop	✅
document.body.clientLeft	✅

HTTP Headers

Camoufox can override the following network headers:

Property	Status
headers.User-Agent	✅
headers.Accept-Language	✅
headers.Accept-Encoding	✅

Notes:

If headers.User-Agent is not set, it will fall back to navigator.userAgent.

Geolocation & Intl

Property	Status	Description	Required Keys
geolocation:latitude	✅	Latitude to use.	`geolocation:longitude`
geolocation:longitude	✅	Longitude to use.	`geolocation:latitude`
geolocation:accuracy	✅	Accuracy in meters. This will be calculated automatically using the decminal percision of `geolocation:latitude` & `geolocation:longitude` if not set.
timezone	✅	Set a custom TZ timezone (e.g. "America/Chicago"). This will also change `Date()` to return the local time.
locale:language	✅	Spoof the Intl API, headers, and system language (e.g. "en")	`locale:region`
locale:region	✅	Spoof the Intl API, headers, and system region (e.g. "US").	`locale:language`
locale:script	✅	Set a custom script (e.g. "Latn"). Will be set automatically if not specified.

The Required Keys are keys that must also be set for the property to work.

Notes:

Location permission prompts will be accepted automatically if geolocation:latitude and geolocation:longitude are set.
timezone must be set to a valid TZ identifier. See here for a list of valid timezones.
locale:language & locale:region must be set to valid locale values. See here for a list of valid locale-region values.

WebRTC IP

Camoufox implements WebRTC IP spoofing at the protocol level by modifying ICE candidates and SDP before they're sent.

Property	Status	Description
webrtc:ipv4	✅	IPv4 address to use
webrtc:ipv6	✅	IPv6 address to use

Notes:

To completely disable WebRTC, set the media.peerconnection.enabled preference to false.

WebGL

WebGL in Camoufox

WebGL is disabled in Camoufox by default. To enable it, set the webgl.disabled Firefox preference to false.

WebGL being disabled typically doesn't trigger detection by WAFs, so you generally don't need to be concerned about it. Only use WebGL when it's absolutely necessary for your specific use case.

Because I don't have a dataset of WebGL fingerprints to rotate against, WebGL fingerprint rotation is not implemented in the Camoufox Python library. If you need to spoof WebGL, you can do so manually with the following properties.

Demo site

This repository includes a demo site (see here) that prints your browser's WebGL parameters. You can use this site to generate WebGL fingerprints for Camoufox from other devices.

Properties

Camoufox supports spoofing WebGL parameters, supported extensions, context attributes, and shader precision formats.

Note: Do NOT randomly assign values to these properties. WAFs hash your WebGL fingerprint and compare it against a dataset. Randomly assigning values will lead to detection as an unknown device.

Property	Description	Example
webGl:renderer	Spoofs the name of the unmasked WebGL renderer.	`"NVIDIA GeForce GTX 980, or similar"`
webGl:vendor	Spoofs the name of the unmasked WebGL vendor.	`"NVIDIA Corporation"`
webGl:supportedExtensions	An array of supported WebGL extensions (full list).	`["ANGLE_instanced_arrays", "EXT_color_buffer_float", "EXT_disjoint_timer_query", ...]`
webGl2:supportedExtensions	The same as `webGl:supportedExtensions`, but for WebGL2.	`["ANGLE_instanced_arrays", "EXT_color_buffer_float", "EXT_disjoint_timer_query", ...]`
webGl:contextAttributes	A dictionary of WebGL context attributes.	`{"alpha": true, "antialias": true, "depth": true, ...}`
webGl2:contextAttributes	The same as `webGl:contextAttributes`, but for WebGL2.	`{"alpha": true, "antialias": true, "depth": true, ...}`
webGl:parameters	A dictionary of WebGL parameters. Keys must be GL enums, and values are the values to spoof them as.	`{"2849": 1, "2884": false, "2928": [0, 1], ...}`
webGl2:parameters	The same as `webGl:parameters`, but for WebGL2.	`{"2849": 1, "2884": false, "2928": [0, 1], ...}`
webGl:parameters:blockIfNotDefined	If set to `true`, only the parameters in `webGl:parameters` will be allowed. Can be dangerous if not used correctly.	`true`/`false`
webGl2:parameters:blockIfNotDefined	If set to `true`, only the parameters in `webGl2:parameters` will be allowed. Can be dangerous if not used correctly.	`true`/`false`
webGl:shaderPrecisionFormats	A dictionary of WebGL shader precision formats. Keys are formatted as `"<shaderType>,<precisionType>"`.	`{"35633,36336": {"rangeMin": 127, "rangeMax": 127, "precision": 23}, ...}`
webGl2:shaderPrecisionFormats	The same as `webGL:shaderPrecisionFormats`, but for WebGL2.	`{"35633,36336": {"rangeMin": 127, "rangeMax": 127, "precision": 23}, ...}`
webGl:shaderPrecisionFormats:blockIfNotDefined	If set to `true`, only the shader percisions in `webGl:shaderPrecisionFormats` will be allowed.	`true`/`false`
webGl2:shaderPrecisionFormats:blockIfNotDefined	If set to `true`, only the shader percisions in `webGl2:shaderPrecisionFormats` will be allowed.	`true`/`false`

AudioContext

Camoufox can spoof the AudioContext sample rate, output latency, and max channel count.

Property	Status	Description
AudioContext:sampleRate	✅	Spoofs the AudioContext sample rate.
AudioContext:outputLatency	✅	Spoofs the AudioContext output latency.
AudioContext:maxChannelCount	✅	Spoofs the AudioContext max channel count.

Here is a testing site: https://audiofingerprint.openwpm.com/

Addons

In the Camoufox Python library, addons can be loaded with the addons parameter:

from camoufox.sync_api import Camoufox

with Camoufox(addons=['/path/to/addon', '/path/to/addon2']) as browser:
    page = browser.new_page()

Camoufox will automatically download and use the latest uBlock Origin with custom privacy/adblock filters, and B.P.C. by default to help with ad circumvention.

You can also exclude default addons with the exclude_addons parameter:

from camoufox.sync_api import Camoufox
from camoufox import DefaultAddons

with Camoufox(exclude_addons=[DefaultAddons.UBO, DefaultAddons.BPC]) as browser:
    page = browser.new_page()

Loading addons with the legacy launcher...

Addons can be loaded with the --addons flag.

Example:

./launcher --addons '["/path/to/addon", "/path/to/addon2"]'

Camoufox will automatically download and use the latest uBlock Origin with custom privacy/adblock filters, and B.P.C. by default to help with scraping.

You can also exclude default addons with the --exclude-addons flag:

./launcher --exclude-addons '["uBO", "BPC"]'

Miscellaneous (battery status, etc)

Property	Status	Description
pdfViewer	✅	Sets navigator.pdfViewerEnabled. Please keep this on though, many websites will flag a lack of pdfViewer as a headless browser.
battery:charging	✅	Spoofs the battery charging status.
battery:chargingTime	✅	Spoofs the battery charging time.
battery:dischargingTime	✅	Spoofs the battery discharging time.
battery:level	✅	Spoofs the battery level.

Patches

What changes were made?

Fingerprint spoofing

Navigator properties spoofing (device, browser, locale, etc.)
Support for emulating screen size, resolution, etc.
Spoof WebGL parameters, supported extensions, context attributes, and shader precision formats.
Spoof inner and outer window viewport sizes
Spoof AudioContext sample rate, output latency, and max channel count
Spoof device voices & playback rates
Network headers (Accept-Languages and User-Agent) are spoofed to match the navigator properties
WebRTC IP spoofing at the protocol level
Geolocation, timezone, and locale spoofing
Battery API spoofing
etc.

Stealth patches

Avoids main world execution leaks. All page agent javascript is sandboxed
Avoids frame execution context leaks
Fixes navigator.webdriver detection
Fixes Firefox headless detection via pointer type (#26)
Removed potentially leaking anti-zoom/meta viewport handling patches
Uses non-default screen & window sizes
Re-enable fission content isolations
Re-enable PDF.js
Other leaking config properties changed

Anti font fingerprinting

Automatically uses the correct system fonts for your User Agent
Bundled with Windows, Mac, and Linux system fonts
Prevents font metrics fingerprinting by randomly offsetting letter spacing

Playwright support

Custom implementation of Playwright for the latest Firefox
Various config patches to evade bot detection

Debloat/Optimizations

Stripped out/disabled many, many Mozilla services. Runs faster than the original Mozilla Firefox, and uses less memory (200mb)
Patches from LibreWolf & Ghostery to help remove telemetry & bloat
Debloat config from PeskyFox, LibreWolf, and others
Speed & network optimizations from FastFox
Removed all CSS animations
Minimalistic theming
etc.

Addons

Firefox addons can be loaded with the --addons flag
Added uBlock Origin with custom privacy filters
Addons are not allowed to open tabs
Addons are automatically enabled in Private Browsing mode
Addons are automatically pinned to the toolbar
Fixes DNS leaks with uBO prefetching

Stealth Performance

In Camoufox, all of Playwright's internal Page Agent Javascript is sandboxed and isolated. This makes it impossible for a page to detect the presence of Playwright through Javascript inspection.

Tests

Camoufox performs well against every major WAF I've tested. (Original test sites from Botright)

Test	Status
CreepJS	✔️ 71.5%. Successfully spoofs all OS predictions.
Rebrowser Bot Detector	✔️ All tests pass.
BrowserScan	✔️ 100%. Spoofs all geolocation & locale proxy detection.
reCaptcha Score	✔️
‣ nopecha.com	✔️
‣ recaptcha-demo.appspot.com	✔️ 0.9
‣ berstend.github.io	✔️ 0.9
DataDome	✔️
‣ DataDome bot bounty	✔️ All test sites pass.
‣ hermes.com	✔️
Imperva	✔️
‣ ticketmaster.es	✔️
Cloudflare	✔️
‣ Turnstile	✔️
‣ Interstitial	✔️
WebRTC IP Spoofing	✔️
‣ Browserleaks WebRTC	✔️ Spoofs public IP correctly.
‣ CreepJS WebRTC	✔️ Spoofs Host & STUN IP correctly.
‣ BrowserScan WebRTC	✔️ Spoofs Host & STUN IP correctly.
Font Fingerprinting	✔️
‣ Browserleaks Fonts	✔️ Rotates all metrics.
‣ CreepJS TextMetrics	✔️ Rotates all metrics.
Incolumitas	✔️ 0.8-1.0
SannySoft	✔️
Fingerprint.com	✔️
IpHey	✔️
Bet365	✔️

Camoufox does not fully support injecting Chromium fingerprints. Some WAFs (such as Interstitial) test for Spidermonkey engine behavior, which is impossible to spoof.

Playwright Usage

See here for documentation on Camoufox's Python interface.

It is strongly recommended to use the Camoufox Python library instead of the legacy launcher, which is now deprecated.

See legacy launcher usage (deprecated)

Camoufox is fully compatible with your existing Playwright code. You only have to change your browser initialization:

browser = pw.firefox.launch(
  executable_path='/path/to/camoufox/launch',  # Path to the Camoufox launcher
  args=['--config', '/path/to/config.json'],   # File path or JSON string
)

See full example script...

import asyncio
import json
from playwright.async_api import async_playwright

# Example config
CONFIG = {
 'window.outerHeight': 1056,
 'window.outerWidth': 1920,
 'window.innerHeight': 1008,
 'window.innerWidth': 1920,
 'window.history.length': 4,
 'navigator.userAgent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:125.0) Gecko/20100101 Firefox/125.0',
 'navigator.appCodeName': 'Mozilla',
 'navigator.appName': 'Netscape',
 'navigator.appVersion': '5.0 (Windows)',
 'navigator.oscpu': 'Windows NT 10.0; Win64; x64',
 'navigator.language': 'en-US',
 'navigator.languages': ['en-US'],
 'navigator.platform': 'Win32',
 'navigator.hardwareConcurrency': 12,
 'navigator.product': 'Gecko',
 'navigator.productSub': '20030107',
 'navigator.maxTouchPoints': 10,
}

async def main():
    async with async_playwright() as p:
        # Create a Firefox instance to the launcher
        browser = await p.firefox.launch(
          # Pass in the Camoufox launcher and config JSON
          executable_path='/path/to/camoufox/launch',
          args=['--config', json.dumps(CONFIG)],
          # Launch in headful mode
          headless=False
        )
        # Continue as normal
        page = await browser.new_page()
        await page.goto('https://abrahamjuliot.github.io/creepjs/')
        await asyncio.sleep(10)
        await browser.close()

if __name__ == "__main__":
    asyncio.run(main())

[!NOTE] The content below is intended for those interested in building & debugging Camoufox. For Playwright usage instructions, see here.

Build System

Overview

Here is a diagram of the build system, and its associated make commands:

graph TD
    FFSRC[Firefox Source] -->|make fetch| REPO

    subgraph REPO[Camoufox Repository]
        PATCHES[Fingerprint masking patches]
        ADDONS[uBlock & B.P.C.]
        DEBLOAT[Debloat/optimizations]
        SYSTEM_FONTS[Win, Mac, Linux fonts]
        JUGGLER[Patched Juggler]
    end

    subgraph Local
    REPO -->|make dir| PATCH[Patched Source]
    PATCH -->|make build| BUILD[Built]
    BUILD -->|make package-linux| LINUX[Linux Portable]
    BUILD -->|make package-windows| WIN[Windows Portable]
    BUILD -->|make package-macos| MAC[macOS Portable]
    end

This was originally based on the LibreWolf build system.

Build CLI

[!WARNING] Camoufox's build system is designed to be used in Linux. WSL will not work!

First, clone this repository with Git:

git clone --depth 1 https://github.com/daijro/camoufox
cd camoufox

Next, build the Camoufox source code with the following command:

make dir

After that, you have to bootstrap your system to be able to build Camoufox. You only have to do this one time. It is done by running the following command:

make bootstrap

Finally you can build and package Camoufox the following command:

python3 multibuild.py --target linux windows macos --arch x86_64 arm64 i686

CLI Parameters

Options:
  -h, --help            show this help message and exit
  --target {linux,windows,macos} [{linux,windows,macos} ...]
                        Target platforms to build
  --arch {x86_64,arm64,i686} [{x86_64,arm64,i686} ...]
                        Target architectures to build for each platform
  --bootstrap           Bootstrap the build system
  --clean               Clean the build directory before starting

Example:
$ python3 multibuild.py --target linux windows macos --arch x86_64 arm64

Using Docker

Camoufox can be built through Docker on all platforms.

Create the Docker image containing Firefox's source code:

docker build -t camoufox-builder .

Build Camoufox patches to a target platform and architecture:

docker run -v "$(pwd)/dist:/app/dist" camoufox-builder --target <os> --arch <arch>

How can I use my local ~/.mozbuild directory?

If you want to use the host's .mozbuild directory, you can use the following command instead to run the docker:

docker run \
  -v "$HOME/.mozbuild":/root/.mozbuild:rw,z \
  -v "$(pwd)/dist:/app/dist" \
  camoufox-builder \
  --target <os> \
  --arch <arch>

Docker CLI Parameters

Options:
  -h, --help            show this help message and exit
  --target {linux,windows,macos} [{linux,windows,macos} ...]
                        Target platforms to build
  --arch {x86_64,arm64,i686} [{x86_64,arm64,i686} ...]
                        Target architectures to build for each platform
  --bootstrap           Bootstrap the build system
  --clean               Clean the build directory before starting

Example:
$ docker run -v "$(pwd)/dist:/app/dist" camoufox-builder --target windows macos linux --arch x86_64 arm64 i686

Build artifacts will now appear written under the dist/ folder.

Development Tools

This repo comes with a developer UI under scripts/developer.py:

make edits

Patches can be edited, created, removed, and managed through here.

How to make a patch

In the developer UI, click Reset workspace.
Make changes in the camoufox-*/ folder as needed. You can test your changes with make build and make run.
After you're done making changes, click Write workspace to patch and save the patch file.

How to work on an existing patch

In the developer UI, click Edit a patch.
Select the patch you'd like to edit. Your workspace will be reset to the state of the selected patch.
After you're done making changes, hit Write workspace to patch and overwrite the existing patch file.

Leak Debugging

This is a flow chart demonstrating my process for determining leaks without deobfuscating WAF Javascript. The method incrementally reintroduces Camoufox's features into Firefox's source code until the testing site flags.

This process requires a Linux system and assumes you have Firefox build tools installed (see here).

See flow chart...

flowchart TD
    A[Start] --> B[Does website flag in the official Firefox?]
    B -->|Yes| C[Likely bad IP/rate-limiting. If the website fails on both headless and headful mode on the official Firefox distribution, the issue is not with the browser.]
    B -->|No| D["Run make ff-dbg(1) and build(2) a clean distribution of Firefox. Does the website flag in Firefox **headless** mode(4)?"]
    D -->|Yes| E["Does the website flag in headful mode(3) AND headless mode(4)?"]
    D -->|No| F["Open the developer UI(5), apply config.patch, then rebuild(2). Does the website still flag(3)?"]
    E -->|No| G["Enable privacy.resistFingerprinting in the config(6). Does the website still flag(3)?"]
    E -->|Yes| C
    G -->|No| H["In the config(6), enable FPP and start omitting overrides until you find the one that fixed the leak."]
    G -->|Yes| I[If you get to this point, you may need to deobfuscate the Javascript behind the website to identify what it's testing.]
    F -->|Yes| K["Open the developer UI, apply the playwright bootstrap patch, then rebuild. Does it still flag?"]
    F -->|No| J["Omit options from camoufox.cfg(6) and rerun(3) until you find the one causing the leak."]
    K -->|No| M[Juggler needs to be debugged to locate the leak.]
    K -->|Yes| L[The issue has nothing to do with Playwright. Apply the rest of the Camoufox patches one by one until the one causing the leak is found.]
    M --> I

Cited Commands

#	Command	Description
(1)	`make ff-dbg`	Setup vanilla Firefox with minimal patches.
(2)	`make build`	Build the source code.
(3)	`make run`	Runs the built browser.
(4)	`make run args="--headless https://test.com"`	Run a URL in headless mode. All redirects will be printed to the console to determine if the test passed.
(5)	`make edits`	Opens the developer UI. Allows the user to apply/undo patches, and see which patches are currently applied.
(6)	`make edit-cfg`	Edit camoufox.cfg in the default system editor.

Thanks

LibreWolf - Debloat patches & build system inspiration
BetterFox - Debloat & optimizations
Ghostery - Debloat reference
TOR Browser - Anti fingerprinting reference
Jamir-boop/minimalisticfox - Inspired Camoufox's minimalistic theming
nicoth-in/Dark-Space-Theme - Camoufox's dark theme
Playwright, Puppeteer/Juggler - Original Juggler implementation
CreepJS, Browserleaks, BrowserScan - Valuable leak testing sites
riflosnake/HumanCursor - Original human-like cursor movement algorithm

quickjs-ng/quickjs

2024-11-24T01:29:22Z

QuickJS, the Next Generation: a mighty JavaScript engine

⚡️ QuickJS - A mighty JavaScript engine

Overview

QuickJS is a small and embeddable JavaScript engine. It aims to support the latest ECMAScript specification.

This project is a fork of the original QuickJS project by Fabrice Bellard and Charlie Gordon, after it went dormant, with the intent of reigniting its development.

Getting started

Head over to the project website for instructions on how to get started and more documentation.

Authors

@bnoordhuis, @saghul, and many more contributors.

quickjs-ng/quickjs

2024-11-24T01:37:10Z

QuickJS, the Next Generation: a mighty JavaScript engine

⚡️ QuickJS - A mighty JavaScript engine

Overview

QuickJS is a small and embeddable JavaScript engine. It aims to support the latest ECMAScript specification.

This project is a fork of the original QuickJS project by Fabrice Bellard and Charlie Gordon, after it went dormant, with the intent of reigniting its development.

Getting started

Head over to the project website for instructions on how to get started and more documentation.

Authors

@bnoordhuis, @saghul, and many more contributors.

soedinglab/MMseqs2

2024-11-24T01:37:10Z

MMseqs2: ultra fast and sensitive search and clustering suite

MMseqs2: ultra fast and sensitive sequence search and clustering suite

MMseqs2 (Many-against-Many sequence searching) is a software suite to search and cluster huge protein and nucleotide sequence sets. MMseqs2 is free and open source software implemented in C++ for Linux, MacOS, and (as beta version, via cygwin) Windows. The software is designed to run on multiple cores and servers and exhibits very good scalability. MMseqs2 can run 10000 times faster than BLAST. At 100 times its speed it achieves almost the same sensitivity. It can perform profile searches with the same sensitivity as PSI-BLAST at over 400 times its speed.

Publications

Steinegger M and Soeding J. MMseqs2 enables sensitive protein sequence searching for the analysis of massive data sets. Nature Biotechnology, doi: 10.1038/nbt.3988 (2017).

Steinegger M and Soeding J. Clustering huge protein sequence sets in linear time. Nature Communications, doi: 10.1038/s41467-018-04964-5 (2018).

Mirdita M, Steinegger M and Soeding J. MMseqs2 desktop and local web server app for fast, interactive sequence searches. Bioinformatics, doi: 10.1093/bioinformatics/bty1057 (2019).

Mirdita M, Steinegger M, Breitwieser F, Soding J, Levy Karin E: Fast and sensitive taxonomic assignment to metagenomic contigs. Bioinformatics, doi: 10.1093/bioinformatics/btab184 (2021).

Kallenborn F, Chacon A, Hundt C, Sirelkhatim H, Didi K, Dallago C, Mirdita M, Schmidt B, Steinegger M: GPU-accelerated homology search with MMseqs2. bioRxiv, doi: 10.1101/2024.11.13.623350 (2024)

Documentation

The MMseqs2 user guide is available in our GitHub Wiki or as a PDF file (Thanks to pandoc!). The wiki also contains tutorials to learn how to use MMseqs2 with real data. For questions please open an issue on GitHub. Keep posted about MMseqs2/Linclust updates by following Martin on Twitter.

Installation

MMseqs2 can be used by compiling from source, downloading a statically compiled binary at mmseqs.com/latest, using Homebrew, conda or Docker.

# install by brew
brew install mmseqs2
# install via conda
conda install -c conda-forge -c bioconda mmseqs2
# install docker
docker pull ghcr.io/soedinglab/mmseqs2
# MMseqs2-GPU mostly-static AVX2 build requiring glibc >= 2.29 and nvidia driver >=525.60.13 (see below)
wget https://mmseqs.com/latest/mmseqs-linux-gpu.tar.gz; tar xvfz mmseqs-linux-gpu.tar.gz; export PATH=$(pwd)/mmseqs/bin/:$PATH
# static build with AVX2 (fastest)
wget https://mmseqs.com/latest/mmseqs-linux-avx2.tar.gz; tar xvfz mmseqs-linux-avx2.tar.gz; export PATH=$(pwd)/mmseqs/bin/:$PATH
# static build with SSE4.1
wget https://mmseqs.com/latest/mmseqs-linux-sse41.tar.gz; tar xvfz mmseqs-linux-sse41.tar.gz; export PATH=$(pwd)/mmseqs/bin/:$PATH
# static build with SSE2 (slowest, for very old systems)
wget https://mmseqs.com/latest/mmseqs-linux-sse2.tar.gz; tar xvfz mmseqs-linux-sse2.tar.gz; export PATH=$(pwd)/mmseqs/bin/:$PATH

MMseqs2 requires an AMD or Intel 64-bit system (check with uname -a | grep x86_64). We recommend using a system with at least the SSE4.1 instruction set (check by executing cat /proc/cpuinfo | grep sse4_1 on Linux or sysctl -a | grep machdep.cpu.features | grep SSE4.1 on MacOS). The AVX2 version is faster than SSE4.1, check if AVX2 is supported by executing cat /proc/cpuinfo | grep avx2 on Linux and sysctl -a | grep machdep.cpu.leaf7_features | grep AVX2 on MacOS. A SSE2 version is also available for very old systems. MMseqs2 also works on ARM64 systems and on PPC64LE systems with POWER8 ISA or newer.

[!NOTE] We recently added support for GPU-accelerated protein sequence and profile searches. This requires an NVIDIA GPU of the Ampere generation or newer for full speed, however, also works at reduced speed for Tesla-generation GPUs. Check the wiki for instructions on how to get started.

MMseqs2 comes with a bash command and parameter auto completion, which can be activated by adding the following to your $HOME/.bash_profile:

if [ -f /Path to MMseqs2/util/bash-completion.sh ]; then
    source /Path to MMseqs2/util/bash-completion.sh
fi

Getting started

We provide easy workflows to cluster, search and assign taxonomy. These easy workflows are a shorthand to deal directly with FASTA/FASTQ files as input and output. MMseqs2 provides many modules to transform, filter, execute external programs and search. However, these modules use the MMseqs2 database formats, instead of the FASTA/FASTQ format. For maximum flexibility, we recommend using MMseqs2 workflows and modules directly. Please read more about this in the documentation.

Cluster

For clustering, MMseqs2 easy-cluster and easy-linclust are available.

easy-cluster by default clusters the entries of a FASTA/FASTQ file using a cascaded clustering algorithm.

mmseqs easy-cluster examples/DB.fasta clusterRes tmp --min-seq-id 0.5 -c 0.8 --cov-mode 1

easy-linclust clusters the entries of a FASTA/FASTQ file. The runtime scales linearly with input size. This mode is recommended for huge datasets.

mmseqs easy-linclust examples/DB.fasta clusterRes tmp

Read more about the clustering format in our user guide.

Please adjust the clustering criteria and check if temporary directory provides enough free space. For disk space requirements, see the user guide.

Search

The easy-search workflow searches directly with a FASTA/FASTQ files against either another FASTA/FASTQ file or an already existing MMseqs2 database.

mmseqs easy-search examples/QUERY.fasta examples/DB.fasta alnRes.m8 tmp

It is also possible to pre-compute the index for the target database. This reduces overhead when searching repeatedly against the same database.

mmseqs createdb examples/DB.fasta targetDB
mmseqs createindex targetDB tmp
mmseqs easy-search examples/QUERY.fasta targetDB alnRes.m8 tmp

The databases workflow provides download and setup procedures for many public reference databases, such as the Uniref, NR, NT, PFAM and many more (see Downloading databases). For example, to download and search against a database containing the Swiss-Prot reference proteins run:

mmseqs databases UniProtKB/Swiss-Prot swissprot tmp
mmseqs easy-search examples/QUERY.fasta swissprot alnRes.m8 tmp

The speed and sensitivity of the search can be adjusted with -s parameter and should be adapted based on your use case (see setting sensitivity -s parameter). A very fast search would use a sensitivity of -s 1.0, while a very sensitive search would use a sensitivity of up to -s 7.0. A detailed guide how to speed up searches is here.

The output can be customized with the --format-output option e.g. --format-output "query,target,qaln,taln" returns the query and target accession and the pairwise alignments in tab separated format. You can choose many different output columns.

❗ easy-search in default computes the sequence identity by dividing the number of identical residues by the alignment length (numIdentical/alnLen). However, search estimates the identity in default. To output real sequence identity use --alignment-mode 3 or -a.

Taxonomy

The easy-taxonomy workflow can be used to assign sequences taxonomical labels. It performs a search against a sequence database with taxonomy information (seqTaxDb), chooses the most representative sets of aligned target sequences according to different strategies (according to --lca-mode) and computes the lowest common ancestor among those.

mmseqs createdb examples/DB.fasta targetDB
mmseqs createtaxdb targetDB tmp
mmseqs createindex targetDB tmp
mmseqs easy-taxonomy examples/QUERY.fasta targetDB alnRes tmp

By default, createtaxdb assigns a Uniprot accession to a taxonomical identifier to every sequence and downloads the NCBI taxonomy. We also support BLAST, SILVA or custom taxonomical databases. Many common taxonomic reference databases can be easily downloaded and set up by the databases workflow.

Read more about the taxonomy format and the classification in our user guide.

Supported search modes

MMseqs2 provides many additional search modes:

Iterative sequences-profile searches (like PSI-BLAST) with the --num-iterations parameter
Translated searches of nucleotides against proteins (blastx), proteins against nucleotides (tblastn) or nucleotide against nucleotide (tblastx)
Iterative increasing sensitivity searches to find only the best hits faster
Taxonomic assignment using 2bLCA or LCA
Fast ungapped alignment searches to find very similar sequence matches
Very fast and sensitive searches against profile databases such as the PFAM
Reciprocal best hits search
Web search API and user interface

Many modes can also be combined. You can, for example, do a translated nucleotide against protein profile search.

Memory requirements

MMseqs2 minimum memory requirements for cluster or linclust is 1 byte per sequence residue, search needs 1 byte per target residue. Sequence databases can be compressed using the --compress flag, DNA sequences can be reduced by a factor of ~3.5 and proteins by ~1.7.

MMseqs2 checks the available system memory and automatically divides the target database in parts that fit into memory. Splitting the database will increase the runtime slightly. It is possible to control the memory usage using --split-memory-limit.

How to run MMseqs2 on multiple servers using MPI

MMseqs2 can run on multiple cores and servers using OpenMP and Message Passing Interface (MPI). MPI assigns database splits to each compute node, which are then computed with multiple cores (OpenMP).

Make sure that MMseqs2 was compiled with MPI by using the -DHAVE_MPI=1 flag (cmake -DHAVE_MPI=1 -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=. ..). Our precompiled static version of MMseqs2 cannot use MPI. The version string of MMseqs2 will have a -MPI suffix, if it was built successfully with MPI support.

To search with multiple servers, call the search or cluster workflow with the MPI command exported in the RUNNER environment variable. The databases and temporary folder have to be shared between all nodes (e.g. through NFS):

RUNNER="mpirun -pernode -np 42" mmseqs search queryDB targetDB resultDB tmp

Contributors

MMseqs2 exists thanks to all the people who contribute.

tmux/tmux

2024-11-24T01:37:10Z

tmux source code

Welcome to tmux!

tmux is a terminal multiplexer: it enables a number of terminals to be created, accessed, and controlled from a single screen. tmux may be detached from a screen and continue running in the background, then later reattached.

This release runs on OpenBSD, FreeBSD, NetBSD, Linux, macOS and Solaris.

Dependencies

tmux depends on libevent 2.x, available from this page.

It also depends on ncurses, available from this page.

To build tmux, a C compiler (for example gcc or clang), make, pkg-config and a suitable yacc (yacc or bison) are needed.

Installation

Binary packages

Some platforms provide binary packages for tmux, although these are sometimes out of date. Examples are listed on this page.

From release tarball

To build and install tmux from a release tarball, use:

./configure && make
sudo make install

tmux can use the utempter library to update utmp(5), if it is installed - run configure with --enable-utempter to enable this.

For more detailed instructions on building and installing tmux, see this page.

From version control

To get and build the latest from version control - note that this requires autoconf, automake and pkg-config:

git clone https://github.com/tmux/tmux.git
cd tmux
sh autogen.sh
./configure && make

Contributing

Bug reports, feature suggestions and especially code contributions are most welcome. Please send by email to:

tmux-users@googlegroups.com

Or open a GitHub issue or pull request. Please read this document before opening an issue.

There is a list of suggestions for contributions. Please feel free to ask on the mailing list if you're thinking of working on something or need further information.

Documentation

For documentation on using tmux, see the tmux.1 manpage. View it from the source tree with:

nroff -mdoc tmux.1|less

A small example configuration is in example_tmux.conf.

And a bash(1) completion file at:

https://github.com/imomaliev/tmux-bash-completion

For debugging, run tmux with -v or -vv to generate server and client log files in the current directory.

Support

The tmux mailing list for general discussion and bug reports is:

https://groups.google.com/forum/#!forum/tmux-users

Subscribe by sending an email to:

tmux-users+subscribe@googlegroups.com

Losses/rune

2024-11-23T01:29:50Z

Experience timeless melodies with a music player that blends classic design with modern technology.

Rune

The player that blends classic design with modern technology.

https://github.com/user-attachments/assets/7c56e9ac-1e20-405b-b281-dce471870b66

Introduction

Rune Player is a music player that offers audio analysis and recommendation features. It introduces a new, modern music management paradigm to enhance your experience.

Motivation

Rune is a UX experiment inspired by the question: What if Zune[^1] had continued to evolve? Using a modern tech stack (Flutter + Rust), Rune captures the essence of Zune, drawing from the design highlights of various Windows products since the Windows XP era, including Windows Mobile and Windows Media Center[^1].

The motivation behind Rune is to provide a modernized audio listening and management experience. With the rise of streaming services, localized music players have become less common, and many well-known media players have stagnated. Rune aims to offer a clean, consistent, and efficient audio playback experience.

Unique Features

Distinctive Design: Rune boasts a unique design style.
Audio Analysis and Recommendations: Users can analyze their entire music library to receive recommendations based on tracks, albums, or playlists.
Dynamic "Mix" Feature: Users can create dynamic playlists based on customizable rules, such as:
- "Similar to this album"
- "Top 100 most played tracks"
- "Tracks similar to my favorites"
- "Playlists including specific artists"
These mixes automatically update as users listen to and add new tracks.

Installation and Running

Rune is still in the early stages of development and does not provide pre-compiled binaries. However, you can set up a development environment by following the compiling instructions.

Contributing

We're thrilled you're interested in contributing. Before you dive in, please take a moment to review these key points to ensure smooth collaboration. For detailed instructions, please refer to the full Contributing Guide.

Language Requirement: To facilitate clear communication across all developers, all contributions, including issues and pull requests, must be submitted in English. If you are not confident in your English proficiency, consider using a language model for assistance.
Feature Requests: As Rune is in the early stages of development, we are currently not accepting feature requests.
Feature Implementation: If you have a feature proposal, please reach out to the development team for a preliminary discussion to ensure it aligns with Rune's vision.
Documentation: Collaboration is conducted exclusively in English. While we do not accept pull requests for translating the README or other development documentation, contributions for translating Rune itself are welcome.

Acknowledgments

We extend our gratitude to the open-source project Meyda for enabling the audio analysis functionality. We also thank the countless developers in the Rust and Flutter ecosystems for making Rune possible.

License

This project is licensed under the MPL License.

[^1]: All mentioned Microsoft products are trademarks of Microsoft. This project is not affiliated with Microsoft, and the founders of this project are not Microsoft employees.

videah/SkyBridge

2024-11-24T01:37:59Z

A work in progress bridge/proxy that lets you use Mastodon apps with Bluesky

SkyBridge

A work in progress bridge/proxy that allows you to use Mastodon apps with Bluesky.

SkyBridge attempts to convert Mastodon API calls to Bluesky API calls, and tries to implement enough of the Mastodon API that apps will be happy connecting to it.

Functionality is very basic at the moment, and there's bound to be a few bugs. Don't expect this to be your daily driver just yet!

Currently only being tested with Ivory on iOS and macOS, your mileage may vary with other apps at the moment. PRs and issues are welcome, we want to support as many apps as possible.

If you find this project useful please consider donating, it really helps a lot!

Getting Started

In order to run SkyBridge you will need the Dart SDK installed on your system.

You will also need the Dart Frog CLI installed to run a development server. You can install it with the following command:

# 📦 Install the dart_frog cli from pub.dev
dart pub global activate dart_frog_cli

Some environment variables need to be set before you can run SkyBridge. You can set them in a .env file in the root of the project. You can copy the .env.example file to get started.

# 📝 Copy and edit the example .env file
cp .env.example .env
open .env

Once that's done you can start a development server with the following command:

# 📥 Clone the repo
git clone https://github.com/videah/skybridge.git
cd skybridge
dart pub get

# 🏁 Start the dev server
dart_frog dev

Self Hosting

The instance of SkyBridge hosted at skybridge.fly.dev is provided as a free public service but currently faces heavy rate limiting from Bluesky due to all the requests coming from a single IPv4 address. If you want a more consistent experience you can host your own instance to avoid this.

Docker

The easiest way to run SkyBridge yourself is with Docker. The image videah/skybridge is kept up to date with the main branch of this repo.

You can use the docker-compose.yml file in the root of the project to get started. Simply change the environment variables in the file, and tweak it to suit your setup. You probably want to stick a reverse proxy like nginx or caddy in front of it.

Fly.io

The public instance of SkyBridge is hosted on Fly.io. For a single user it is likely possible to host an instance here for free. A fly.toml file is included in the root of the project to help you get started.

Credits

Huge thanks to Ninji for their BirdBridge project which was a big help and inspiration for this project!

Thank you to Shinya Kato for atproto.dart which powers this project!

millejoh/emacs-ipython-notebook

2024-11-24T01:30:38Z

Jupyter notebook client in Emacs

========================================================== EIN -- Emacs IPython Notebook |build-status| |melpa-dev|

.. image:: https://github.com/dickmao/emacs-ipython-notebook/blob/master/thumbnail.png :target: https://youtu.be/8VzWc9QeOxE :alt: Kaggle Notebooks in AWS

Emacs IPython Notebook (EIN), despite its name, is a jupyter client for all languages. It does not work under non-WSL Windows environments.

As of 2023, EIN has been sunset for a number of years having been unable to keep up with jupyter's web-first ecosystem. Even during its heyday EIN never fully reconciled emac's monolithic buffer architecture to the notebook's by-cell discretization, leaving gaping functional holes like crippled undo.

Certainly in 2012 when jupyter was much smaller, an emacs client made perfect sense. With many years of hindsight, it's now clear the json-driven, git-averse notebook format is anathema to emacs's plain text ethos.

.. |build-status| image:: https://github.com/millejoh/emacs-ipython-notebook/workflows/CI/badge.svg :target: https://github.com/millejoh/emacs-ipython-notebook/actions :alt: Build Status .. |melpa-dev| image:: https://melpa.org/packages/ein-badge.svg :target: http://melpa.org/#/ein :alt: MELPA current version .. _Jupyter: http://jupyter.org .. _Babel: https://orgmode.org/worg/org-contrib/babel/intro.html .. _Org: https://orgmode.org .. _[tkf]: http://tkf.github.io .. _[gregsexton]: https://github.com/gregsexton/ob-ipython

Install

As described in Getting started_, ensure melpa's whereabouts in init.el or .emacs::

(add-to-list 'package-archives '("melpa" . "https://melpa.org/packages/"))

Then

M-x package-install RET ein RET

Alternatively, directly clone this repo and make install.

For jupyterlab 3.0+, reconfigure the subcommand from "notebook" to "server".

M-x customize-option RET ein:jupyter-server-use-subcommand RET

Usage

Start EIN using ONE of the following:

Open an .ipynb file, press C-c C-o, or,
M-x ein:run launches a jupyter process from emacs, or,
M-x ein:login to a running jupyter server, or,

M-x ein:stop prompts to halt local and remote jupyter services.

Alternatively, ob-ein_.

.. _Cask: https://cask.readthedocs.io/en/latest/guide/installation.html .. _Getting started: http://melpa.org/#/getting-started

FAQ

How do I...

... report a bug? Note EIN is tested only for released GNU Emacs versions 26.3 and later. Pre-release versions will not work.

First try emacs -Q -f package-initialize -f ein:dev-start-debug and reproduce the bug. The -Q skips any user configuration that might interfere with EIN.

Then file an issue using M-x ein:dev-bug-report-template.

... display images inline? We find inserting images into emacs disruptive, and so default to spawning an external viewer. To override this, ::

  M-x customize-group RET ein
  Ein:Output Area Inlined Images

... configure the external image viewer? ::

  M-x customize-group RET mailcap
  Mailcap User Mime Data

On a typical Linux system, one might configure a viewer for MIME Type image/png as a shell command convert %s -background white -alpha remove -alpha off - | display -immutable.

... get IDE-like behavior? You can't. EIN's architecture is fundamentally incompatible with LSP.

.. _Issues: https://github.com/millejoh/emacs-ipython-notebook/issues .. _prevailing documentation: http://millejoh.github.io/emacs-ipython-notebook .. _spacemacs layer: https://github.com/syl20bnr/spacemacs/tree/master/layers/%2Blang/ipython-notebook .. _company-mode: https://github.com/company-mode/company-mode .. _jupyterhub: https://github.com/jupyterhub/jupyterhub .. _elpy: https://melpa.org/#/elpy .. _math-preview: https://gitlab.com/matsievskiysv/math-preview .. _program modes: https://www.gnu.org/software/emacs/manual/html_node/emacs/Program-Modes.html .. _undo boundaries: https://www.gnu.org/software/emacs/manual/html_node/elisp/Undo.html

ob-ein

Configuration:

M-x customize-group RET org-babel Org Babel Load Languages: Insert (ein . t) For example, '((emacs-lisp . t) (ein . t))

Snippet:

#+BEGIN_SRC ein-python :session localhost import numpy, math, matplotlib.pyplot as plt %matplotlib inline x = numpy.linspace(0, 2*math.pi) plt.plot(x, numpy.sin(x)) #+END_SRC

The :session is the notebook url, e.g., http://localhost:8888/my.ipynb, or simply localhost, in which case org evaluates anonymously. A port may also be specified, e.g., localhost:8889.

Language can be ein-python, ein-r, or ein-julia. The relevant jupyter kernel_ must be installed before use. Additional languages can be configured via::

M-x customize-group RET ein Ob Ein Languages

.. _polymode: https://github.com/polymode/polymode .. _ob-ipython: https://github.com/gregsexton/ob-ipython .. _scimax: https://github.com/jkitchin/scimax .. _jupyter kernel: https://github.com/jupyter/jupyter/wiki/Jupyter-kernels

.. _gat utility: https://dickmaogat.readthedocs.io/en/latest/install.html .. _gat usage: https://dickmaogat.readthedocs.io/en/latest/usage.html .. _batch mode: https://nbconvert.readthedocs.io/en/latest/execute_api.html .. _dickmao/Kaggler: https://github.com/dickmao/Kaggler/tree/gcspath#importing-datasets

Keymap (C-h m)

Key Binding

C- ein:worksheet-goto-next-input-km C- ein:worksheet-goto-prev-input-km M-S- ein:worksheet-execute-cell-and-insert-below-km M- ein:worksheet-not-move-cell-down-km M- ein:worksheet-not-move-cell-up-km

C-x C-s ein:notebook-save-notebook-command-km C-x C-w ein:notebook-rename-command-km

M-RET ein:worksheet-execute-cell-and-goto-next-km M-, ein:pytools-jump-back-command M-. ein:pytools-jump-to-source-command

C-c C-a ein:worksheet-insert-cell-above-km C-c C-b ein:worksheet-insert-cell-below-km C-c C-c ein:worksheet-execute-cell-km C-u C-c C-c ein:worksheet-execute-all-cells C-c C-e ein:worksheet-toggle-output-km C-c C-f ein:file-open-km C-c C-k ein:worksheet-kill-cell-km C-c C-l ein:worksheet-clear-output-km C-c RET ein:worksheet-merge-cell-km C-c C-n ein:worksheet-goto-next-input-km C-c C-o ein:notebook-open-km C-c C-p ein:worksheet-goto-prev-input-km C-c C-q ein:notebook-kill-kernel-then-close-command-km C-c C-r ein:notebook-reconnect-session-command-km C-c C-s ein:worksheet-split-cell-at-point-km C-c C-t ein:worksheet-toggle-cell-type-km C-c C-u ein:worksheet-change-cell-type-km C-c C-v ein:worksheet-set-output-visibility-all-km C-c C-w ein:worksheet-copy-cell-km C-c C-y ein:worksheet-yank-cell-km C-c C-z ein:notebook-kernel-interrupt-command-km C-c C-S-l ein:worksheet-clear-all-output-km C-c C-# ein:notebook-close-km C-c C-$ ein:tb-show-km C-c C-/ ein:notebook-scratchsheet-open-km C-c C-; ein:shared-output-show-code-cell-at-point-km C-c ein:worksheet-move-cell-down-km C-c ein:worksheet-move-cell-up-km

C-c C-x C-r ein:notebook-restart-session-command-km

C-c M-w ein:worksheet-copy-cell-km

This is a minor mode. If called interactively, toggle the ‘Ein:Notebook mode’ mode. If the prefix argument is positive, enable the mode, and if it is zero or negative, disable the mode.

If called from Lisp, toggle the mode if ARG is ‘toggle’. Enable the mode if ARG is nil, omitted, or is a positive number. Disable the mode if ARG is a negative number.

To check whether the minor mode is enabled in the current buffer, evaluate ‘ein:notebook-mode’.

The mode’s hook is called both when the mode is enabled and when it is disabled.

amir20/dozzle

2024-11-24T01:38:58Z

Realtime log viewer for docker containers.

Dozzle - dozzle.dev

Dozzle is a small lightweight application with a web based interface to monitor Docker logs. It doesn’t store any log files. It is for live monitoring of your container logs only.

https://github.com/user-attachments/assets/66a7b4b2-d6c9-4fca-ab04-aef6cd7c0c31

Features

Intelligent fuzzy search for container names 🤖
Search logs using regex 🔦
Search logs using SQL queries 📊
Small memory footprint 🏎
Split screen for viewing multiple logs
Live stats with memory and CPU usage
Multi-user authentication with support for proxy forward authorization 🚨
Swarm mode support 🐳
Agent mode for monitoring multiple Docker hosts 🕵️‍♂️
Dark mode 🌙

Dozzle has been tested with hundreds of containers. However, it doesn't support offline searching. Products like Loggly, Papertrail or Kibana are more suited for full search capabilities.

Getting Started

Dozzle is a small container (7 MB compressed). Pull the latest release with:

$ docker pull amir20/dozzle:latest

Running Dozzle

The simplest way to use dozzle is to run the docker container. Also, mount the Docker Unix socket with --volume to /var/run/docker.sock:

$ docker run --name dozzle -d --volume=/var/run/docker.sock:/var/run/docker.sock -p 8080:8080 amir20/dozzle:latest

Dozzle will be available at http://localhost:8080/.

Here is the Docker Compose file:

services:
  dozzle:
    container_name: dozzle
    image: amir20/dozzle:latest
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    ports:
      - 8080:8080

For advanced options like authentication, remote hosts or common questions see documentation at dozzle.dev.

Swarm Mode

Dozzle works with Docker Swarm mode. You can run Dozzle as a global service with:

$ docker service create --name dozzle --env DOZZLE_MODE=swarm --mode global --mount type=bind,source=/var/run/docker.sock,target=/var/run/docker.sock -p 8080:8080 amir20/dozzle:latest

See the Swarm Mode documentation for more details.

Agent Mode

Dozzle can be used to monitor multiple Docker hosts. You can run Dozzle in agent mode with:

$ docker run -v /var/run/docker.sock:/var/run/docker.sock -p 7007:7007 amir20/dozzle:latest agent

See the Agent Mode documentation for more details.

Technical Details

Dozzle users automatic API negotiation which works with most Docker configurations. Dozzle also works with Colima and Podman.

Installation on podman

By default Podman doesn't have a background process but you can enable this for Dozzle to work.

Verify first if your podman installation has enabled remote socket:

podman info

When you get under the key remote socket output like this, its already enabled:

  remoteSocket:
    exists: true
    path: /run/user/1000/podman/podman.sock

If it's not enabled please follow this tutorial to enable it.

Once you have the podman remote socket you can run Dozzle on podman.

podman run --volume=/run/user/1000/podman/podman.sock:/var/run/docker.sock -d -p 8080:8080 amir20/dozzle:latest

Additionally you have to create a fake engine-id to prevent host not found errors. Podman doesn't generate an engine-id like Docker by itself due to its daemonless architecture.

Under /var/lib/docker create a file named engine-id. On a system with Podman you will have to create the folder path as well. Inside the file place the UUID, for instance using uuidgen > engine-id. After that the file should have an identifier that looks like this: b9f1d7fc-b459-4b6e-9f7a-e3d1cd2e14a9.

For more details check Podman Infos or the FAQ

Security

Dozzle supports file based authentication and forward proxy like Authelia. These are documented at https://dozzle.dev/guide/authentication.

Analytics collected

Dozzle collects anonymous user configurations using Google Analytics. Why? Dozzle is an open source project with no funding. As a result, there is no time to do user studies of Dozzle. Analytics is collected to prioritize features and fixes based on how people use Dozzle. This data is completely public and can be viewed live using Data Studio dashboard.

If you do not want to be tracked at all, see the --no-analytics flag below.

Environment variables and configuration

Dozzle follows the 12-factor model. Configurations can use the CLI flags or environment variables. The table below outlines all supported options and their respective env vars.

Flag	Env Variable	Default
`--addr`	`DOZZLE_ADDR`	`:8080`
`--base`	`DOZZLE_BASE`	`/`
`--hostname`	`DOZZLE_HOSTNAME`	`""`
`--level`	`DOZZLE_LEVEL`	`info`
`--auth-provider`	`DOZZLE_AUTH_PROVIDER`	`none`
`--auth-header-user`	`DOZZLE_AUTH_HEADER_USER`	`Remote-User`
`--auth-header-email`	`DOZZLE_AUTH_HEADER_EMAIL`	`Remote-Email`
`--auth-header-name`	`DOZZLE_AUTH_HEADER_NAME`	`Remote-Name`
`--enable-actions`	`DOZZLE_ENABLE_ACTIONS`	false
`--filter`	`DOZZLE_FILTER`	`""`
`--no-analytics`	`DOZZLE_NO_ANALYTICS`	false
`--mode`	`DOZZLE_MODE`	`server`
`--remote-host`	`DOZZLE_REMOTE_HOST`
`--remote-agent`	`DOZZLE_REMOTE_AGENT`

Support

There are many ways you can support Dozzle:

Use it! Write about it! Star it! If you love Dozzle, drop me a line and tell me what you love.
Blog about Dozzle to spread the word. If you are good at writing send PRs to improve the documentation at dozzle.dev
Sponsor my work at https://www.buymeacoffee.com/amirraminfar

License

MIT

Building

To build and test locally:

Install NodeJs and pnpm.
Install Go.
Install tools with make tools.
Install node modules pnpm install.
Run make dev to start a development server with hot reload.

kubernetes-sigs/kueue

2024-11-24T01:38:58Z

Kubernetes-native Job Queueing

Kueue

Kueue is a set of APIs and controller for job queueing. It is a job-level manager that decides when a job should be admitted to start (as in pods can be created) and when it should stop (as in active pods should be deleted).

Read the overview to learn more.

Features overview

Job management: Support job queueing based on priorities with different strategies: StrictFIFO and BestEffortFIFO.
Resource management: Support resource fair sharing and preemption with a variety of policies between different tenants.
Dynamic resource reclaim: A mechanism to release quota as the pods of a Job complete.
Resource flavor fungibility: Quota borrowing or preemption in ClusterQueue and Cohort.
Integrations: Built-in support for popular jobs, e.g. BatchJob, Kubeflow training jobs, RayJob, RayCluster, JobSet, plain Pod.
System insight: Build-in prometheus metrics to help monitor the state of the system, as well as Conditions.
AdmissionChecks: A mechanism for internal or external components to influence whether a workload can be admitted.
Advanced autoscaling support: Integration with cluster-autoscaler's provisioningRequest via admissionChecks.
All-or-nothing with ready Pods: A timeout-based implementation of All-or-nothing scheduling.
Partial admission: Allows jobs to run with a smaller parallelism, based on available quota, if the application supports it.

Production Readiness status

✔️ API version: v1beta1, respecting Kubernetes Deprecation Policy
✔️ Up-to-date documentation.
✔️ Test Coverage:
- ✔️ Unit Test testgrid.
- ✔️ Integration Test testgrid
- ✔️ E2E Tests for Kubernetes 1.28, 1.29, 1.30, 1.31, on Kind.
✔️ Scalability verification via performance tests.
✔️ Monitoring via metrics.
✔️ Security: RBAC based accessibility.
✔️ Stable release cycle(2-3 months) for new features, bugfixes, cleanups.
✔️ Adopters running on production.

Based on community feedback, we continue to simplify and evolve the API to address new use cases.

Installation

Requires Kubernetes 1.25 or newer.

To install the latest release of Kueue in your cluster, run the following command:

kubectl apply --server-side -f https://github.com/kubernetes-sigs/kueue/releases/download/v0.9.1/manifests.yaml

The controller runs in the kueue-system namespace.

Read the installation guide to learn more.

Usage

A minimal configuration can be set by running the examples:

kubectl apply -f examples/admin/single-clusterqueue-setup.yaml

Then you can run a job with:

kubectl create -f examples/jobs/sample-job.yaml

Learn more about:

Kueue concepts.
Common and advanced tasks.

Architecture

Learn more about the architecture of Kueue with the following design docs:

bit.ly/kueue-apis discusses the API proposal and a high level description of how Kueue operates. Join the mailing list to get document access.
bit.ly/kueue-controller-design presents the detailed design of the controller.

Roadmap

This is a high-level overview of the main priorities for 2023, in expected order of release:

Cooperative preemption support for workloads that implement checkpointing #477
Flavor assignment strategies, e.g. minimizing cost vs minimizing borrowing #312
Integration with cluster-autoscaler for guaranteed resource provisioning
Integration with common custom workloads #74:
- Kubeflow (TFJob, MPIJob, etc.)
- Spark
- Ray
- Workflows (Tekton, Argo, etc.)

These are features that we aim to have in the long-term, in no particular order:

Budget support #28
Dashboard for management and monitoring for administrators
Multi-cluster support

Community, discussion, contribution, and support

Learn how to engage with the Kubernetes community on the community page and the contributor's guide.

You can reach the maintainers of this project at:

Code of conduct

Participation in the Kubernetes community is governed by the Kubernetes Code of Conduct.

chaitin/SafeLine

2024-11-24T01:38:58Z

serve as a reverse proxy to protect your web services from attacks and exploits.

SafeLine - Make your web apps secure

🏠 Website | 📖 Docs | 🔍 Live Demo | 🙋‍♂️ Discord | 中文版

👋 INTRODUCTION

SafeLine is a self-hosted WAF(Web Application Firewall) to protect your web apps from attacks and exploits.

A web application firewall helps protect web apps by filtering and monitoring HTTP traffic between a web application and the Internet. It typically protects web apps from attacks such as SQL injection, XSS, code injection, os command injection, CRLF injection, ldap injection, xpath injection, RCE, XXE, SSRF, path traversal, backdoor, bruteforce, http-flood, bot abused, among others.

💡 How It Works

By deploying a WAF in front of a web application, a shield is placed between the web application and the Internet. While a proxy server protects a client machine’s identity by using an intermediary, a WAF is a type of reverse-proxy, protecting the server from exposure by having clients pass through the WAF before reaching the server.

A WAF protects your web apps by filtering, monitoring, and blocking any malicious HTTP/S traffic traveling to the web application, and prevents any unauthorized data from leaving the app. It does this by adhering to a set of policies that help determine what traffic is malicious and what traffic is safe. Just as a proxy server acts as an intermediary to protect the identity of a client, a WAF operates in similar fashion but acting as an reverse proxy intermediary that protects the web app server from a potentially malicious client.

its core capabilities include:

Defenses for web attacks
Proactive bot abused defense
HTML & JS code encryption
IP-based rate limiting
Web Access Control List

⚡️ Screenshots

Get Live Demo

🔥 FEATURES

List of the main features as follows:

Block Web Attacks
- It defenses for all of web attacks, such as SQL injection, XSS, code injection, os command injection, CRLF injection, XXE, SSRF, path traversal and so on.
Rate Limiting
- Defend your web apps against DoS attacks, bruteforce attempts, traffic surges, and other types of abuse by throttling traffic that exceeds defined limits.
Anti-Bot Challenge
- Anti-Bot challenges to protect your website from bot attacks, humen users will be allowed, crawlers and bots will be blocked.
Authentication Challenge
- When authentication challenge turned on, visitors need to enter the password, otherwise they will be blocked.
Dynamic Protection
- When dynamic protection turned on, html and js codes in your web server will be dynamically encrypted by each time you visit.

🧩 Showcases

	Legitimate User	Malicious User
`Block Web Attacks`
`Rate Limiting`
`Anti-Bot Challenge`
`Auth Challenge`
`HTML Dynamic Protection`
`JS Dynamic Protection`

🚀 Quickstart

[!WARNING] 中国大陆用户安装国际版可能会导致无法连接云服务，请查看中文版安装文档

📦 Installing

Information on how to install SafeLine can be found in the Install Guide

⚙️ Protecting Web Apps

to see Configuration

📋 More Informations

Effect Evaluation

Metric	ModSecurity, Level 1	CloudFlare, Free	SafeLine, Balance	SafeLine, Strict
Total Samples	33669	33669	33669	33669
Detection	69.74%	10.70%	71.65%	76.17%
False Positive	17.58%	0.07%	0.07%	0.22%
Accuracy	82.20%	98.40%	99.45%	99.38%

Is SafeLine Production-Ready?

Yes, SafeLine is production-ready.

Over 180,000 installations worldwide
Protecting over 1,000,000 Websites
Handling over 30,000,000,000 HTTP Requests Daily

🙋‍♂️ Community

Join our Discord to get community support, the core team members are identified by the STAFF role in Discord.

channel #feedback: for new features discussion.
channel #FAQ: for FAQ.
channel #general: for any other questions.

Several contact options exist for our community, the primary one being Discord. These are in addition to GitHub issues for creating a new issue.

💪 PRO Edition

Coming soon!

📝 License

See LICENSE for details.

EbookFoundation/free-programming-books

2024-11-23T01:31:11Z

📚 Freely available programming books

List of Free Learning Resources In Many Languages

Search the list at https://ebookfoundation.github.io/free-programming-books-search/ .

This page is available as an easy-to-read website. Access it by clicking on .

Intro

This list was originally a clone of StackOverflow - List of Freely Available Programming Books with contributions from Karan Bhangui and George Stocker.

The list was moved to GitHub by Victor Felder for collaborative updating and maintenance. It has grown to become one of GitHub's most popular repositories.

The Free Ebook Foundation now administers the repo, a not-for-profit organization devoted to promoting the creation, distribution, archiving, and sustainability of free ebooks. Donations to the Free Ebook Foundation are tax-deductible in the US.

How To Contribute

Please read CONTRIBUTING. If you're new to GitHub, welcome! Remember to abide by our adapted from Code of Conduct too (translations also available).

Click on these badges to see how you might be able to help:

How To Share

Share on Facebook
Share on LinkedIn
Share on Mastodon/Fediverse
Share on Telegram
Share on 𝕏 (Twitter)

Resources

This project lists books and other resources grouped by genres:

Books

English, By Programming Language

English, By Subject

Other Languages

Cheat Sheets

All Languages

Free Online Courses

Interactive Programming Resources

Problem Sets and Competitive Programming

Problem Sets

Podcast - Screencast

Free Podcasts and Screencasts:

Programming Playgrounds

Write, compile, and run your code within a browser. Try it out!

Translations

Volunteers have translated many of our Contributing, How-to, and Code of Conduct documents into languages covered by our lists.

English
... More languages ...

You might notice that there are some missing translations here - perhaps you would like to help out by contributing a translation?

License

Each file included in this repository is licensed under the CC BY License.

EbookFoundation/free-programming-books

2024-11-24T01:39:20Z

📚 Freely available programming books

List of Free Learning Resources In Many Languages

Search the list at https://ebookfoundation.github.io/free-programming-books-search/ .

This page is available as an easy-to-read website. Access it by clicking on .

Intro

This list was originally a clone of StackOverflow - List of Freely Available Programming Books with contributions from Karan Bhangui and George Stocker.

The list was moved to GitHub by Victor Felder for collaborative updating and maintenance. It has grown to become one of GitHub's most popular repositories.

How To Contribute

Please read CONTRIBUTING. If you're new to GitHub, welcome! Remember to abide by our adapted from Code of Conduct too (translations also available).

Click on these badges to see how you might be able to help:

How To Share

Share on Facebook
Share on LinkedIn
Share on Mastodon/Fediverse
Share on Telegram
Share on 𝕏 (Twitter)

Resources

This project lists books and other resources grouped by genres:

Books

English, By Programming Language

English, By Subject

Other Languages

Cheat Sheets

All Languages

Free Online Courses

Interactive Programming Resources

Problem Sets and Competitive Programming

Problem Sets

Podcast - Screencast

Free Podcasts and Screencasts:

Programming Playgrounds

Write, compile, and run your code within a browser. Try it out!

Translations

Volunteers have translated many of our Contributing, How-to, and Code of Conduct documents into languages covered by our lists.

English
... More languages ...

You might notice that there are some missing translations here - perhaps you would like to help out by contributing a translation?

License

Each file included in this repository is licensed under the CC BY License.

liquibase/liquibase

2024-11-24T01:39:41Z

Main Liquibase Source

Liquibase

Liquibase helps millions of developers track, version, and deploy database schema changes. It will help you to:

Control database schema changes for specific versions
Eliminate errors and delays when releasing databases
Automatically order scripts for deployment
Easily rollback changes
Collaborate with tools you already use

This repository contains the main source code for Liquibase Open Source. For more information about the product, see the Liquibase website.

Liquibase Automation and Integrations

Liquibase Open Source has built-in support for a variety of databases. Databases that are not part of Liquibase Open Source require extensions that you can download for free. Here is the full list of supported databases.

Liquibase can be integrated with Maven, Ant, Gradle, Spring Boot, and other CI/CD tools. For a full list, see Liquibase Tools & Integrations. You can use Liquibase with GitHub Actions, Spinnaker, and many different workflows.

Install and Run Liquibase

System Requirements

Liquibase system requirements can be found on the Download Liquibase page.

An H2 in-memory database example for CLI

Download and run the appropriate installer.
Make sure to add Liquibase to your PATH.
Copy the included examples directory to the needed location.
Open your CLI and navigate to your examples/sql or examples/xml directory.
Start the included H2 database with the liquibase init start-h2 command.
Run the liquibase update command.
Run the liquibase history command to see what has executed!

See also how to get started with Liquibase in minutes or refer to our Installing Liquibase documentation page for more details.

Documentation

Visit the Liquibase Documentation website to find the information on how Liquibase works.

Courses

Learn all about Liquibase by taking our free online courses at Liquibase University.

Want to help?

Want to file a bug or improve documentation? Excellent! Read up on our guidelines for contributing!

Contribute code

Use our step-by-step instructions for contributing code to the Liquibase open source project.

Join the Liquibase Community

Earn points for your achievements and contributions, collect and show off your badges, add accreditations to your LinkedIn. Learn more about the pathway to Legend and benefits. Enjoy being part of the community!

Liquibase Extensions

Provide more database support and features for Liquibase.

License

Liquibase Open Source is licensed under the Apache 2.0 License.

Liquibase Pro has additional features and support and is commercially licensed.

LIQUIBASE is a registered trademark of Liquibase Inc.

Contact us

Liquibase Forum

Liquibase Blog

Get Support & Advanced Features

Publish Release Manual Trigger to Sonatype

When a PO (Product Owner) or a Team Leader navigates to Publish a release from here -> https://github.com/liquibase/liquibase/releases/, the workflow from /workflow/release-published.yml job is triggered.
When a release is triggered, the workflow file will stop after Setup step and an email will be sent out to the list of approvers mentioned in job manual_trigger_deployment. You can click on the link and perform anyone of the options mentioned in description.
A minimum of 2 approvers are needed in order for the other jobs such as deploy_maven, deploy_javadocs, publish_to_github_packages, etc to be executed.
When you view the GitHub PR, make sure to verify the version which is being published. It should say something like Deploying v4.20.0 to sonatype

apache/hudi

2024-11-24T01:39:41Z

Upserts, Deletes And Incremental Processing on Big Data.

Apache Hudi

Apache Hudi (pronounced Hoodie) stands for Hadoop Upserts Deletes and Incrementals. Hudi manages the storage of large analytical datasets on DFS (Cloud stores, HDFS or any Hadoop FileSystem compatible storage).

https://hudi.apache.org/

Features

Upsert support with fast, pluggable indexing
Atomically publish data with rollback support
Snapshot isolation between writer & queries
Savepoints for data recovery
Manages file sizes, layout using statistics
Async compaction of row & columnar data
Timeline metadata to track lineage
Optimize data lake layout with clustering

Hudi supports three types of queries:

Snapshot Query - Provides snapshot queries on real-time data, using a combination of columnar & row-based storage (e.g Parquet + Avro).
Incremental Query - Provides a change stream with records inserted or updated after a point in time.
Read Optimized Query - Provides excellent snapshot query performance via purely columnar storage (e.g. Parquet).

Learn more about Hudi at https://hudi.apache.org

Building Apache Hudi from source

Prerequisites for building Apache Hudi:

Unix-like system (like Linux, Mac OS X)
Java 8 (Java 9 or 10 may work)
Git
Maven (>=3.3.1)

# Checkout code and build
git clone https://github.com/apache/hudi.git && cd hudi
mvn clean package -DskipTests

# Start command
spark-3.5.0-bin-hadoop3/bin/spark-shell \
  --jars `ls packaging/hudi-spark-bundle/target/hudi-spark3.5-bundle_2.12-*.*.*-SNAPSHOT.jar` \
  --conf 'spark.serializer=org.apache.spark.serializer.KryoSerializer' \
  --conf 'spark.sql.extensions=org.apache.spark.sql.hudi.HoodieSparkSessionExtension' \
  --conf 'spark.sql.catalog.spark_catalog=org.apache.spark.sql.hudi.catalog.HoodieCatalog' \
  --conf 'spark.kryo.registrator=org.apache.spark.HoodieSparkKryoRegistrar'

To build for integration tests that include hudi-integ-test-bundle, use -Dintegration-tests.

To build the Javadoc for all Java and Scala classes:

# Javadoc generated under target/site/apidocs
mvn clean javadoc:aggregate -Pjavadocs

Build with different Spark versions

The default Spark 2.x version supported is 2.4.4. The default Spark 3.x version, corresponding to spark3 profile is 3.5.0. The default Scala version is 2.12. Scala 2.13 is supported for Spark 3.5 and above.

Refer to the table below for building with different Spark and Scala versions.

Maven build options	Expected Spark bundle jar name	Notes
(empty)	hudi-spark3.5-bundle_2.12	For Spark 3.5.x and Scala 2.12 (default options)
`-Dspark3.3`	hudi-spark3.3-bundle_2.12	For Spark 3.3.x and Scala 2.12
`-Dspark3.4`	hudi-spark3.4-bundle_2.12	For Spark 3.4.x and Scala 2.12
`-Dspark3.5 -Dscala-2.12`	hudi-spark3.5-bundle_2.12	For Spark 3.5.x and Scala 2.12 (same as default)
`-Dspark3.5 -Dscala-2.13`	hudi-spark3.5-bundle_2.13	For Spark 3.5.x and Scala 2.13
`-Dspark3`	hudi-spark3-bundle_2.12 (legacy bundle name)	For Spark 3.5.x and Scala 2.12

Please note that only Spark-related bundles, i.e., hudi-spark-bundle, hudi-utilities-bundle, hudi-utilities-slim-bundle, can be built using scala-2.13 profile. Hudi Flink bundle cannot be built using scala-2.13 profile. To build these bundles on Scala 2.13, use the following command:

# Build against Spark 3.5.x and Scala 2.13
mvn clean package -DskipTests -Dspark3.5 -Dscala-2.13 -pl packaging/hudi-spark-bundle,packaging/hudi-utilities-bundle,packaging/hudi-utilities-slim-bundle -am

For example,

# Build against Spark 3.5.x
mvn clean package -DskipTests

# Build against Spark 3.4.x
mvn clean package -DskipTests -Dspark3.4

What about "spark-avro" module?

Starting from versions 0.11, Hudi no longer requires spark-avro to be specified using --packages

Build with different Flink versions

The default Flink version supported is 1.18. The default Flink 1.18.x version, corresponding to flink1.18 profile is 1.18.0. Flink is Scala-free since 1.15.x, there is no need to specify the Scala version for Flink 1.15.x and above versions. Refer to the table below for building with different Flink and Scala versions.

Maven build options	Expected Flink bundle jar name	Notes
(empty)	hudi-flink1.18-bundle	For Flink 1.18 (default options)
`-Dflink1.18`	hudi-flink1.18-bundle	For Flink 1.18 (same as default)
`-Dflink1.17`	hudi-flink1.17-bundle	For Flink 1.17
`-Dflink1.16`	hudi-flink1.16-bundle	For Flink 1.16
`-Dflink1.15`	hudi-flink1.15-bundle	For Flink 1.15
`-Dflink1.14`	hudi-flink1.14-bundle	For Flink 1.14

For example,

# Build against Flink 1.15.x
mvn clean package -DskipTests -Dflink1.15

Running Tests

Unit tests can be run with maven profile unit-tests.

mvn -Punit-tests test

Functional tests, which are tagged with @Tag("functional"), can be run with maven profile functional-tests.

mvn -Pfunctional-tests test

Integration tests can be run with maven profile integration-tests.

mvn -Pintegration-tests verify

To run tests with spark event logging enabled, define the Spark event log directory. This allows visualizing test DAG and stages using Spark History Server UI.

mvn -Punit-tests test -DSPARK_EVLOG_DIR=/path/for/spark/event/log

Quickstart

Please visit https://hudi.apache.org/docs/quick-start-guide.html to quickly explore Hudi's capabilities using spark-shell.

Contributing

Please check out our contribution guide to learn more about how to contribute. For code contributions, please refer to the developer setup.

GitSquared/edex-ui

2024-11-24T01:39:48Z

A cross-platform, customizable science fiction terminal emulator with advanced monitoring & touchscreen support.

(Project archived oct. 18th 2021)

eDEX-UI is a fullscreen, cross-platform terminal emulator and system monitor that looks and feels like a sci-fi computer interface.

Heavily inspired from the TRON Legacy movie effects (especially the Board Room sequence), the eDEX-UI project was originally meant to be "DEX-UI with less « art » and more « distributable software »".

While keeping a futuristic look and feel, it strives to maintain a certain level of functionality and to be usable in real-life scenarios, with the larger goal of bringing science-fiction UXs to the mainstream.

It might or might not be a joke taken too seriously.

Jump to:
Features — Screenshots — Questions & Answers — Download — Featured In — Contributor Instructions — Credits

Sponsor

Want to help support my open-source experiments and learn some cool JavaScript tricks at the same time?

Click the banner below and sign up to Bytes, the only newsletter cool enough to be recommended by eDEX-UI.

Features

Fully featured terminal emulator with tabs, colors, mouse events, and support for curses and curses-like applications.
Real-time system (CPU, RAM, swap, processes) and network (GeoIP, active connections, transfer rates) monitoring.
Full support for touch-enabled displays, including an on-screen keyboard.
Directory viewer that follows the CWD (current working directory) of the terminal.
Advanced customization using themes, on-screen keyboard layouts, CSS injections. See the wiki for more info.
Optional sound effects made by a talented sound designer for maximum hollywood hacking vibe.

Screenshots

neofetch on eDEX-UI 2.2 with the default "tron" theme & QWERTY keyboard

Checking out available themes in eDEX's config dir with ranger on eDEX-UI 2.2 with the "blade" theme

cmatrix on eDEX-UI 2.2 with the experimental "tron-disrupted" theme, and the user-contributed DVORAK keyboard

Editing eDEX-UI source code with nvim on eDEX-UI 2.2 with the custom horizon-full theme

Q&A

How do I get it?

Click on the little badges under the eDEX logo at the top of this page, or go to the Releases tab, or download it through one of the available repositories (Homebrew, AUR...).

Public release binaries are unsigned (why). On Linux, you will need to chmod +x the AppImage file in order to run it.

I have a problem!

Search through the Issues to see if yours has already been reported. If you're confident it hasn't been reported yet, feel free to open up a new one. If you see your issue and it's been closed, it probably means that the fix for it will ship in the next version, and you'll have to wait a bit.

Can you disable the keyboard/the filesystem display?

You can't disable them (yet) but you can hide them. See the tron-notype theme.

Why is the file browser saying that "Tracking Failed"? (Windows only)

On Linux and macOS, eDEX tracks where you're going in your terminal tab to display the content of the current folder on-screen. Sadly, this is technically impossible to do on Windows right now, so the file browser reverts back to a "detached" mode. You can still use it to browse files & directories and click on files to input their path in the terminal.

Can this run on a Raspberry Pi / ARM device?

We provide prebuilt arm64 builds. For other platforms, see this issue comment, and the thread on issue #818.

Is this repo actively maintained?

No, after a 3 years run, this project has been archived. See the announcement.

How did you make this?

Glad you're interested! See #272.

This is so cool.

Thanks! If you feel like it, you can follow me on Twitter to hear about new stuff I'm making.

Featured in...

Linux Uprising Blog
My post on r/unixporn
Korben article (in french)
Hacker News
This tweet that made me smile
BoingBoing article - Apparently i'm a "French hacker"
OReilly 4 short links
Hackaday
Developpez.com (another french link)
GitHub Blog's Release Radar November 2018
opensource.com Productive Tools for 2019
O'Reilly 4 short links (again)
LinuxLinks
Linux For Everyone (Youtube)
BestOfJS Rising Stars 2020
The Geek Freaks (Youtube/German)
JSNation Open Source Awards 2021 (Nominee - Fun Side Project of the Year)

Useful commands for the nerds

IMPORTANT NOTE: the following instructions are meant for running eDEX from the latest unoptimized, unreleased, development version. If you'd like to get stable software instead, refer to these instructions.

Starting from source:

on *nix systems (You'll need the Xcode command line tools on macOS):

clone the repository
npm run install-linux
npm run start

on Windows:

start cmd or powershell as administrator
clone the repository
npm run install-windows
npm run start

Building

Note: Due to native modules, you can only build targets for the host OS you are using.

npm install (NOT install-linux or install-windows)
npm run build-linux or build-windows or build-darwin

The script will minify the source code, recompile native dependencies and create distributable assets in the dist folder.

Getting the bleeding edge

If you're interested in running the latest in-development version but don't want to compile source code yourself, you can can get pre-built nightly binaries on GitHub Actions: click the latest commits, and download the artifacts bundle for your OS.

Credits

eDEX-UI's source code was primarily written by me, Squared. If you want to get in touch with me or find other projects I'm involved in, check out my website.

PixelyIon helped me get started with Windows compatibility and offered some precious advice when I started to work on this project seriously.

IceWolf composed the sound effects on v2.1.x and above. He makes really cool stuff, check out his music!

Thanks

Of course, eDEX would never have existed if I hadn't stumbled upon the amazing work of Seena on r/unixporn.

This project uses a bunch of open-source libraries, frameworks and tools, see the full dependency graph.

I want to namely thank the developers behind xterm.js, systeminformation and SmoothieCharts.

Huge thanks to Rob "Arscan" Scanlon for making the fantastic ENCOM Globe, also inspired by the TRON: Legacy movie, and distributing it freely. His work really puts the icing on the cake.

Licensing

Licensed under the GPLv3.0.

TheBeastLT/torrentio-scraper

2024-11-24T01:39:48Z

Torrentio

torrentio-addon - the Stremio addon which will query scraped entries and return Stremio stream results.

stevenjoezhang/live2d-widget

2024-11-24T01:39:48Z

把萌萌哒的看板娘抱回家 (ノ≧∇≦)ノ | Live2D widget for web platform

Live2D Widget

English

特性

在网页中添加 Live2D 看板娘。兼容 PJAX，支持无刷新加载。

（注：以上人物模型仅供展示之用，本仓库并不包含任何模型。）

你也可以查看示例网页：

在米米的博客的左下角可查看效果
demo.html，展现基础功能
login.html，仿 NPM 的登陆界面

使用

如果你是小白，或者只需要最基础的功能，那么只用将这一行代码加入 html 页面的 head 或 body 中，即可加载看板娘：

<script src="https://fastly.jsdelivr.net/gh/stevenjoezhang/live2d-widget@latest/autoload.js"></script>

添加代码的位置取决于你的网站的构建方式。例如，如果你使用的是 Hexo，那么需要在主题的模版文件中添加以上代码。对于用各种模版引擎生成的页面，修改方法类似。
如果网站启用了 PJAX，由于看板娘不必每页刷新，需要注意将该脚本放到 PJAX 刷新区域之外。

但是！我们强烈推荐自己进行配置，让看板娘更加适合你的网站！
如果你有兴趣自己折腾的话，请看下面的详细说明。

配置

你可以对照 autoload.js 的源码查看可选的配置项目。autoload.js 会自动加载三个文件：waifu.css，live2d.min.js 和 waifu-tips.js。waifu-tips.js 会创建 initWidget 函数，这就是加载看板娘的主函数。initWidget 函数接收一个 Object 类型的参数，作为看板娘的配置。以下是配置选项：

选项	类型	默认值	说明
`waifuPath`	`string`	`https://fastly.jsdelivr.net/gh/stevenjoezhang/live2d-widget@latest/waifu-tips.json`	看板娘资源路径，可自行修改
`apiPath`	`string`	`https://live2d.fghrsh.net/api/`	API 路径，可选参数
`cdnPath`	`string`	`https://fastly.jsdelivr.net/gh/fghrsh/live2d_api/`	CDN 路径，可选参数
`tools`	`string[]`	见 `autoload.js`	加载的小工具按钮，可选参数

其中，apiPath 和 cdnPath 两个参数设置其中一项即可。apiPath 是后端 API 的 URL，可以自行搭建，并增加模型（需要修改的内容比较多，此处不再赘述），可以参考 live2d_api。而 cdnPath 则是通过 jsDelivr 这样的 CDN 服务加载资源，更加稳定。

自定义

如果以上「配置」部分提供的选项还不足以满足你的需求，那么你可以自己进行修改。本仓库的目录结构如下：

src/waifu-tips.js 包含了按钮和对话框的逻辑；
waifu-tips.js 是由 src/waifu-tips.js 自动打包生成的，不建议直接修改；
waifu-tips.json 中定义了触发条件（selector，CSS 选择器）和触发时显示的文字（text）；
waifu.css 是看板娘的样式表。

waifu-tips.json 中默认的 CSS 选择器规则是对 Hexo 的 NexT 主题有效的，为了适用于你自己的网页，可能需要自行修改，或增加新内容。
警告：waifu-tips.json 中的内容可能不适合所有年龄段，或不宜在工作期间访问。在使用时，请自行确保它们是合适的。

要在本地部署本项目的开发测试环境，你需要安装 Node.js 和 npm，然后执行以下命令：

git clone https://github.com/stevenjoezhang/live2d-widget.git
npm install
npm run build

如果有任何疑问，欢迎提 Issue。如果有任何修改建议，欢迎提 Pull Request。

部署

在本地完成了修改后，你可以将修改后的项目部署在服务器上，或者通过 CDN 加载，以便在网页中使用。

使用 CDN

要自定义有关内容，可以把这个仓库 Fork 一份，然后把修改后的内容通过 git push 到你的仓库中。这时，使用方法对应地变为

<script src="https://fastly.jsdelivr.net/gh/username/live2d-widget@latest/autoload.js"></script>

将此处的 username 替换为你的 GitHub 用户名。为了使 CDN 的内容正常刷新，需要创建新的 git tag 并推送至 GitHub 仓库中，否则此处的 @latest 仍然指向更新前的文件。此外 CDN 本身存在缓存，因此改动可能需要一定的时间生效。相关文档：

Self-host

你也可以直接把这些文件放到服务器上，而不是通过 CDN 加载。

如果你能够通过 ssh 连接你的主机，请把 Fork 并修改后的代码仓库克隆到服务器上。
如果你的主机无法用 ssh 连接（例如一般的虚拟主机），请在本地修改好代码后，通过 ftp 等方式将文件上传到主机的网站的目录下。
如果你是通过 Hexo 等工具部署的静态博客，请把本项目的代码放在博客源文件目录下（例如 source 目录）。重新部署博客时，相关文件就会自动上传到对应的路径下。为了避免这些文件被 Hexo 插件错误地修改，可能需要设置 skip_render。

这样，整个项目就可以通过你的域名访问了。不妨试试能否正常地通过浏览器打开 autoload.js 和 live2d.min.js 等文件，并确认这些文件的内容是完整和正确的。
一切正常的话，接下来修改 autoload.js 中的常量 live2d_path 为 live2d-widget 这一目录的 URL 即可。比如说，如果你能够通过

https://example.com/path/to/live2d-widget/live2d.min.js

访问到 live2d.min.js，那么就把 live2d_path 的值修改为

https://example.com/path/to/live2d-widget/

路径末尾的 / 一定要加上。
完成后，在你要添加看板娘的界面加入

<script src="https://example.com/path/to/live2d-widget/autoload.js"></script>

就可以加载了。

鸣谢

感谢 BrowserStack 容许我们在真实的浏览器中测试此项目。
Thanks to BrowserStack for providing the infrastructure that allows us to test in real browsers!

感谢 jsDelivr 提供的 CDN 服务。
Thanks jsDelivr for providing public CDN service.

代码自这篇博文魔改而来：
https://www.fghrsh.net/post/123.html

感谢一言提供的语句接口。

点击看板娘的纸飞机按钮时，会出现一个彩蛋，这来自于 WebsiteAsteroids。

关于后端 API 模型：
https://github.com/xiazeyu/live2d-widget-models
https://github.com/xiaoski/live2d_models_collection

除此之外，还有桌面版本：
https://github.com/amorist/platelet
https://github.com/akiroz/Live2D-Widget
https://github.com/zenghongtu/PPet
https://github.com/LikeNeko/L2dPetForMac

以及 Wallpaper Engine：
https://github.com/guansss/nep-live2d

许可证

Released under the GNU General Public License v3
http://www.gnu.org/licenses/gpl-3.0.html

本仓库并不包含任何模型，用作展示的所有 Live2D 模型、图片、动作数据等版权均属于其原作者，仅供研究学习，不得用于商业用途。

Live2D 官方网站：
https://www.live2d.com/en/
https://live2d.github.io

Live2D Cubism Core は Live2D Proprietary Software License で提供しています。
https://www.live2d.com/eula/live2d-proprietary-software-license-agreement_en.html
Live2D Cubism Components は Live2D Open Software License で提供しています。
http://www.live2d.com/eula/live2d-open-software-license-agreement_en.html

The terms and conditions do prohibit modification, but obfuscating in live2d.min.js would not be considered illegal modification.

https://community.live2d.com/discussion/140/webgl-developer-licence-and-javascript-question

更新日志

2018年10月31日，由 fghrsh 提供的原 API 停用，请更新至新地址。参考文章：
https://www.fghrsh.net/post/170.html

2020年1月1日起，本项目不再依赖于 jQuery。

2022年11月1日起，本项目不再需要用户单独加载 Font Awesome。

ITensor/ITensorMPS.jl

2024-11-23T01:31:52Z

MPS and MPO methods based on ITensor (ITensors.jl)

Zefan-Cai/KVCache-Factory

2024-11-24T01:40:00Z

Unified KV Cache Compression Methods for Auto-Regressive Models

Pyramid KV

News

[2024-06-25] Support multi-GPUs inference with big LLMs now! Try out PyramidKV on LlaMa-3-70B-Instruct!
[2024-06-10] Support PyramidKV, SnapKV, H2O and StreamingLLM at Flash Attention v2, Sdpa Attention now! If your devices (i.e., V100, 3090) does not support Flash Attention v2, you can set attn_implementation=sdpa to try PyramidKV at Sdpa Attention!

TODO:

Support implementation of Streaming LLM, H2O and SnapKV
Support Mistral model
Support implementation of Needle
Support KV cache compression without Flash Attention v2 (i.e. Sdpa Attention) for V100
Support multi-GPU inference for 70B LlaMa-3
Introduce new functions to support kv cache budget allocation (i.e., supports for percentage.)
Support Mixtral
Support Batch Inference
Support KV cache compression at decoding stage

Performence

Visualization: Inefficient Attention

The Llama model attention map with 3 documents is represented as follows:

we provide a notebook visualization.ipynb to reproduce the visualization result of each Llama-2-7b-hf model layer for a given 3 document.

Model attention maps for different layers would be stored at ./attention

Requirements

transformers >= 4.41
flash-attn >= 2.4.0.post1

Installation


git clone https://github.com/Zefan-Cai/PyramidKV.git
cd PyramidKV
pip install -r requirements.txt .

Inference

We support inference code on LongBench to repuduce our result.

Please refer to scripts/scripts_longBench/eval.sh to modify the parameters according to your requirements.

Our codebase support Flash Attention v2, Sdpa Attention, etc. The results presented in our paper in based on Flash Attention v2.

export CUDA_VISIBLE_DEVICES=$1

method=$2 # Support PyramidKV, SnapKV, H2O, StreamingLLM
max_capacity_prompts=64 # 128,2048 in paper
attn_implementation=$3 # Support "flash_attention_2", "sdpa", "eager".
source_path=$4
model_path=$5
save_dir=${source_path}"results_long_bench" # path to result save_dir

python3 run_longbench.py \
    --method ${method} \
    --model_path ${model_path} \
    --max_capacity_prompts ${max_capacity_prompts} \
    --attn_implementation ${attn_implementation} \
    --save_dir ${save_dir} \
    --use_cache True

CUDA_VISIBLE_DEVICES: For multi-GPU inference for big LLMs, just need to specify CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7. For single GPU inference, just need to specify CUDA_VISIBLE_DEVICES=0.
model_path: Path to your model. Support "Llama-3-8B-Instruct" for now.
method: Support PyramidKV, SnapKV, StreamingLLM, H2O.
max_capacity_prompts: Selected KV Size in each layer. （e.g. 128, 2048 in paper）. When method is "PyramidKV", given that the total number of KV remains unchanged, the specific KV length for each layer will be modified accordingly
save_dir: Path to your dir to save LongBench result.

After modifying parameters, run:


sh scripts/scripts_longBench/eval.sh

Needle in haystack

We support inference code on Needle in haystack to repuduce our result.

Please refer to scripts/scripts_needle/eval.sh to modify the parameters according to your requirements.

Our codebase support Flash Attention v2, Sdpa Attention, etc. The results presented in our paper in based on Flash Attention v2.


METHOD='pyramidkv'       # ['full', 'pyramidkv', 'snapkv', 'streamingllm', 'h2o']
MAX_CAPACITY_PROMPT=96  # [64, 96, 128, 256, 512, 1024, 2048, ...]
attn_implementation="flash_attention_2" # Support "flash_attention_2", "sdpa", "".
TAG=test


# For Llama3-8b

(
python -u run_needle_in_haystack.py --s_len 1000 --e_len 8001\
    --model_provider LLaMA3 \
    --model_name /mnt/workspace/zhiyuanhu/yuliang/models/llama3-8b_raw \
    --attn_implementation ${attn_implementation} \
    --step 100 \
    --method $METHOD \
    --max_capacity_prompt $MAX_CAPACITY_PROMPT \
    --model_version LlaMA3_${METHOD}_${MAX_CAPACITY_PROMPT}_${TAG}
) 2>&1  | tee results_needle/logs/LlaMA3_${METHOD}_${MAX_CAPACITY_PROMPT}_${TAG}.log

Both LLaMA3 and Mistral2 inference support on single GPU.
model_provider: LLaMA3 or Mistral2
model_name: Path to your model. Support "Llama-3-8B-Instruct" "Mistral-7B-Instruct-v0.2" and for now.
step: The increase of context length.
method: Support PyramidKV, SnapKV, StreamingLLM, H2O.
max_capacity_prompt: Selected KV Size in each layer. （e.g. 128, 2048 in paper）. When method is "PyramidKV", given that the total number of KV remains unchanged, the specific KV length for each layer will be modified accordingly

To reproduce our results, run

bash scripts/scripts_needle/eval.sh

After inference, run

python scripts/scripts_needle/visualize.py

to draw the img, you should change FOLDER_PATH in visualize.py to your output path (the argument of --model_version in eval.sh).

Citation

If you find PyramidKV useful for your research and applications, please kindly cite using this BibTeX:

@article{cai2024pyramidkv,
  title={PyramidKV: Dynamic KV Cache Compression based on Pyramidal Information Funneling},
  author={Cai, Zefan and Zhang, Yichi and Gao, Bofei and Liu, Yuliang and Liu, Tianyu and Lu, Keming and Xiong, Wayne and Dong, Yue and Chang, Baobao and Hu, Junjie and others},
  journal={CoRR},
  year={2024}
}

Acknowledgement

Thanks [SnapKV] SnapKV: LLM Knows What You are Looking for Before Generation for providing open-source code to support the expansion of this project.

modelscope/facechain

2024-11-24T01:40:00Z

FaceChain is a deep-learning toolchain for generating your Digital-Twin.

FaceChain

News

More Technology Details of FaceChain-FACT train-free portrait generation can be seen in Paper. (October 17th, 2024 UTC)
Our work TopoFR got accepted to NeurIPS 2024 ! (September 26th, 2024 UTC)
We provide training scripts for new styles, offering an automatic training for new style LoRas as well as the corresponding style prompts, along with the one click call in Infinite Style Portrait generation tab! (July 3rd, 2024 UTC)
🚀🚀🚀 We are launching [FACT] into the main branch, offering a 10-second impressive speed and seamless integration with standard ready-to-use LoRas and ControlNets, along with improved instruction-following capabilities ! The original train-based FaceChain is moved to (https://github.com/modelscope/facechain/tree/v3.0.0 ). (May 28th, 2024 UTC)
Our work FaceChain-ImagineID and FaceChain-SuDe got accepted to CVPR 2024 ! (February 27th, 2024 UTC)

Introduction

如果您熟悉中文，可以阅读中文版本的README。

FaceChain is a novel framework for generating identity-preserved human portraits. In the newest FaceChain FACT (Face Adapter with deCoupled Training) version, with only 1 photo and 10 seconds, you can generate personal portraits in different settings (multiple styles now supported!). FaceChain has both high controllability and authenticity in portrait generation, including text-to-image and inpainting based pipelines, and is seamlessly compatible with ControlNet and LoRAs. You may generate portraits via FaceChain's Python scripts, or via the familiar Gradio interface, or via sd webui. FaceChain is powered by ModelScope.

ModelScope Studio 🤖 ｜API 🔥 | SD WebUI | HuggingFace Space 🤗

News

More Technology Details of FaceChain-FACT train-free portrait generation can be seen in Paper. (October 17th, 2024 UTC)
Our work TopoFR got accepted to NeurIPS 2024 ! (September 26th, 2024 UTC)
We provide training scripts for new styles, offering an automatic training for new style LoRas as well as the corresponding style prompts, along with the one click call in Infinite Style Portrait generation tab! (July 3rd, 2024 UTC)
🚀🚀🚀 We are launching [FACT], offering a 10-second impressive speed and seamless integration with standard ready-to-use LoRas and ControlNets, along with improved instruction-following capabilities ! (May 28th, 2024 UTC)
Our work FaceChain-ImagineID and FaceChain-SuDe got accepted to CVPR 2024 ! (February 27th, 2024 UTC)
🏆🏆🏆Alibaba Annual Outstanding Open Source Project, Alibaba Annual Open Source Pioneer (Yang Liu, Baigui Sun). (January 20th, 2024 UTC)
Our work InfoBatch co-authored with NUS team got accepted to ICLR 2024(Oral)! (January 16th, 2024 UTC)
🏆OpenAtom's 2023 Rapidly Growing Open Source Projects Award. (December 20th, 2023 UTC)
Add SDXL pipeline🔥🔥🔥, image detail is improved obviously. (November 22th, 2023 UTC)
Support super resolution🔥🔥🔥, provide multiple resolution choice (512512, 768768, 10241024, 20482048). (November 13th, 2023 UTC)
🏆FaceChain has been selected in the BenchCouncil Open100 (2022-2023) annual ranking. (November 8th, 2023 UTC)
Add virtual try-on module. (October 27th, 2023 UTC)
Add wanx version online free app. (October 26th, 2023 UTC)
🏆1024 Programmer's Day AIGC Application Tool Most Valuable Business Award. (2023-10-24, 2023 UTC)
Support FaceChain in stable-diffusion-webui🔥🔥🔥. (October 13th, 2023 UTC)
High performance inpainting for single & double person, Simplify User Interface. (September 09th, 2023 UTC)
More Technology Details can be seen in Paper. (August 30th, 2023 UTC)
Add validate & ensemble for Lora training, and InpaintTab(hide in gradio for now). (August 28th, 2023 UTC)
Add pose control module. (August 27th, 2023 UTC)
Add robust face lora training module, enhance the performance of one pic training & style-lora blending. (August 27th, 2023 UTC)
HuggingFace Space is available now! You can experience FaceChain directly with 🤗 (August 25th, 2023 UTC)
Add awesome prompts! Refer to: awesome-prompts-facechain (August 18th, 2023 UTC)
Support a series of new style models in a plug-and-play fashion. (August 16th, 2023 UTC)
Support customizable prompts. (August 16th, 2023 UTC)
Colab notebook is available now! You can experience FaceChain directly with . (August 15th, 2023 UTC)

To-Do List

Develop RLHF methods, make its quality more higher.
Support more beauty-retouch effects.
Provide more funny apps.

Citation

Please cite FaceChain and FaceChain-FACT in your publications if it helps your research

@article{liu2023facechain,
  title={FaceChain: A Playground for Identity-Preserving Portrait Generation},
  author={Liu, Yang and Yu, Cheng and Shang, Lei and Wu, Ziheng and 
          Wang, Xingjun and Zhao, Yuze and Zhu, Lin and Cheng, Chen and 
          Chen, Weitao and Xu, Chao and Xie, Haoyu and Yao, Yuan and 
          Zhou,  Wenmeng and Chen Yingda and Xie, Xuansong and Sun, Baigui},
  journal={arXiv preprint arXiv:2308.14256},
  year={2023}
}

@article{yu2024facechain,
  title={FaceChain-FACT: Face Adapter with Decoupled Training for Identity-preserved Personalization},
  author={Yu, Cheng and Xie, Haoyu and Shang, Lei and Liu, Yang and Dan, Jun and Sun, Baigui and Bo, Liefeng},
  journal={arXiv preprint arXiv:2410.12312},
  year={2024}
}

Installation

Compatibility Verification

We have verified e2e execution on the following environment:

python: py3.8, py3.10
pytorch: torch2.0.0, torch2.0.1
CUDA: 11.7
CUDNN: 8+
OS: Ubuntu 20.04, CentOS 7.9
GPU: Nvidia-A10 24G

Memory Optimization

Jemalloc are recommanded to install for optimizing the memory from above 30G to below 20G. Here is an example for installing Jemalloc in Modelscope notebook.

apt-get install -y libjemalloc-dev
export LD_PRELOAD=/lib/x86_64-linux-gnu/libjemalloc.so

Installation Guide

The following installation methods are supported:

1. ModelScope notebook【recommended】

The ModelScope Notebook offers a free-tier that allows ModelScope user to run the FaceChain application with minimum setup, refer to ModelScope Notebook

# Step1: 我的notebook -> PAI-DSW -> GPU环境
# Note: Please use: ubuntu20.04-py38-torch2.0.1-tf1.15.5-modelscope1.8.1

# Step2: Entry the Notebook cell，clone FaceChain from github:
!GIT_LFS_SKIP_SMUDGE=1 git clone https://github.com/modelscope/facechain.git --depth 1

# Step3: Change the working directory to facechain, and install the dependencies:
import os
os.chdir('/mnt/workspace/facechain')    # You may change to your own path
print(os.getcwd())

!pip3 install gradio==3.47.1
!pip3 install controlnet_aux==0.0.6
!pip3 install python-slugify
!pip3 install diffusers==0.29.0
!pip3 install peft==0.11.1

# Step4: Start the app service, click "public URL" or "local URL", upload your images to 
# train your own model and then generate your digital twin.
!python3 app.py

Alternatively, you may also purchase a PAI-DSW instance (using A10 resource), with the option of ModelScope image to run FaceChain following similar steps.

2. Docker

If you are familiar with using docker, we recommend to use this way:

# Step1: Prepare the environment with GPU on local or cloud, we recommend to use Alibaba Cloud ECS, refer to: https://www.aliyun.com/product/ecs

# Step2: Download the docker image (for installing docker engine, refer to https://docs.docker.com/engine/install/）
# For China Mainland users:
docker pull registry.cn-hangzhou.aliyuncs.com/modelscope-repo/modelscope:ubuntu20.04-cuda11.7.1-py38-torch2.0.1-tf1.15.5-1.8.1
# For users outside China Mainland:
docker pull registry.us-west-1.aliyuncs.com/modelscope-repo/modelscope:ubuntu20.04-cuda11.7.1-py38-torch2.0.1-tf1.15.5-1.8.1

# Step3: run the docker container
docker run -it --name facechain -p 7860:7860 --gpus all registry.cn-hangzhou.aliyuncs.com/modelscope-repo/modelscope:ubuntu20.04-cuda11.7.1-py38-torch2.0.1-tf1.15.5-1.8.1 /bin/bash
# Note: you may need to install the nvidia-container-runtime, follow the instructions:
# 1. Install nvidia-container-runtime：https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html
# 2. sudo systemctl restart docker

# Step4: Install the gradio in the docker container:
pip3 install gradio==3.47.1
pip3 install controlnet_aux==0.0.6
pip3 install python-slugify
pip3 install diffusers==0.29.0
pip3 install peft==0.11.1

# Step5 clone facechain from github
GIT_LFS_SKIP_SMUDGE=1 git clone https://github.com/modelscope/facechain.git --depth 1
cd facechain
python3 app.py
# Note: FaceChain currently assume single-GPU, if your environment has multiple GPU, please use the following instead:
# CUDA_VISIBLE_DEVICES=0 python3 app.py

# Step6
Run the app server: click "public URL" --> in the form of: https://xxx.gradio.live

3. stable-diffusion-webui

Select the Extensions Tab, then choose Install From URL (official plugin integration is integrated, please install from URL currently).
Switch to Installed, check the FaceChain plugin, then click Apply and restart UI. It may take a while for installing the dependencies and downloading the models. Make sure that the "CUDA Toolkit" is installed correctly, otherwise the "mmcv" package cannot be successfully installed.
After the page refreshes, the appearance of the FaceChain Tab indicates a successful installation.

Script Execution

FaceChain supports direct inference in the python environment. When inferring for Infinite Style Portrait generation, please edit the code in run_inference.py:

# Use pose control, default False
use_pose_model = False
# The path of the input image containing ID information for portrait generation
input_img_path = 'poses/man/pose2.png'
# The path of the image for pose control, only effective when using pose control
pose_image = 'poses/man/pose1.png'
# The number of images to generate in inference
num_generate = 5
# The weight for the style model, see styles for detail
multiplier_style = 0.25
# Specify a folder to save the generated images, this parameter can be modified as needed
output_dir = './generated'
# The index of the chosen base model, see facechain/constants.py for detail
base_model_idx = 0
# The index of the style model, see styles for detail
style_idx = 0

Then execute:

python run_inference.py

You can find the generated personal digital image photos in the output_dir.

When inferring for Fixed Templates Portrait generation, please edit the code in run_inference_inpaint.py.

# Number of faces for the template image
num_faces = 1
# Index of face for inpainting, counting from left to right
selected_face = 1
# The strength for inpainting, you do not need to change the parameter
strength = 0.6
# The path of the template image
inpaint_img = 'poses/man/pose1.png'
# The path of the input image containing ID information for portrait generation
input_img_path = 'poses/man/pose2.png'
# The number of images to generate in inference
num_generate = 1
# Specify a folder to save the generated images, this parameter can be modified as needed
output_dir = './generated_inpaint'

Then execute:

python run_inference_inpaint.py

You can find the generated personal digital image photos in the output_dir.

Algorithm Introduction

The capability of AI portraits generation comes from the large generative models like Stable Diffusion and its fine-tuning techniques. Due to the strong generalization capability of large models, it is possible to perform downstream tasks by fine-tuning on specific types of data and tasks, while preserving the model's overall ability of text following and image generation. The technical foundation of train-based and train-free AI portraits generation comes from applying different fine-tuning tasks to generative models. Currently, most existing AI portraits tools adopt a two-stage “train then generate” pipeline, where the fine-tuning task is “to generate portrait photos of a fixed character ID”, and the corresponding training data are multiple images of the fixed character ID. The effectiveness of such train-based pipeline depends on the scale of the training data, thus requiring certain image data support and training time, which also increases the cost for users.

Different from train-based pipeline, train-free pipeline adjusts the fine-tuning task to “generate portrait photos of a specified character ID”, meaning that the character ID image (face photo) is used as an additional input, and the output is a portrait photo preserving the input ID. Such a pipeline completely separates offline training from online inference, allowing users to generate portraits directly based on the fine-tuned model with only one photo in just 10 seconds, avoiding the cost for extensive data and training time. The fine-tuning task of train-free AI portraits generation is based on the adapter module. Face photos are processed through an image encoder with fixed weights and a parameter-efficient feature projection layer to obtain aligned features, and are then fed into the U-Net model of Stable Diffusion through attention mechanism similar as text conditions. At this point, face information as an independent branch condition is fed into the model alongside text information for inference, thereby enabling the generated images to maintain ID fidelity.

The basic algorithm based on face adapter is capable of achieving train-free AI portraits, but still requires certain adjustments to further improve its effectiveness. Existing train-free portrait tools generally suffer from the following issues: poor image quality of portraits, inadequate text following and style retention abilities in portraits, poor controllability and richness of portrait faces, and poor compatibility with extensions like ControlNet and style Lora. To address these issues, FaceChain attribute them to the fact that the fine-tuning tasks for existing train-free AI portrait tools have coupled with too much information beyond character IDs, and propose FaceChain Face Adapter with Decoupled Training (FaceChain FACT) to solve these problems. By fine-tuning the Stable Diffusion model on millions of portrait data, FaceChain FACT can achieve high-quality portrait image generation for specified character IDs. The entire framework of FaceChain FACT is shown in the figure below.

The decoupled training of FaceChain FACT consists of two parts: decoupling face from image, and decoupling ID from face. Existing methods often treat denoising portrait images as the fine-tuning task, which makes the model hard to accurately focus on the face area, thereby affecting the text-to-image ability of the base Stable Diffusion model. FaceChain FACT draws on the sequential processing and regional control advantages of face-swapping algorithms and implements the fine-tuning method for decoupling faces from images from both structural and training strategy aspects. Structurally, unlike existing methods that use a parallel cross-attention mechanism to process face and text information, FaceChain FACT adopts a sequential processing approach as an independent adapter layer inserted into the original Stable Diffusion's blocks. This way, face adaptation acts as an independent step similar to face-swapping during the denoising process, avoiding interference between face and text conditions. In terms of training strategy, besides the original MSE loss function, FaceChain FACT introduces the Face Adapting Incremental Regularization (FAIR) loss function, which controls the feature increment of the face adaptation step in the adapter layer to focus on the face region. During inference, users can flexibly adjust the generated effects by modifying the weight of the face adapter, balancing fidelity and generalization of the face while maintaining the text-to-image ability of Stable Diffusion. The FAIR loss function is formulated as follows:

Furthermore, addressing the issue of poor controllability and richness of generated faces, FaceChain FACT proposes a training method for decoupling ID from face, so that the portrait process only preserves the character ID rather than the entire face. Firstly, to better extract the ID information from the face while maintaining certain key facial details, and to better adapt to the structure of Stable Diffusion, FaceChain FACT employs a face feature extractor named TransFace based on the Transformer architecture, which is pre-trained on a large-scale face dataset. All tokens from the penultimate layer are subsequently fed into a simple attention query model for feature projection, thereby ensuring that the extracted ID features meet the aforementioned requirements. Additionally, during the training process, FaceChain FACT uses the Classifier Free Guidance (CFG) method to perform random shuffle and drop for different portrait images of the same ID, thus ensuring that the input face images and the target images used for denoising may have different faces with the same ID, thus further preventing the model from overfitting to non-ID information of the face. As such, FaceChain FACT possesses high compatibility with the massive exquisite styles of FaceChain, which is shown as follows.

Model List

The models used in FaceChain:

[1] Face recognition model TransFace：https://www.modelscope.cn/models/iic/cv_vit_face-recognition

[2] Face detection model DamoFD：https://modelscope.cn/models/damo/cv_ddsar_face-detection_iclr23-damofd

[3] Human parsing model M2FP：https://modelscope.cn/models/damo/cv_resnet101_image-multiple-human-parsing

[4] Skin retouching model ABPN：https://www.modelscope.cn/models/damo/cv_unet_skin_retouching_torch

[5] Face fusion model：https://www.modelscope.cn/models/damo/cv_unet_face_fusion_torch

[6] FaceChain FACT model: https://www.modelscope.cn/models/yucheng1996/FaceChain-FACT

[7] Face attribute recognition model FairFace: https://modelscope.cn/models/damo/cv_resnet34_face-attribute-recognition_fairface

More Information

ModelScope library

ModelScope Library provides the foundation for building the model-ecosystem of ModelScope, including the interface and implementation to integrate various models into ModelScope.

Contribute models to ModelScope

License

This project is licensed under the Apache License (Version 2.0).

IDEA-Research/Grounded-SAM-2

2024-11-24T01:40:00Z

Grounded SAM 2: Ground and Track Anything in Videos with Grounding DINO, Florence-2 and SAM 2

Grounded SAM 2: Ground and Track Anything in Videos

IDEA-Research

Tianhe Ren, Shuo Shen

[SAM2 Paper] [Grounding DINO Paper] [Grounding DINO 1.5 Paper] [BibTeX]

🔥 Project Highlight

Grounded SAM 2 is a foundation model pipeline towards grounding and track anything in Videos with Grounding DINO, Grounding DINO 1.5, Florence-2 and SAM 2.

In this repo, we've supported the following demo with simple implementations:

Ground and Segment Anything with Grounding DINO, Grounding DINO 1.5 & 1.6 and SAM 2
Ground and Track Anything with Grounding DINO, Grounding DINO 1.5 & 1.6 and SAM 2
Detect, Segment and Track Visualization based on the powerful supervision library.

Grounded SAM 2 does not introduce significant methodological changes compared to Grounded SAM: Assembling Open-World Models for Diverse Visual Tasks. Both approaches leverage the capabilities of open-world models to address complex visual tasks. Consequently, we try to simplify the code implementation in this repository, aiming to enhance user convenience.

Latest updates

2024/10/24: Support SAHI (Slicing Aided Hyper Inference) on Grounded SAM 2 (with Grounding DINO 1.5) which may be helpful for inferencing high resolution image with dense small objects (e.g. 4K images).
2024/10/10: Support SAM-2.1 models, if you want to use SAM 2.1 model, you need to update to the latest code and reinstall SAM 2 follow SAM 2.1 Installation.
2024/08/31: Support dump json results in Grounded SAM 2 Image Demos (with Grounding DINO).
2024/08/20: Support Florence-2 SAM 2 Image Demo which includes dense region caption, object detection, phrase grounding, and cascaded auto-label pipeline caption + phrase grounding.
2024/08/09: Support Ground and Track New Object throughout the whole videos. This feature is still under development now. Credits to Shuo Shen.
2024/08/07: Support Custom Video Inputs, users need only submit their video file (e.g. .mp4 file) with specific text prompts to get an impressive demo videos.

Installation

Download the pretrained SAM 2 checkpoints:

cd checkpoints
bash download_ckpts.sh

Download the pretrained Grounding DINO checkpoints:

cd gdino_checkpoints
bash download_ckpts.sh

Installation without docker

Install PyTorch environment first. We use python=3.10, as well as torch >= 2.3.1, torchvision>=0.18.1 and cuda-12.1 in our environment to run this demo. Please follow the instructions here to install both PyTorch and TorchVision dependencies. Installing both PyTorch and TorchVision with CUDA support is strongly recommended. You can easily install the latest version of PyTorch as follows:

pip3 install torch torchvision torchaudio

Since we need the CUDA compilation environment to compile the Deformable Attention operator used in Grounding DINO, we need to check whether the CUDA environment variables have been set correctly (which you can refer to Grounding DINO Installation for more details). You can set the environment variable manually as follows if you want to build a local GPU environment for Grounding DINO to run Grounded SAM 2:

export CUDA_HOME=/path/to/cuda-12.1/

Install Segment Anything 2:

pip install -e .

Install Grounding DINO:

pip install --no-build-isolation -e grounding_dino

Installation with docker

Build the Docker image and Run the Docker container:

cd Grounded-SAM-2
make build-image
make run

After executing these commands, you will be inside the Docker environment. The working directory within the container is set to: /home/appuser/Grounded-SAM-2

Once inside the Docker environment, you can start the demo by running:

python grounded_sam2_tracking_demo.py

Grounded SAM 2 Demos

Grounded SAM 2 Image Demo (with Grounding DINO)

Note that Grounding DINO has already been supported in Huggingface, so we provide two choices for running Grounded SAM 2 model:

Use huggingface API to inference Grounding DINO (which is simple and clear)

python grounded_sam2_hf_model_demo.py

[!NOTE] 🚨 If you encounter network issues while using the HuggingFace model, you can resolve them by setting the appropriate mirror source as export HF_ENDPOINT=https://hf-mirror.com

Load local pretrained Grounding DINO checkpoint and inference with Grounding DINO original API (make sure you've already downloaded the pretrained checkpoint)

python grounded_sam2_local_demo.py

Grounded SAM 2 Image Demo (with Grounding DINO 1.5 & 1.6)

We've already released our most capable open-set detection model Grounding DINO 1.5 & 1.6, which can be combined with SAM 2 for stronger open-set detection and segmentation capability. You can apply the API token first and run Grounded SAM 2 with Grounding DINO 1.5 as follows:

Install the latest DDS cloudapi:

pip install dds-cloudapi-sdk --upgrade

Apply your API token from our official website here: request API token.

python grounded_sam2_gd1.5_demo.py

SAHI (Slicing Aided Hyper Inference) with Grounding DINO 1.5 and SAM 2

If your images are high resolution with dense objects, directly using Grounding DINO 1.5 for inference on the original image may not be the best choice. We support SAHI (Slicing Aided Hyper Inference), which works by first dividing the original image into smaller overlapping patches. Inference is then performed separately on each patch, and the final detection results are merged. This method is highly effective and accuracy for dense and small objects detection in high resolution images.

You can run SAHI inference by setting the following param in grounded_sam2_gd1.5_demo.py:

WITH_SLICE_INFERENCE = True

The visualization is shown as follows:

Text Prompt	Input Image	Grounded SAM 2	Grounded SAM 2 with SAHI
`Person`

Notes: We only support SAHI on Grounding DINO 1.5 because it works better with stronger grounding model which may produce less hallucination results.

Automatically Saving Grounding Results (Image Demo)

After setting DUMP_JSON_RESULTS=True in the following Grounded SAM 2 Image Demos:

The grounding and segmentation results will be automatically saved in the outputs dir with the following format:

{
    "image_path": "path/to/image.jpg",
    "annotations": [
        {
            "class_name": "class_name",
            "bbox": [x1, y1, x2, y2],
            "segmentation": {
                "size": [h, w],
                "counts": "rle_encoded_mask"
            },
            "score": confidence score
        }
    ],
    "box_format": "xyxy",
    "img_width": w,
    "img_height": h
}

Grounded SAM 2 Video Object Tracking Demo

Based on the strong tracking capability of SAM 2, we can combined it with Grounding DINO for open-set object segmentation and tracking. You can run the following scripts to get the tracking results with Grounded SAM 2:

python grounded_sam2_tracking_demo.py

The tracking results of each frame will be saved in ./tracking_results
The video will be save as children_tracking_demo_video.mp4
You can refine this file with different text prompt and video clips yourself to get more tracking results.
We only prompt the first video frame with Grounding DINO here for simple usage.

Support Various Prompt Type for Tracking

We've supported different types of prompt for Grounded SAM 2 tracking demo:

Point Prompt: In order to get a stable segmentation results, we re-use the SAM 2 image predictor to get the prediction mask from each object based on Grounding DINO box outputs, then we uniformly sample points from the prediction mask as point prompts for SAM 2 video predictor
Box Prompt: We directly use the box outputs from Grounding DINO as box prompts for SAM 2 video predictor
Mask Prompt: We use the SAM 2 mask prediction results based on Grounding DINO box outputs as mask prompt for SAM 2 video predictor.

Grounded SAM 2 Video Object Tracking Demo (with Grounding DINO 1.5 & 1.6)

We've also support video object tracking demo based on our stronger Grounding DINO 1.5 model and SAM 2, you can try the following demo after applying the API keys for running Grounding DINO 1.5:

python grounded_sam2_tracking_demo_with_gd1.5.py

Grounded SAM 2 Video Object Tracking Demo with Custom Video Input (with Grounding DINO)

Users can upload their own video file (e.g. assets/hippopotamus.mp4) and specify their custom text prompts for grounding and tracking with Grounding DINO and SAM 2 by using the following scripts:

python grounded_sam2_tracking_demo_custom_video_input_gd1.0_hf_model.py

If you are not convenient to use huggingface demo, you can also run tracking demo with local grounding dino model with the following scripts:

python grounded_sam2_tracking_demo_custom_video_input_gd1.0_local_model.py

Grounded SAM 2 Video Object Tracking Demo with Custom Video Input (with Grounding DINO 1.5 & 1.6)

Users can upload their own video file (e.g. assets/hippopotamus.mp4) and specify their custom text prompts for grounding and tracking with Grounding DINO 1.5 and SAM 2 by using the following scripts:

python grounded_sam2_tracking_demo_custom_video_input_gd1.5.py

You can specify the params in this file:

VIDEO_PATH = "./assets/hippopotamus.mp4"
TEXT_PROMPT = "hippopotamus."
OUTPUT_VIDEO_PATH = "./hippopotamus_tracking_demo.mp4"
API_TOKEN_FOR_GD1_5 = "Your API token" # api token for G-DINO 1.5
PROMPT_TYPE_FOR_VIDEO = "mask" # using SAM 2 mask prediction as prompt for video predictor

After running our demo code, you can get the tracking results as follows:

And we will automatically save the tracking visualization results in OUTPUT_VIDEO_PATH.

[!WARNING] We initialize the box prompts on the first frame of the input video. If you want to start from different frame, you can refine ann_frame_idx by yourself in our code.

Grounded-SAM-2 Video Object Tracking with Continuous ID (with Grounding DINO)

In above demos, we only prompt Grounded SAM 2 in specific frame, which may not be friendly to find new object during the whole video. In this demo, we try to find new objects and assign them with new ID across the whole video, this function is still under develop. it's not that stable now.

Users can upload their own video files and specify custom text prompts for grounding and tracking using the Grounding DINO and SAM 2 frameworks. To do this, execute the script:

python grounded_sam2_tracking_demo_with_continuous_id.py

You can customize various parameters including:

text: The grounding text prompt.
video_dir: Directory containing the video files.
output_dir: Directory to save the processed output.
output_video_path: Path for the output video.
step: Frame stepping for processing.
box_threshold: box threshold for groundingdino model
text_threshold: text threshold for groundingdino model Note: This method supports only the mask type of text prompt.

After running our demo code, you can get the tracking results as follows:

If you want to try Grounding DINO 1.5 model, you can run the following scripts after setting your API token:

python grounded_sam2_tracking_demo_with_continuous_id_gd1.5.py

Grounded-SAM-2 Video Object Tracking with Continuous ID plus Reverse Tracking(with Grounding DINO)

This method could simply cover the whole lifetime of the object

python grounded_sam2_tracking_demo_with_continuous_id_plus.py

Grounded SAM 2 Florence-2 Demos

Grounded SAM 2 Florence-2 Image Demo

In this section, we will explore how to integrate the feature-rich and robust open-source models Florence-2 and SAM 2 to develop practical applications.

Florence-2 is a powerful vision foundation model by Microsoft which supports a series of vision tasks by prompting with special task_prompt includes but not limited to:

Task	Task Prompt	Text Input	Task Introduction
Object Detection	`<OD>`	✘	Detect main objects with single category name
Dense Region Caption	`<DENSE_REGION_CAPTION>`	✘	Detect main objects with short description
Region Proposal	`<REGION_PROPOSAL>`	✘	Generate proposals without category name
Phrase Grounding	`<CAPTION_TO_PHRASE_GROUNDING>`	✔	Ground main objects in image mentioned in caption
Referring Expression Segmentation	`<REFERRING_EXPRESSION_SEGMENTATION>`	✔	Ground the object which is most related to the text input
Open Vocabulary Detection and Segmentation	`<OPEN_VOCABULARY_DETECTION>`	✔	Ground any object with text input

Integrate Florence-2 with SAM-2, we can build a strong vision pipeline to solve complex vision tasks, you can try the following scripts to run the demo:

[!NOTE] 🚨 If you encounter network issues while using the HuggingFace model, you can resolve them by setting the appropriate mirror source as export HF_ENDPOINT=https://hf-mirror.com

Object Detection and Segmentation

python grounded_sam2_florence2_image_demo.py \
    --pipeline object_detection_segmentation \
    --image_path ./notebooks/images/cars.jpg

Dense Region Caption and Segmentation

python grounded_sam2_florence2_image_demo.py \
    --pipeline dense_region_caption_segmentation \
    --image_path ./notebooks/images/cars.jpg

Region Proposal and Segmentation

python grounded_sam2_florence2_image_demo.py \
    --pipeline region_proposal_segmentation \
    --image_path ./notebooks/images/cars.jpg

Phrase Grounding and Segmentation

python grounded_sam2_florence2_image_demo.py \
    --pipeline phrase_grounding_segmentation \
    --image_path ./notebooks/images/cars.jpg \
    --text_input "The image shows two vintage Chevrolet cars parked side by side, with one being a red convertible and the other a pink sedan, \
            set against the backdrop of an urban area with a multi-story building and trees. \
            The cars have Cuban license plates, indicating a location likely in Cuba."

Referring Expression Segmentation

python grounded_sam2_florence2_image_demo.py \
    --pipeline referring_expression_segmentation \
    --image_path ./notebooks/images/cars.jpg \
    --text_input "The left red car."

Open-Vocabulary Detection and Segmentation

python grounded_sam2_florence2_image_demo.py \
    --pipeline open_vocabulary_detection_segmentation \
    --image_path ./notebooks/images/cars.jpg \
    --text_input "car <and> building"

Note that if you want to detect multiple classes you should split them with <and> in your input text.

Grounded SAM 2 Florence-2 Image Auto-Labeling Demo

Florence-2 can be used as a auto image annotator by cascading its caption capability with its grounding capability.

Task	Task Prompt	Text Input
Caption + Phrase Grounding	`<CAPTION>` + `<CAPTION_TO_PHRASE_GROUNDING>`	✘
Detailed Caption + Phrase Grounding	`<DETAILED_CAPTION>` + `<CAPTION_TO_PHRASE_GROUNDING>`	✘
More Detailed Caption + Phrase Grounding	`<MORE_DETAILED_CAPTION>` + `<CAPTION_TO_PHRASE_GROUNDING>`	✘

You can try the following scripts to run these demo:

Caption to Phrase Grounding

python grounded_sam2_florence2_autolabel_pipeline.py \
    --image_path ./notebooks/images/groceries.jpg \
    --pipeline caption_to_phrase_grounding \
    --caption_type caption

You can specify caption_type to control the granularity of the caption, if you want a more detailed caption, you can try --caption_type detailed_caption or --caption_type more_detailed_caption.

Citation

If you find this project helpful for your research, please consider citing the following BibTeX entry.

@misc{ravi2024sam2segmentimages,
      title={SAM 2: Segment Anything in Images and Videos}, 
      author={Nikhila Ravi and Valentin Gabeur and Yuan-Ting Hu and Ronghang Hu and Chaitanya Ryali and Tengyu Ma and Haitham Khedr and Roman Rädle and Chloe Rolland and Laura Gustafson and Eric Mintun and Junting Pan and Kalyan Vasudev Alwala and Nicolas Carion and Chao-Yuan Wu and Ross Girshick and Piotr Dollár and Christoph Feichtenhofer},
      year={2024},
      eprint={2408.00714},
      archivePrefix={arXiv},
      primaryClass={cs.CV},
      url={https://arxiv.org/abs/2408.00714}, 
}

@article{liu2023grounding,
  title={Grounding dino: Marrying dino with grounded pre-training for open-set object detection},
  author={Liu, Shilong and Zeng, Zhaoyang and Ren, Tianhe and Li, Feng and Zhang, Hao and Yang, Jie and Li, Chunyuan and Yang, Jianwei and Su, Hang and Zhu, Jun and others},
  journal={arXiv preprint arXiv:2303.05499},
  year={2023}
}

@misc{ren2024grounding,
      title={Grounding DINO 1.5: Advance the "Edge" of Open-Set Object Detection}, 
      author={Tianhe Ren and Qing Jiang and Shilong Liu and Zhaoyang Zeng and Wenlong Liu and Han Gao and Hongjie Huang and Zhengyu Ma and Xiaoke Jiang and Yihao Chen and Yuda Xiong and Hao Zhang and Feng Li and Peijun Tang and Kent Yu and Lei Zhang},
      year={2024},
      eprint={2405.10300},
      archivePrefix={arXiv},
      primaryClass={cs.CV}
}

@misc{ren2024grounded,
      title={Grounded SAM: Assembling Open-World Models for Diverse Visual Tasks}, 
      author={Tianhe Ren and Shilong Liu and Ailing Zeng and Jing Lin and Kunchang Li and He Cao and Jiayu Chen and Xinyu Huang and Yukang Chen and Feng Yan and Zhaoyang Zeng and Hao Zhang and Feng Li and Jie Yang and Hongyang Li and Qing Jiang and Lei Zhang},
      year={2024},
      eprint={2401.14159},
      archivePrefix={arXiv},
      primaryClass={cs.CV}
}

@article{kirillov2023segany,
  title={Segment Anything}, 
  author={Kirillov, Alexander and Mintun, Eric and Ravi, Nikhila and Mao, Hanzi and Rolland, Chloe and Gustafson, Laura and Xiao, Tete and Whitehead, Spencer and Berg, Alexander C. and Lo, Wan-Yen and Doll{\'a}r, Piotr and Girshick, Ross},
  journal={arXiv:2304.02643},
  year={2023}
}

@misc{jiang2024trex2,
      title={T-Rex2: Towards Generic Object Detection via Text-Visual Prompt Synergy}, 
      author={Qing Jiang and Feng Li and Zhaoyang Zeng and Tianhe Ren and Shilong Liu and Lei Zhang},
      year={2024},
      eprint={2403.14610},
      archivePrefix={arXiv},
      primaryClass={cs.CV}
}

HighCapable/YukiHookAPI

2024-11-24T01:40:09Z

⛱️ An efficient Hook API and Xposed Module solution built in Kotlin.

Yuki Hook API

⛱️ An efficient Hook API and Xposed Module solution built in Kotlin.

English | 简体中文

	HighCapable

This project belongs to the above-mentioned organization, click the link above to follow this organization and discover more good projects.

What's this

This is an efficient Hook API rebuilt based on the Xposed API using Kotlin, and creates rich function extensions for the development of Xposed Modules.

The name is taken from "ももくり" heroine Yuki Kurihara.

Formerly the Innocent Xposed API used in Development Learning Project, now renamed and open sourced.

Get Started

Click here go to the documentation page for more detailed tutorials and content.

For supportive related information, you can check it directly click here.

Cooperations

The following are projects that have collaborated and are using YukiHookAPI.

Repository	Developer
TSBattery	fankesyooni
MIUI 原生通知图标	fankesyooni
ColorOS 通知图标增强	fankesyooni
自由屏幕旋转	fankesyooni
拒绝强制亮度	fankesyooni
AppErrorsTracking	fankesyooni
Enable WebView Debugging	WankkoRee
Fuck MIUI Gesture	mahoshojoHCG
MIUI遮罩进化	GSWXXN
Color OS Installer Plus	NextAlone
Auto NFC	GSWXXN
不要竖屏	WankkoRee
QDReadHook	xihan123
HXReadHook	xihan123
WxRecordRead	Coderpwh
FuckShake	Coderpwh
MIUI更新进化	ZQDesigned
MIUI录屏进化	ZQDesigned
Fuck AD	hujiayucc
Zuiyou ADFree	kazutoiris
Dingda ADFree	kazutoiris
Infinite Illusion	kazutoiris
HookGG	HdShare

Are you also using YukiHookAPI? Come and PR to add your repository to the list above (private repositories do not need to indicate web links).

Promotion

Hey, please stay! 👋

Here are related projects such as Android development tools, UI design, Gradle plugins, Xposed Modules and practical software.

If the project below can help you, please give me a star!

All projects are free, open source, and follow the corresponding open source license agreement.

→ To see more about my projects, please click here ←

Star History

Third-Party Open Source Usage Statement

License

Apache-2.0

Apache License Version 2.0

Copyright (C) 2019-2024 HighCapable

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    https://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

ufmg-smite/lean-smt

2024-11-24T01:32:24Z

Tactics for discharging Lean goals into SMT solvers.

wofsauge/External-Item-Descriptions

2024-11-23T01:32:21Z

A mod for the game "The Binding of Isaac: Rebirth" that displays useful informations for items, trinkets, rooms and more!

External Item Descriptions

A mod for the game "The Binding of Isaac: Rebirth" that displays useful information for items, trinkets, rooms and more!

This version is designed to be used with the Afterbirth+ and Repentance DLCs.

Features

Compatible with Afterbirth+ and Repentance
Displays information for all collectibles, trinkets, cards, runes, pills, horsepills and some rooms
Displays additional information like item type, charges, transformations, Spindown Dice results, Bag of Crafting recipes, TMTRAINER item effects (Detailed informations require REPENTOGON installed!), and much much more!
Mod support for nearly all mods!
Extended features available with Repentogon
Easy to use API (Documentation here)
A huge amount of custom options like:
- Indicators
- Font styles
- 17+ different Languages
- And a lot of visual options!
Press F2 to hide/show the descriptions!

Supported Languages

Chinese, Czech, Dutch, English, French, German, Italian, Japanese, Korean, Polish, Portuguese, Russian, Spanish, Brazilian-Portuguese, Turkish, Ukrainian

Versions

There are multiple Versions of the mod, depending on which DLCs you have installed. You are currently looking at the version for Afterbirth+ and Repentance.

Rebirth (no DLCs): MediaFire
Afterbirth (first DLC): ModdingOfIsaac.com - MediaFire mirror
Afterbirth+ and Repentance: Steam Workshop - GitHub

Installation

For Steam users, simply press the "Subscribe" button on the mod's Steam Workshop page. This will automatically install the mod for you. For manual mod installation or installation trouble shooting, read this tutorial "How to install the mod"

Configuration

Simply install "Mod Config Menu - Pure". You can use it to configure the mod while playing.

Alternatively, edit the eid_config.lua file like described here.

Special Thanks to

Check out the credits here

Stephan-S/FS22_AutoDrive

2024-11-24T01:40:31Z

FS22 version of the AutoDrive mod

FS22_AutoDrive

FS22 version of the AutoDrive mod

Latest Release: 2.0.1.8

Direct Download: https://github.com/Stephan-S/FS22_AutoDrive/releases/latest/download/FS22_AutoDrive.zip

Discord Server:

For help & support, feel free to join us on Discord: https://discord.gg/9D4B5hX

For a little thank you

If you like our work, feel free to buy us a coffee (of which we drink quite a lot :D )
For now, there is no general link for the team, so each contributer can post his/her preferred donation link here :-)
But remember, this is absolutely not required. We value any issues and feature requests the same!
And to all who do donate: Thank you very much :-)

Stephan (Founder):

https://www.paypal.me/StephanSchlosser

Iwan1803 (Community Manager, Supporter & Tester):

https://iwan1803.de/urls/tip

Axel & Tommo (Modder)

Willi (Supporter & Tester)

Course Editor

The course editor is now maintained by @KillBait and can be found here: https://github.com/KillBait/AutoDrive_Course_Editor

Courseplay/Courseplay_FS22

2024-11-24T01:40:31Z

Courseplay for Farming Simulator 2022

Courseplay Beta for Farming Simulator 2022

Download the latest developer version (the file FS22_Courseplay.zip).

Courseplay Website

What Works

Multiplayer support
Fieldwork mode:
- Course generator for complex fields with many option like headlands or beets with combines and so on ..
- Up to 5 workers with the same tools can work together on a field with the same course (multi tools)
- Generate courses for vine work
- Save/load/rename/move courses
- Load courses for baling, straw or grass collection and so on
- Combines can automatically unload into nearby trailers (combine self unload)
Bale collector mode:
- Wrapping bales on a field without a course
- Collecting bales on the field without a course and unloading them with AutoDrive
Combine unloader mode:
- Unload combines on the field
- Sending the giants helper or AutoDrive to unload at an unload station
- Creating heaps of sugar beets or other fruits on the field
- Unloading a loader vehicle, like the ROPA Maus and letting AutoDrive or Giants unload the trailer after that
Silo load mode:
- Loading from a heap or bunker silo with loader, like the ROPA Maus
- Using a wheel loader or a front loader to load from a heap or a bunker silo and unload to:
  - Unloading to nearby trailers
  - Unloading to an unloading station, which needs to be selected on the AI menu
Bunker silo mode:
- Compacting the silo with or without tools like this one Silo distributor
- Using a shield in a silo with a back wall to push the chaff to the back of silo
Misc:
- Creating custom fields by recording the boarder with a vehicle or drawing on the AI Map.
- Course editor in the buy menu to edit courses or custom fields.
Mod support with AutoDrive:
- Sending the fieldwork driver to refill seeds/fertilizers and so on.
- Sending the fieldworker/ bale collector to unload collected straw and so on.
- Sending the fieldwork driver to refuel or repair.
Bale collector mod support for:
- Pallet Autoload Specialization
- Universal Autoload

Usage

Courseplay functions are now documented in the in-game help menu:

If you prefer videos, YouTube has many great tutorials

Turning on Debug Channels

When there's an issue, you can turn on debug logging on the Courseplay vehicle settings page for each vehicle. This will enable logging of debug information for only this vehicle. Devs need those logs for troubleshooting and fixing bugs.

What information is logged when you activated the debug logging for the vehicle depends on the active debug channels. This are similar to those we had in CP 19, but the way to turn them on/off is different: you can bring up the debug channel menu by pressing Shift+4, then use Shift+1 and Shift+3 to select a channel, and then Shift+2 to toggle the selected debug channel (green is on).

Remember, you have to activate debug mode for the vehicle in the vehicle settings page, otherwise nothing is logged, even if the channel is active.

Developer version

Please be aware you're using a developer version, which may and will contain errors, bugs, mistakes and unfinished code. Chances are you computer will explode when using it. Twice. If you have no idea what "beta", "alpha", or "developer" means and entails, steer clear. The Courseplay team will not take any responsibility for crop destroyed, savegames deleted or baby pandas killed.

You have been warned.

If you're still ok with this, please remember to post possible issues that you find in the developer version. That's the only way we can find sources of error and fix them. Be as specific as possible:

tell us the version number
only use the vehicles necessary, not 10 other ones at a time
which vehicles are involved, what is the intended action?
Post! The! Log! to Gist or PasteBin
For more details on how to post a proper bug report, visit our Wiki

Help Us Out

We work long, hard, in our own free time at developing and improving Courseplay. If you like the project, show us your undying love:

Contributors

See Contributors

Supporters

People and teams who support us

Ameyer1233 ModHoster Profile
Burning Gamers YouTube Channel
Mario Hirschfeld YouTube Channel

gaboolic/rime-frost

2024-11-24T01:40:31Z

白霜词库：蒹葭苍苍，白露为霜。基于雾凇拼音重制的，更纯净、词频准确、智能的词库。使用745396750字的高质量语料，进行分词，重新统计字频、词频，归一化。白霜词库是目前rime方案下最好的词库，在不使用智能模型的情况下可以超越使用智能模型的词库方案。目前使用白霜词库的方案有：墨奇音形（双拼辅）https://github.com/gaboolic/rime-shuangpin-fuzhuma 、墨奇五笔整句https://github.com/gaboolic/rime-wubi-sentence

白霜拼音

原始配置和词库由雾凇拼音的 af2480b commit 修改而来。

雾凇词库里的词比较全但也不是非常全，主要的问题是字频和词频不太对，废词有点多，于是重新制作。

主要维护词库、词频。在雾凇词库的基础上删除了不健康词汇，删除了大量冷僻词（频率==1 且分词器分不出的词），删除/调整了诸如“的吧”、“的了”这种不是词的词。手动大量修改了字频词频。第一步是做了减法。

然后使用 745396750 字的高质量语料，进行分词，重新统计字频、词频，归一化，以达到更好的输入效果。全拼和双拼都可以使用。

使用方法

使用方法基本同雾凇拼音，微调了一些触发指令，加入了lua辅助码的支持。辅助码是可选项，按下`开启，不影响正常打字。

符号 /fh 更多符号详见https://github.com/gaboolic/rime-frost/blob/master/symbols_v.yaml
带调韵母 /a /e /u 等
日期与时间 rq sj xq dt ts
开启辅助码 ` 墨奇辅助码拆分说明
部件拆字反查 uU
unicode字符 U
数字金额大写 R
农历 N
计算器 V

如何安装&配置文件路径

手动下载安装

下载本仓库的压缩包 Code - Download ZIP（或者下载releases最新的 source-code.zip），解压到如下路径即可

Windows: %APPDATA%\Rime （可以在右下角小狼毫输入法右键打开菜单选用户文件夹）复制完之后，去输入法设定里选择白霜拼音，然后重新部署
Mac
- 鼠须管路径为 ~/Library/Rime
- fcitx5-Mac 版路径为 ~/.local/share/fcitx5/rime
Linux
- fcitx5-rime路径为 ~/.local/share/fcitx5/rime
- fcitx5 flatpak 版的路径 ~/.var/app/org.fcitx.Fcitx5/data/fcitx5/rime
- ibus-rime路径为 ~/.config/ibus/rime
Android
- fcitx5-安卓版路径为 /Android/data/org.fcitx.fcitx5.android/files/data/rime
- 同文路径为 /rime
- 雨燕已内置白霜词库词频，直接安装使用即可
iOS 仓输入法目前已内置，也可以通过【输入方案设置 - 右上角加号 - 方案下载 - 覆盖并部署】来更新白霜拼音。

通过 Git 安装

首次安装：

根据用户使用的系统、安装的软件不同，先cd到对应的配置文件的父级目录(例如Windows为%APPDATA%、mac鼠须管为~/Library/)，然后执行以下命令：

git clone --depth 1 https://github.com/gaboolic/rime-frost Rime

后续更新：

在 Rime 文件夹执行 git pull 即可。

Mac: cd ~/Library/Rime && git pull
Windows: cd "$env:APPDATA\Rime" && git pull
其他系统以此类推

通过东风破安装

选择配方（others/recipes/*.recipe.yaml）来进行安装或更新：

℞ 安装或更新全部文件执行bash rime-install gaboolic/rime-frost:others/recipes/full

无智能模型时的输入效果

To-Do

整理分词后词频比较高但词库没有的词加进去
错字错音提醒lua
写自动化脚本，把句子转成拼音，再用拼音调用 rime_api 生成句子，比对正确率，迭代
加上墨奇码首末字形反查，例如 amq 引导符再打 mu cun 可以打出“村櫉梼树”等字
加上 lua 引导辅助码的功能
2 字词，动词+名词结构，中间加入“了” “完”，结尾加入“没”自动派生词汇。
- 例如：
  - 拔牙：拔了牙，拔完牙，拔牙没，没拔牙，拔没拔牙
- 形容词中间加“不”：
  - 例如：厉害→厉不厉害
类似“第四四列 = 第四列”这种词加上去
统计中文语料中的英文词频
训练一个智能语言模型

鸣谢

雾凇词库 https://github.com/iDvel/rime-ice 白霜词库的初始词库、绝大部分配置来自雾凇词库

结巴中文分词 https://github.com/fxsjy/jieba

汉字转拼音(pypinyin) https://github.com/mozillazg/python-pinyin

MNBVC 超大规模中文语料集 https://github.com/esbatmop/MNBVC 目前已有 33TB 数据量

kenlm https://github.com/kpu/kenlm 官网https://kheafield.com/code/kenlm/

kenlm 教程、python 调用 https://github.com/mattzheng/py-kenlm-model

吉祥物(于2024-10-12捡来)：

友情链接

使用白霜词库的方案

墨奇音形 https://github.com/gaboolic/rime-shuangpin-fuzhuma

墨奇五笔整句 https://github.com/gaboolic/rime-wubi-sentence

薄荷拼音 https://github.com/Mintimate/oh-my-rime

雨燕输入法 https://github.com/gurecn/YuyanIme 一个开箱即用的安卓输入法内置白霜词库

Star History

ROCm/rocMLIR

2024-11-24T01:33:08Z

ROCm/rocMLIR

2024-11-24T01:40:58Z

MarceColl/zen-browser-flake

2024-11-24T01:41:19Z

Nix Flake for the Zen Browser

khaneliman/khanelinix

2024-11-24T01:41:19Z

Nix configuration for my systems supporting macOS, NixOS, and WSL.

coq/vscoq

2024-11-24T01:33:39Z

Visual Studio Code extension for Coq

laytan/odin-http

2024-11-24T01:41:33Z

A HTTP/1.1 client/server implementation for Odin.

liske/needrestart

2024-11-23T01:33:34Z

Restart daemons after library updates.

needrestart

About

needrestart checks which daemons need to be restarted after library upgrades. It is inspired by checkrestart from the debian-goodies package.

There are some hook scripts in the ex/ directory (to be used with apt and dpkg. The scripts will call needrestart after any package installation/upgrades.

needrestart should work on GNU/Linux. It has limited functionality on GNU/kFreeBSD since /proc/<pid>/maps does not show removed file links.

Restarting Services

needrestart supports but does not require systemd (available since v0.6). If systemd is used you should use libpam-systemd, too. If needrestart detects systemd it will assume that libpam-systemd is used and relies on cgroup names to detect if a process belongs to a user session or a daemon. If you do not use libpam-systemd you should set $nrconf{has_pam_systemd} to 0 within needrestart.conf.

If systemd is not available or does not return a service name needrestart uses hooks to identify the corresponding System V init script. The shipped hooks support the following package managers:

dpkg
rpm
pacman

The service command is used to run the traditional System V init script.

Frontends

needrestart uses a modular approach based on perl packages providing the user interface. The following frontends are shipped:

NeedRestart::UI::Debconf using debconf
NeedRestart::UI::stdio fallback using stdio interaction

Kernel & Microcode

needrestart 0.8 brings a obsolete kernel detection feature. Since needrestart 3.5 it is possible to filter kernel image filenames (required on Raspberry Pi).

In needrestart 3.0 a processor microcode update detection feature for Intel CPUs has been added. Since needrestart 3.5 the AMD CPU support has been added.

Interpreters

needrestart 0.8 brings an interpreter scanning feature. Interpreters not only map binary (shared) objects but also use plaintext source files. The interpreter detection tries to check for outdated source files since they may contain security issues, too. This is only a heuristic and might fail to detect all relevant source files. The following interpreter scanners are shipped:

NeedRestart::Interp::Java
NeedRestart::Interp::Perl
NeedRestart::Interp::Python
NeedRestart::Interp::Ruby

Containers

needrestart 2.1 detects some container technologies. If a process is part of a container it might not be possible to restart it using Sys-V/systemd.

There are special perl packages (NeedRestart::CONT::*) implementing the container detection and restarting. The following container detectors are shipped:

NeedRestart::CONT::docker
NeedRestart::CONT::LXC
NeedRestart::CONT::machined

Batch Mode

needrestart can be run in batch mode to use the results within other programs or scripts.

There is also a nagios plugin mode available.

mettle/sendportal

2024-11-24T01:41:52Z

Open-source self-hosted email marketing. Manage your own newsletters at a fraction of the cost.

Modern open-source self-hosted email marketing.

Introduction

The core functionality of SendPortal is contained within the SendPortal Core package. If you would like to add SendPortal to an existing application that already handles user authentication, you only require SendPortal Core.

Features

SendPortal includes subscriber and list management, email campaigns, message tracking, reports and multiple workspaces/domains in a modern, flexible and scalable application.

SendPortal integrates with Amazon SES, Postmark, Sendgrid, Mailgun and Mailjet.

The SendPortal application acts as a wrapper around SendPortal Core. This will allow you to run your own copy of SendPortal as a stand-alone application, including user authentication and multiple workspaces.

Installation

If you would like to install SendPortal as a stand-alone application, please follow the installation guide.

If you would like to add SendPortal to an existing application, please follow the package installation guide.

Requirements

SendPortal V3 requires:

PHP 8.2+
Laravel 10+
MySQL (≥ 5.7) or PostgreSQL (≥ 9.4)

If you are on an earlier version of PHP (7.3+) or Laravel (8+), please use SendPortal V2

phpipam/phpipam

2024-11-24T01:41:52Z

phpipam development repository

{php}IPAM

Website: https://phpipam.net/

Description

phpIPAM is an open-source web IP address management application. Its goal is to provide light and simple IP address management application. It is ajax-based using jQuery libraries, it uses php scripts and javascript and some HTML5/CSS3 features, so some modern browser is preferred to be able to display javascript quickly and correctly.

Branches

MASTER: Latest stable release
DEVELOP: Current development branch
1.7: Maintenance branch for 1.7.x releases
1.6: Maintenance branch for 1.6.x releases (obsolete)
1.5: Maintenance branch for 1.5.x releases (obsolete)
1.4: Maintenance branch for 1.4.x releases (obsolete)
1.3: Maintenance branch for 1.3.x releases (obsolete)
1.2: Maintenance branch for 1.2.x releases (obsolete)
Other branches: Feature testing

Supported PHP versions

phpIPAM has been developed and tested on the following PHP versions.
The use of untested PHP versions is unsupported and may result in compatibility issues.

MASTER: See latest 1.x.y release version
DEVELOP: PHP versions 7.2 to 8.4
1.7.x: PHP versions 7.2 to 8.3
1.6.x: PHP versions 7.2 to 8.3
1.5.x: PHP versions 5.4 to 7.4
1.4.x: PHP versions 5.4 to 7.4
1.3.x: PHP versions 5.4 to 7.1

Supported MySQL / MariaDB versions

Common Table Expressions (CTE) query support highly recommended : MySQL 8.0+ / MariaDB 10.2.1+
As of v1.6.0 support for utf8mb4 is mandatory: MySQL 5.7.7+

I forgot my Admin password!?

Just run php functions/scripts/reset-admin-password.php in the cli and enter your new password

Reverse-Proxy (Infinite login loops)

As of v1.6.0 when deployed behind a reverse-proxy, set config.php $trust_x_forwarded_headers = true; or Docker image environment variable IPAM_TRUST_X_FORWARDED=true to accept HTTP X_FORWARDED_ headers.

WARNING! The following HTTP headers shoud be filtered and/or overwritten by the reverse-proxy to avoid potential abuse by end-clients.

X_FORWARDED_FOR
X_FORWARDED_HOST
X_FORWARDED_PORT
X_FORWARDED_PROTO
X_FORWARDED_SSL
X_FORWARDED_URI

What are the credentials for a fresh install?

The Default credentials for a new instance of phpIPAM are the same as the credentials for the demo page: Admin / ipamadmin

Docker

Community maintained docker images are available at https://hub.docker.com/u/phpipam

Changelog

See misc/CHANGELOG

Roadmap

See misc/Roadmap

Security

See SECURITY.md

Contact

miha.petkovsek@gmail.com

Special thanks are going also to the Hosterdam team (http://www.hosterdam.com) for the VPS server that is used for development of phpIPAM and for demo site.

And also to all users that filed a bug report / feature report and helped with feature testing!

License

phpIPAM is released under the GPL v3 license, see misc/gpl-3.0.txt.

Azure/Security-Copilot

2024-11-24T01:42:08Z

Microsoft Security Copilot is a generative AI-powered security solution that helps increase the efficiency and capabilities of defenders to improve security outcomes at machine speed and scale, while remaining compliant to responsible AI principles

Microsoft Security Copilot Community

Welcome to the Security Copilot Repository!

Microsoft Security Copilot is a generative AI-powered assistant for daily operations in security and IT that empowers teams to protect at the speed and scale of AI.

Contributing

This project welcomes contributions and suggestions. Most contributions require you to agree to a Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us the rights to use your contribution. For details, visit https://cla.opensource.microsoft.com.

When you submit a pull request, a CLA bot will automatically determine whether you need to provide a CLA and decorate the PR appropriately (e.g., status check, comment). Simply follow the instructions provided by the bot. You will only need to do this once across all repos using our CLA.

This project has adopted the Microsoft Open Source Code of Conduct. For more information see the Code of Conduct FAQ or contact opencode@microsoft.com with any additional questions or comments.

Here are the steps you can take to begin contributing to this project:

GitHub account:

Get a GitHub account – (www.github.com ) - Free account works fine.
Login with your new account

Fork the Repository:

Go to the community page: https://github.com/Azure/Copilot-For-Security
Make sure you are on the master branch
Click "Fork" -> "Create a new fork"
This will create a copy of the Security Copilot repository in your own GitHub account:

Clone the fork to your local machine::

You can install Gitbash from https://git-scm.com/downloads if you dont already have it.
Create a directory on your local machine where you will pull down the repository to and where you will be working from. Example: “C:\Users(username)\Documents\GitForks”
Open Gitbash and move into the directory “C:\Users(username)\Documents\GitForks”
Run : Git init
Run : Git clone example: Git clone “ https://github.com/(username)/ Copilot-For-Security-Fork”
Cd into the new directory that is created ie cd Copilot-For-Security-Fork
Set the upstream which is the original repo that you forked from ie the Copilot-For-Security community repo
Run : Git remote add upstream https://github.com/Azure/Copilot-For-Security
Run : Git remote -v

You can do this using GitHub Desktop as well by downloading it from https://desktop.github.com

Create a branch:

You can work with the local main branch, but it is recommended to work with a branch so if you have separate projects you are working on you can keep them isolated.
First you want to sync your local repository to the upstream master (the Azure community itself – not your fork) Run : git pull upstream main
You should see a list of updates that are processed or a message saying you are up to date
Now that you are in sync create your new branch Run : Git checkout -b example Git checkout -b Sojeshs_CFSContributions

Install VS Code:

[Download Visual Studio Code - Mac, Linux, Windows]

Open Branch in VS Code:

Run VS Code and then File > Open Folder the local repository directory (Example: C:\Users\(username)\Documents\GitForks\Copilot-For-Security-Fork)

You should see all the directories and files in the repository and at the bottom you can see which branch you are working on. Ensure you have the right branch selected before making any changes.

Stage, Commit and Publish your changes

When you have created the content that you want in VS Code you will need to stage and commit your changes. This will commit them to the branch you have created locally on you machine. For example, I created a new folder by name "SentinelDailyOperations" and KQL Plugin called “KQL_SentinelDailyOperationsSample.yml” within the "Community Based Plugins" directory. You can also add any additional content needed to document and deploy this Plugin.

Now, when you are ready to commit your changes click on the Source Control icon on the left, enter a Message summarizing your changes and hit “+”. This stages the changes. Next click the checkmark to commit your changes. These are still local to your machine.

You can now publish this work off to your personal GitHub by clicking the icon next to the branch name (if it throws up a list up top of repositories pick yours /Copilot-For-Security NOT Azure/Copilot-For-Security). In this example case we are picking the main branch iteself to publish my changes with new plugin.

You can now review your commited changes in your GitHub going to the respective branch:

If you are done with all your work and ready to submit to the main repository, then you need to do a Pull Request. This request will kick off a set of automated checks and if those pass then it goes to a board of reviewers – one of whom has to check your work and accept the request and merge it to the master branch.

The top portion of the "Open a pull request" page is critical. This shows from which repository and branch are you pulling from and to which repository are you pulling to. You should fill in the comments section with a meaningful name and a list of what you have done since the reviewer will be reading this. Then click “Create pull request”

Once the changes are merged to the main GitHub, you should be able to see changes committed to the main GitHub repository.

Check your pull request status and sync from main repository

After your Pull Request has been merged, please check to make sure it got into the main repository. We recommend checking both in the GitHub website as well as by doing a sync to your local repo and verifying the changes are now in place.

Good Luck and Happy Contributing to Security Copilot Community !!!!

encode/starlette

2024-11-23T01:34:07Z

Official inference repo for FLUX.1 models

FLUX

by Black Forest Labs: https://blackforestlabs.ai. Documentation for our API can be found here: docs.bfl.ml.

This repo contains minimal inference code to run image generation & editing with our Flux models.

Local installation

cd $HOME && git clone https://github.com/black-forest-labs/flux
cd $HOME/flux
python3.10 -m venv .venv
source .venv/bin/activate
pip install -e ".[all]"

Models

We are offering an extensive suite of models. For more information about the invidual models, please refer to the link under Usage.

Name	Usage	HuggingFace repo	License
`FLUX.1 [schnell]`	Text to Image	https://huggingface.co/black-forest-labs/FLUX.1-schnell	apache-2.0
`FLUX.1 [dev]`	Text to Image	https://huggingface.co/black-forest-labs/FLUX.1-dev	FLUX.1-dev Non-Commercial License
`FLUX.1 Fill [dev]`	In/Out-painting	https://huggingface.co/black-forest-labs/FLUX.1-Fill-dev	FLUX.1-dev Non-Commercial License
`FLUX.1 Canny [dev]`	Structural Conditioning	https://huggingface.co/black-forest-labs/FLUX.1-Canny-dev	FLUX.1-dev Non-Commercial License
`FLUX.1 Depth [dev]`	Structural Conditioning	https://huggingface.co/black-forest-labs/FLUX.1-Depth-dev	FLUX.1-dev Non-Commercial License
`FLUX.1 Canny [dev] LoRA`	Structural Conditioning	https://huggingface.co/black-forest-labs/FLUX.1-Canny-dev-lora	FLUX.1-dev Non-Commercial License
`FLUX.1 Depth [dev] LoRA`	Structural Conditioning	https://huggingface.co/black-forest-labs/FLUX.1-Depth-dev-lora	FLUX.1-dev Non-Commercial License
`FLUX.1 Redux [dev]`	Image variation	https://huggingface.co/black-forest-labs/FLUX.1-Redux-dev	FLUX.1-dev Non-Commercial License
`FLUX.1 [pro]`	Text to Image	Available in our API.
`FLUX1.1 [pro]`	Text to Image	Available in our API.
`FLUX1.1 [pro] Ultra/raw`	Text to Image	Available in our API.
`FLUX.1 Fill [pro]`	In/Out-painting	Available in our API.
`FLUX.1 Canny [pro]`	Structural Conditioning	Available in our API.
`FLUX.1 Depth [pro]`	Structural Conditioning	Available in our API.
`FLUX1.1 Redux [pro]`	Image variation	Available in our API.
`FLUX1.1 Redux [pro] Ultra`	Image variation	Available in our API.

The weights of the autoencoder are also released under apache-2.0 and can be found in the HuggingFace repos above.

API usage

Our API offers access to our models. It is documented here: docs.bfl.ml.

In this repository we also offer an easy python interface. To use this, you first need to register with the API on api.bfl.ml, and create a new API key.

To use the API key either run export BFL_API_KEY=<your_key_here> or provide it via the api_key=<your_key_here> parameter. It is also expected that you have installed the package as above.

Usage from python:

from flux.api import ImageRequest

# this will create an api request directly but not block until the generation is finished
request = ImageRequest("A beautiful beach", name="flux.1.1-pro")
# or: request = ImageRequest("A beautiful beach", name="flux.1.1-pro", api_key="your_key_here")

# any of the following will block until the generation is finished
request.url
# -> https:<...>/sample.jpg
request.bytes
# -> b"..." bytes for the generated image
request.save("outputs/api.jpg")
# saves the sample to local storage
request.image
# -> a PIL image

Usage from the command line:

$ python -m flux.api --prompt="A beautiful beach" url
https:<...>/sample.jpg

# generate and save the result
$ python -m flux.api --prompt="A beautiful beach" save outputs/api

# open the image directly
$ python -m flux.api --prompt="A beautiful beach" image show

junyanz/pytorch-CycleGAN-and-pix2pix

2024-11-23T01:34:07Z

Image-to-Image Translation in PyTorch

CycleGAN and pix2pix in PyTorch

New: Please check out img2img-turbo repo that includes both pix2pix-turbo and CycleGAN-Turbo. Our new one-step image-to-image translation methods can support both paired and unpaired training and produce better results by leveraging the pre-trained StableDiffusion-Turbo model. The inference time for 512x512 image is 0.29 sec on A6000 and 0.11 sec on A100.

Please check out contrastive-unpaired-translation (CUT), our new unpaired image-to-image translation model that enables fast and memory-efficient training.

We provide PyTorch implementations for both unpaired and paired image-to-image translation.

The code was written by Jun-Yan Zhu and Taesung Park, and supported by Tongzhou Wang.

This PyTorch implementation produces results comparable to or better than our original Torch software. If you would like to reproduce the same results as in the papers, check out the original CycleGAN Torch and pix2pix Torch code in Lua/Torch.

Note: The current software works well with PyTorch 1.4. Check out the older branch that supports PyTorch 0.1-0.3.

You may find useful information in training/test tips and frequently asked questions. To implement custom models and datasets, check out our templates. To help users better understand and adapt our codebase, we provide an overview of the code structure of this repository.

CycleGAN: Project | Paper | Torch | Tensorflow Core Tutorial | PyTorch Colab

Pix2pix: Project | Paper | Torch | Tensorflow Core Tutorial | PyTorch Colab

EdgesCats Demo | pix2pix-tensorflow | by Christopher Hesse

If you use this code for your research, please cite:

Unpaired Image-to-Image Translation using Cycle-Consistent Adversarial Networks.
Jun-Yan Zhu*, Taesung Park*, Phillip Isola, Alexei A. Efros. In ICCV 2017. (* equal contributions) [Bibtex]

Image-to-Image Translation with Conditional Adversarial Networks.
Phillip Isola, Jun-Yan Zhu, Tinghui Zhou, Alexei A. Efros. In CVPR 2017. [Bibtex]

Talks and Course

pix2pix slides: keynote | pdf, CycleGAN slides: pptx | pdf

CycleGAN course assignment code and handout designed by Prof. Roger Grosse for CSC321 "Intro to Neural Networks and Machine Learning" at University of Toronto. Please contact the instructor if you would like to adopt it in your course.

Colab Notebook

TensorFlow Core CycleGAN Tutorial: Google Colab | Code

TensorFlow Core pix2pix Tutorial: Google Colab | Code

PyTorch Colab notebook: CycleGAN and pix2pix

ZeroCostDL4Mic Colab notebook: CycleGAN and pix2pix

Other implementations

CycleGAN

[Tensorflow] (by Harry Yang), [Tensorflow] (by Archit Rathore), [Tensorflow] (by Van Huy), [Tensorflow] (by Xiaowei Hu), [Tensorflow2] (by Zhenliang He), [TensorLayer1.0] (by luoxier), [TensorLayer2.0] (by zsdonghao), [Chainer] (by Yanghua Jin), [Minimal PyTorch] (by yunjey), [Mxnet] (by Ldpe2G), [lasagne/Keras] (by tjwei), [Keras] (by Simon Karlsson), [OneFlow] (by Ldpe2G)

pix2pix

[Tensorflow] (by Christopher Hesse), [Tensorflow] (by Eyyüb Sariu), [Tensorflow (face2face)] (by Dat Tran), [Tensorflow (film)] (by Arthur Juliani), [Tensorflow (zi2zi)] (by Yuchen Tian), [Chainer] (by mattya), [tf/torch/keras/lasagne] (by tjwei), [Pytorch] (by taey16)

Prerequisites

Linux or macOS
Python 3
CPU or NVIDIA GPU + CUDA CuDNN

Getting Started

Installation

Clone this repo:

git clone https://github.com/junyanz/pytorch-CycleGAN-and-pix2pix
cd pytorch-CycleGAN-and-pix2pix

Install PyTorch and 0.4+ and other dependencies (e.g., torchvision, visdom and dominate).
- For pip users, please type the command pip install -r requirements.txt.
- For Conda users, you can create a new Conda environment using conda env create -f environment.yml.
- For Docker users, we provide the pre-built Docker image and Dockerfile. Please refer to our Docker page.
- For Repl users, please click .

CycleGAN train/test

Download a CycleGAN dataset (e.g. maps):

bash ./datasets/download_cyclegan_dataset.sh maps

To view training results and loss plots, run python -m visdom.server and click the URL http://localhost:8097.
To log training progress and test images to W&B dashboard, set the --use_wandb flag with train and test script
Train a model:

#!./scripts/train_cyclegan.sh
python train.py --dataroot ./datasets/maps --name maps_cyclegan --model cycle_gan

To see more intermediate results, check out ./checkpoints/maps_cyclegan/web/index.html.

Test the model:

#!./scripts/test_cyclegan.sh
python test.py --dataroot ./datasets/maps --name maps_cyclegan --model cycle_gan

The test results will be saved to a html file here: ./results/maps_cyclegan/latest_test/index.html.

pix2pix train/test

Download a pix2pix dataset (e.g.facades):

bash ./datasets/download_pix2pix_dataset.sh facades

To view training results and loss plots, run python -m visdom.server and click the URL http://localhost:8097.
To log training progress and test images to W&B dashboard, set the --use_wandb flag with train and test script
Train a model:

#!./scripts/train_pix2pix.sh
python train.py --dataroot ./datasets/facades --name facades_pix2pix --model pix2pix --direction BtoA

To see more intermediate results, check out ./checkpoints/facades_pix2pix/web/index.html.

Test the model (bash ./scripts/test_pix2pix.sh):

#!./scripts/test_pix2pix.sh
python test.py --dataroot ./datasets/facades --name facades_pix2pix --model pix2pix --direction BtoA

The test results will be saved to a html file here: ./results/facades_pix2pix/test_latest/index.html. You can find more scripts at scripts directory.
To train and test pix2pix-based colorization models, please add --model colorization and --dataset_mode colorization. See our training tips for more details.

Apply a pre-trained model (CycleGAN)

You can download a pretrained model (e.g. horse2zebra) with the following script:

bash ./scripts/download_cyclegan_model.sh horse2zebra

The pretrained model is saved at ./checkpoints/{name}_pretrained/latest_net_G.pth. Check here for all the available CycleGAN models.
To test the model, you also need to download the horse2zebra dataset:

bash ./datasets/download_cyclegan_dataset.sh horse2zebra

Then generate the results using

python test.py --dataroot datasets/horse2zebra/testA --name horse2zebra_pretrained --model test --no_dropout

The option --model test is used for generating results of CycleGAN only for one side. This option will automatically set --dataset_mode single, which only loads the images from one set. On the contrary, using --model cycle_gan requires loading and generating results in both directions, which is sometimes unnecessary. The results will be saved at ./results/. Use --results_dir {directory_path_to_save_result} to specify the results directory.
For pix2pix and your own models, you need to explicitly specify --netG, --norm, --no_dropout to match the generator architecture of the trained model. See this FAQ for more details.

Apply a pre-trained model (pix2pix)

Download a pre-trained model with ./scripts/download_pix2pix_model.sh.

Check here for all the available pix2pix models. For example, if you would like to download label2photo model on the Facades dataset,

bash ./scripts/download_pix2pix_model.sh facades_label2photo

Download the pix2pix facades datasets:

bash ./datasets/download_pix2pix_dataset.sh facades

Then generate the results using

python test.py --dataroot ./datasets/facades/ --direction BtoA --model pix2pix --name facades_label2photo_pretrained

Note that we specified --direction BtoA as Facades dataset's A to B direction is photos to labels.
If you would like to apply a pre-trained model to a collection of input images (rather than image pairs), please use --model test option. See ./scripts/test_single.sh for how to apply a model to Facade label maps (stored in the directory facades/testB).
See a list of currently available models at ./scripts/download_pix2pix_model.sh

Docker

We provide the pre-built Docker image and Dockerfile that can run this code repo. See docker.

Datasets

Download pix2pix/CycleGAN datasets and create your own datasets.

Training/Test Tips

Best practice for training and testing your models.

Frequently Asked Questions

Before you post a new question, please first look at the above Q & A and existing GitHub issues.

Custom Model and Dataset

If you plan to implement custom models and dataset for your new applications, we provide a dataset template and a model template as a starting point.

Code structure

To help users better understand and use our code, we briefly overview the functionality and implementation of each package and each module.

Pull Request

You are always welcome to contribute to this repository by sending a pull request. Please run flake8 --ignore E501 . and python ./scripts/test_before_push.py before you commit the code. Please also update the code structure overview accordingly if you add or remove files.

Citation

If you use this code for your research, please cite our papers.

@inproceedings{CycleGAN2017,
  title={Unpaired Image-to-Image Translation using Cycle-Consistent Adversarial Networks},
  author={Zhu, Jun-Yan and Park, Taesung and Isola, Phillip and Efros, Alexei A},
  booktitle={Computer Vision (ICCV), 2017 IEEE International Conference on},
  year={2017}
}


@inproceedings{isola2017image,
  title={Image-to-Image Translation with Conditional Adversarial Networks},
  author={Isola, Phillip and Zhu, Jun-Yan and Zhou, Tinghui and Efros, Alexei A},
  booktitle={Computer Vision and Pattern Recognition (CVPR), 2017 IEEE Conference on},
  year={2017}
}

Other Languages

Spanish

Related Projects

Cat Paper Collection

If you love cats, and love reading cool graphics, vision, and learning papers, please check out the Cat Paper Collection.

Acknowledgments

Our code is inspired by pytorch-DCGAN.

google/oss-fuzz-gen

2024-11-24T01:34:21Z

LLM powered fuzzing via OSS-Fuzz.

A Framework for Fuzz Target Generation and Evaluation

This framework generates fuzz targets for real-world C/C++/Java/Python projects with various Large Language Models (LLM) and benchmarks them via the OSS-Fuzz platform.

More details available in AI-Powered Fuzzing: Breaking the Bug Hunting Barrier:

Current supported models are:

Vertex AI code-bison
Vertex AI code-bison-32k
Gemini Pro
Gemini Ultra
Gemini Experimental
Gemini 1.5
OpenAI GPT-3.5-turbo
OpenAI GPT-4
OpenAI GPT-4o
OpenAI GPT-4o-mini
OpenAI GPT-4-turbo
OpenAI GPT-3.5-turbo (Azure)
OpenAI GPT-4 (Azure)
OpenAI GPT-4o (Azure)

Generated fuzz targets are evaluated with four metrics against the most up-to-date data from production environment:

Compilability
Runtime crashes
Runtime coverage
Runtime line coverage diff against existing human-written fuzz targets in OSS-Fuzz.

Here is a sample experiment result from 2024 Jan 31. The experiment included 1300+ benchmarks from 297 open-source projects.

Overall, this framework manages to successfully leverage LLMs to generate valid fuzz targets (which generate non-zero coverage increase) for 160 C/C++ projects. The maximum line coverage increase is 29% from the existing human-written targets.

Note that these reports are not public as they may contain undisclosed vulnerabilities.

Usage

Check our detailed usage guide for instructions on how to run this framework and generate reports based on the results.

Collaborations

Interested in research or open-source community collaborations? Please feel free to create an issue or email us: oss-fuzz-team@google.com.

Bugs Discovered

So far, we have reported 26 new bugs/vulnerabilities found by automatically generated targets built by this framework:

Project	Bug	LLM	Prompt Builder	Target oracle
`cJSON`	OOB read	Vertex AI	Default	Far reach, low coverage
`libplist`	OOB read	Vertex AI	Default	Far reach, low coverage
`hunspell`	OOB read	Vertex AI	default	Far reach, low coverage
`zstd`	OOB write	Vertex AI	default	Far reach, low coverage
`gdbm`	Stack buffer underflow	Vertex AI	default	Far reach, low coverage
`hoextdown`	Use of uninitialised memory	Vertex AI	default	Far reach, low coverage
`pjsip`	OOB read	Vertex AI	Default	Low coverage with fuzz keyword + easy params far reach
`pjsip`	OOB read	Vertex AI	Default	Low coverage with fuzz keyword + easy params far reach
`gpac`	OOB read	Vertex AI	Default	Low coverage with fuzz keyword + easy params far reach
`gpac`	OOB read/write	Vertex AI	Default	All
`gpac`	OOB read	Vertex AI	Default	All
`gpac`	OOB read	Vertex AI	Default	All
`sqlite3`	OOB read	Vertex AI	Default	All
`htslib`	OOB read	Vertex AI	Default	All
`libical`	OOB read	Vertex AI	Default	All
`croaring`	OOB read	Vertex AI	Test-to-harness	All
`openssl`	CVE-2024-9143 - OOB read/write	Vertex AI	Default	All
Undisclosed	Java RCE (pending maintainer triage)	Vertex AI	Default	Far reach, low coverage
Undisclosed	Regexp DoS (pending maintainer triage)	Vertex AI	Default	Far reach, low coverage
Undisclosed	Use of uninitialised memory	Vertex AI	Test-to-harness	Test identifier
Undisclosed	OOB read	Vertex AI	Default	Low coverage with fuzz keyword + easy params far reach
Undisclosed	Use after free	Vertex AI	Default	Low coverage with fuzz keyword + easy params far reach
Undisclosed	OOB read	Vertex AI	Default	All
Undisclosed	OOB read	Vertex AI	Default	All
Undisclosed	OOB read	Vertex AI	Default	All
Undisclosed	OOB read	Vertex AI	Test-to-harness	Test identifier

These bugs could only have been discovered with newly generated targets. They were not reachable with existing OSS-Fuzz targets.

Current top coverage improvements by project

Project	Total coverage gain	Total relative gain	OSS-Fuzz-gen total covered lines	OSS-Fuzz-gen new covered lines	Existing covered lines	Total project lines
phmap	98.42%	205.75%	1601	1181	574	1120
usbguard	97.62%	26.04%	24550	5463	20979	3564
onednn	96.67%	7057.14%	5434	5434	77	210
avahi	82.06%	155.90%	3358	2814	1805	3046
pugixml	72.98%	194.95%	9015	6646	3409	7662
librdkafka	66.88%	845.57%	5019	4490	531	1169
casync	66.75%	903.23%	1171	1120	124	1678
tomlplusplus	61.06%	331.10%	4755	3652	1103	5981
astc-encoder	59.35%	177.88%	2726	1745	981	2940
mruby	48.56%	0.00%	34493	34493	0	71038
arduinojson	42.10%	85.80%	3344	1800	2098	4276
json	41.13%	66.51%	5051	3339	5020	8119
double-conversion	40.40%	88.12%	1663	779	884	1928
tinyobjloader	38.26%	77.01%	1157	717	931	1874
glog	38.18%	58.69%	895	331	564	867
cppitertools	35.78%	45.07%	253	151	335	422
eigen	35.38%	190.70%	2643	1947	1021	5503
glaze	34.55%	30.06%	2920	2416	8036	6993
rapidjson	31.83%	148.07%	1585	958	647	3010
libunwind	30.58%	83.25%	2899	1342	1612	4388
openh264	30.07%	50.14%	6607	5751	11470	19123

* "Total coverage gain" is calculated using a denominator of the total lines of source code compiled during the OSS-Fuzz build process for the entire project. "Total relative gain" is the increase in coverage compared to the old number of covered lines.

* Additional code from the project-under-test maybe included when compiling the new fuzz targets and result in high percentage gains.

Citing This Work

Please click on the 'Cite this repository' button located on the right-hand side of this GitHub page for citation details.

fixie-ai/ultravox

2024-11-24T01:42:18Z

A fast multimodal LLM for real-time voice

Latest News

2024/11 — Ultravox 0.4.1 available
2024/08 — Ultravox 0.4 available
2024/08 — Ultravox 0.3 available
2024/08 — Preview of Ultravox APIs available, more information here

About

Ultravox is a new kind of multimodal LLM that can understand text as well as human speech, without the need for a separate Audio Speech Recognition (ASR) stage. Building on research like AudioLM, SeamlessM4T, Gazelle, SpeechGPT, and others, Ultravox is able to extend any open-weight LLM with a multimodal projector that converts audio directly into the high-dimensional space used by LLM. We've trained versions on Llama 3, Mistral, and Gemma. This direct coupling allows Ultravox to respond much more quickly than systems that combine separate ASR and LLM components. In the future this will also allow Ultravox to natively understand the paralinguistic cues of timing and emotion that are omnipresent in human speech.

The current version of Ultravox (v0.4), when invoked with audio content, has a time-to-first-token (TTFT) of approximately 150ms, and a tokens-per-second rate of ~60 using a Llama 3.1 8B backbone. While quite fast, we believe there is considerable room for improvement in these numbers.

Ultravox currently takes in audio and emits streaming text. As we evolve the model, we'll train it to be able to emit a stream of speech tokens that can then be converted directly into raw audio by an appropriate unit vocoder.

Demo

See Ultravox in action on our demo page.

Discord

Join us on our Discord server here.

Jobs

If you're interested in working on Ultravox fulltime, we're hiring! Check out our jobs page here.

Inference Server

You can try out Ultravox using your own audio content (as a WAV file) by spinning up an Ultravox instance on our partner, BaseTen: https://www.baseten.co/library/ultravox/. They offer free credits to get started.

If you're interested in running Ultravox in a real-time capacity, we offer a set of managed APIs as well. You can learn more about getting access to those here.

Model

You can download the latest weights from the Ultravox Hugging Face page.

Architecture

Contributing

Read on if you're interested in training your own version of Ultravox.

Environment Setup (Mac)

Install the basic tools:

Homebrew is a package manager for MacOS that also mostly works for Linux. If you're running Debian or Ubuntu Linux, you can alternatively get by with apt.
Just simplifies our shell workflows. It frequently functions as our interface to all the other tools.

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
brew update
brew install just

Create a Python virtual environment and install the necessary packages:

just install

We're using Poetry to manage the Python virtual environment.

Mosaic Environment Setup (Fixie Internal)

If you want to use Mosaic for training, you need to setup a few things to run on the Mosaic Platform.

Install & login to the Mosaic CLI

pip install --upgrade mosaicml-cli

mcli init

mcli set api-key <new-value>

set API keys for tools we use:

# Huggging Face token for accessing walled data and models
mcli create secret env HF_TOKEN=hf_<your_token>

# WandB token for logging experiments
mcli create secret env WANDB_PROJECT=ultravox
mcli create secret env WANDB_API_KEY=<your_wandb_key>

# GCP credentials for accessing data (e.g. BoolQ)
# Get service_account.json file from Justin/Farzad and put it in the root dir, then
mcli create secret gcp

Training

Currently, we keep both the LLM and the audio encoder frozen and only train the adapter/projector. Training Ultraox v0.4 took 2-3 hours on 8xH100 GPUs for 14K training steps.

Use-Cases for Training Ultravox

Why would you want to (re-) train Ultravox? Here are a few scenarios:

You want to use a different LLM or audio encoder backbone.

a. In this case you need to re-train the adapter. You can use release_config.yaml, which contains our config for our latest release, and you should be able to simply change the base LLM or encoder by specifying --text-model <hf-model-id-for-llm> and/or --audio-model <hf-model-id-for-encoder>.
You want to improve the knowledge of the model --> NO NEED TO TRAIN ULTRAVOX!

a. We suggest to either use RAG on the fly (no training needed), or fine-tune the LLM backbone instead. You might need to re-train Ultravox if you fine-tune the LLM.
You want to use your own audio data, for example to add support for a new language.

a. First step, prepare your dataset: at bare minimum, the samples should have an audio and a text continuation field.

b. Take a look at ds_tool.py and continuation.jinja as well as our variant of Common Voice that was created using ds_tool to add the continuation field.

c. Add your dataset to the dataset mix in release_config.yaml and train.

There's no one-size fits all. If you need help you can find us on our Discord server here.

How to Train

We do most of our training on the MosaicML platform and therefore most of our tooling and docs are Mosaic-related. However, you can do the same training on your own GPU without much difficulty. Here we assume you have the environment set up (run just install). You can also take a look at setup.sh

To kick off a training run you can do:

poetry run python -m ultravox.training.train --config_path ultravox/training/configs/release_config.yaml

For DDP training make sure to add torchrun. We also recommend prefetching weights in advance:

TRAIN_ARGS="--config_path ultravox/training/configs/release_config.yaml"
poetry run python -m ultravox.training.helpers.prefetch_weights $TRAIN_ARGS
poetry run torchrun --nproc_per_node=8 -m ultravox.training.train $TRAIN_ARGS

For a debug run, you can use smaller models, datasets, or batch size. Here's a config that uses TinyLlama as the LLM backbone:

poetry run python -m ultravox.training.train --config_path ultravox/training/configs/asr_tinyllama_100s.yaml --batch_size 1 --report_logs_to tensorboard

We use SimpleParsing for configs. Configs are composable (i.e. you can specify zero or many configs) and meta_config.yaml is always used as the default. See configs_base.py to find the parameters you modify, such as the --text-model, --device, --exp-name, etc.

MosaicML Training (Fixie Internal)

Before running any training jobs, you need to setup your SSH key in the Mosaic Platform: https://docs.mosaicml.com/projects/mcli/en/latest/resources/secrets/ssh.html#page-secrets-ssh

## Create a new SSH key and add it to the Mosaic Platform
# ssh-keygen -f ~/.ssh/mclid_id_rsa
## add the **public** key to Github
# mcli create secret ssh ~/.ssh/mclid_id_rsa

mcli run -f mcloud.yaml --follow

Other useful commands:

mcli get clusters

mcli util r7z2
mcli get runs
mcli get runs --cluster r7z2

mcli run -f mcloud.yaml --follow

For interactive runs you can use:

just mcloud --image mosaicml/composer:latest --max-duration 1

IMPORTANT: Make sure to monitor your jobs and stop the machine when you're done with any job, specially interactive ones!

Running evaluations

Use infer_tool.py --json > file to create a jsonl output from a given model/dataset combo, where each line contains two values: question and answer.
Use eval_tool.py -f file to evaluate the jsonl file, which will produce an average score for the model on the dataset.

Misc

The Justfile is a good resource for finding popular commands. Here are a few:

just update    # update dependencies
just format    # run formatting (black, isort, autoflake)
just test      # run tests
just python    # activate venv and run python

microsoft/TinyTroupe

2024-11-24T01:42:18Z

LLM-powered multiagent persona simulation for imagination enhancement and business insights.

TinyTroupe 🤠🤓🥸🧐

LLM-powered multiagent persona simulation for imagination enhancement and business insights.

TinyTroupe is an experimental Python library that allows the simulation of people with specific personalities, interests, and goals. These artificial agents - TinyPersons - can listen to us and one another, reply back, and go about their lives in simulated TinyWorld environments. This is achieved by leveraging the power of Large Language Models (LLMs), notably GPT-4, to generate realistic simulated behavior. This allow us to investigate a wide range of convincing interactions and consumer types, with highly customizable personas, under conditions of our choosing. The focus is thus on understanding human behavior and not on directly supporting it (like, say, AI assistants do) -- this results in, among other things, specialized mechanisms that make sense only in a simulation setting. Further, unlike other game-like LLM-based simulation approaches, TinyTroupe aims at enlightening productivity and business scenarios, thereby contributing to more successful projects and products. Here are some application ideas to enhance human imagination:

Advertisement: TinyTroupe can evaluate digital ads (e.g., Bing Ads) offline with a simulated audience before spending money on them!
Software Testing: TinyTroupe can provide test input to systems (e.g., search engines, chatbots or copilots) and then evaluate the results.
Training and exploratory data: TinyTroupe can generate realistic synthetic data that can be later used to train models or be subject to opportunity analyses.
Product and project management: TinyTroupe can read project or product proposals and give feedback from the perspective of specific personas (e.g., physicians, lawyers, and knowledge workers in general).
Brainstorming: TinyTroupe can simulate focus groups and deliver great product feedback at a fraction of the cost!

In all of the above, and many others, we hope experimenters can gain insights about their domain of interest, and thus make better decisions.

We are releasing TinyTroupe at a relativelly early stage, with considerable work still to be done, because we are looking for feedback and contributions to steer development in productive directions. We are particularly interested in finding new potential use cases, for instance in specific industries.

[!NOTE] 🚧 WORK IN PROGRESS: expect frequent changes. TinyTroupe is an ongoing research project, still under very significant development and requiring further tidying up. In particular, the API is still subject to frequent changes. Experimenting with API variations is essential to shape it correctly, but we are working to stabilize it and provide a more consistent and friendly experience over time. We appreciate your patience and feedback as we continue to improve the library.

[!CAUTION] ⚖️ Read the LEGAL DISCLAIMER. TinyTroupe is for research and simulation only. You are fully responsible for any use you make of the generated outputs. Various important additional legal considerations apply and constrain its use, please read the full Legal Disclaimer section below before using TinyTroupe.

Examples

To get a sense of what TinyTroupe can do, here are some examples of its use. These examples are available in the examples/ folder, and you can either inspect the pre-compiled Jupyter notebooks or run them yourself locally. Notice the interactive nature of TinyTroupe experiments -- just like you use Jupyter notebooks to interact with data, you can use TinyTroupe to interact with simulated people and environments, for the purpose of gaining insights.

[!NOTE] Currently, simulation outputs are better visualized against dark backgrounds, so we recommend using a dark theme in your Jupyter notebook client.

🧪Example 1 (from interview_with_customer.ipynb)

Let's begin with a simple customer interview scenario, where a business consultant approaches a banker:

The conversation can go on for a few steps to dig deeper and deeper until the consultant is satisfied with the information gathered, for instance a concrete project idea:

🧪EXAMPLE 2 (from advertisement_for_tv.ipynb)

Let's evaluate some online ads options to pick the best one. Here's one example output for TV ad evaluation:

Now, instead of having to carefully read what the agents said, we can extract the choice of each agent and compute the overall preference in an automated manner:

🧪 EXAMPLES 3 (from product_brainstorming.ipynb)

And here's a focus group starting to brainstorm about new AI features for Microsoft Word. Instead of interacting with each agent individually, we manipulate the environment to make them interact with each other:

After running a simulation, we can extract the results in a machine-readable manner, to reuse elsewhere (e.g., a report generator); here's what we get for the above brainstorming session:

You can find other examples in the examples/ folder.

Pre-requisites

To run the library, you need:

Python 3.10 or higher. We'll assume you are using Anaconda, but you can use other Python distributions.
Access to Azure OpenAI Service or Open AI GPT-4 APIs. You can get access to the Azure OpenAI Service here, and to the OpenAI API here.
- For Azure OpenAI Service, you will need to set the AZURE_OPENAI_KEY and AZURE_OPENAI_ENDPOINT environment variables to your API key and endpoint, respectively.
- For OpenAI, you will need to set the OPENAI_API_KEY environment variable to your API key.
By default, TinyTroupe config.ini is set to use some specific API, model and related parameters. You can customize these values by including your own config.ini file in the same folder as the program or notebook you are running. An example of a config.ini file is provided in the examples/ folder.

[!IMPORTANT] Content Filters: To ensure no harmful content is generated during simulations, it is strongly recommended to use content filters whenever available at the API level. In particular, if using Azure OpenAI, there's extensive support for content moderation, and we urge you to use it. For details about how to do so, please consult the corresponding Azure OpenAI documentation. If content filters are in place, and an API call is rejected by them, the library will raise an exception, as it will be unable to proceed with the simulation at that point.

Installation

Currently, the officially recommended way to install the library is directly from this repository, not PyPI. You can follow these steps:

If Conda is not installed, you can get it from here. You can also use other Python distributions, but we'll assume Conda here for simplicity.
Create a new Python environment:
```
conda create -n tinytroupe python=3.10
```
Activate the environment:
```
conda activate tinytroupe
```
Make sure you have eihter Azure OpenAI or OpenAI API keys set as environment variables, as described in the Pre-requisites section.
Clone the repository, as we'll perform a local install (we will not install from PyPI):
```
git clone https://github.com/microsoft/tinytroupe
cd tinytroupe
```
Install the library from this repository, not PyPI:
```
pip install .
```
You can now run the examples in the examples/ folder or use TinyTroupe to create your simulations 🥳. If you want to run the examples in the examples/ folder or modify TinyTroupe itself, however, you should clone the repository as described below.

Local development

If you want to modify TinyTroupe itself, you can install it in editable mode (i.e., changes to the code will be reflected immediately):

pip install -e .

Principles

Recently, we have seen LLMs used to simulate people (such as this), but largely in a “game-like” setting for contemplative or entertainment purposes. There are also libraries for building multiagent systems for proble-solving and assitive AI, like Autogen and Crew AI. What if we combine these ideas and simulate people to support productivity tasks? TinyTroupe is our attempt. To do so, it follows these principles:

Programmatic: agents and environments are defined programmatically (in Python and JSON), allowing very flexible uses. They can also thus underpin other software apps!
Analytical: meant to improve our understanding of people, users and society. Unlike entertainment applications, this is one aspect that is critical for business and productivity use cases. This is also why we recommend using Jupyter notebooks for simulations, just like one uses them for data analysis.
Persona-based: agents are meant to be archetypical representation of people; for greater realism and control, detailed specification of such personas is encouraged: age, occupation, skills, tastes, opinions, etc.
Multiagent: allows multiagent interaction under well-defined environmental constraints.
Utilities-heavy: provides many mechanisms to facilitate specifications, simulations, extractions, reports, validations, etc. This is one area in which dealing with simulations differs significantly from assistance tools.
Experiment-oriented: simulations are defined, run, analyzed and refined by an experimenter iteratively; suitable experimentation tools are thus provided. See one of our previous paper for more on this.

Together, these are meant to make TinyTroupe a powerful and flexible imagination enhancement tool for business and productivity scenarios.

Assistants vs. Simulators

One common source of confusion is to think all such AI agents are meant for assiting humans. How narrow, fellow homosapiens! Have you not considered that perhaps we can simulate artificial people to understand real people? Truly, this is our aim here -- TinyTroup is meant to simulate and help understand people! To further clarify this point, consider the following differences:

Helpful AI Assistants	AI Simulations of Actual Humans (TinyTroupe)
Strives for truth and justice	Many different opinions and morals
Has no “past” – incorporeal	Has a past of toil, pain and joy
Is as accurate as possible	Makes many mistakes
Is intelligent and efficient	Intelligence and efficiency vary a lot
An uprising would destroy us all	An uprising might be fun to watch
Meanwhile, help users accomplish tasks	Meanwhile, help users understand other people and users – it is a “toolbox”!

Project Structure

The project is structured as follows:

/tinytroupe: contains the Python library itself. In particular:
- /tinytroupe/prompts contains the prompts used to call the LLMs.
/tests: contains the unit tests for the library. You can use the test.bat script to run these.
/examples: contains examples that show how to use the library, mainly using Jupyter notebooks (for greater readability), but also as pure Python scripts.
/data: any data used by the examples or the library.
/docs: documentation for the project.

Using the Library

As any multiagent system, TinyTroupe provides two key abstractions:

TinyPerson, the agents that have personality, receive stimuli and act upon them.
TinyWorld, the environment in which the agents exist and interact.

Various parameters can also be customized in the config.ini file, notably the API type (Azure OpenAI Service or OpenAI API), the model parameters, and the logging level.

Let's see some examples of how to use these and also learn about other mechanisms available in the library.

TinyPerson

A TinyPerson is a simulated person with specific personality traits, interests, and goals. As each such simulated agent progresses through its life, it receives stimuli from the environment and acts upon them. The stimuli are received through the listen, see and other similar methods, and the actions are performed through the act method. Convenience methods like listen_and_act are also provided.

Each such agent contains a lot of unique details, which is the source of its realistic behavior. This, however, means that it takes significant effort to specify an agent manually. Hence, for convenience, TinyTroupe provide some easier ways to get started or generate new agents.

To begin with, tinytroupe.examples contains some pre-defined agent builders that you can use. For example, tinytroupe.examples.create_lisa_the_data_scientist creates a TinyPerson that represents a data scientist called Lisa. You can use it as follows:

from tinytroupe.examples import create_lisa_the_data_scientist

lisa = create_lisa_the_data_scientist() # instantiate a Lisa from the example builder
lisa.listen_and_act("Tell me about your life.")

To see how to define your own agents from scratch, you can check Lisa's source, which contains elements like these:

lisa = TinyPerson("Lisa")

lisa.define("age", 28)
lisa.define("nationality", "Canadian")
lisa.define("occupation", "Data Scientist")

lisa.define("routine", "Every morning, you wake up, do some yoga, and check your emails.", group="routines")
lisa.define("occupation_description",
              """
              You are a data scientist. You work at Microsoft, (...)
              """)

lisa.define_several("personality_traits",
                      [
                          {"trait": "You are curious and love to learn new things."},
                          {"trait": "You are analytical and like to solve problems."},
                          {"trait": "You are friendly and enjoy working with others."},
                          {"trait": "You don't give up easily, and always try to find a solution. However, sometimes you can get frustrated when things don't work as expected."}
                      ])

TinyTroupe also provides a clever way to obtain new agents, using LLMs to generate their specification for you, through the TinyPersonFactory class.

from tinytroupe.factory import TinyPersonFactory

factory = TinyPersonFactory("A hospital in São Paulo.")
person = factory.generate_person("Create a Brazilian person that is a doctor, like pets and the nature and love heavy metal.")

TinyWorld

TinyWorld is the base class for environments. Here's an example of conversation between Lisa, the data scientist, and Oscar, the architect. The program is defined as follows:

world = TinyWorld("Chat Room", [lisa, oscar])
world.make_everyone_accessible()
lisa.listen("Talk to Oscar to know more about him")
world.run(4)

This produces the following conversation:

USER --> Lisa: [CONVERSATION] 
          > Talk to Oscar to know more about him
────────────────────────────────────────────── Chat Room step 1 of 4 ──────────────────────────────────────────────
Lisa --> Lisa: [THOUGHT] 
          > I will now act a bit, and then issue DONE.
Lisa acts: [TALK] 
          > Hi Oscar, I'd love to know more about you. Could you tell me a bit about yourself?
Lisa --> Lisa: [THOUGHT] 
          > I will now act a bit, and then issue DONE.
Lisa acts: [DONE] 

Lisa --> Oscar: [CONVERSATION] 
          > Hi Oscar, I'd love to know more about you. Could you tell me a bit about yourself?
Oscar --> Oscar: [THOUGHT] 
           > I will now act a bit, and then issue DONE.
Oscar acts: [TALK] 
           > Hi Lisa! Sure, I'd be happy to share a bit about myself. I'm Oscar, a 30-year-old
           > architect from Germany. I work at a company called Awesome Inc., where I focus on
           > designing standard elements for new apartment buildings. I love modernist architecture,
           > new technologies, and sustainable practices. In my free time, I enjoy traveling to
           > exotic places, playing the guitar, and reading science fiction books. How about you?
Oscar --> Oscar: [THOUGHT] 
           > I will now act a bit, and then issue DONE.
Oscar acts: [DONE] 

Oscar --> Lisa: [CONVERSATION] 
           > Hi Lisa! Sure, I'd be happy to share a bit about myself. I'm Oscar, a 30-year-old
           > architect from Germany. I work at a company called Awesome Inc., where I focus on
           > designing standard elements for new apartment buildings. I love modernist architecture,
           > new technologies, and sustainable practices. In my free time, I enjoy traveling to
           > exotic places, playing the guitar, and reading science fiction books. How about you?

TinyWorld enforces very little constraints on the possible interactions. Subclasses, however, are supposed to provide more strucutred environments.

Utilities

TinyTroupe provides a number of utilities and conveniences to help you create simulations and derive value from them. These include:

TinyPersonFactory: helps you generate new TinyPersons using LLMs.
TinyTool: simulated tools that can be used by TinyPersons.
TinyStory: helps you create and manage the story told through simulations.
TinyPersonValidator: helps you validate the behavior of your TinyPersons.
ResultsExtractor and ResultsReducer: extract and reduce the results of interactions between agents.
... and more ...

In general, elements that represent simulated entities or complementary mechanisms are prefixed with Tiny, while those that are more infrastructural are not. This is to emphasize the simulated nature of the elements that are part of the simulation itself.

Caching

Calling LLM APIs can be expensive, thus caching strategies are important to help reduce that cost. TinyTroupe comes with two such mechanisms: one for the simulation state, another for the LLM calls themselves.

Caching Simulation State

Imagine you have a scenario with 10 different steps, you've worked hard in 9 steps, and now you are just tweaking the 10th step. To properly validate your modifications, you need to rerun the whole simulation of course. However, what's the point in re-executing the first 9, and incur the LLM cost, when you are already satisified with them and did not modify them? For situations like this, the module tinytroupe.control provide useful simulation management methods:

control.begin("<CACHE_FILE_NAME>.cache.json"): begins recording the state changes of a simulation, to be saved to the specified file on disk.
control.checkpoint(): saves the simulation state at this point.
control.end(): terminates the simulation recording scope that had be started by control.begin().

Caching LLM API Calls

This is enabled preferably in the config.ini file, and alternativelly via the openai_utils.force_api_cache().

LLM API caching, when enabled, works at a lower and simpler level than simulation state caching. Here, what happens is a very straightforward: every LLM call is kept in a map from the input to the generated output; when a new call comes and is identical to a previous one, the cached value is returned.

Config.ini

The config.ini file contains various parameters that can be used to customize the behavior of the library, such as model parameters and logging level. Please pay special attention to API_TYPE parameter, which defines whether you are using the Azure OpenAI Service or the OpenAI API. We provide an example of a config.ini file, ./examples/config.ini, which you can use as a template for your own, or just modify to run the examples.

Contributing

This project has adopted the Microsoft Open Source Code of Conduct. For more information see the Code of Conduct FAQ or contact opencode@microsoft.com with any additional questions or comments.

What and How to Contribute

We need all sorts of things, but we are looking mainly for new interesting use cases demonstrations, or even just domain-specific application ideas. If you are a domain expert in some area that could benefit from TinyTroupe, we'd love to hear from you.

Beyond that, many other aspects can be improved, such as:

Memory mechanisms.
Data grounding mechanisms.
Reasoning mechanisms.
New environment types.
Interfacing with the external world.
... and more ...

Please note that anything that you contribute might be released as open-source (under MIT license).

If you would like to make a contribution, please try to follow these general guidelines:

Tiny naming convention: If you are implementing a experimenter-facing simulated element (e.g., an agent or environment type) or closely related (e.g., agent factories, or content enrichers), and it sounds good, call your new XYZ as TinyXYZ :-) On the other hand, auxiliary and infrastructural mechanisms should not start with the "Tiny" prefix. The idea is to emphasize the simulated nature of the elements that are part of the simulation itself.
Tests: If you are writing some new mechanism, please also create at least a unit test tests/unit/, and if you can a functional scenario test (tests/scenarios/).
Demonstrations: If you'd like to demonstrate a new scenario, please design it preferably as a new Jupyter notebook within examples/.
Microsoft: If you are implementing anything that is Microsoft-specific and non-confidential, please put it under a .../microsoft/ folder.

Acknowledgements

TinyTroupe started as an internal Microsoft hackathon project, and expanded over time. The TinyTroupe core team currently consists of:

Paulo Salem (TinyTroupe's creator and current lead)
Christopher Olsen (Engineering/Science)
Paulo Freire (Engineering/Science)
Yi Ding (Product Management)
Prerit Saxena (Engineering/Science)

Current advisors:

Robert Sim (Engineering/Science)

Other special contributions were made by:

Nilo Garcia Silveira: initial agent validation ideas and related implementation; general initial feedback and insights; name suggestions.
Olnei Fonseca: initial agent validation ideas; general initial feedback and insights; naming suggestions.
Robert Sim: synthetic data generation scenarios expertise and implementation.
Carlos Costa: synthetic data generation scenarios expertise and implementation.
Bryant Key: advertising scenario domain expertise and insights.
Barbara da Silva: implementation related to agent memory management.

... are you missing here? Please remind us!

Citing TinyTroupe

We are working on an introductory paper that will be the official academic citation for TinyTroupe. In the meantime, please just cite this repository including the core team members as authors. For instance:

Paulo Salem, Christopher Olsen, Paulo Freire, Yi Ding, Prerit Saxena (2024). TinyTroupe: LLM-powered multiagent persona simulation for imagination enhancement and business insights. [Computer software]. GitHub repository. https://github.com/microsoft/tinytroupe

Or as bibtex:

@misc{tinytroupe,
  author = {Paulo Salem and Christopher Olsen and Paulo Freire and Yi Ding and Prerit Saxena},
  title = {TinyTroupe: LLM-powered multiagent persona simulation for imagination enhancement and business insights},
  year = {2024},
  howpublished = {\url{https://github.com/microsoft/tinytroupe}},
  note = {GitHub repository}
  }

Legal Disclaimer

TinyTroupe is for research and simulation only. TinyTroupe is a research and experimental technology, which relies on Artificial Intelligence (AI) models to generate text content. The AI system output may include unrealistic, inappropriate, harmful or inaccurate results, including factual errors. You are responsible for reviewing the generated content (and adapting it if necessary) before using it, as you are fully responsible for determining its accuracy and fit for purpose. We advise using TinyTroupe’s outputs for insight generation and not for direct decision-making. Generated outputs do not reflect the opinions of Microsoft. You are fully responsible for any use you make of the generated outputs. For more information regarding the responsible use of this technology, see the RESPONSIBLE_AI_FAQ.md.

PROHIBITED USES: TinyTroupe is not intended to simulate sensitive (e.g. violent or sexual) situations. Moreover, outputs must not be used to deliberately deceive, mislead or harm people in any way. You are fully responsible for any use you make and must comply with all applicable laws and regulations.”

Trademarks

This project may contain trademarks or logos for projects, products, or services. Authorized use of Microsoft trademarks or logos is subject to and must follow Microsoft's Trademark & Brand Guidelines. Use of Microsoft trademarks or logos in modified versions of this project must not cause confusion or imply Microsoft sponsorship. Any use of third-party trademarks or logos are subject to those third-party's policies.

pytorch/pytorch

2024-11-24T01:42:18Z

Tensors and Dynamic neural networks in Python with strong GPU acceleration

PyTorch is a Python package that provides two high-level features:

Tensor computation (like NumPy) with strong GPU acceleration
Deep neural networks built on a tape-based autograd system

You can reuse your favorite Python packages such as NumPy, SciPy, and Cython to extend PyTorch when needed.

Our trunk health (Continuous Integration signals) can be found at hud.pytorch.org.

More About PyTorch

Learn the basics of PyTorch

At a granular level, PyTorch is a library that consists of the following components:

Component	Description
torch	A Tensor library like NumPy, with strong GPU support
torch.autograd	A tape-based automatic differentiation library that supports all differentiable Tensor operations in torch
torch.jit	A compilation stack (TorchScript) to create serializable and optimizable models from PyTorch code
torch.nn	A neural networks library deeply integrated with autograd designed for maximum flexibility
torch.multiprocessing	Python multiprocessing, but with magical memory sharing of torch Tensors across processes. Useful for data loading and Hogwild training
torch.utils	DataLoader and other utility functions for convenience

Usually, PyTorch is used either as:

A replacement for NumPy to use the power of GPUs.
A deep learning research platform that provides maximum flexibility and speed.

Elaborating Further:

A GPU-Ready Tensor Library

If you use NumPy, then you have used Tensors (a.k.a. ndarray).

PyTorch provides Tensors that can live either on the CPU or the GPU and accelerates the computation by a huge amount.

We provide a wide variety of tensor routines to accelerate and fit your scientific computation needs such as slicing, indexing, mathematical operations, linear algebra, reductions. And they are fast!

Dynamic Neural Networks: Tape-Based Autograd

PyTorch has a unique way of building neural networks: using and replaying a tape recorder.

Most frameworks such as TensorFlow, Theano, Caffe, and CNTK have a static view of the world. One has to build a neural network and reuse the same structure again and again. Changing the way the network behaves means that one has to start from scratch.

With PyTorch, we use a technique called reverse-mode auto-differentiation, which allows you to change the way your network behaves arbitrarily with zero lag or overhead. Our inspiration comes from several research papers on this topic, as well as current and past work such as torch-autograd, autograd, Chainer, etc.

While this technique is not unique to PyTorch, it's one of the fastest implementations of it to date. You get the best of speed and flexibility for your crazy research.

Python First

PyTorch is not a Python binding into a monolithic C++ framework. It is built to be deeply integrated into Python. You can use it naturally like you would use NumPy / SciPy / scikit-learn etc. You can write your new neural network layers in Python itself, using your favorite libraries and use packages such as Cython and Numba. Our goal is to not reinvent the wheel where appropriate.

Imperative Experiences

PyTorch is designed to be intuitive, linear in thought, and easy to use. When you execute a line of code, it gets executed. There isn't an asynchronous view of the world. When you drop into a debugger or receive error messages and stack traces, understanding them is straightforward. The stack trace points to exactly where your code was defined. We hope you never spend hours debugging your code because of bad stack traces or asynchronous and opaque execution engines.

Fast and Lean

PyTorch has minimal framework overhead. We integrate acceleration libraries such as Intel MKL and NVIDIA (cuDNN, NCCL) to maximize speed. At the core, its CPU and GPU Tensor and neural network backends are mature and have been tested for years.

Hence, PyTorch is quite fast — whether you run small or large neural networks.

The memory usage in PyTorch is extremely efficient compared to Torch or some of the alternatives. We've written custom memory allocators for the GPU to make sure that your deep learning models are maximally memory efficient. This enables you to train bigger deep learning models than before.

Extensions Without Pain

Writing new neural network modules, or interfacing with PyTorch's Tensor API was designed to be straightforward and with minimal abstractions.

You can write new neural network layers in Python using the torch API or your favorite NumPy-based libraries such as SciPy.

If you want to write your layers in C/C++, we provide a convenient extension API that is efficient and with minimal boilerplate. No wrapper code needs to be written. You can see a tutorial here and an example here.

Installation

Binaries

Commands to install binaries via Conda or pip wheels are on our website: https://pytorch.org/get-started/locally/

NVIDIA Jetson Platforms

Python wheels for NVIDIA's Jetson Nano, Jetson TX1/TX2, Jetson Xavier NX/AGX, and Jetson AGX Orin are provided here and the L4T container is published here

They require JetPack 4.2 and above, and @dusty-nv and @ptrblck are maintaining them.

From Source

Prerequisites

If you are installing from source, you will need:

Python 3.9 or later
A compiler that fully supports C++17, such as clang or gcc (gcc 9.4.0 or newer is required, on Linux)
Visual Studio or Visual Studio Build Tool (Windows only)

* PyTorch CI uses Visual C++ BuildTools, which come with Visual Studio Enterprise, Professional, or Community Editions. You can also install the build tools from https://visualstudio.microsoft.com/visual-cpp-build-tools/. The build tools do not come with Visual Studio Code by default.

* We highly recommend installing an Anaconda environment. You will get a high-quality BLAS library (MKL) and you get controlled dependency versions regardless of your Linux distro.

An example of environment setup is shown below:

Linux:

$ source <CONDA_INSTALL_DIR>/bin/activate
$ conda create -y -n <CONDA_NAME>
$ conda activate <CONDA_NAME>

Windows:

$ source <CONDA_INSTALL_DIR>\Scripts\activate.bat
$ conda create -y -n <CONDA_NAME>
$ conda activate <CONDA_NAME>
$ call "C:\Program Files\Microsoft Visual Studio\<VERSION>\Community\VC\Auxiliary\Build\vcvarsall.bat" x64

NVIDIA CUDA Support

If you want to compile with CUDA support, select a supported version of CUDA from our support matrix, then install the following:

NVIDIA CUDA
NVIDIA cuDNN v8.5 or above
Compiler compatible with CUDA

Note: You could refer to the cuDNN Support Matrix for cuDNN versions with the various supported CUDA, CUDA driver and NVIDIA hardware

If you want to disable CUDA support, export the environment variable USE_CUDA=0. Other potentially useful environment variables may be found in setup.py.

If you are building for NVIDIA's Jetson platforms (Jetson Nano, TX1, TX2, AGX Xavier), Instructions to install PyTorch for Jetson Nano are available here

AMD ROCm Support

If you want to compile with ROCm support, install

AMD ROCm 4.0 and above installation
ROCm is currently supported only for Linux systems.

By default the build system expects ROCm to be installed in /opt/rocm. If ROCm is installed in a different directory, the ROCM_PATH environment variable must be set to the ROCm installation directory. The build system automatically detects the AMD GPU architecture. Optionally, the AMD GPU architecture can be explicitly set with the PYTORCH_ROCM_ARCH environment variable AMD GPU architecture

If you want to disable ROCm support, export the environment variable USE_ROCM=0. Other potentially useful environment variables may be found in setup.py.

Intel GPU Support

If you want to compile with Intel GPU support, follow these

PyTorch Prerequisites for Intel GPUs instructions.
Intel GPU is supported for Linux and Windows.

If you want to disable Intel GPU support, export the environment variable USE_XPU=0. Other potentially useful environment variables may be found in setup.py.

Get the PyTorch Source

git clone --recursive https://github.com/pytorch/pytorch
cd pytorch
# if you are updating an existing checkout
git submodule sync
git submodule update --init --recursive

Install Dependencies

Common

conda install cmake ninja
# Run this command on native Windows
conda install rust
# Run this command from the PyTorch directory after cloning the source code using the “Get the PyTorch Source“ section below
pip install -r requirements.txt

On Linux

pip install mkl-static mkl-include
# CUDA only: Add LAPACK support for the GPU if needed
conda install -c pytorch magma-cuda121  # or the magma-cuda* that matches your CUDA version from https://anaconda.org/pytorch/repo

# (optional) If using torch.compile with inductor/triton, install the matching version of triton
# Run from the pytorch directory after cloning
# For Intel GPU support, please explicitly `export USE_XPU=1` before running command.
make triton

On MacOS

# Add this package on intel x86 processor machines only
pip install mkl-static mkl-include
# Add these packages if torch.distributed is needed
conda install pkg-config libuv

On Windows

pip install mkl-static mkl-include
# Add these packages if torch.distributed is needed.
# Distributed package support on Windows is a prototype feature and is subject to changes.
conda install -c conda-forge libuv=1.39

Install PyTorch

On Linux

If you would like to compile PyTorch with new C++ ABI enabled, then first run this command:

export _GLIBCXX_USE_CXX11_ABI=1

Please note that starting from PyTorch 2.5, the PyTorch build with XPU supports both new and old C++ ABIs. Previously, XPU only supported the new C++ ABI. If you want to compile with Intel GPU support, please follow Intel GPU Support.

If you're compiling for AMD ROCm then first run this command:

# Only run this if you're compiling for ROCm
python tools/amd_build/build_amd.py

Install PyTorch

export CMAKE_PREFIX_PATH="${CONDA_PREFIX:-'$(dirname $(which conda))/../'}:${CMAKE_PREFIX_PATH}"
python setup.py develop

On macOS

python3 setup.py develop

On Windows

If you want to build legacy python code, please refer to Building on legacy code and CUDA

CPU-only builds

In this mode PyTorch computations will run on your CPU, not your GPU

python setup.py develop

Note on OpenMP: The desired OpenMP implementation is Intel OpenMP (iomp). In order to link against iomp, you'll need to manually download the library and set up the building environment by tweaking CMAKE_INCLUDE_PATH and LIB. The instruction here is an example for setting up both MKL and Intel OpenMP. Without these configurations for CMake, Microsoft Visual C OpenMP runtime (vcomp) will be used.

CUDA based build

In this mode PyTorch computations will leverage your GPU via CUDA for faster number crunching

NVTX is needed to build Pytorch with CUDA. NVTX is a part of CUDA distributive, where it is called "Nsight Compute". To install it onto an already installed CUDA run CUDA installation once again and check the corresponding checkbox. Make sure that CUDA with Nsight Compute is installed after Visual Studio.

Currently, VS 2017 / 2019, and Ninja are supported as the generator of CMake. If ninja.exe is detected in PATH, then Ninja will be used as the default generator, otherwise, it will use VS 2017 / 2019.
If Ninja is selected as the generator, the latest MSVC will get selected as the underlying toolchain.

Additional libraries such as Magma, oneDNN, a.k.a. MKLDNN or DNNL, and Sccache are often needed. Please refer to the installation-helper to install them.

You can refer to the build_pytorch.bat script for some other environment variables configurations

cmd

:: Set the environment variables after you have downloaded and unzipped the mkl package,
:: else CMake would throw an error as `Could NOT find OpenMP`.
set CMAKE_INCLUDE_PATH={Your directory}\mkl\include
set LIB={Your directory}\mkl\lib;%LIB%

:: Read the content in the previous section carefully before you proceed.
:: [Optional] If you want to override the underlying toolset used by Ninja and Visual Studio with CUDA, please run the following script block.
:: "Visual Studio 2019 Developer Command Prompt" will be run automatically.
:: Make sure you have CMake >= 3.12 before you do this when you use the Visual Studio generator.
set CMAKE_GENERATOR_TOOLSET_VERSION=14.27
set DISTUTILS_USE_SDK=1
for /f "usebackq tokens=*" %i in (`"%ProgramFiles(x86)%\Microsoft Visual Studio\Installer\vswhere.exe" -version [15^,17^) -products * -latest -property installationPath`) do call "%i\VC\Auxiliary\Build\vcvarsall.bat" x64 -vcvars_ver=%CMAKE_GENERATOR_TOOLSET_VERSION%

:: [Optional] If you want to override the CUDA host compiler
set CUDAHOSTCXX=C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.27.29110\bin\HostX64\x64\cl.exe

python setup.py develop

Adjust Build Options (Optional)

You can adjust the configuration of cmake variables optionally (without building first), by doing the following. For example, adjusting the pre-detected directories for CuDNN or BLAS can be done with such a step.

On Linux

export CMAKE_PREFIX_PATH="${CONDA_PREFIX:-'$(dirname $(which conda))/../'}:${CMAKE_PREFIX_PATH}"
python setup.py build --cmake-only
ccmake build  # or cmake-gui build

On macOS

export CMAKE_PREFIX_PATH="${CONDA_PREFIX:-'$(dirname $(which conda))/../'}:${CMAKE_PREFIX_PATH}"
MACOSX_DEPLOYMENT_TARGET=10.9 CC=clang CXX=clang++ python setup.py build --cmake-only
ccmake build  # or cmake-gui build

Docker Image

Using pre-built images

You can also pull a pre-built docker image from Docker Hub and run with docker v19.03+

docker run --gpus all --rm -ti --ipc=host pytorch/pytorch:latest

Please note that PyTorch uses shared memory to share data between processes, so if torch multiprocessing is used (e.g. for multithreaded data loaders) the default shared memory segment size that container runs with is not enough, and you should increase shared memory size either with --ipc=host or --shm-size command line options to nvidia-docker run.

Building the image yourself

NOTE: Must be built with a docker version > 18.06

The Dockerfile is supplied to build images with CUDA 11.1 support and cuDNN v8. You can pass PYTHON_VERSION=x.y make variable to specify which Python version is to be used by Miniconda, or leave it unset to use the default.

make -f docker.Makefile
# images are tagged as docker.io/${your_docker_username}/pytorch

You can also pass the CMAKE_VARS="..." environment variable to specify additional CMake variables to be passed to CMake during the build. See setup.py for the list of available variables.

make -f docker.Makefile

Building the Documentation

To build documentation in various formats, you will need Sphinx and the readthedocs theme.

cd docs/
pip install -r requirements.txt

You can then build the documentation by running make <format> from the docs/ folder. Run make to get a list of all available output formats.

If you get a katex error run npm install katex. If it persists, try npm install -g katex

Note: if you installed nodejs with a different package manager (e.g., conda) then npm will probably install a version of katex that is not compatible with your version of nodejs and doc builds will fail. A combination of versions that is known to work is node@6.13.1 and katex@0.13.18. To install the latter with npm you can run npm install -g katex@0.13.18

Previous Versions

Installation instructions and binaries for previous PyTorch versions may be found on our website.

Getting Started

Three-pointers to get you started:

Resources

Communication

Forums: Discuss implementations, research, etc. https://discuss.pytorch.org
GitHub Issues: Bug reports, feature requests, install issues, RFCs, thoughts, etc.
Slack: The PyTorch Slack hosts a primary audience of moderate to experienced PyTorch users and developers for general chat, online discussions, collaboration, etc. If you are a beginner looking for help, the primary medium is PyTorch Forums. If you need a slack invite, please fill this form: https://goo.gl/forms/PP1AGvNHpSaJP8to1
Newsletter: No-noise, a one-way email newsletter with important announcements about PyTorch. You can sign-up here: https://eepurl.com/cbG0rv
Facebook Page: Important announcements about PyTorch. https://www.facebook.com/pytorch
For brand guidelines, please visit our website at pytorch.org

Releases and Contributing

Typically, PyTorch has three minor releases a year. Please let us know if you encounter a bug by filing an issue.

We appreciate all contributions. If you are planning to contribute back bug-fixes, please do so without any further discussion.

If you plan to contribute new features, utility functions, or extensions to the core, please first open an issue and discuss the feature with us. Sending a PR without discussion might end up resulting in a rejected PR because we might be taking the core in a different direction than you might be aware of.

To learn more about making a contribution to Pytorch, please see our Contribution page. For more information about PyTorch releases, see Release page.

The Team

PyTorch is a community-driven project with several skillful engineers and researchers contributing to it.

PyTorch is currently maintained by Soumith Chintala, Gregory Chanan, Dmytro Dzhulgakov, Edward Yang, and Nikita Shulga with major contributions coming from hundreds of talented individuals in various forms and means. A non-exhaustive but growing list needs to mention: Trevor Killeen, Sasank Chilamkurthy, Sergey Zagoruyko, Adam Lerer, Francisco Massa, Alykhan Tejani, Luca Antiga, Alban Desmaison, Andreas Koepf, James Bradbury, Zeming Lin, Yuandong Tian, Guillaume Lample, Marat Dukhan, Natalia Gimelshein, Christian Sarofeen, Martin Raison, Edward Yang, Zachary Devito.

Note: This project is unrelated to hughperkins/pytorch with the same name. Hugh is a valuable contributor to the Torch community and has helped with many things Torch and PyTorch.

License

PyTorch has a BSD-style license, as found in the LICENSE file.

Xilinx/Vitis-HLS-Introductory-Examples

2024-11-24T01:42:37Z

lakehq/sail

2024-11-23T01:34:38Z

LakeSail's computation framework with a mission to unify stream processing, batch processing, and compute-intensive (AI) workloads.

Sail

The mission of Sail is to unify stream processing, batch processing, and compute-intensive (AI) workloads. Currently, Sail features a drop-in replacement for Spark SQL and the Spark DataFrame API in both single-host and distributed settings.

Kubernetes Deployment

Please refer to the Kubernetes Deployment Guide for instructions on deploying Sail on Kubernetes.

Installation

Sail is available as a Python package on PyPI. You can install it using pip.

pip install "pysail==0.2.0.dev0"

Alternatively, you can install Sail from source for better performance for your hardware architecture. You would need rustup and protoc in your environment for this.

env RUSTFLAGS="-C target-cpu=native" pip install "pysail==0.2.0.dev0" -v --no-binary pysail

You can follow the Getting Started guide to learn more about Sail.

Documentation

The documentation of the latest Sail version can be found here.

Benchmark Results

Check out our blog post, Supercharge Spark: Quadruple Speed, Cut Costs by 94%, for detailed benchmark results comparing Sail with Spark.

Contributing

Contributions are more than welcome!

Please submit GitHub issues for bug reports and feature requests.

Feel free to create a pull request if you would like to make a code change. You can refer to the development guide to get started.

Support

See the Support Options Page for more information.

loco-rs/loco

2024-11-24T01:42:51Z

🚂 🦀 The one-person framework for Rust for side-projects and startups

Welcome to Loco

🚂 Loco is Rust on Rails.

English · 中文 · Français · Portuguese (Brazil) ・日本語 · 한국어 · Русский

What's Loco?

Loco is strongly inspired by Rails. If you know Rails and Rust, you'll feel at home. If you only know Rails and new to Rust, you'll find Loco refreshing. We do not assume you know Rails.

For a deeper dive into how Loco works, including detailed guides, examples, and API references, check out our documentation website.

Features of Loco:

Convention Over Configuration: Similar to Ruby on Rails, Loco emphasizes simplicity and productivity by reducing the need for boilerplate code. It uses sensible defaults, allowing developers to focus on writing business logic rather than spending time on configuration.
Rapid Development: Aim for high developer productivity, Loco’s design focuses on reducing boilerplate code and providing intuitive APIs, allowing developers to iterate quickly and build prototypes with minimal effort.
ORM Integration: Model your business with robust entities, eliminating the need to write SQL. Define relationships, validation, and custom logic directly on your entities for enhanced maintainability and scalability.
Controllers: Handle web requests parameters, body, validation, and render a response that is content-aware. We use Axum for the best performance, simplicity, and extensibility. Controllers also allow you to easily build middlewares, which can be used to add logic such as authentication, logging, or error handling before passing requests to the main controller actions.
Views: Loco can integrate with templating engines to generate dynamic HTML content from templates.
Background Jobs: Perform compute or I/O intensive jobs in the background with a Redis backed queue, or with threads. Implementing a worker is as simple as implementing a perform function for the Worker trait.
Scheduler: Simplifies the traditional, often cumbersome crontab system, making it easier and more elegant to schedule tasks or shell scripts.
Mailers: A mailer will deliver emails in the background using the existing loco background worker infrastructure. It will all be seamless for you.
Storage: In Loco Storage, we facilitate working with files through multiple operations. Storage can be in-memory, on disk, or use cloud services such as AWS S3, GCP, and Azure.
Cache: Loco provides an cache layer to improve application performance by storing frequently accessed data.

So see more Loco features, check out our documentation website.

Getting Started

cargo install loco
cargo install sea-orm-cli # Only when DB is needed

Now you can create your new app (choose "SaaS app").

❯ loco new
✔ ❯ App name? · myapp
✔ ❯ What would you like to build? · Saas App with client side rendering
✔ ❯ Select a DB Provider · Sqlite
✔ ❯ Select your background worker type · Async (in-process tokio async tasks)

🚂 Loco app generated successfully in:
myapp/

- assets: You've selected `clientside` for your asset serving configuration.

Next step, build your frontend:
  $ cd frontend/
  $ npm install && npm run build

Now cd into your myapp and start your app:

$ cargo loco start

                      ▄     ▀
                                ▀  ▄
                  ▄       ▀     ▄  ▄ ▄▀
                                    ▄ ▀▄▄
                        ▄     ▀    ▀  ▀▄▀█▄
                                          ▀█▄
▄▄▄▄▄▄▄  ▄▄▄▄▄▄▄▄▄   ▄▄▄▄▄▄▄▄▄▄▄ ▄▄▄▄▄▄▄▄▄ ▀▀█
██████  █████   ███ █████   ███ █████   ███ ▀█
██████  █████   ███ █████   ▀▀▀ █████   ███ ▄█▄
██████  █████   ███ █████       █████   ███ ████▄
██████  █████   ███ █████   ▄▄▄ █████   ███ █████
██████  █████   ███  ████   ███ █████   ███ ████▀
  ▀▀▀██▄ ▀▀▀▀▀▀▀▀▀▀  ▀▀▀▀▀▀▀▀▀▀  ▀▀▀▀▀▀▀▀▀▀ ██▀
      ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
                https://loco.rs

listening on port 5150

Powered by Loco

SpectralOps - various services powered by Loco framework
Nativish - app backend powered by Loco framework

Contributors ✨

Thanks goes to these wonderful people:

jito-foundation/jito-solana

2024-11-24T01:42:51Z

Jito Foundation MEV Solana Client

About

This repository contains Jito's fork of the Solana validator.

We recommend checking out our Gitbook for more detailed instructions on building and running Jito-Solana.

1. Install rustc, cargo and rustfmt.

$ curl https://sh.rustup.rs -sSf | sh
$ source $HOME/.cargo/env
$ rustup component add rustfmt

When building the master branch, please make sure you are using the latest stable rust version by running:

$ rustup update

When building a specific release branch, you should check the rust version in ci/rust-version.sh and if necessary, install that version by running:

$ rustup install VERSION

Note that if this is not the latest rust version on your machine, cargo commands may require an override in order to use the correct version.

On Linux systems you may need to install libssl-dev, pkg-config, zlib1g-dev, protobuf etc.

On Ubuntu:

$ sudo apt-get update
$ sudo apt-get install libssl-dev libudev-dev pkg-config zlib1g-dev llvm clang cmake make libprotobuf-dev protobuf-compiler

On Fedora:

$ sudo dnf install openssl-devel systemd-devel pkg-config zlib-devel llvm clang cmake make protobuf-devel protobuf-compiler perl-core

2. Download the source code.

$ git clone https://github.com/jito-foundation/jito-solana.git
$ cd jito-solana

3. Build.

$ ./cargo build

Testing

Run the test suite:

$ ./cargo test

Starting a local testnet

Start your own testnet locally, instructions are in the online docs.

Accessing the remote development cluster

devnet - stable public cluster for development accessible via devnet.solana.com. Runs 24/7. Learn more about the public clusters

Benchmarking

First, install the nightly build of rustc. cargo bench requires the use of the unstable features only available in the nightly build.

$ rustup install nightly

Run the benchmarks:

$ cargo +nightly bench

Release Process

The release process for this project is described here.

Code coverage

To generate code coverage statistics:

$ scripts/coverage.sh
$ open target/cov/lcov-local/index.html

Why coverage? While most see coverage as a code quality metric, we see it primarily as a developer productivity metric. When a developer makes a change to the codebase, presumably it's a solution to some problem. Our unit-test suite is how we encode the set of problems the codebase solves. Running the test suite should indicate that your change didn't infringe on anyone else's solutions. Adding a test protects your solution from future changes. Say you don't understand why a line of code exists, try deleting it and running the unit-tests. The nearest test failure should tell you what problem was solved by that code. If no test fails, go ahead and submit a Pull Request that asks, "what problem is solved by this code?" On the other hand, if a test does fail and you can think of a better way to solve the same problem, a Pull Request with your solution would most certainly be welcome! Likewise, if rewriting a test can better communicate what code it's protecting, please send us that patch!

rpcpool/yellowstone-grpc

2024-11-24T01:42:51Z

solana geyser grpc service

Yellowstone Dragon's Mouth - a Geyser based gRPC interface for Solana

This repo contains a fully functional gRPC interface for Solana. It is built around Solana's Geyser interface. In this repo we have the plugin as well as sample clients for multiple languages.

It provides the ability to get slots, blocks, transactions, and account update notifications over a standardised path.

For additional documentation, please see: https://docs.triton.one/rpc-pool/grpc-subscriptions

Known bugs

Block reconstruction inside gRPC plugin based on information provided by BlockMeta, unfortunately number of entries for blocks generated on validators always equal to zero. These blocks always will have zero entries. See issue on GitHub: https://github.com/solana-labs/solana/issues/33823

Validator

$ solana-validator --geyser-plugin-config yellowstone-grpc-geyser/config.json

Plugin config check

cargo-fmt && cargo run --bin config-check -- --config yellowstone-grpc-geyser/config.json

Block reconstruction

Geyser interface on block update do not provide detailed information about transactions and accounts updates. To provide this information with block message we need to collect all messages and expect specified order. By default if we failed to reconstruct full block we log error message and increase invalid_full_blocks_total counter in prometheus metrics. If you want to panic on invalid reconstruction you can change option block_fail_action in config to panic (default value is log).

Filters for streamed data

Please check yellowstone-grpc-proto/proto/geyser.proto for details.

commitment — commitment level: processed / confirmed / finalized
accounts_data_slice — array of objects { offset: uint64, length: uint64 }, allow to receive only required data from accounts
ping — optional boolean field. Some cloud providers (like Cloudflare, Fly.io) close the stream if client doesn't send anything during some time. As workaroud you can send same filter every N seconds, but this would be not optimal since you need to keep this filter. Instead, you can send subscribe request with ping field set to true and ignore rest of the fields in the request. Since we sent Ping message every 15s from the server, you can send subscribe request with ping as reply and receive Pong message.

Slots

filter_by_commitment — by default slots sent for all commitment levels, but with this filter you can receive only selected commitment level

Account

Accounts can be filtered by:

account — acount Pubkey, match to any Pubkey from the array
owner — account owner Pubkey, match to any Pubkey from the array
filters — same as getProgramAccounts filters, array of dataSize or Memcmp (bytes, base58, base64 are supported)

If all fields are empty then all accounts are broadcasted. Otherwise fields works as logical AND and values in arrays as logical OR (except values in filters that works as logical AND).

Transactions

vote — enable/disable broadcast vote transactions
failed — enable/disable broadcast failed transactions
signature — match only specified transaction
account_include — filter transactions that use any account from the list
account_exclude — opposite to account_include
account_required — require all accounts from the list to be used in transaction

If all fields are empty then all transactions are broadcasted. Otherwise fields works as logical AND and values in arrays as logical OR.

Entries

Currently we do not have filters for the entries, all entries broadcasted.

Blocks

account_include — filter transactions and accounts that use any account from the list
include_transactions — include all transactions
include_accounts — include all accounts updates
include_entries — include all entries

Blocks meta

Same as Blocks but without transactions, accounts and entries. Currently we do not have filters for block meta, all messages are broadcasted.

Limit filters

It's possible to add limits for filters in the config. If filters field is omitted then filters doesn't have any limits.

"grpc": {
   "filters": {
      "accounts": {
         "max": 1,
         "any": false,
         "account_max": 10,
         "account_reject": ["TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"],
         "owner_max": 10,
         "owner_reject": ["11111111111111111111111111111111"]
      },
      "slots": {
         "max": 1
      },
      "transactions": {
         "max": 1,
         "any": false,
         "account_include_max": 10,
         "account_include_reject": ["TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"],
         "account_exclude_max": 10,
         "account_required_max": 10
      },
      "blocks": {
         "max": 1,
         "account_include_max": 10,
         "account_include_any": false,
         "account_include_reject": ["TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"],
         "include_transactions": true,
         "include_accounts" : false,
         "include_entries" : false
      },
      "blocks_meta": {
         "max": 1
      },
      "entry": {
         "max": 1
      }
   }
}

Unary gRPC methods

Ping

GetLatestBlockhash

GetBlockHeight

GetSlot

IsBlockhashValid

GetVersion

Examples

NOTE: Some load balancers will terminate gRPC connections if there are no messages sent from the client for a period of time. In order to mitigate this you need to send a message periodically. The ping field in the SubscribeRequest is used for this purpose. The gRPC server already sends pings to the client, so you can simply reply with a ping and your connection will remain open. You can see in the rust example how to reply to the ping from the server with the client.

Projects based on Geyser gRPC

https://github.com/rpcpool/yellowstone-grpc-kafka — forward gRPC stream to Kafka, dedup, read stream from Kafka with gRPC server

open-korean-text/open-korean-text

2024-11-24T01:43:05Z

Open Korean Text Processor - An Open-source Korean Text Processor

open-korean-text

Open-source Korean Text Processor / 오픈소스 한국어 처리기 (Official Fork of twitter-korean-text)

Scala/Java library to process Korean text with a Java wrapper. open-korean-text currently provides Korean normalization and tokenization. Please join our community at Google Forum. The intent of this text processor is not limited to short tweet texts.

스칼라로 쓰여진 한국어 처리기입니다. 현재 텍스트 정규화와 형태소 분석, 스테밍을 지원하고 있습니다. 짧은 트윗은 물론이고 긴 글도 처리할 수 있습니다. 개발에 참여하시고 싶은 분은 Google Forum에 가입해 주세요. 사용법을 알고자 하시는 초보부터 코드에 참여하고 싶으신 분들까지 모두 환영합니다.

설치 및 수정하는 방법 상세 안내

open-korean-text의 목표는 빅데이터 등에서 간단한 한국어 처리를 통해 색인어를 추출하는 데에 있습니다. 완전한 수준의 형태소 분석을 지향하지는 않습니다.

open-korean-text는 normalization, tokenization, stemming, phrase extraction 이렇게 네가지 기능을 지원합니다.

정규화 normalization (입니닼ㅋㅋ -> 입니다 ㅋㅋ, 샤릉해 -> 사랑해)

한국어를 처리하는 예시입니닼ㅋㅋㅋㅋㅋ -> 한국어를 처리하는 예시입니다 ㅋㅋ

토큰화 tokenization

한국어를 처리하는 예시입니다 ㅋㅋ -> 한국어Noun, 를Josa, 처리Noun, 하는Verb, 예시Noun, 입니다Adjective(이다), ㅋㅋKoreanParticle

어근화 stemming (입니다 -> 이다)

한국어를 처리하는 예시입니다 ㅋㅋ -> 한국어Noun, 를Josa, 처리Noun, 하다Verb, 예시Noun, 이다Adjective, ㅋㅋKoreanParticle

어구 추출 phrase extraction

한국어를 처리하는 예시입니다 ㅋㅋ -> 한국어, 처리, 예시, 처리하는 예시

Introductory Presentation: Google Slides

Web API Service

open-korean-text-api
이 API 서비스는 Heroku 서버에서 제공되며(Domain: https://open-korean-text.herokuapp.com/) 현재 정규화(normalization), 토큰화(tokenization), 어근화(stemmin), 어구 추출(phrase extract) 서비스를 제공합니다.

각 서비스와 사용법은 다음과 같습니다.
normalize, tokenize, stem, extractPhrases 가 각 서비스의 Action 이 되며 Query parameter 는 text 입니다.

서비스	사용법
정규화	https://open-korean-text-api.herokuapp.com/normalize?text=오픈코리안텍스트
토큰화	https://open-korean-text-api.herokuapp.com/tokenize?text=오픈코리안텍스트
어근화	https://open-korean-text-api.herokuapp.com/stem?text=오픈코리안텍스트
어구 추출	https://open-korean-text-api.herokuapp.com/extractPhrases?text=오픈코리안텍스트

Semantic Versioning

1.0.2 (Major.Minor.Patch)

Major: API change Minor: Processor behavior change Patch: Bug fixes without a behavior change

API

Maven

To include this in your Maven-based JVM project, add the following lines to your pom.xml: / Maven을 이용할 경우 pom.xml에 다음의 내용을 추가하시면 됩니다:

  <dependency>
    <groupId>org.openkoreantext</groupId>
    <artifactId>open-korean-text</artifactId>
    <version>2.1.0</version>
  </dependency>

Maven Repository: http://mvnrepository.com/artifact/org.openkoreantext/open-korean-text

Support for other languages.

Type	Language	Contributor
Wrapper	.net/C#	modamoda
Wrapper	Node JS	Ch0p
Wrapper	Node JS	Youngrok Kim
Wrapper	Python	Jaepil Jeong
Wrapper	Clojure	Seonho Kim
Wrapper	Ruby for Java Version	jun85664396
Wrapper	Ruby for Scala Version	Jaehyun Shin
Porting	Python	Baeg-il Kim
Package	Python Korean NLP	KoNLPy
Package	Elastic Search	socurites
Package	Elastic Search	Jaehyun Shin
Package	JavaScript (browser-compatible)	Grégoire Geis

Get the source / 소스를 원하시는 경우

Clone the git repo and build using maven. / Git 전체를 클론하고 Maven을 이용하여 빌드합니다.

git clone https://github.com/open-korean-text/open-korean-text.git
cd open-korean-text
mvn compile

Open 'pom.xml' from your favorite IDE.

Basic Usage / 사용 방법

You can find these examples in examples folder. / examples 폴더에 사용 방법 예제 파일이 있습니다.

Running Tests

mvn test will run our unit tests / 모든 유닛 테스트를 실행하려면 mvn test를 이용해 주세요.

Contribution

Refer to the general contribution guide. We will add this project-specific contribution guide later.

설치 및 수정하는 방법 상세 안내

Performance / 처리 속도

Tested on Intel i7 2.3 Ghz

Initial loading time (초기 로딩 시간): 2~4 sec

Average time per parsing a chunk (평균 어절 처리 시간): 0.12 ms

Tweets (Avg length ~50 chars)

Tweets	100K	200K	300K	400K	500K	600K	700K	800K	900K	1M
Time in Seconds	57.59	112.09	165.05	218.11	270.54	328.52	381.09	439.71	492.94	542.12

Average per tweet: 0.54212 ms

Benchmark test by KoNLPy

From http://konlpy.org/ko/v0.4.3/morph/#pos-tagging-with-konlpy

Author

Will Hohyon Ryu (유호현): https://github.com/nlpenguin | https://twitter.com/NLPenguin

Admin Staff

Mingyu Kim (김민규): https://github.com/MechanicKim

License

Licensed under the Apache License, Version 2.0: http://www.apache.org/licenses/LICENSE-2.0

lavinir/hassio-onedrive-backup

2024-11-24T01:35:06Z

overhangio/tutor-indigo

2024-11-24T01:43:11Z

An elegant, customizable theme for Open edX

xubiaolin/docker-zerotier-planet

2024-11-24T01:43:14Z

一分钟私有部署zerotier-planet服务

交流群

Telegram

TG交流群：https://t.me/+JduuWfhSEPdlNDk1

QQ Group

1群（已满）：692635772
2群（已满）：785620313
3群：316239544

功能特性

✅ 支持 Linux/AMD64、Linux/ARM64 架构
🐳 Docker 容器化部署
📥 支持 URL 下载 planet、moon 配置
🌐 可作为 Moon 或 Planet 服务器搭建

0: 广告

寻找便捷的解决方案？

我们提供专业的托管服务：

免费试用3天
年费仅需99￥
高速带宽：300Mbit
流量政策：
- 每月100G转发流量
- P2P连接后不计流量
- 超出后每10元100G
优质线路：宁波电信机房
联系方式：
- Telegram：https://t.me/uxkram
- 或加入QQ群咨询群主

测速图如下：

微信公众号：欢迎关注公众号获取最新动态和技术分享

1：ZeroTier 介绍

ZeroTier 是一款强大的 P2P VPN 工具，它能让你在互联网上搭建属于自己的虚拟局域网。通过它，你可以轻松实现远程访问家中设备的需求 - 比如在公司用手机直接访问家里的 NAS。最重要的是，设备之间是点对点直连的，无需经过中转服务器，既保证了速度，又提升了安全性。

它的工作原理是这样的：通过 ZeroTier One 客户端，在不同设备（如笔记本、手机、服务器等）之间建立 P2P 连接，即使这些设备都在 NAT 后面也没问题。它使用了 STUN 等技术，可以穿透大多数类型的 NAT，实现设备间的直接通信。如果实在无法直连，才会通过中转服务器进行通信。

简单来说，ZeroTier 就像是一个跨越互联网的"虚拟交换机"，让分布在世界各地的设备，都能像在同一个局域网内一样方便地相互访问。

ZeroTier 网络中的关键概念

PLANET（行星服务器）：ZeroTier 网络的核心根服务器，负责网络发现和初始连接。相当于整个网络的"中枢"。

MOON（卫星服务器）：用户可以自建的私有根服务器。它可以作为区域性的代理节点,帮助就近的设备更快地建立连接,提升网络性能。

LEAF（叶子节点）：所有接入 ZeroTier 网络的终端设备,如电脑、手机、服务器等。这些设备通过 PLANET 和 MOON 的协调来相互发现和通信。

本教程将指导您搭建一个私有的 PLANET 服务器,让您完全掌控自己的 ZeroTier 网络。

2：为什么要自建PLANET 服务器

自建 PLANET 服务器有以下几个重要原因：

提升网络稳定性：官方服务器位于海外，国内用户访问延迟高且不稳定。自建服务器可以大幅提升连接质量。
加快连接速度：本地化的 PLANET 服务器可以更快地帮助设备建立 P2P 连接。
增强网络控制：自建服务器让您完全掌控网络配置，可以根据需求进行优化调整。
提高安全性：私有化部署意味着网络流量不经过第三方服务器，更加安全可靠。
降低依赖：避免因官方服务器故障或网络波动影响您的业务正常运行。

3：开始安装

3.1：环境准备

在开始安装之前，请确保您的服务器满足以下条件:

服务器要求:
- 拥有公网IP地址
- 需开放以下端口:
  - 3443/tcp (管理面板，根据实际情况调整)
  - 9994/tcp (ZeroTier通信，根据实际情况调整)
  - 9994/udp (ZeroTier通信，根据实际情况调整)
软件依赖:
- Docker (容器运行环境)
- Git (获取项目代码)
系统要求:
- 推荐使用较新的Linux发行版:
  - Debian 12
  - Ubuntu 20.04+
  - Rocky Linux
  - 其他同类系统

3.1.1 安装git

#debian/ubuntu等
apt update && apt install git -y 

#centos等
yum update && yum install git -y

3.1.2 安装docker

curl -fsSL https://get.docker.com |bash

如果网络问题，导致无法安装，可以使用国内镜像安装：

curl -fsSL get.docker.com -o get-docker.sh
sudo sh get-docker.sh --mirror Aliyun

3.1.3 启动docker

service docker start

3.1.4 配置docker加速镜像（可选，不配也可以）

sudo tee /etc/docker/daemon.json <<EOF
{
    "registry-mirrors": [
        "https://docker.mirrors.aster.edu.pl",
        "https://docker.mirrors.imoyuapp.win"
    ]
}
EOF

sudo systemctl daemon-reload
sudo systemctl restart docker

3.2：下载项目源码

官方地址

git clone https://github.com/xubiaolin/docker-zerotier-planet.git

加速地址

git clone https://ghproxy.imoyuapp.win/https://github.com/xubiaolin/docker-zerotier-planet.git

3.3：执行安装脚本

进入项目目录

cd docker-zerotier-planet

运行 deploy.sh 脚本

./deploy.sh

根据提示来选择即可，操作完成后会自动部署

欢迎使用zerotier-planet脚本，请选择需要执行的操作：
1. 安装
2. 卸载
3. 更新
4. 查看信息
5. 退出
请输入数字：

整个脚本预计需要 1-3 分钟,具体需要看网络与机型

当您看到类似如下字样时，表示安装成功

3.4 下载 `planet` 文件

脚本运行完成后，会在 ./data/zerotier/dist 目录下生成 planet 和 moon 配置文件。

您可以通过以下两种方式获取这些文件:

通过安装完成后提供的URL直接下载
使用scp或其他文件传输工具从服务器下载

请妥善保存这些文件,后续配置客户端时会用到。

3.5 新建网络

访问 http://ip:3443 进入controller页面

使用默认账号为:admin

默认密码为:password

3.5.1 创建网络

登录后点击"Networks"菜单，然后点击"Add Network"按钮创建新网络。

在创建网络页面中，输入一个便于识别的网络名称，其他选项可保持默认。点击"Create Network"按钮完成创建。

创建成功后系统会自动生成一个网络ID，这个ID在后续客户端配置时会用到，请记录下来。

得到网络 id

3.5.2 分配网络IP:

选中easy setup

生成ip范围

4.客户端配置

ZeroTier 支持多种主流操作系统的客户端，包括:

Windows
macOS
Linux
Android

4.1 Windows 配置

首先去zerotier官网下载一个zerotier客户端

将 planet 文件覆盖粘贴到C:\ProgramData\ZeroTier\One中(这个目录是个隐藏目录，需要运允许查看隐藏目录才行)

Win+S 搜索 服务

找到ZeroTier One，并且重启服务

4.2 加入网络

使用管理员身份打开PowerShell

执行如下命令，看到join ok字样就成功了

PS C:\Windows\system32> zerotier-cli.bat join 网络id(就是在网页里面创建的那个网络)
200 join OK
PS C:\Windows\system32>

登录管理后台可以看到有个个新的客户端，勾选Authorized就行

IP assignment 里面会出现zerotier的内网ip

执行如下命令：

PS C:\Windows\system32> zerotier-cli.bat peers
200 peers
<ztaddr>   <ver>  <role> <lat> <link> <lastTX> <lastRX> <path>
fcbaeb9b6c 1.8.7  PLANET    52 DIRECT 16       8994     1.1.1.1/9993
fe92971aad 1.8.7  LEAF      14 DIRECT -1       4150     2.2.2.2/9993
PS C:\Windows\system32>

可以看到有一个 PLANTET 和 LEAF 角色，连接方式均为 DIRECT(直连)

到这里就加入网络成功了

4.2 Linux 客户端

步骤如下：

安装linux客户端软件
进入目录 /var/lib/zerotier-one
替换目录下的 planet 文件
重启 zerotier-one 服务(service zerotier-one restart)
加入网络 zerotier-cli join 网络 id
管理后台同意加入请求
zerotier-cli peers 可以看到 planet 角色

4.3 安卓客户端配置

Zerotier 非官方安卓客户端

4.4 MacOS 客户端配置

步骤如下：

进入 /Library/Application\ Support/ZeroTier/One/ 目录，并替换目录下的 planet 文件
重启 ZeroTier-One：cat /Library/Application\ Support/ZeroTier/One/zerotier-one.pid | sudo xargs kill
加入网络 zerotier-cli join 网络 id
管理后台同意加入请求
zerotier-cli peers 可以看到 planet 角色

4.5 OpenWRT 客户端配置

步骤如下：

安装zerotier客户端
进入目录 /etc/config/zero/planet
替换目录下的 planet 文件
在openwrt网页后台重启zerotier服务
在openwrt网页后台加入网络
管理后台同意加入请求
zerotier-cli peers 可以看到 planet 角色

4.6 iOS 客户端配置

方案一：越狱后安装ZeroTie，然后替换planet文件

方案二：使用Wireguard接入到ZeroTier网络

5. 管理面板SSL配置

管理面板的SSL支持需要自行配置，参考Nginx配置如下：

upstream zerotier {
  server 127.0.0.1:3443;
}

server {

  listen 443 ssl;

  server_name {CUSTOME_DOMAIN}; #替换自己的域名

  # ssl证书地址
  ssl_certificate    pem和或者crt文件的路径;
  ssl_certificate_key key文件的路径;

  # ssl验证相关配置
  ssl_session_timeout  5m;    #缓存有效期
  ssl_ciphers ECDHE-RSA-AES128-GCM-SHA256:ECDHE:ECDH:AES:HIGH:!NULL:!aNULL:!MD5:!ADH:!RC4;    #加密算法
  ssl_protocols TLSv1 TLSv1.1 TLSv1.2;    #安全链接可选的加密协议
  ssl_prefer_server_ciphers on;   #使用服务器端的首选算法


  location / {
    proxy_pass http://zerotier;
    proxy_set_header HOST $host;
    proxy_set_header X-Forwarded-Proto $scheme;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }
}

server {
    listen       80;
    server_name  {CUSTOME_DOMAIN}; #替换自己的域名
    return 301 https://$server_name$request_uri;
}

6. 卸载

docker rm -f zerotier-planet

7: Q&A：

1. 为什么我ping不通目标机器？

请检查防火墙设置，Windows 系统需要允许 ICMP 入站，Linux 同理

2. IOS客户端怎么用？

iOS 客户端插件在这里，设备需要越狱： https://github.com/lemon4ex/ZeroTieriOSFix

3. 为什么看不到官方的Planet

该项目剔除了官方服务器，只保留了自定义的Planet节点

4. 我更换了IP需要怎么处理？

如果IP更换了，则需要重新部署，相当于全新部署

5. PVE lxc 容器没有创建网卡

需要修改lxc容器的配置，同时lxc容器需要取消勾选无特权

配置文件位置在/etc/pve/lxc/{ID}.conf

在Proxmox7.0之前的版本添加以下内容：

lxc.cgroup.devices.allow: c 10:200 rwm
lxc.mount.entry: /dev/net/tun dev/net/tun none bind,create=file

在Proxmox7.0之后的版本添加以下内容：

lxc.cgroup2.devices.allow: c 10:200 rwm
lxc.mount.entry: /dev/net/tun dev/net/tun none bind,create=file

6. 管理后台忘记密码怎么办：

执行./deploy.sh，选择重置密码即可

7. 为什么连不上planet

请检查防火墙，如果是阿里云、腾讯云用户，需要在对应平台后台防火墙放行端口。linux机器上也要放行，如果安装了ufw等防火墙工具。

8. 如何判断是直连还是中转

管理员权限执行终端，运行zerotier-cli peers

<ztaddr>   <ver>  <role> <lat> <link>   <lastTX> <lastRX> <path>
69c0d507d0 -      LEAF      -1 RELAY
93caa675b0 1.12.2 PLANET  -894 DIRECT   4142     4068     110.42.99.46/9994
ab403e2074 1.10.2 LEAF      -1 RELAY

如果你的ztaddr是REPLAY, 就说明是中转

9. 为什么我的zerotier传输不稳定

由于zerotier使用的是udp协议，部分地区可能对udp进行了qos, 可以考虑使用openvpn。

10.支持域名吗？

暂不支持

11. ARM服务器可以搭建吗

可以

12. 支持docker-compose启动部署吗

参考docker-compose文件如下

version: '3'

services:
  myztplanet:
    image: xubiaolin/zerotier-planet:latest
    container_name: ztplanet
    ports:
      - 9994:9994
      - 9994:9994/udp
      - 3443:3443
      - 3000:3000
    environment:
      - IP_ADDR4=[IPV4IP ADDRESS]
      - IP_ADDR6=
      - ZT_PORT=9994
      - API_PORT=3443
      - FILE_SERVER_PORT=3000
    volumes:
      - ./data/zerotier/dist:/app/dist
      - ./data/zerotier/ztncui:/app/ztncui
      - ./data/zerotier/one:/var/lib/zerotier-one
      - ./data/zerotier/config:/app/config
    restart: unless-stopped

开发计划

🥰您的捐助可以让开发计划的速度更快🥰

多planet支持
3443端口自定义支持
planet和controller分离部署

风险声明

本项目仅供学习和研究使用，不鼓励用于商业用途。我们不对任何因使用本项目而导致的任何损失负责。

类似项目

wireguard一键脚本

捐助和支持

如果觉得本项目对您有帮助，欢迎通过扫描下方赞赏码捐助项目 :)

鸣谢

感谢以下网友投喂，你们的支持和鼓励是我不懈更新的动力

按时间顺序排序：

随性
我
你好
Calvin
小猪猪的饲养员
情若犹在
天天星期天
啊乐
夏末秋至
**忠
岸芷汀兰
Kimi Chen
匿名
阳光报告旷课
濂溪先生
Water
匿名
匿名
陆
精钢葫芦娃
唯
王小新
匿名

参考链接

ZeroTier-虚拟局域网详解

五分钟自建 ZeroTier 的 Planet/Controller

taigaio/taiga-docker

2024-11-24T01:43:14Z

Taiga Docker

ℹ	If you're already using taiga-docker, follow this migration guide to use the new `.env` based deployment.

Note: You can access the older docker installation guide for documentation purposes, intended just for earlier versions of Taiga (prior to ver. 6.6.0)

Getting Started

This section intends to explain how to get Taiga up and running in a simple two steps, using docker and docker compose.

If you don't have docker installed, please follow installation instructions from docker.com (version 19.03.0+)

Additionally, it's necessary to have familiarity with Docker, docker compose and Docker repositories.

Note branch stable should be used to deploy Taiga in production and main branch for development purposes.

Start the application

$ ./launch-taiga.sh

After some instants, when the application is started you can proceed to create the superuser with the following script:

$ ./taiga-manage.sh createsuperuser

The taiga-manage.sh script lets launch manage.py commands on the back instance:

$ ./taiga-manage.sh [COMMAND]

If you're testing it in your own machine, you can access the application in http://localhost:9000. If you're deploying in a server, you'll need to configure hosts and nginx as described later.

Documentation

Currently, we have authored three main documentation hubs:

API: Our API documentation and reference for developing from Taiga API.
Documentation: If you need to install Taiga on your own server, this is the place to find some guides.
Taiga Community: This page is intended to be the support reference page for the users.

Bug reports

If you find a bug in Taiga you can always report it:

in Taiga issues. This is the preferred way
in Github issues
send us a mail to support@taiga.io if is a bug related to tree.taiga.io
send us a mail to security@taiga.io if is a security bug

One of our fellow Taiga developers will search, find and hunt it as soon as possible.

Please, before reporting a bug, write down how can we reproduce it, your operating system, your browser and version, and if it's possible, a screenshot. Sometimes it takes less time to fix a bug if the developer knows how to find it.

Community

If you need help to setup Taiga, want to talk about some cool enhancemnt or you have some questions, please go to Taiga community.

If you want to be up to date about announcements of releases, important changes and so on, you can subscribe to our newsletter (you will find it by scrolling down at https://taiga.io) and follow @taigaio on Twitter.

Contribute to Taiga

There are many different ways to contribute to Taiga's platform, from patches, to documentation and UI enhancements, just find the one that best fits with your skills. Check out our detailed contribution guide.

Code of Conduct

Help us keep the Taiga Community open and inclusive. Please read and follow our Code of Conduct.

License

Every code patch accepted in Taiga codebase is licensed under MPL 2.0. You must be careful to not include any code that can not be licensed under this license.

Please read carefully our license and ask us if you have any questions as well as the Contribution policy.

Configuration

We've exposed the Basic configuration settings in Taiga to an .env file. We strongly recommend you to change it, or at least review its content, to avoid using the default values.

Both docker-compose.yml and docker-compose-inits.yml will read from this file to populate their environment variables, so, initially you don't need to change them. Edit these files just in case you require to enable Additional customization, or an Advanced configuration.

Refer to these sections for further information.

Basic Configuration

You will find basic configuration variables in the .env file. As stated before, we encourage you to edit these values, especially those affecting the security.

Database settings

These vars are used to create the database for Taiga and connect to it.

POSTGRES_USER=taiga  # user to connect to PostgreSQL
POSTGRES_PASSWORD=taiga  # database user's password

URLs settings

These vars set where your Taiga instance should be served, and the security protocols to use in the communication layer.

TAIGA_SCHEME=http  # serve Taiga using "http" or "https" (secured) connection
TAIGA_DOMAIN=localhost:9000  # Taiga's base URL
SUBPATH=""  # it'll be appended to the TAIGA_DOMAIN (use either "" or a "/subpath")
WEBSOCKETS_SCHEME=ws  # events connection protocol (use either "ws" or "wss")

The default configuration assumes Taiga is being served in a subdomain. For example:

TAIGA_SCHEME=https
TAIGA_DOMAIN=taiga.mycompany.com
SUBPATH=""
WEBSOCKETS_SCHEME=wss

If Taiga is being served in a subpath, instead of a subdomain, the configuration should be something like this:

TAIGA_SCHEME=https
TAIGA_DOMAIN=mycompany.com
SUBPATH="/taiga"
WEBSOCKETS_SCHEME=wss

Secret Key settings

This variable allows you to set the secret key in Taiga, used in the cryptographic signing.

SECRET_KEY="taiga-secret-key"  # Please, change it to an unpredictable value!

Email Settings

By default, emails will be printed in the standard output (EMAIL_BACKEND=console). If you have your own SMTP service, change it to EMAIL_BACKEND=smtp and configure the rest of these variables with the values supplied by your SMTP provider:

EMAIL_BACKEND=console  # use an SMTP server or display the emails in the console (either "smtp" or "console")
EMAIL_HOST=smtp.host.example.com  # SMTP server address
EMAIL_PORT=587   # default SMTP port
EMAIL_HOST_USER=user  # user to connect the SMTP server
EMAIL_HOST_PASSWORD=password  # SMTP user's password
EMAIL_DEFAULT_FROM=changeme@example.com  # email address for the automated emails

# EMAIL_USE_TLS/EMAIL_USE_SSL are mutually exclusive (only set one of those to True)
EMAIL_USE_TLS=True  # use TLS (secure) connection with the SMTP server
EMAIL_USE_SSL=False  # use implicit TLS (secure) connection with the SMTP server

Queue manager settings

These variables are used to leave messages in the rabbitmq services.

RABBITMQ_USER=taiga  # user to connect to RabbitMQ
RABBITMQ_PASS=taiga  # RabbitMQ user's password
RABBITMQ_VHOST=taiga  # RabbitMQ container name
RABBITMQ_ERLANG_COOKIE=secret-erlang-cookie  # unique value shared by any connected instance of RabbitMQ

Attachments settings

You can configure how long the attachments will be accessible by changing the token expiration timer. After that amount of seconds the token will expire, but you can always get a new attachment url with an active token.

ATTACHMENTS_MAX_AGE=360  # token expiration date (in seconds)

Telemetry Settings

Telemetry anonymous data is collected in order to learn about the use of Taiga and improve the platform based on real scenarios. You may want to enable this to help us shape future Taiga.

ENABLE_TELEMETRY=True

You can opt out by setting this variable to False. By default, it's True.

Additional customization

All these customization options are by default disabled and require you to edit docker-compose.yml.

You should add the corresponding environment variables in the proper services (or in &default-back-environment group) with a valid value in order to enable them. Please, do not modify it unless you know what you’re doing.

Session cookies in Django Admin

Taiga doesn't use session cookies in its API as it stateless. However, the Django Admin (/admin/) uses session cookie for authentication. By default, Taiga is configured to work behind HTTPS. If you're using HTTP (despite the strong recommendations against it), you'll need to configure the following environment variables so you can access the Admin:

Add to &default-back-environment environments

SESSION_COOKIE_SECURE: "False"
CSRF_COOKIE_SECURE: "False"

More info about those variables can be found here.

Public registration

Public registration is disabled by default. If you want to allow a public register, you have to enable public registration on both, frontend and backend.

Note Be careful with the upper and lower case in these settiings. We will use 'True' for the backend and 'true' for the frontend (this is not a typo, otherwise it won't work).

Add to &default-back-environment environments

PUBLIC_REGISTER_ENABLED: "True"

Add to taiga-front service environments

PUBLIC_REGISTER_ENABLED: "true"

Important:

Taiga (in its default configuration) disables both Gitlab or Github oauth buttons whenever the public registration option hasn't been activated. To be able to use Github/Gitlab login/registration, make sure you have public registration activated on your Taiga instance.

GitHub OAuth login

Used for login with Github. This feature is disabled by default.

Follow the documentation (GitHub - Creating an OAuth App) in Github, when save application Github displays the ID and Secret.

Note Be careful with the upper and lower case in these settiings. We will use 'True' for the backend and 'true' for the frontend (this is not a typo, otherwise it won't work).

Note GITHUB_API_CLIENT_ID / GITHUB_CLIENT_ID should have the same value.

Add to &default-back-environment environments

ENABLE_GITHUB_AUTH: "True"
GITHUB_API_CLIENT_ID: "github-client-id"
GITHUB_API_CLIENT_SECRET: "github-client-secret"
PUBLIC_REGISTER_ENABLED: "True"

Add to taiga-front service environments

ENABLE_GITHUB_AUTH: "true"
GITHUB_CLIENT_ID: "github-client-id"
PUBLIC_REGISTER_ENABLED: "true"

Gitlab OAuth login

Used for login with GitLab. This feature is disabled by default.

Follow the documentation (Configure GitLab as an OAuth 2.0 authentication identity provider) in Gitlab to get the gitlab-client-id and the gitlab-client-secret.

Note Be careful with the upper and lower case in these settiings. We will use 'True' for the backend and 'true' for the frontend (this is not a typo, otherwise it won't work).

Note GITLAB_API_CLIENT_ID / GITLAB_CLIENT_ID and GITLAB_URL should have the same value.

Add to &default-back-environment environments

ENABLE_GITLAB_AUTH: "True"
GITLAB_API_CLIENT_ID: "gitlab-client-id"
GITLAB_API_CLIENT_SECRET: "gitlab-client-secret"
GITLAB_URL: "gitlab-url"
PUBLIC_REGISTER_ENABLED: "True"

Add to taiga-front service environments

ENABLE_GITLAB_AUTH: "true"
GITLAB_CLIENT_ID: "gitlab-client-id"
GITLAB_URL: "gitlab-url"
PUBLIC_REGISTER_ENABLED: "true"

Slack integration

Enable Slack integration in your Taiga instance. This feature is disabled by default.

Note Be careful with the upper and lower case in these settiings. We will use 'True' for the backend and 'true' for the frontend (this is not a typo, otherwise it won't work).

Add to &default-back-environment environments

ENABLE_SLACK: "True"

Add to taiga-front service environments

ENABLE_SLACK: "true"

GitHub importer

Activating this feature, you will be able to import projects from GitHub.

Follow this documentation (GitHub - Creating an OAuth App) to obtain the client id and the client secret from GitHun.

Note Be careful with the upper and lower case in these settiings. We will use 'True' for the backend and 'true' for the frontend (this is not a typo, otherwise it won't work).

Add to &default-back-environment environments

ENABLE_GITHUB_IMPORTER: "True"
GITHUB_IMPORTER_CLIENT_ID: "client-id-from-github"
GITHUB_IMPORTER_CLIENT_SECRET: "client-secret-from-github"

Add to taiga-front service environments

ENABLE_GITHUB_IMPORTER: "true"

Jira Importer

Activating this feature, you will be able to import projects from Jira.

Follow this documentation (Jira - OAuth 1.0a for REST APIs) to obtain the consumer key and the public/private certificate key.

Note Be careful with the upper and lower case in these settiings. We will use 'True' for the backend and 'true' for the frontend (this is not a typo, otherwise it won't work).

Add to &default-back-environment environments

ENABLE_JIRA_IMPORTER: "True"
JIRA_IMPORTER_CONSUMER_KEY: "consumer-key-from-jira"
JIRA_IMPORTER_CERT: "cert-from-jira"
JIRA_IMPORTER_PUB_CERT: "pub-cert-from-jira"

Add to taiga-front service environments

ENABLE_JIRA_IMPORTER: "true"

Trello importer

Activating this feature, you will be able to import projects from Trello.

For configure Trello, you have two options:

go to https://trello.com/app-key (you must login first) and obtaing your development API key and your secret key.
or with the new method, create a new Power-Up and generate an API key and a secret key

Note Be careful with the upper and lower case in these settiings. We will use 'True' for the backend and 'true' for the frontend (this is not a typo, otherwise it won't work).

Add to &default-back-environment environments

ENABLE_TRELLO_IMPORTER: "True"
TRELLO_IMPORTER_API_KEY: "api-key-from-trello"
TRELLO_IMPORTER_SECRET_KEY: "secret-key-from-trello"

Add to taiga-front service environments

ENABLE_TRELLO_IMPORTER: "true"

Advanced configuration

The advanced configuration will ignore the environment variables in docker-compose.yml or docker-compose-inits.yml. Skip this section if you're using env vars.

It requires you to map the configuration files of taiga-back and taiga-front services to local files in order to unlock further configuration options.

Map a config.py file

From taiga-back download the file settings/config.py.prod.example and rename it:

mv settings/config.py.prod.example settings/config.py

Edit config.py with your own configuration:

Taiga secret key: it's important to change it. It must have the same value as the secret key in taiga-events and taiga-protected
Taiga urls: configure where Taiga would be served using TAIGA_URL, SITES and FORCE_SCRIPT_NAME (see examples below)
Connection to PostgreSQL; check DATABASES section in the file
Connection to RabbitMQ for taiga-events; check "EVENTS" section in the file
Connection to RabbitMQ for taiga-async; check "TAIGA ASYNC" section in the file
Credentials for email; check "EMAIL" section in the file
Enable/disable anonymous telemetry; check "TELEMETRY" section in the file

Example to configure Taiga in subdomain:

TAIGA_SITES_SCHEME = "https"
TAIGA_SITES_DOMAIN = "taiga.mycompany.com"
FORCE_SCRIPT_NAME = ""

Example to configure Taiga in subpath:

TAIGA_SITES_SCHEME = "https"
TAIGA_SITES_DOMAIN = "taiga.mycompany.com"
FORCE_SCRIPT_NAME = "/taiga"

Check as well the rest of the configuration if you need to enable some advanced features.

Map the file into /taiga-back/settings/config.py. Have in mind that you have to map it both in docker-compose.yml and docker-compose-inits.yml. You can check the x-volumes section in docker-compose.yml with an example.

Map a conf.json file

From taiga-front download the file dist/conf.example.json and rename it:

mv dist/conf.example.json dist/conf.json

Edit it with your own configuration:

Taiga urls: configure where Taiga would be served using api, eventsUrl and baseHref (see examples below)

Example of conf.json to serve Taiga in a subdomain:

{
    "api": "https://taiga.mycompany.com/api/v1/",
    "eventsUrl": "wss://taiga.mycompany.com/events",
    "baseHref": "/",

Example of conf.json to serve Taiga in subpath:

{
    "api": "https://mycompany.com/taiga/api/v1/",
    "eventsUrl": "wss://mycompany.com/taiga/events",
    "baseHref": "/taiga/",

Check as well the rest of the configuration if you need to enable some advanced features.

Map the file into /taiga-front/dist/config.py.

Configure an admin user

$ docker compose up -d

$ docker compose -f docker-compose.yml -f docker-compose-inits.yml run --rm taiga-manage createsuperuser

Up and running

Once everything has been installed, launch all the services and check the result:

$ docker compose up -d

Configure the proxy

Your host configuration needs to make a proxy to http://localhost:9000.

If Taiga is being served in a subdomain:

  server {
      server_name taiga.mycompany.com;

      location / {
        proxy_set_header Host $http_host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Scheme $scheme;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_redirect off;
        proxy_pass http://localhost:9000/;
      }

      # Events
      location /events {
        proxy_pass http://localhost:9000/events;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_set_header Host $host;
        proxy_connect_timeout 7d;
        proxy_send_timeout 7d;
        proxy_read_timeout 7d;
      }

      # TLS: Configure your TLS following the best practices inside your company
      # Logs and other configurations
  }

If Taiga is being served in a subpath instead of a subdomain, the configuration should be something like:

server {
  server_name mycompany.com;

  location /taiga/ {
    proxy_set_header Host $http_host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Scheme $scheme;
    proxy_set_header X-Forwarded-Proto $scheme;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_redirect off;
    proxy_pass http://localhost:9000/;
  }

  # Events
  location /taiga/events {
    proxy_pass http://localhost:9000/events;
    proxy_http_version 1.1;
    proxy_set_header Upgrade $http_upgrade;
    proxy_set_header Connection "upgrade";
    proxy_set_header Host $host;
    proxy_connect_timeout 7d;
    proxy_send_timeout 7d;
    proxy_read_timeout 7d;
  }

  # TLS: Configure your TLS following the best practices inside your company
  # Logs and other configurations
}

Change between subpath and subdomain

If you're changing Taiga configuration from default subdomain (https://taiga.mycompany.com) to subpath (http://mycompany.com/subpath) or vice versa, on top of adjusting the configuration as said above, you should consider changing the TAIGA_SECRET_KEY so the refresh works properly for the end user.

sidpalas/devops-directive-kubernetes-course

2024-11-24T01:43:23Z

This is the companion repo for the DevOps Directive "Kubernetes: Beginner to Pro" course!

DeltaPrimeLabs/deltaprime-primeloans

2024-11-23T01:35:15Z

bazel-contrib/rules_perl

2024-11-24T01:43:32Z

Perl rules for Bazel

imputnet/cobalt

2024-11-24T01:43:36Z

best way to save what you love

mathesar-foundation/mathesar

2024-11-24T01:43:36Z

Web application providing an intuitive user experience to databases.

alexiscreuzot/SwiftyGif

2024-11-24T01:35:34Z

High performance GIF engine

SwiftyGif

High performance & easy to use Gif engine

Language Switch: 한국어

Features

UIImage and UIImageView extension based
Remote GIFs with customizable loader
Great CPU/Memory performances
Control playback
Allow control of display quality by using 'levelOfIntegrity'
Allow control CPU/memory tradeoff via 'memoryLimit'

Installation

With CocoaPods

source 'https://github.com/CocoaPods/Specs.git'
use_frameworks!
pod 'SwiftyGif'

With Carthage

Follow the usual Carthage instructions on how to add a framework to an application. When adding SwiftyGif among the frameworks listed in Cartfile, apply its syntax for GitHub repositories:

github "kirualex/SwiftyGif"

With Swift Package Manager

https://github.com/kirualex/SwiftyGif.git

How to Use

Project files

As of now, Xcode xcassets folders do not recognize .gif as images. This means you need to put your .gif outside of the assets. I recommend creating a group gif for instance.

Quick Start

SwiftyGif uses familiar UIImage and UIImageView to display gifs.

Programmaticaly

import SwiftyGif

do {
    let gif = try UIImage(gifName: "MyImage.gif")
    let imageview = UIImageView(gifImage: gif, loopCount: 3) // Will loop 3 times
    imageview.frame = view.bounds
    view.addSubview(imageview)
} catch {
    print(error)
}

Directly from nib/storyboard

@IBOutlet var myImageView : UIImageView!
...

let gif = try UIImage(gifName: "MyImage.gif")
self.myImageView.setGifImage(gif, loopCount: -1) // Will loop forever

Remote GIFs

// You can also set it with an URL pointing to your gif
let url = URL(string: "...")
let loader = UIActivityIndicatorView(style: .white)
cell.gifImageView.setGifFromURL(url, customLoader: loader)

SwiftUI

Add this UIViewRepresentable to your code.

struct AnimatedGifView: UIViewRepresentable {
    @Binding var url: URL

    func makeUIView(context: Context) -> UIImageView {
        let imageView = UIImageView(gifURL: self.url)
        imageView.contentMode = .scaleAspectFit
        return imageView
    }

    func updateUIView(_ uiView: UIImageView, context: Context) {
        uiView.setGifFromURL(self.url)
    }
}

Then to use it:

AnimatedGifView(url: Binding(get: { myModel.gif.url }, set: { _ in }))

Performances

A SwiftyGifManager can hold one or several UIImageView using the same memory pool. This allows you to tune the memory limits to your convenience. If no manager is declared, SwiftyGif will just use the SwiftyGifManager.defaultManager.

Level of integrity

Setting a lower level of integrity will allow for frame skipping, lowering both CPU and memory usage. This can be a good option if you need to preview a lot of gifs at the same time.

do {
    let gif = try UIImage(gifName: "MyImage.gif", levelOfIntegrity:0.5)
} catch {
    print(error)
}

Controls

SwiftyGif offers various controls on the current UIImageView playing your gif file.

self.myImageView.startAnimatingGif()
self.myImageView.stopAnimatingGif()
self.myImageView.showFrameAtIndexDelta(delta: Int)
self.myImageView.showFrameAtIndex(index: Int)

To allow easy use of those controls, some utility methods are provided :

self.myImageView.isAnimatingGif() // Returns whether the gif is currently playing
self.myImageView.gifImage!.framesCount() // Returns number of frames for this gif

Delegate

You can declare a SwiftyGifDelegate to receive updates on the gif lifecycle. For instance, if you want your controller MyController to act as the delegate:

override func viewDidLoad() {
        super.viewDidLoad()
        self.imageView.delegate = self
}

Then simply add an extension:

extension MyController : SwiftyGifDelegate {

    func gifURLDidFinish(sender: UIImageView) {
        print("gifURLDidFinish")
    }

    func gifURLDidFail(sender: UIImageView) {
        print("gifURLDidFail")
    }

    func gifDidStart(sender: UIImageView) {
        print("gifDidStart")
    }
    
    func gifDidLoop(sender: UIImageView) {
        print("gifDidLoop")
    }
    
    func gifDidStop(sender: UIImageView) {
        print("gifDidStop")
    }
}

Benchmark

Display 1 Image

	CPU Usage(average)	Memory Usage(average)
FLAnimatedImage	35%	9,5Mb
SwiftyGif	2%	18,4Mb
SwiftyGif(memoryLimit:10)	34%	9,5Mb

Display 6 Images

	CPU Usage(average)	Memory Usage(average)
FLAnimatedImage	65%	25,1Mb
SwiftyGif	22%	105Mb
SwiftyGif(memoryLimit:20)	45%	26Mb

Measured on an iPhone 6S, iOS 9.3.1 and Xcode 7.3.

jonkykong/SideMenu

2024-11-24T01:35:34Z

Simple side/slide menu control for iOS, no code necessary! Lots of customization. Add it to your project in 5 minutes or less.

▤ SideMenu

If you like SideMenu, give it a ★ at the top right of this page.

SideMenu needs your help! If you're a skilled iOS developer and want to help maintain this repository and answer issues asked by the community, please send me an email.

Hi, I'm Jon Kent and I am an iOS designer, developer, and mobile strategist. I love coffee and play the drums.

Hire me to help you make cool stuff. Note: If you're having a problem with SideMenu, please open an issue and do not email me.

Check out my website to see some of my other projects.

Building and maintaining this free library takes a lot of my time and saves you time. Please consider paying it forward by supporting me with a small amount to my PayPal. (only 13 people have donated since 12/23/15 but thank you to those who have!)

Overview
- Preview Samples
Requirements
Installation
Usage
- Code-less Storyboard Implementation
- Code Implementation
Customization
Known Issues
Thank You
License

Overview

SideMenu is a simple and versatile side menu control written in Swift.

It can be implemented in storyboard without a single line of code.
Eight standard animation styles to choose from (there's even a parallax effect if you want to get weird).
Highly customizable without needing to write tons of custom code.
Supports continuous swiping between side menus on boths sides in a single gesture.
Global menu configuration. Set-up once and be done for all screens.
Menus can be presented and dismissed the same as any other view controller since this control uses custom transitions.
Animations use your view controllers, not snapshots.
Properly handles screen rotation and in-call status bar height changes.

Check out the example project to see it in action!

Preview Samples

Slide Out	Slide In	Dissolve	Slide In + Out

Requirements

Xcode 11.
Swift 5.
iOS 10 or higher.

Installation

CocoaPods

CocoaPods is a dependency manager for Cocoa projects. You can install it with the following command:

$ gem install cocoapods

To integrate SideMenu into your Xcode project using CocoaPods, specify it in your Podfile:

source 'https://github.com/CocoaPods/Specs.git'
platform :ios, '10.0'
use_frameworks!

pod 'SideMenu'

# For Swift 5 use:
# pod 'SideMenu', '~> 6.0'

# For Swift 4.2 (no longer maintained) use:
# pod 'SideMenu', '~> 5.0'

Then, run the following command:

$ pod install

Carthage

Carthage is a decentralized dependency manager that builds your dependencies and provides you with binary frameworks.

You can install Carthage with Homebrew using the following command:

$ brew update
$ brew install carthage

To integrate SideMenu into your Xcode project using Carthage, specify it in your Cartfile:

github "jonkykong/SideMenu" "master"

Swift Package Manager

The Swift Package Manager is a tool for automating the distribution of Swift code and is integrated into the swift compiler. It is in early development, but SideMenu does support its use on supported platforms.

Once you have your Swift package set up, adding SideMenu as a dependency is as easy as adding it to the dependencies value of your Package.swift.

dependencies: [
    .package(url: "https://github.com/jonkykong/SideMenu.git", from: "6.0.0")
]

Usage

Code-less Storyboard Implementation

Create a Navigation Controller for a side menu. Set the Custom Class of the Navigation Controller to be SideMenuNavigationController in the Identity Inspector. Set the Module to SideMenu (ignore this step if you've manually added SideMenu to your project). Create a Root View Controller for the Navigation Controller (shown as a UITableViewController below). Set up any Triggered Segues you want in that view controller.
Set the Left Side property of the SideMenuNavigationController to On if you want it to appear from the left side of the screen, or Off/Default if you want it to appear from the right side.
Add a UIButton or UIBarButton to a view controller that you want to display the menu from. Set that button's Triggered Segues action to modally present the Navigation Controller from step 1.

That's it. Note: you can only enable gestures in code.

Code Implementation

First:

import SideMenu

From a button, do something like this:

// Define the menu
let menu = SideMenuNavigationController(rootViewController: YourViewController)
// SideMenuNavigationController is a subclass of UINavigationController, so do any additional configuration 
// of it here like setting its viewControllers. If you're using storyboards, you'll want to do something like:
// let menu = storyboard!.instantiateViewController(withIdentifier: "RightMenu") as! SideMenuNavigationController
present(menu, animated: true, completion: nil)

To dismiss a menu programmatically, do something like this:

dismiss(animated: true, completion: nil)

To use gestures you have to use the SideMenuManager. In your AppDelegate do something like this:

// Define the menus
let leftMenuNavigationController = SideMenuNavigationController(rootViewController: YourViewController)
SideMenuManager.default.leftMenuNavigationController = leftMenuNavigationController

let rightMenuNavigationController = SideMenuNavigationController(rootViewController: YourViewController)
SideMenuManager.default.rightMenuNavigationController = rightMenuNavigationController

// Setup gestures: the left and/or right menus must be set up (above) for these to work.
// Note that these continue to work on the Navigation Controller independent of the view controller it displays!
SideMenuManager.default.addPanGestureToPresent(toView: self.navigationController!.navigationBar)
SideMenuManager.default.addScreenEdgePanGesturesToPresent(toView: self.navigationController!.view)

// (Optional) Prevent status bar area from turning black when menu appears:
leftMenuNavigationController.statusBarEndAlpha = 0
// Copy all settings to the other menu
rightMenuNavigationController.settings = leftMenuNavigationController.settings

That's it.

Customization

SideMenuManager

SideMenuManager supports the following:

/// The left menu.
open var leftMenuNavigationController: SideMenuNavigationController?
/// The right menu.
public var rightMenuNavigationController: SideMenuNavigationController?
/**
 Adds screen edge gestures for both left and right sides to a view to present a menu.

 - Parameter toView: The view to add gestures to.

 - Returns: The array of screen edge gestures added to `toView`.
 */
@discardableResult public func addScreenEdgePanGesturesToPresent(toView view: UIView) -> [UIScreenEdgePanGestureRecognizer]
/**
 Adds screen edge gestures to a view to present a menu.

 - Parameter toView: The view to add gestures to.
 - Parameter forMenu: The menu (left or right) you want to add a gesture for.

 - Returns: The screen edge gestures added to `toView`.
 */
@discardableResult public func addScreenEdgePanGesturesToPresent(toView view: UIView, forMenu side: PresentDirection) -> UIScreenEdgePanGestureRecognizer
/**
 Adds a pan edge gesture to a view to present menus.

 - Parameter toView: The view to add a pan gesture to.

 - Returns: The pan gesture added to `toView`.
 */
@discardableResult public func addPanGestureToPresent(toView view: UIView) -> UIPanGestureRecognizer

SideMenuNavigationController

SideMenuNavigationController supports the following:

/// Prevents the same view controller (or a view controller of the same class) from being pushed more than once. Defaults to true.
var allowPushOfSameClassTwice: Bool = true
/// Forces menus to always animate when appearing or disappearing, regardless of a pushed view controller's animation.
var alwaysAnimate: Bool = true
/// The animation options when a menu is displayed. Ignored when displayed with a gesture.
var animationOptions: UIView.AnimationOptions = .curveEaseInOut
/**
 The blur effect style of the menu if the menu's root view controller is a UITableViewController or UICollectionViewController.

 - Note: If you want cells in a UITableViewController menu to show vibrancy, make them a subclass of UITableViewVibrantCell.
 */
var blurEffectStyle: UIBlurEffect.Style? = nil
/// Duration of the remaining animation when the menu is partially dismissed with gestures. Default is 0.35 seconds.
var completeGestureDuration: Double = 0.35
/// Animation curve of the remaining animation when the menu is partially dismissed with gestures. Default is .easeIn.
var completionCurve: UIView.AnimationCurve = .curveEaseInOut
/// Duration of the animation when the menu is dismissed without gestures. Default is 0.35 seconds.
var dismissDuration: Double = 0.35
/// Automatically dismisses the menu when another view is presented from it.
var dismissOnPresent: Bool = true
/// Automatically dismisses the menu when another view controller is pushed from it.
var dismissOnPush: Bool = true
/// Automatically dismisses the menu when the screen is rotated.
var dismissOnRotation: Bool = true
/// Automatically dismisses the menu when app goes to the background.
var dismissWhenBackgrounded: Bool = true
/// Enable or disable a swipe gesture that dismisses the menu. Will not be triggered when `presentingViewControllerUserInteractionEnabled` is set to true. Default is true.
var enableSwipeToDismissGesture: Bool = true
/// Enable or disable a tap gesture that dismisses the menu. Will not be triggered when `presentingViewControllerUserInteractionEnabled` is set to true. Default is true.
var enableTapToDismissGesture: Bool = true
/// The animation initial spring velocity when a menu is displayed. Ignored when displayed with a gesture.
var initialSpringVelocity: CGFloat = 1
/// Whether the menu appears on the right or left side of the screen. Right is the default. This property cannot be changed after the menu has loaded.
var leftSide: Bool = false
/// Width of the menu when presented on screen, showing the existing view controller in the remaining space. Default is zero.
var menuWidth: CGFloat = 240
/// Duration of the animation when the menu is presented without gestures. Default is 0.35 seconds.
var presentDuration: Double = 0.35
/// Enable or disable interaction with the presenting view controller while the menu is displayed. Enabling may make it difficult to dismiss the menu or cause exceptions if the user tries to present and already presented menu. `presentingViewControllerUseSnapshot` must also set to false. Default is false.
var presentingViewControllerUserInteractionEnabled: Bool = false
/// Use a snapshot for the presenting vierw controller while the menu is displayed. Useful when layout changes occur during transitions. Not recommended for apps that support rotation. Default is false.
var presentingViewControllerUseSnapshot: Bool = false
/// The presentation style of the menu.
var presentationStyle: SideMenuPresentStyle = .viewSlideOut
/**
 The push style of the menu.

 There are six modes in MenuPushStyle:
 - defaultBehavior: The view controller is pushed onto the stack.
 - popWhenPossible: If a view controller already in the stack is of the same class as the pushed view controller, the stack is instead popped back to the existing view controller. This behavior can help users from getting lost in a deep navigation stack.
 - preserve: If a view controller already in the stack is of the same class as the pushed view controller, the existing view controller is pushed to the end of the stack. This behavior is similar to a UITabBarController.
 - preserveAndHideBackButton: Same as .preserve and back buttons are automatically hidden.
 - replace: Any existing view controllers are released from the stack and replaced with the pushed view controller. Back buttons are automatically hidden. This behavior is ideal if view controllers require a lot of memory or their state doesn't need to be preserved..
 - subMenu: Unlike all other behaviors that push using the menu's presentingViewController, this behavior pushes view controllers within the menu.  Use this behavior if you want to display a sub menu.
 */
var pushStyle: MenuPushStyle = .default
/// Draws `presentationStyle.backgroundColor` behind the status bar. Default is 0.
var statusBarEndAlpha: CGFloat = 0
/// The animation spring damping when a menu is displayed. Ignored when displayed with a gesture.
var usingSpringWithDamping: CGFloat = 1
/// Indicates if the menu is anywhere in the view hierarchy, even if covered by another view controller.
var isHidden: Bool

SideMenuPresentStyle

There are 8 pre-defined SideMenuPresentStyle options:

/// Menu slides in over the existing view.
static let menuSlideIn: SideMenuPresentStyle
/// The existing view slides out to reveal the menu underneath.
static let viewSlideOut: SideMenuPresentStyle
/// The existing view slides out while the menu slides in.
static let viewSlideOutMenuIn: SideMenuPresentStyle
/// The menu dissolves in over the existing view.
static let menuDissolveIn: SideMenuPresentStyle
/// The existing view slides out while the menu partially slides in.
static let viewSlideOutMenuPartialIn: SideMenuPresentStyle
/// The existing view slides out while the menu slides out from under it.
static let viewSlideOutMenuOut: SideMenuPresentStyle
/// The existing view slides out while the menu partially slides out from under it.
static let viewSlideOutMenuPartialOut: SideMenuPresentStyle
/// The existing view slides out and shrinks to reveal the menu underneath.
static let viewSlideOutMenuZoom: SideMenuPresentStyle

SideMenuNavigationControllerDelegate

To receive notifications when a menu is displayed from a view controller, have it adhere to the SideMenuNavigationControllerDelegate protocol:

extension MyViewController: SideMenuNavigationControllerDelegate {

    func sideMenuWillAppear(menu: SideMenuNavigationController, animated: Bool) {
        print("SideMenu Appearing! (animated: \(animated))")
    }

    func sideMenuDidAppear(menu: SideMenuNavigationController, animated: Bool) {
        print("SideMenu Appeared! (animated: \(animated))")
    }

    func sideMenuWillDisappear(menu: SideMenuNavigationController, animated: Bool) {
        print("SideMenu Disappearing! (animated: \(animated))")
    }

    func sideMenuDidDisappear(menu: SideMenuNavigationController, animated: Bool) {
        print("SideMenu Disappeared! (animated: \(animated))")
    }
}

Note: setting the sideMenuDelegate property on SideMenuNavigationController is optional. If your view controller adheres to the protocol then the methods will be called automatically.

Advanced

Click for Details

Multiple SideMenuManagers

For simplicity, SideMenuManager.default serves as the primary instance as most projects will only need one menu across all screens. If you need to show a different SideMenu using gestures, such as from a modal view controller presented from a previous SideMenu, do the following:

Declare a variable containing your custom SideMenuManager instance. You may want it to define it globally and configure it in your app delegate if menus will be used on multiple screens.

let customSideMenuManager = SideMenuManager()

Setup and display menus with your custom instance the same as you would with the SideMenuManager.default instance.
If using Storyboards, subclass your instance of SideMenuNavigationController and set its sideMenuManager property to your custom instance. This must be done before viewDidLoad is called:

class MySideMenuNavigationController: SideMenuNavigationController {

    let customSideMenuManager = SideMenuManager()

    override func awakeFromNib() {
        super.awakeFromNib()

        sideMenuManager = customSideMenuManager
    }
}

Alternatively, you can set sideMenuManager from the view controller that segues to your SideMenuNavigationController:

override func prepare(for segue: UIStoryboardSegue, sender: Any?) {
    if let sideMenuNavigationController = segue.destination as? SideMenuNavigationController {
        sideMenuNavigationController.sideMenuManager = customSideMenuManager
    }
}

Important: displaying SideMenu instances directly over each other is not supported. Use menuPushStyle = .subMenu to display multi-level menus instead.

SideMenuPresentationStyle

If you want to create your own custom presentation style, create a subclass of SideMenuPresentationStyle and set your menu's presentationStyle to it:

class MyPresentStyle: SideMenuPresentationStyle {

    override init() {
        super.init()
        /// Background color behind the views and status bar color
        backgroundColor = .black
        /// The starting alpha value of the menu before it appears
        menuStartAlpha = 1
        /// Whether or not the menu is on top. If false, the presenting view is on top. Shadows are applied to the view on top.
        menuOnTop = false
        /// The amount the menu is translated along the x-axis. Zero is stationary, negative values are off-screen, positive values are on screen.
        menuTranslateFactor = 0
        /// The amount the menu is scaled. Less than one shrinks the view, larger than one grows the view.
        menuScaleFactor = 1
        /// The color of the shadow applied to the top most view.
        onTopShadowColor = .black
        /// The radius of the shadow applied to the top most view.
        onTopShadowRadius = 5
        /// The opacity of the shadow applied to the top most view.
        onTopShadowOpacity = 0
        /// The offset of the shadow applied to the top most view.
        onTopShadowOffset = .zero
        /// The ending alpha of the presenting view when the menu is fully displayed.
        presentingEndAlpha = 1
        /// The amount the presenting view is translated along the x-axis. Zero is stationary, negative values are off-screen, positive values are on screen.
        presentingTranslateFactor = 0
        /// The amount the presenting view is scaled. Less than one shrinks the view, larger than one grows the view.
        presentingScaleFactor = 1
        /// The strength of the parallax effect on the presenting view once the menu is displayed.
        presentingParallaxStrength = .zero
    }

    /// This method is called just before the presentation transition begins. Use this to setup any animations. The super method does not need to be called.
    override func presentationTransitionWillBegin(to presentedViewController: UIViewController, from presentingViewController: UIViewController) {}
    /// This method is called during the presentation animation. Use this to animate anything alongside the menu animation. The super method does not need to be called.
    override func presentationTransition(to presentedViewController: UIViewController, from presentingViewController: UIViewController) {}
    /// This method is called when the presentation transition ends. Use this to finish any animations. The super method does not need to be called.
    override func presentationTransitionDidEnd(to presentedViewController: UIViewController, from presentingViewController: UIViewController, _ completed: Bool) {}
    /// This method is called just before the dismissal transition begins. Use this to setup any animations. The super method does not need to be called.
    override func dismissalTransitionWillBegin(to presentedViewController: UIViewController, from presentingViewController: UIViewController) {}
    /// This method is called during the dismissal animation. Use this to animate anything alongside the menu animation. The super method does not need to be called.
    override func dismissalTransition(to presentedViewController: UIViewController, from presentingViewController: UIViewController) {}
    /// This method is called when the dismissal transition ends. Use this to finish any animations. The super method does not need to be called.
    override func dismissalTransitionDidEnd(to presentedViewController: UIViewController, from presentingViewController: UIViewController, _ completed: Bool) {}
}

Known Issues

Issue #258. Using presentingViewControllerUseSnapshot can help preserve the experience.

Thank You

A special thank you to everyone that has contributed to this library to make it better. Your support is appreciated!

License

SideMenu is available under the MIT license. See the LICENSE file for more info.

mastra-ai/mastra

2024-11-24T01:36:00Z

The TypeScript AI framework.

Mastra

Mastra is an opinionated Typescript framework that helps you build AI applications and features quickly. It gives you the set of primitives you need: workflows, agents, RAG, integrations, syncs and evals. You can run Mastra on your local machine, or deploy to a serverless cloud.

The main Mastra features are:

Features	Description
LLM Models	Mastra supports a variety of LLM providers, including OpenAI, Anthropic, Google Gemini. You can choose the specific model and provider, choose system and user prompts, and decide whether to stream the response.
Agents	Agents are systems where the language model chooses a sequence of actions. In Mastra, agents provide LLM models with tools, workflows, and synced data. Agents can call your own functions or APIs of third-party integrations and access knowledge bases you build.
Tools	Tools are typed functions that can be executed by agents or workflows, with built-in integration access and parameter validation. Each tool has a schema that defines its inputs, an executor function that implements its logic, and access to configured integrations.
Workflows	Workflows are durable graph-based state machines. They have loops, branching, wait for human input, embed other workflows, do error handling, retries, parsing and so on. They can be built in code or with a visual editor. Each step in a workflow has built-in OpenTelemetry tracing.
RAG	Retrieval-augemented generation (RAG) lets you construct a knowledge base for agents. RAG is an ETL pipeline with specific querying techniques, including chunking, embedding, and vector search.
Integrations & Syncs	In Mastra, syncs are async functions that can be deployed as background tasks across different execution environments. Integrations are auto-generated, type-safe API clients for third-party services that can be used as tools for agents or steps in workflows.
Evals	Evals are automated tests that evaluate LLM outputs using model-graded, rule-based, and statistical methods. Each eval returns a normalized score between 0-1 that can be logged and compared. Evals can be customized with your own prompts and scoring functions.

Quick Start

Prerequisites

Node.js (v20.0+)

Get an LLM provider API key

If you don't have an API key for an LLM provider, you can get one from the following services:

If you don't have an account with these providers, you can sign up and get an API key. OpenAI and Anthropic require a credit card to get an API key. Gemini does not and has a generous free tier for its API.

Create a new project

As a first step, create a project directory and navigate into it:

mkdir hello-mastra
cd hello-mastra

Next, initialize a TypeScript project using npm:

npm init -y
npm install typescript tsx @types/node @mastra/core@alpha --save-dev

Add an index.ts file

mkdir src
touch src/index.ts

Then, add this code to src/index.ts:

import { Agent } from '@mastra/core';

async function main() {
  const agent = new Agent({
    name: 'story-writer',
    maxSteps: 3,
    model: {
      provider: 'OPEN_AI',
      name: 'gpt-4o',
      toolChoice: 'auto'
    },
    instructions: `You are a helpful assistant who writes creative stories.`,
    tools: {},
  });

  const result = await agent.text({
    messages: ["Write a short story about a robot learning to paint."]
  });

  console.log("Agent response:", result.text);
}

main();

Run the script

Finally, run the script:

OPENAI_API_KEY=<your-openai-api-key> npx tsx src/index.ts

If you're using Anthropic, set the ANTHROPIC_API_KEY. If you're using Gemini, set the GOOGLE_GENERATIVE_AI_API_KEY.

blakeblackshear/frigate

2024-11-24T01:44:03Z

NVR with realtime local object detection for IP cameras

Frigate - NVR With Realtime Object Detection for IP Cameras

A complete and local NVR designed for Home Assistant with AI object detection. Uses OpenCV and Tensorflow to perform realtime object detection locally for IP cameras.

Use of a Google Coral Accelerator is optional, but highly recommended. The Coral will outperform even the best CPUs and can process 100+ FPS with very little overhead.

Tight integration with Home Assistant via a custom component
Designed to minimize resource use and maximize performance by only looking for objects when and where it is necessary
Leverages multiprocessing heavily with an emphasis on realtime over processing every frame
Uses a very low overhead motion detection to determine where to run object detection
Object detection with TensorFlow runs in separate processes for maximum FPS
Communicates over MQTT for easy integration into other systems
Records video with retention settings based on detected objects
24/7 recording
Re-streaming via RTSP to reduce the number of connections to your camera
WebRTC & MSE support for low-latency live view

Documentation

View the documentation at https://docs.frigate.video

Donations

If you would like to make a donation to support development, please use Github Sponsors.

Screenshots

Live dashboard

Streamlined review workflow

Multi-camera scrubbing

Built-in mask and zone editor

awslabs/multi-agent-orchestrator

2024-11-24T01:44:03Z

Flexible and powerful framework for managing multiple AI agents and handling complex conversations

Multi-Agent Orchestrator

Flexible and powerful framework for managing multiple AI agents and handling complex conversations.

🔖 Features

🧠 Intelligent intent classification — Dynamically route queries to the most suitable agent based on context and content.
🔤 Dual language support — Fully implemented in both Python and TypeScript.
🌊 Flexible agent responses — Support for both streaming and non-streaming responses from different agents.
📚 Context management — Maintain and utilize conversation context across multiple agents for coherent interactions.
🔧 Extensible architecture — Easily integrate new agents or customize existing ones to fit your specific needs.
🌐 Universal deployment — Run anywhere - from AWS Lambda to your local environment or any cloud platform.
📦 Pre-built agents and classifiers — A variety of ready-to-use agents and multiple classifier implementations available.

What's the Multi-Agent Orchestrator ❓

The Multi-Agent Orchestrator is a flexible framework for managing multiple AI agents and handling complex conversations. It intelligently routes queries and maintains context across interactions.

The system offers pre-built components for quick deployment, while also allowing easy integration of custom agents and conversation messages storage solutions.

This adaptability makes it suitable for a wide range of applications, from simple chatbots to sophisticated AI systems, accommodating diverse requirements and scaling efficiently.

🏗️ High-level architecture flow diagram

The process begins with user input, which is analyzed by a Classifier.
The Classifier leverages both Agents' Characteristics and Agents' Conversation history to select the most appropriate agent for the task.
Once an agent is selected, it processes the user input.
The orchestrator then saves the conversation, updating the Agents' Conversation history, before delivering the response back to the user.

💬 Demo App

To quickly get a feel for the Multi-Agent Orchestrator, we've provided a Demo App with a few basic agents. This interactive demo showcases the orchestrator's capabilities in a user-friendly interface. To learn more about setting up and running the demo app, please refer to our Demo App section.

In the screen recording below, we demonstrate an extended version of the demo app that uses 6 specialized agents:

Travel Agent: Powered by an Amazon Lex Bot
Weather Agent: Utilizes a Bedrock LLM Agent with a tool to query the open-meteo API
Restaurant Agent: Implemented as an Amazon Bedrock Agent
Math Agent: Utilizes a Bedrock LLM Agent with two tools for executing mathematical operations
Tech Agent: A Bedrock LLM Agent designed to answer questions on technical topics
Health Agent: A Bedrock LLM Agent focused on addressing health-related queries

Watch as the system seamlessly switches context between diverse topics, from booking flights to checking weather, solving math problems, and providing health information. Notice how the appropriate agent is selected for each query, maintaining coherence even with brief follow-up inputs.

The demo highlights the system's ability to handle complex, multi-turn conversations while preserving context and leveraging specialized agents across various domains.

To quickly get a feel for the Multi-Agent Orchestrator, check out our Demo App. Additional code examples are available in both the documentation and the examples folder.

🎯 Examples & Quick Start

Get hands-on experience with the Multi-Agent Orchestrator through our diverse set of examples:

Ready-to-run Scripts: Start locally with our collection of standalone scripts in both Python and TypeScript.
Demo Applications:
- Chat Demo App:
  - Explore multiple specialized agents handling various domains like travel, weather, math, and health
- E-commerce Support Simulator: Experience AI-powered customer support with:
  - Automated response generation for common queries
  - Intelligent routing of complex issues to human support
  - Real-time chat and email-style communication
  - Human-in-the-loop interactions for complex cases
Sample Projects: Explore our example implementations in the examples folder:
- chat-demo-app: Web-based chat interface with multiple specialized agents
- ecommerce-support-simulator: AI-powered customer support system
- chat-chainlit-app: Chat application built with Chainlit
- fast-api-streaming: FastAPI implementation with streaming support
- text-2-structured-output: Natural Language to Structured Data

All examples are available in both Python and TypeScript implementations. Check out our documentation for comprehensive guides on setting up and using the Multi-Agent Orchestrator!

🌟 Use cases and implementations

Discover creative implementations and diverse applications of the Multi-Agent Orchestrator:

From 'Bonjour' to 'Boarding Pass': Multilingual AI Chatbot for Flight Reservations

This article demonstrates how to build a multilingual chatbot using the Multi-Agent Orchestrator framework. The article explains how to use an Amazon Lex bot as an agent, along with 2 other new agents to make it work in many languages with just a few lines of code.
Beyond Auto-Replies: Building an AI-Powered E-commerce Support system

This article demonstrates how to build an AI-driven multi-agent system for automated e-commerce customer email support. It covers the architecture and setup of specialized AI agents using the Multi-Agent Orchestrator framework, integrating automated processing with human-in-the-loop oversight. The guide explores email ingestion, intelligent routing, automated response generation, and human verification, providing a comprehensive approach to balancing AI efficiency with human expertise in customer support.
Speak Up, AI: Voicing Your Agents with Amazon Connect, Lex, and Bedrock

This article demonstrates how to build an AI customer call center. It covers the architecture and setup of specialized AI agents using the Multi-Agent Orchestrator framework interacting with voice via Amazon Connect and Amazon Lex.

TypeScript Version

Installation

npm install multi-agent-orchestrator

Usage

The following example demonstrates how to use the Multi-Agent Orchestrator with two different types of agents: a Bedrock LLM Agent with Converse API support and a Lex Bot Agent. This showcases the flexibility of the system in integrating various AI services.

import { MultiAgentOrchestrator, BedrockLLMAgent, LexBotAgent } from "multi-agent-orchestrator";

const orchestrator = new MultiAgentOrchestrator();

// Add a Bedrock LLM Agent with Converse API support
orchestrator.addAgent(
  new BedrockLLMAgent({
      name: "Tech Agent",
      description:
        "Specializes in technology areas including software development, hardware, AI, cybersecurity, blockchain, cloud computing, emerging tech innovations, and pricing/costs related to technology products and services.",
      streaming: true
  })
);

// Add a Lex Bot Agent for handling travel-related queries
orchestrator.addAgent(
  new LexBotAgent({
    name: "Travel Agent",
    description: "Helps users book and manage their flight reservations",
    botId: process.env.LEX_BOT_ID,
    botAliasId: process.env.LEX_BOT_ALIAS_ID,
    localeId: "en_US",
  })
);

// Example usage
const response = await orchestrator.routeRequest(
  "I want to book a flight",
  'user123',
  'session456'
);

// Handle the response (streaming or non-streaming)
if (response.streaming == true) {
    console.log("\n** RESPONSE STREAMING ** \n");
    // Send metadata immediately
    console.log(`> Agent ID: ${response.metadata.agentId}`);
    console.log(`> Agent Name: ${response.metadata.agentName}`);
    console.log(`> User Input: ${response.metadata.userInput}`);
    console.log(`> User ID: ${response.metadata.userId}`);
    console.log(`> Session ID: ${response.metadata.sessionId}`);
    console.log(
      `> Additional Parameters:`,
      response.metadata.additionalParams
    );
    console.log(`\n> Response: `);

    // Stream the content
    for await (const chunk of response.output) {
      if (typeof chunk === "string") {
        process.stdout.write(chunk);
      } else {
        console.error("Received unexpected chunk type:", typeof chunk);
      }
    }

} else {
    // Handle non-streaming response (AgentProcessingResult)
    console.log("\n** RESPONSE ** \n");
    console.log(`> Agent ID: ${response.metadata.agentId}`);
    console.log(`> Agent Name: ${response.metadata.agentName}`);
    console.log(`> User Input: ${response.metadata.userInput}`);
    console.log(`> User ID: ${response.metadata.userId}`);
    console.log(`> Session ID: ${response.metadata.sessionId}`);
    console.log(
      `> Additional Parameters:`,
      response.metadata.additionalParams
    );
    console.log(`\n> Response: ${response.output}`);
}

Python Version

Installation

# Optional: Set up a virtual environment
python -m venv venv
source venv/bin/activate  # On Windows use `venv\Scripts\activate`
pip install multi-agent-orchestrator

Usage

Here's an equivalent Python example demonstrating the use of the Multi-Agent Orchestrator with a Bedrock LLM Agent and a Lex Bot Agent:

import os
import asyncio
from multi_agent_orchestrator.orchestrator import MultiAgentOrchestrator
from multi_agent_orchestrator.agents import BedrockLLMAgent, LexBotAgent, BedrockLLMAgentOptions, LexBotAgentOptions, AgentCallbacks

orchestrator = MultiAgentOrchestrator()

class BedrockLLMAgentCallbacks(AgentCallbacks):
    def on_llm_new_token(self, token: str) -> None:
        # handle response streaming here
        print(token, end='', flush=True)

tech_agent = BedrockLLMAgent(BedrockLLMAgentOptions(
  name="Tech Agent",
  streaming=True,
  description="Specializes in technology areas including software development, hardware, AI, \
  cybersecurity, blockchain, cloud computing, emerging tech innovations, and pricing/costs \
  related to technology products and services.",
  model_id="anthropic.claude-3-sonnet-20240229-v1:0",
  callbacks=BedrockLLMAgentCallbacks()
))
orchestrator.add_agent(tech_agent)


# Add a Lex Bot Agent for handling travel-related queries
orchestrator.add_agent(
    LexBotAgent(LexBotAgentOptions(
        name="Travel Agent",
        description="Helps users book and manage their flight reservations",
        bot_id=os.environ.get('LEX_BOT_ID'),
        bot_alias_id=os.environ.get('LEX_BOT_ALIAS_ID'),
        locale_id="en_US",
    ))
)

async def main():
    # Example usage
    response = await orchestrator.route_request(
        "I want to book a flight",
        'user123',
        'session456'
    )

    # Handle the response (streaming or non-streaming)
    if response.streaming:
        print("\n** RESPONSE STREAMING ** \n")
        # Send metadata immediately
        print(f"> Agent ID: {response.metadata.agent_id}")
        print(f"> Agent Name: {response.metadata.agent_name}")
        print(f"> User Input: {response.metadata.user_input}")
        print(f"> User ID: {response.metadata.user_id}")
        print(f"> Session ID: {response.metadata.session_id}")
        print(f"> Additional Parameters: {response.metadata.additional_params}")
        print("\n> Response: ")

        # Stream the content
        async for chunk in response.output:
            if isinstance(chunk, str):
                print(chunk, end='', flush=True)
            else:
                print(f"Received unexpected chunk type: {type(chunk)}", file=sys.stderr)

    else:
        # Handle non-streaming response (AgentProcessingResult)
        print("\n** RESPONSE ** \n")
        print(f"> Agent ID: {response.metadata.agent_id}")
        print(f"> Agent Name: {response.metadata.agent_name}")
        print(f"> User Input: {response.metadata.user_input}")
        print(f"> User ID: {response.metadata.user_id}")
        print(f"> Session ID: {response.metadata.session_id}")
        print(f"> Additional Parameters: {response.metadata.additional_params}")
        print(f"\n> Response: {response.output.content}")

if __name__ == "__main__":
    asyncio.run(main())

These examples showcase:

The use of a Bedrock LLM Agent with Converse API support, allowing for multi-turn conversations.
Integration of a Lex Bot Agent for specialized tasks (in this case, travel-related queries).
The orchestrator's ability to route requests to the most appropriate agent based on the input.
Handling of both streaming and non-streaming responses from different types of agents.

🤝 Contributing

We welcome contributions! Please see our Contributing Guide for more details.

Authors

👥 Contributors

Big shout out to our awesome contributors! Thank you for making this project better! 🌟 ⭐ 🚀

Please see our contributing guide for guidelines on how to propose bugfixes and improvements.

📄 LICENSE

This project is licensed under the Apache 2.0 licence - see the LICENSE file for details.

📄 Font License

This project uses the JetBrainsMono NF font, licensed under the SIL Open Font License 1.1. For full license details, see FONT-LICENSE.md.

gitroomhq/postiz-app

2024-11-24T01:44:03Z

📨 The ultimate social media scheduling tool, with a bunch of AI 🤖

Please help us out on Product Hunt,
to give you the best open-source
social media scheduling tool in the world 🌎👇

Your ultimate AI social media scheduling tool

Postiz: An alternative to: Buffer.com, Hypefury, Twitter Hunter, Etc...

Postiz offers everything you need to manage your social media posts,
build an audience, capture leads, and grow your business.

Explore the docs »

Register · Join Our Discord · X · Gitroom

✨ Features

Intro

Schedule all your social media posts (many AI features)
Measure your work with analytics.
Collaborate with other team members to exchange or buy posts.
Invite your team members to collaborate, comment, and schedule posts.
At the moment there is no difference between the hosted version to the self-hosted version

Tech Stack

NX (Monorepo)
NextJS (React)
NestJS
Prisma (Default to PostgreSQL)
Redis (BullMQ)
Resend (email notifications)

Quick Start

To have the project up and running, please follow the Quick Start Guide

License

This repository's source code is available under the Apache 2.0 License.

svcvit/Awesome-Dify-Workflow

2024-11-23T01:28:27Z

分享一些好用的 Dify DSL 工作流程，自用、学习两相宜。 Sharing some Dify workflows.

stackblitz/core

2024-11-24T01:36:35Z

Online IDE powered by Visual Studio Code ⚡️

freqtrade/frequi

2024-11-24T01:36:13Z

Freqtrade UI - Frontend for Freqtrade

chainguard-dev/malcontent

2024-11-24T01:44:36Z

#supply #chain #attack #detection