GitHub 1C Enterprise Daily Trending

ComposioHQ/composio

2024-07-23T01:28:40Z

Composio equips agents with well-crafted tools empowering them to tackle complex tasks

EN | CN | JP

Production Ready Toolset for AI Agents

Equip your agent with high-quality tools & integrations without worrying about authentication, accuracy, and reliability in a single line of code!

Explore the Docs »

Try on Dashboard | Homepage | SDK | APIs

✨ Socials >> Discord | Youtube | Twitter | Linkedin

⛏️ Contribute >> Report Bugs | Request Feature | Contribute

📋 Table of contents

🤔 Why Composio?

We believe AI Based Agents/Workflows are the future. Composio is the best toolset to integrate AI Agents to best Agentic Tools and use them to accomplish tasks.

🔥 Key Features

100+ Tools: Support for a range of different categories
- Software: Do anything on GitHub, Notion, Linear, Gmail, Slack, Hubspot, Salesforce, & 90 more.
- OS: Click anywhere, Type anything, Copy to Clipboard, & more.
- Browser: Smart Search, Take a screenshot, MultiOn, Download, Upload, & more.
- Search: Google Search, Perplexity Search, Tavily, Exa & more.
- SWE: Ngrok, Database, Redis, Vercel, Git, etc.
- RAG: Agentic RAG for any type of data on the fly!
Frameworks: Use tools with agent frameworks like OpenAI, Claude, LlamaIndex, Langchain, CrewAI, Autogen, Gemini, Julep, Lyzr, and more in a single line of code.
Managed Authorisation: Supports six different auth protocols. Access Token, Refresh token, OAuth, API Keys, JWT, and more abstracted out so you can focus on the building agents.
Accuracy: Get upto 40% better agentic accuracy in your tool calls due to better tool designs.
Embeddable: Whitelabel in the backend of your applications managing Auth & Integrations for all your users & agents and maintain a consistent experience.
Pluggable: Designed to be extended with additional Tools, Frameworks and Authorisation Protocols very easily.

🚀 Getting Started with Python

1. Installation

To get started, type the following command in your Terminal.

pip install composio-core

If you want to install the 'composio' package along with its openai plugin: pip install composio-openai.

2. Testing Composio in Action

Let's use Composio to create an AI Agent that can star a Github Repo.

composio add github # Connect your Github - Run this in terminal


from openai import OpenAI
from composio_openai import ComposioToolSet, App, Action

openai_client = OpenAI(
    api_key="{{OPENAIKEY}}"
)

# Initialise the Composio Tool Set

composio_tool_set = ComposioToolSet()

# Get GitHub tools that are pre-configured
actions = composio_tool_set.get_actions(
    actions=[Action.GITHUB_ACTIVITY_STAR_REPO_FOR_AUTHENTICATED_USER]
)

my_task = "Star a repo composiodev/composio on GitHub"

# Setup openai assistant
assistant_instruction = "You are a super intelligent personal assistant"

assistant = openai_client.beta.assistants.create(
    name="Personal Assistant",
    instructions=assistant_instruction,
    model="gpt-4-turbo",
    tools=actions,
)

# create a thread
thread = openai_client.beta.threads.create()

message = openai_client.beta.threads.messages.create(
    thread_id=thread.id,
    role="user",
    content=my_task
)

# Execute Agent with integrations
run = openai_client.beta.threads.runs.create(
    thread_id=thread.id,
    assistant_id=assistant.id
)


# Execute Function calls
response_after_tool_calls = composio_tool_set.wait_and_handle_assistant_tool_calls(
    client=openai_client,
    run=run,
    thread=thread,
)

print(response_after_tool_calls)

🚀 Getting Started with Javascript

To get started with the Composio SDK in Javascript, follow these steps:

1. Install the Composio SDK:

npm install composio-core

2. Setup the OpenAI and Composio Tool Set:

import { OpenAI } from "openai";
import { OpenAIToolSet } from "composio-core";

const toolset = new OpenAIToolSet({
    apiKey: process.env.COMPOSIO_API_KEY,
});

async function setupUserConnectionIfNotExists(entityId) {
    const entity = await toolset.client.getEntity(entityId);
    const connection = await entity.getConnection('github');

    if (!connection) {
        // If this entity/user hasn't already connected the account
        const connection = await entity.initiateConnection(appName);
        console.log("Log in via: ", connection.redirectUrl);
        return connection.waitUntilActive(60);
    }

    return connection;
}

async function executeAgent(entityName) {
    const entity = await toolset.client.getEntity(entityName)
    await setupUserConnectionIfNotExists(entity.id);

    const tools = await toolset.get_actions({ actions: ["github_issues_create"] }, entity.id);
    const instruction = "Make an issue with sample title in the repo - himanshu-dixit/custom-repo-breaking"

    const client = new OpenAI({ apiKey: process.env.OPEN_AI_API_KEY })
    const response = await client.chat.completions.create({
        model: "gpt-4-turbo",
        messages: [{
            role: "user",
            content: instruction,
        }],
        tools: tools,
        tool_choice: "auto",
    })

    console.log(response.choices[0].message.tool_calls);
    await toolset.handle_tool_call(response, entity.id);
}

executeAgent("your-entity-name");

3. Run your script:

node your_script.js

This will set up the Composio SDK and execute an agent that creates a GitHub issue using the provided instructions.

For more details, refer to the Composio SDK Documentation.

💡 Examples

Star History

📋 Read Our Code Of Conduct

As part of our open-source community, we hold ourselves and other contributors to a high standard of communication. As a participant and contributor to this project, you agree to abide by our Code of Conduct.

🤗 Contributions

Composio is open-source and we welcome contributions. Please fork the repository, create a new branch for your feature, add your feature or improvement, and send a pull request.

Also go through our Contribution Guidelines and Code of Conduct before you start.

🔗 Links

🛡️ License

Composio is licensed under the Elastic License - see the LICENSE file for details.

💪 Thanks To All Contributors

openstatusHQ/openstatus

2024-07-23T01:28:40Z

基于python的网页自动化工具。既能控制浏览器，也能收发数据包。可兼顾浏览器自动化的便利性和requests的高效率。功能强大，内置无数人性化设计和便捷功能。语法简洁而优雅，代码量少。

How to use: Documents

This project is mainly updated in gitee, and will be submitted to GitHub after producing a stable version. Check out the latest developments at gitee.

✨️ Overview

DrissionPage is a python-based web page automation tool. It can control the browser, send and receive data packets, and combine the two into one. It can take into account the convenience of browser automation and the high efficiency of requests. It is powerful and has countless built-in user-friendly designs and convenient functions. Its syntax is concise and elegant, the amount of code is small, and it is friendly to novices.

Your star is the greatest support for me.💖

Captcha Solver

CapSolver is an AI-powered service that specializes in solving various types of captchas automatically, empowers data collection by helping developers easily overcome the captcha challenges encountered during Web Scraping. It supports captchas such as reCAPTCHA V2, reCAPTCHA V3, hCaptcha, FunCaptcha, DataDome, AWS Captcha, Geetest, and Cloudflare turnstile among others. For developers, Capsolver offers API integration options detailed in documentation, facilitating the integration of captcha solving into applications. They also provide browser extensions for Chrome and Firefox, making it easy to use their service directly within a browser. Different pricing packages are available to accommodate varying needs, ensuring flexibility for users.

Watch ads that support open source authors, thx.

☕ Buy me coffee

If this project is helpful to you, why not buy the author a cup of coffee :)

📕 background

When using requests for data collection, when facing a website to log in to, you have to analyze data packets and JS source code, construct complex requests, and often have to deal with anti-crawling methods such as verification codes, JS obfuscation, and signature parameters. The threshold is high and the development efficiency is low. high. Using a browser can largely bypass these pitfalls, but the browser is not very efficient.

Therefore, the original intention of this library is to combine them into one and achieve "fast writing" and "fast running" at the same time. It can switch the corresponding mode when different needs are needed, and provide a humanized usage method to improve development and operation efficiency. In addition to merging the two, this library also encapsulates commonly used functions in web page units, providing very simple operations and statements, allowing users to reduce considerations of details and focus on function implementation. Implement powerful functions in a simple way and make your code more elegant.

The previous version was implemented by repackaging selenium. Starting from 3.0, the author started from scratch, redeveloped the bottom layer, got rid of the dependence on selenium, enhanced functions, and improved operating efficiency.

💡 Concept

Simple yet powerful!

☀️ Features and Highlights

After long-term practice, the author has stepped through countless pitfalls, and all the experiences he has summarized have been written down in this library.

🎇 Powerful self-developed core

This library uses a fully self-developed kernel, has built-in N number of practical functions, and has integrated and optimized common functions. Compared with selenium, it has the following advantages:

No webdriver features
No need to download different drivers for different browser versions
Runs faster
Can find elements across <iframe> without switching in and out
Treat <iframe> as a normal element. After obtaining it, you can directly search for elements in it, making the logic clearer.
You can operate multiple tabs in the browser at the same time, even if the tab is inactive, no need to switch
Can directly read the browser cache to save images without using the GUI to click save
You can take screenshots of the entire web page, including parts outside the viewport (supported by browsers 90 and above)
Can handle shadow-root in non-open state

🎇 Highlighted features

In addition to the above advantages, this library also has numerous built-in humanized designs.

Minimalist grammar rules. Integrate a large number of commonly used functions to make the code more elegant
Positioning elements is easier and the function is more powerful and stable
Ubiquitous wait and auto-retry functionality. Make unstable networks easier to control, programs more stable, and writing more worry-free
Provide powerful download tools. You can also enjoy fast and reliable download functions when operating the browser
Allows repeated use of already open browsers. No need to start the browser from scratch every time, making debugging very convenient
Use ini files to save commonly used configurations and call them automatically, providing convenient settings and staying away from complicated configuration items.
Built-in lxml as a parsing engine, the parsing speed is improved by several orders of magnitude
Encapsulated using POM mode, which can be directly used for testing and easy to expand.
Highly integrated convenient functions, reflected in every detail
There are many details, so I won’t list them all here. You are welcome to experience them in actual use:)

🖐🏻 Disclaimer

Please do not apply DrissionPage to any work that may violate legal regulations and moral constraints. Please use DrissionPage in a friendly manner, comply with the spider agreement, and do not use DrissionPage for any illegal purposes. If you choose to use DrissionPage This means that you abide by this agreement. The author does not bear any legal risks and losses caused by your violation of this agreement. You will be responsible for all consequences.

ZuodaoTech/everyone-can-use-english

2024-07-23T01:28:40Z

人人都能用英语

AI 是当今世界上最好的外语老师，Enjoy 做 AI 最好的助教。

安装及使用

下载及使用相关说明，请参阅文档。

预览

开发

yarn install
yarn enjoy:start

tony9402/baekjoon

2024-07-24T01:30:21Z

코딩테스트 대비 문제집(Baekjoon Online Judge)

코딩테스트 대비 문제집 with Baekjoon

코딩테스트 문제집

백준 레포에서 확장을 하여 사이트로 만들었습니다. 필터링, 검색 기능도 있으니 깃헙으로 보는 것보다 조금 더 편할 수 있습니다.

https://algorithm.tony9402.com/

집단지성 프로젝트

코딩테스트 문제집 확장을 하여 해당 레포에 솔루션 업로드가 아닌 알고리즘 솔루션에서 PR을 올려주시면 됩니다. 현재 main 브랜치에 merge된 솔루션은 다 이전을 완료했습니다.

현재 Open된 PR 올려주신 분들도 저 레포에 다시 올려주시면 감사하겠습니다.

백준 코딩테스트 문제집

❈ 코딩테스트을 준비하시는 분들을 위해 문제집을 만들어봤습니다. ❈

❗️ 주의 ❗️
알고리즘을 처음 공부하시는 분들은 알고리즘 설명 링크 모음 등을 활용하여 알고리즘 먼저 공부하시기 바랍니다.

이 레포는 꾸준히 업데이트를 할 예정이며 문제집 어느정도 완성 후 풀이를 Python, Java, C++ 3가지 언어를 올릴 예정입니다.
(C++로 먼저 올릴 예정입니다.)

최근 기업 코딩테스트 알고리즘 분류 정리

바로가기

최근 기업 코딩테스트에 나왔던 알고리즘들을 정리해보았습니다.

대부분은 코딩테스트를 본 분들에게 들은거라 몇개가 누락되었거나 잘못된 부분이 있을 수도 있습니다.

각 알고리즘 문제집

❗️❗️순번은 알고리즘 공부 순서와는 무관합니다.❗️❗️

여기에서는 각 알고리즘 개념을 설명하는 것이 없습니다. 알고리즘 설명 링크 모음

문제 뽑은 기준 : 각 태그에 해당하는 문제(코딩 테스트에 나올 정도) 들을 최대한 많이 뽑고 반드시 풀고 넘어가면 좋은 문제를 체크해놨습니다.

❈ 중요❗️❗️ ❈

이 레포는 코딩테스트에 나올만한 유형에 대한 문제를 모았습니다.
알고리즘 유형이 회사마다 다릅니다. 따라서 아래 알고리즘들을 꼭 다 안풀어도 됩니다.
지원하시는 회사에 나오는 유형에 맞춰 골라 푸시기 바랍니다.
(문제집에도 추천 문제도 골라 푸셔도 됩니다.)

순번	Tag	태그	문제집	추천 문제 수	총 문제 수
00	Data Structure	자료구조	바로가기	16	25
01	Data Structure 2	자료구조 2	바로가기	11	21
02	Tree	트리	바로가기	15	44
03	Math	수학	바로가기	18	29
04	Greedy	탐욕법	바로가기	27	62
05	Dynamic Programming 1	동적계획법 1	바로가기	27	80
06	Dynamic Programming 2	동적계획법 2	바로가기	28	81
07	Two Pointer	투 포인터	바로가기	13	36
08	Implementation	구현	바로가기	30	51
09	Graph Traversal	그래프 탐색	바로가기	31	96
10	Brute Force	완전탐색	바로가기	33	94
11	Simulation	시뮬레이션	바로가기	30	48
12	Binary Search	이분탐색	바로가기	20	66
13	Backtracking	백트래킹	바로가기	28	75
14	Divide and conquer	분할정복	바로가기	08	18
15	Prefix Sum	누적 합	바로가기	11	32
16	String	문자열	바로가기	19	63
17	Shortest Path	최단거리	바로가기	18	53
18	Topological Sorting	위상정렬	바로가기	05	14
19	Disjoint Set	분리 집합	바로가기	06	20
20	Minimum Spanning Tree(MST)	최소 스패닝 트리	바로가기	08	24
21	Trie	트라이	바로가기	05	09
22	Dynamic Programming On Trees	트리디피	바로가기	04	08

현재 진행정도

모의 문제집

이 문제는 알고리즘 분류와 관련 없이 문제를 뽑아놓은 문제입니다.

이 부분은 오늘의 문제로 대체합니다

Contributors

tony9402	VSFe	kim1109123	cola314	nnnlog
Baekjoon solved.ac	Baekjoon solved.ac	Baekjoon solved.ac	Baekjoon solved.ac	Baekjoon solved.ac
inclue	yeonjungin	cpprhtn	seastar105	Dev-RubinJo
Baekjoon solved.ac	private	Baekjoon solved.ac	Baekjoon solved.ac	Baekjoon solved.ac
shjeong92	chj3748	seung-00	bn-tw2020	kjh03160
Baekjoon solved.ac	Baekjoon solved.ac	Baekjoon solved.ac	Baekjoon solved.ac	Baekjoon solved.ac
CoodingPenguin	bsm8734	gkgg123	simon-hoon	gusdn3477
Baekjoon solved.ac	Baekjoon solved.ac	Baekjoon solved.ac	Baekjoon solved.ac	Baekjoon solved.ac
rlawngus0910	tallua	kyjun719	chance0523	lms0806
Baekjoon solved.ac	Baekjoon solved.ac	Baekjoon solved.ac	Baekjoon solved.ac	Baekjoon solved.ac
zmrdltl	cieske	Rain3321	sio2whocodes	kang-hyuck
Baekjoon solved.ac	Baekjoon solved.ac	Baekjoon solved.ac	Baekjoon solved.ac	Baekjoon solved.ac
witch-factory	youngjun0627	suinj8	juheon-jeong	Won-JoonChoi
Baekjoon solved.ac	Baekjoon solved.ac	Baekjoon solved.ac	Baekjoon solved.ac	Baekjoon solved.ac
parkgwangwook	parkjonggyeong18	Ryu-JM	Cho-Hyun-Ji	HaegyeongKim01
Baekjoon solved.ac	Baekjoon solved.ac	Baekjoon solved.ac	Baekjoon solved.ac	Baekjoon solved.ac
HyeonJaePark	changuii	bangrr	ingyu1008	220v-K
Baekjoon solved.ac	Baekjoon solved.ac	Baekjoon solved.ac	Baekjoon solved.ac	Baekjoon solved.ac
pill27211	beberiche
Baekjoon solved.ac	Baekjoon solved.ac

업데이트 로그

뽑아야 하는 문제가 많고 이를 보기 좋게 표로 정리하는 과정은 너무 노가다성이 많기 때문에 편하게 작업할 수 있도록 업데이트 하고 있습니다.

자세히

2021.04.28
- 오늘의 문제 뽑히는 문제 난이도 변경
  - 이전 난이도
    - 1번 브론즈 5 ~ 실버 1
    - 2번 골드 5 ~ 골드 3
    - 3번 골드 5 ~ 골드 3
    - 4번 골드 2 ~ 골드 1
  - 변경된 난이도
    - 1번 브론즈 5 ~ 실버 3
    - 2번 실버 2 ~ 골드 4
    - 3번 실버 2 ~ 골드 4
    - 4번 골드 3 ~ 골드 1
2021.04.22 ~ 2021.04.23
- 코드 리팩토링 일부 완료
  - 나머지는 시간 날때마다 하나씩 할 예정
- 문제 뽑는 방식 변경
  - 이전 방식에서 새로운 방식으로 변경
  - 이전 방식 : [추천 문제 여부],[문제 이름],[문제 번호],[난이도],[솔루션 링크]
  - 새로운 방식 : [추천 문제 여부],[문제 번호],[솔루션 링크]
- 매일 새벽에 자동으로 문제 뽑는 스크립트 제작 및 기능 추가
  - Solved.ac 기준 브론즈 5 ~ 골드 1 사이인 문제가 4문제 일정 조건 안에서 랜덤하게 뽑음
  - 오늘 문제 형식으로 업데이트.
  - 문제 뽑는 스크립트
- Contributors 정보 만드는 표 스크립트 제작
  - Contributor 정보만 여기에 넣으면 자동으로 표를 생성
2021.04.20
- tree 태그 추가
  - 트리와 관련된 문제 뽑았습니다.
- Contributors 디자인을 변경하였습니다.
- 문제집 전체를 업데이트 하였습니다.
- 각 문제집에 문제 번호를 볼 수 있도록 추가하였고 문제 번호로도 백준으로 이동할 수 있도록 업데이트 했습니다.
2021.04.03
- discussions 추가
2021.04.02
- README.md 자동 생성 스크립트 제작
  - 각 알고리즘 문제는 자동으로 추가되고 status.md에 자동으로 카운팅되지만 README.md에서는 안되는 현상 발견하여 해결
- 알고리즘 문제 제목 틀린거 자동으로 찾아 수정
- 일정 주기마다 알고리즘 난이도 갱신
- 문제 정보를 담는 json을 만듦
2021.03.31
- Github Actions 도입
- solved의 난이도 변경을 일정 시간마다 체크하여 자동 업데이트 (백준 문제집은 X)
- 난이도 변경은 로그로 남겨놓음
- 솔루션 파일만 폴더 형식에만 맞추면 알아서 README 업데이트(솔루션 링크 연결 등)
2021.03.27
- README.md 업데이트를 더더욱 자동화를 위해 README.md 위에 설명 부분을 header.md로 분리
2021.03.15
- 추천 문제 solution (C++ 기준) 완성도 정리하는 스크립트 생성
2021.01.15
- 문제 이렇게 뽑으면 자동으로 markdown 테이블을 만들어주는 스크립트 제작

TODO

자세히

코드 리팩토링
Contributors 추가 스크립트화
문제 뽑으면 Discussions 또는 Issue에서 바로 간단한 명령어로 추가 기능(스크립트화)
문제 추가 방식 변경

microsoft/ebpf-for-windows

2024-07-24T01:30:13Z

eBPF implementation that runs on top of Windows

eBPF for Windows

eBPF is a well-known technology for providing programmability and agility, especially for extending an OS kernel, for use cases such as DoS protection and observability. This project is a work-in-progress that allows existing eBPF toolchains and APIs familiar in the Linux ecosystem to be used on top of Windows. That is, this project takes existing eBPF projects as submodules and adds the layer in between to make them run on top of Windows.

New to eBPF?

See our basic eBPF tutorial and our tutorial on debugging eBPF verification failures.

Architectural Overview

The following diagram shows the basic architecture of this project and related components:

As shown in the diagram, existing eBPF toolchains (clang, etc.) can be used to generate eBPF bytecode from source code in various languages. Bytecode can be consumed by any application, or via bpftool or the Netsh command line tool, which use a shared library that exposes Libbpf APIs, though this is still in progress.

The eBPF bytecode is sent to a static verifier (the PREVAIL verifier) that is hosted in a secure user-mode environment such as a system service (which is the case at present), enclave, or trusted VM. If the eBPF program passes all the verifier checks, it can be loaded into the kernel-mode execution context. Typically this is done by being JIT compiled (via the uBPF JIT compiler) into native code that is passed to the execution context. In a debug build, the byte code can instead be directly loaded into an interpreter (from uBPF in the kernel-mode execution context) though the interpreter is not present in a release build as it is considered less secure. See also the HVCI FAQ answer below.

eBPF programs installed into the kernel-mode execution context can attach to various hooks and call various helper APIs exposed by the eBPF shim, which internally wraps public Windows kernel APIs, allowing the use of eBPF on existing versions of Windows. Many helpers already exist, and more hooks and helpers will be added over time.

Getting Started

This project supports eBPF on Windows 10 or later, and on Windows Server 2019 or later. To try out this project, see our Getting Started Guide.

Want to help? We welcome contributions! See our Contributing guidelines. Feel free to take a look at our Good First Issues list if you're looking for somewhere to start.

Want to chat with us? We have a:

Slack channel (If you are new, sign up at http://slack.cilium.io/)
Zoom meeting for github issue triage: see meeting info

For tracking Q&A and general discussion, we use Discussions in github. This can also function similar to a mailing list if you subscribe to discussion notifications by clicking "Watch" (or "Unwatch") and selecting "Custom" -> "Discussions" (or by selecting "All Activity" if you want to receive notifications about everything else too).

If you have issues with an eBPF program, start with the Troubleshooting Guide.

Frequently Asked Questions

1. Is this a fork of eBPF?

No.

The eBPF for Windows project leverages existing projects, including the IOVisor uBPF project and the PREVAIL verifier, running them on top of Windows by adding the Windows-specific hosting environment for that code.

2. Does this provide app compatibility with eBPF programs written for Linux?

The intent is to provide source code compatibility for code that uses common hooks and helpers that apply across OS ecosystems.

Linux provides many hooks and helpers, some of which are very Linux specific (e.g., using Linux internal data structs) that would not be applicable to other platforms. Other hooks and helpers are generically applicable and the intent is to support them for eBPF programs.

Similarly, the eBPF for Windows project exposes Libbpf APIs to provide source code compatibility for applications that interact with eBPF programs.

3. Will eBPF work with HyperVisor-enforced Code Integrity (HVCI)?

Yes. With HVCI enabled, eBPF programs cannot be JIT compiled, but can be run either natively or in interpreted mode (but the interpreter is disabled in release builds and is only supported in debug builds). To understand why JIT compiled mode does not work, we must first understand what HVCI does.

HyperVisor-enforced Code Integrity (HVCI) is a mechanism whereby a hypervisor, such as Hyper-V, uses hardware virtualization to protect kernel-mode processes against the injection and execution of malicious or unverified code. Code integrity validation is performed in a secure environment that is resistant to attack from malicious software, and page permissions for kernel mode are set and maintained by the hypervisor.

Since a hypervisor doing such code integrity checks will refuse to accept code pages that aren't signed by a key that the hypervisor trusts, this does impact eBPF programs running natively. As such, when HVCI is enabled, eBPF programs work fine in interpreted mode, but not when using JIT compilation because the JIT compiler does not have a key that the hypervisor trusts. And since interpreted mode is absent in release builds, neither mode will work on an HVCI-enabled production system.

Instead, a third mode is also supported by eBPF for Windows, in addition to JIT compiled and interpreted modes. This third mode entails compiling eBPF programs into regular Windows drivers that can be accepted by HVCI. For more discussion, see the Native Code Generation documentation.

viti95/FastDoom

2024-07-24T01:30:13Z

Doom port for DOS, optimized to be as fast as possible!

FastDOOM

Doom port for DOS, based on PCDoom by @nukeykt. The goal of this port is to make it as fast as possible for 386/486 personal computers.

FastDOOM vs Original

Added FPS ingame viewer
Added FPS calculation after timedemo runs
Added option to render visplanes (ceiling and floors) without textures
Added option to render Spectres and invisible objects like real transparent objects (harder to see, a little faster to render)
Added option to render sky as a flat fixed color
Added option to render Spectre and invisible objects like the Sega Saturn port did
Added option to render Spectre and invisible objects like Heretic/Hexen
New option to show only objects that are not far away from the player. All the enemies are still rendered as they're important
PC Speaker uses all sounds available (just for fun!)
New mode for PC Speaker (digitized sound!)
Disney Sound Source support
COVOX LPT DAC support
Adlib OPL2 PCM support
OPL2LPT and OPL3LPT support
Tandy 3-voice PCM support (SN76489)
Creative Music System / Game Blaster support
Audio-CD music support
PCM music support (through sound fx device)
Hercules automap support
Lot's of optimizations to make the game run faster / smoother
Removed low memory limit (may cause crashes with low RAM)
New detail level: Potato. It renders the full scene with a quarter width resolution (max 80x200). Much faster rendering, specially on 386 cpu's and slow 8-bit VGA ISA cards.
New option to allow more than 8Mb of memory allocation. Enabled with "-ram"
Removed network gaming support
Removed joystick support
Removed Y mouse movement (move forward/backwards)
Added autorun support (F12 key)
Added mono sound support
Replaced DOS/4GW with DOS/32A providing a good speedup!
New setup program
New video modes (Mode 13h, MDA, CGA, EGA, Hercules, Text modes, VESA 2.0, Plantronics Colorplus, Sigma Color 400)
Advanced benchmark support

DEMO

	Doom 1.9 Audio	Doom 1.9 NoAudio	FastDoom 0.2 Audio	FastDoom 0.2 Audio FlatVisplanes	FastDoom 0.2 Audio FlatVisplanes FlatTransparency	FastDoom 0.2 Audio FlatVisplanes Sega Saturn transparency	FastDoom 0.2 NoAudio	FastDoom 0.2 NoAudio flatVisplanes Sega Saturn transparency
FPS	19.56	21.68	22.44	25.77	25.86	26.02	24.79	29.05
Gain	100.00%	110.20%	114.70%	131.70%	132.20%	133.00%	126.74%	148.52%

FastDoom 0.8 Live Demo (Texas Instruments 486DLC @40 MHz, Cirrus Logic GD-5422 ISA):

https://user-images.githubusercontent.com/8323882/147228550-bf93cc50-3c92-4a7a-b84f-65c8bbe1d3a9.mp4

Full video here

Build instructions (FastDOOM)

Install Open Watcom C version 2.0
Install NASM
Install DOS/32A
Add Watcom's bin folder (binnt on Windows, binw on DOS) to the PATH.
Run makeall.bat

Build instructions (FDSETUP)

Install Borland C++ 4.52 (Windows 3.1, Windows 9x)
Install Laughing Dog Screen Maker 1.14 (MS-DOS)
Run .\FDSETUP\SCREENS\MAKE.BAT (MS-DOS)
Open setup.ide project in Borland C++ IDE
Build the project

Contributors

This project exists thanks to all the people who contribute.

Star History

Contributing

Feel free to add issues or pull requests here on GitHub. I cannot guarantee that I will accept your changes, but feel free to fork the repo and make changes as you see fit. Thanks!

Aikoyori/ProgrammingVTuberLogos

2024-07-23T01:29:42Z

Underscores + Bootstrap = Understrap, the renowned open-source WordPress starter theme.

See: Official Demo | Read: Official Docs Page

Understrap WordPress Theme Framework

Website: understrap.com

Child Theme Project: github.com/understrap/understrap-child

Premium Child Themes: understrap.com/child-themes/

About

Understrap is the renowned open-source WordPress starter theme that combines Underscores with Bootstrap. Trusted by more than 100,000 developers.

Documentation

Full documentation for this theme is available at docs.understrap.com.

Questions

For support requests and bugs, we recommend browsing our issues and opening a new issue if necessary. For more broad discussion, like questions about the roadmap, visit our discussion board.

Changelog

See changelog

Basic Features

Combines Underscore’s PHP/JS files and Bootstrap’s HTML/CSS/JS.
Comes with Bootstrap (v4 and/or v5) Sass source files and additional .scss files. Nicely sorted and ready to add your own variables and customize the Bootstrap variables.
Uses a single minified CSS file for all the basic stuff.
Font Awesome integration (v4.7.0)
Jetpack ready
WooCommerce support
Contact Form 7 support
Child Theme ready
Translation ready

Understrap Academy

Become an Understrap Expert. Presented by the team behind the Understrap Theme Framework, Understrap Academy is a collection of online courses that will help you speed up your development process, make your projects more profitable, and become an Understrap expert in record time.

License

https://www.gnu.org/licenses/gpl-3.0.en.html

Credits

Font Awesome: https://fontawesome.com/v4.7/license/ (Font: SIL OFL 1.1, (S)CSS: MIT)
Bootstrap: https://getbootstrap.com | https://github.com/twbs/bootstrap/blob/main/LICENSE (MIT)
WP Bootstrap Navwalker by Edward McIntyre & William Patton: https://github.com/wp-bootstrap/wp-bootstrap-navwalker (GNU GPLv3)

esl/escalus

2024-07-23T01:30:29Z

An XMPP client library in Erlang for conveniently testing XMPP servers

processone/xmpp

2024-07-23T01:30:29Z

Erlang/Elixir XMPP parsing and serialization library on top of Fast XML

ForNeVeR/fornever.me

2024-07-23T01:30:31Z

Friedrich von Never: Engineer, Programmer, Gentleman.

fornever.me: Engineer, Programmer, Gentleman

This is the fornever.me site source code. It uses ForneverMind — a simple homemade blog engine mainly written in F# programming language.

Features

ASP.NET Core web engine.
Main pages layout in Razor.
Blog posts are written in Markdown.
Source code highlighting is provided by highlight.js on the server side.
There's a Plans page that provides a daily quote from the Evil Overlord List.
- A quote for each day is stored in a LiteDB database.
Disqus comment system.

Contributing

To know how to develop the application locally, read the contributor guide.

Deployment

To install the application from Docker, run the following command:

$ docker run -d \
    --restart unless-stopped \
    -p:$PORT:80 \
    --name $NAME \
    -v $DATA:/data \
    revenrof/fornever.me:$VERSION

Where

$PORT is the port you want to expose the application on
$NAME is the container name
$VERSION is the version you want to deploy, or latest for the latest available one
$DATA is the database directory

For example, a production server may use the following settings (note this command uses the Bash syntax; adapt for your shell if necessary):

PORT=5001
NAME=fornevermind
VERSION=latest
DATA=/opt/fornever/fornever.me/data
docker pull revenrof/fornever.me:$VERSION
docker rm -f $NAME
docker run -d \
    --restart unless-stopped \
    -p $PORT:80 \
    --name $NAME \
    -v $DATA:/data \
    revenrof/fornever.me:$VERSION

Documentation

celestiaorg/CIPs

2024-07-24T01:32:03Z

htmlstreamofficial/preline

2024-07-24T01:32:14Z

Preline UI is an open-source set of prebuilt UI components based on the utility-first Tailwind CSS framework.

Why use Preline UI?

Based on the Tailwind CSS utility classes, Preline UI's prebuilt components and UI elements help you quickly design and customize responsive mobile-first websites with the components a website needs, including buttons, dropdowns, navigation bars, modals, and more.

What's in the box?

Components are grouped by visual usability criteria (components, navigation, forms, etc.) and styled directly on top of Tailwind CSS, making them easy to extend and customize. This is a lifesaver for developers looking to create a unique and eye-catching design system without the hassle of creating each component by hand.

Getting Started

Quick Setup

This guide will help you get started with Preline UI, including how to run, customize, update, and integrate your project!

First, you need to make sure that you have a working Tailwind CSS project installed and that you also have Node and NPM installed on your machine.

Require via NPM

Install preline via npm

npm i preline

Include Preline UI as a plugin in the tailwind.config.js file

module.exports = {
  content: [
    'node_modules/preline/dist/*.js'
  ],
  plugins: [
    require('preline/plugin')
  ],
}

Include the JavaScript <script> that powers the interactive elements near the end of your <body> tag:

<script src="./node_modules/preline/dist/preline.js"></script>

Documentation

For full documentation of the Preline options, visit preline.co. The site also contains information on the wide variety of plugins that are available for TailwindCSS projects.

Community

For help, discussion about best practices, or any other conversation that would benefit from being searchable use GitHub Discussions

License

Preline UI is free for both personal and commercial projects, released under dual license terms MIT and Preline UI Fair Use License , and copyrighted 2024 by Preline Labs Ltd.

Preline UI Figma is free for both commercial and personal projects, learn more here.

All brand icons are trademarks of their respective owners. The use of these trademarks does not indicate endorsement of the trademark holder by Preline UI, nor vice versa.

A product of Htmlstream

Preline UI is built and maintend by Htmlstream team. Over the last decade at Htmlstream, our journey has involved crafting UI Components and Templates. This process has allowed us to understand and explore a range of strategies for developing versatile UI designs that can adapt to a variety of needs.

Share your thoughts about Preline on Twitter or leave supportive review on ProductHunt.

danielfarrell/bootstrap-combobox

2024-07-23T01:32:04Z

A combobox plugin that works with twitter bootstrap

chrishrb/gx.nvim

2024-07-23T01:32:13Z

Implementation of gx without the need of netrw

🔗 gx.nvim

ATTENTION: There was a breaking change in version v0.5.0. The keybinding gx must now be configured manually. See Installation

✨ Features

open links without netrw
normal and visual mode support
links with/without an explicit protocol (e.g. google.com will open https://google.com)
open plugins in the browser with a single command (e.g. in lazy, packer you can hover over a plugin name, simply press gx or execute command Browse and you get to the github page of the plugin)
open github issues directly in the browser (e.g. Fixes #22 opens https://github.com/chrishrb/gx.nvim/issues/22)
dependencies from package.json (e.g. line "express": "^4.18.2", in the package.json opens https://www.npmjs.com/package/express)
formulae and casks from Brewfile (e.g. line brew "neovim" in the Brewfile opens https://formulae.brew.sh/formula/neovim)
go packages from an import statement (e.g. line import "github.com/joho/godotenv" opens https://pkg.go.dev/github.com/joho/godotenv)
if there is no url found under the cursor, the word/selection is automatically searched on the web
supports user defined handlers to extend the functionality
support for macOS, Linux and Windows
if multiple patterns match you can simply select the desired URL from the menu

⚡️ Requirements

Neovim >= 0.5.0
macOS (open), Linux (xdg-open) or Windows (powershell.exe start explorer.exe)

📦 Installation

lazy.nvim


require("lazy").setup({
  {
    "chrishrb/gx.nvim",
    keys = { { "gx", "<cmd>Browse<cr>", mode = { "n", "x" } } },
    cmd = { "Browse" },
    init = function ()
      vim.g.netrw_nogx = 1 -- disable netrw gx
    end,
    dependencies = { "nvim-lua/plenary.nvim" },
    config = true, -- default settings
    submodules = false, -- not needed, submodules are required only for tests

    -- you can specify also another config if you want
    config = function() require("gx").setup {
      open_browser_app = "os_specific", -- specify your browser app; default for macOS is "open", Linux "xdg-open" and Windows "powershell.exe"
      open_browser_args = { "--background" }, -- specify any arguments, such as --background for macOS' "open".
      handlers = {
        plugin = true, -- open plugin links in lua (e.g. packer, lazy, ..)
        github = true, -- open github issues
        brewfile = true, -- open Homebrew formulaes and casks
        package_json = true, -- open dependencies from package.json
        search = true, -- search the web/selection on the web if nothing else is found
        go = true, -- open pkg.go.dev from an import statement (uses treesitter)
        jira = { -- custom handler to open Jira tickets (these have higher precedence than builtin handlers)
          name = "jira", -- set name of handler
          handle = function(mode, line, _)
            local ticket = require("gx.helper").find(line, mode, "(%u+-%d+)")
            if ticket and #ticket < 20 then
              return "http://jira.company.com/browse/" .. ticket
            end
          end,
        },
        rust = { -- custom handler to open rust's cargo packages
          name = "rust", -- set name of handler
          filetype = { "toml" }, -- you can also set the required filetype for this handler
          filename = "Cargo.toml", -- or the necessary filename
          handle = function(mode, line, _)
            local crate = require("gx.helper").find(line, mode, "(%w+)%s-=%s")

            if crate then
              return "https://crates.io/crates/" .. crate
            end
          end,
        },
      },
      handler_options = {
        search_engine = "google", -- you can select between google, bing, duckduckgo, ecosia and yandex
        search_engine = "https://search.brave.com/search?q=", -- or you can pass in a custom search engine
        select_for_search = false, -- if your cursor is e.g. on a link, the pattern for the link AND for the word will always match. This disables this behaviour for default so that the link is opened without the select option for the word AND link

        git_remotes = { "upstream", "origin" }, -- list of git remotes to search for git issue linking, in priority
        git_remotes = function(fname) -- you can also pass in a function
            if fname:match("myproject") then
                return { "mygit" }
            end
            return { "upstream", "origin" }
        end,

        git_remote_push = false, -- use the push url for git issue linking,
        git_remote_push = function(fname) -- you can also pass in a function
          return fname:match("myproject")
        end,
      },
    } end,
  },
})

📡 Commands

Browse <URL or WORDS>, e.g. Browse http://google.de, Browse example
OR hover/select words, links and more and execute command Browse

🚀 Usage

When your cursor is over a link or you mark a link or part of a link with the visual mode, you can press gx to open the link in the browser.

📄 Acknowledgements

lua functions library plenary.nvim

intel/intel-xpu-backend-for-triton

2024-07-24T01:33:48Z

OpenAI Triton backend for Intel® GPUs

linode/apl-core

2024-07-23T01:32:44Z

Application Platform for LKE (and any other conformant K8s)

lamw/vmware-scripts

2024-07-24T01:34:29Z

Various scripts for VMware based solutions

VMware Script Repository

This repository contains a collection of sample scripts across various programming/scripting languages for VMware based solutions.

chocolatey/boxstarter

2024-07-23T01:33:34Z

Repeatable, reboot resilient windows environment installations made easy using Chocolatey packages

Boxstarter

Repeatable, reboot resilient windows environment installations made easy using Chocolatey packages.

For more information and How Tos, visit the official Boxstarter website.

The source of the Boxstarter website can be found in the boxstarter.org repository.

Windows Environment Creation Made Easy

100% Unattended Install with pending reboot detection and automatic logon.
Remote machine deployments.
Integrates with Hyper-V and Windows Azure VMs supporting checkpoint restore and creation.
Installation packages build on top of Chocolatey package management.
Easily install with just a Gist and the Boxstarter Web Launcher or create a private repository on a thumb drive or network share.
See the supported operating systems but may work on older.
Lots of Windows configuration utilities including installing critical updates, changing Windows Explorer options, and more.

Quickly install your favorite applications and settings, on any machine, with a gist! No pre-installed software needed

Grab your Gist

Launch the Boxstarter launcher

Easily Package Installation Scripts and Resources In a NuGet Package

A Simple Hello World

Import-Module Boxstarter.Chocolatey
New-BoxstarterPackage HelloWorld
Set-Content (Join-Path $Boxstarter.LocalRepo "HelloWorld\Tools\ChocolateyInstall.ps1") `
  -Value "Write-Host `"Hello World! from `$env:COMPUTERNAME`";choco install Git" -Force
Invoke-BoxstarterBuild HelloWorld

Install On Another Computer

$creds = Get-Credential win\mwrock
Install-BoxstarterPackage -ComputerName win `
  -Package HelloWorld -Credential $creds

NOTE: PowerShell Remoting must be enabled on the remote machine. Launch a PowerShell Console as administrator:

Enable-PSRemoting -Force

Information

Documentation

Please see the Boxstarter docs.

Requirements

Boxstarter requires the following to work:

Operating System: See the Chocolatey supported Windows operating systems.
PowerShell Version 2 or higher.
Administrative privileges on the machine where Boxstarter is running.

License / Credits

Apache 2.0 - see LICENSE and NOTICE files.

Etiquette Regarding Communication

If you are an open source user requesting support, please remember that most folks in the Chocolatey community are volunteers that have lives outside of open source and are not paid to ensure things work for you, so please be considerate of others' time when you are asking for things. Many of us have families that also need time as well and only have so much time to give on a daily basis. A little consideration and patience can go a long way. After all, you are using a pretty good tool without cost. It may not be perfect (yet), and we know that.

Submitting Issues

If you are having issues with a Chocolatey package, please see the Chocolatey package triage process.
If you are having issues with Chocolatey products please see Troubleshooting and the FAQ to see if your question or issue already has an answer.

Observe the following help for submitting an issue.

Prerequisites

When creating an issue, please ensure you read the guidance at the top which includes links for Contributing and Submitting Issues documentation.
The issue has to do with Boxstarter itself and is not a Boxstarter website issue, Chocolatey package issue, a Chocolatey product issue.
Please check to see if your issue already exists with a quick search of both open and closed issues. Start with one relevant term and then add if you get too many results.
You are not submitting an "Enhancement". Enhancements should observe CONTRIBUTING guidelines.
You are not submitting a question - questions are better served as emails or Community Chat.
Please make sure you've read over and agree with the etiquette regarding communication.

Creating an Issue

We'll need debug and verbose output, so please run and capture the log with -Debug -Verbose (ie. Install-Boxstarter -PackageName <PACKAGE NAME OR GIST> -Verbose -Debug. If it is less than 50 lines you can submit that with the issue or if it is longer, create a gist and link it.
Please note that the debug/verbose output for some commands may have sensitive data (passwords or API Keys) related so please remove those if they are there prior to submitting the issue.
If your issue needs output from choco.exe, then it logs to a file in $env:ChocolateyInstall\log\. You can grab the specific log output from there so you don't have to capture or redirect screen output. Please limit the amount included to just the command run (the log is appended to with every command).
Please save the log output in a gist (save the file as log.sh) and link to the gist from the issue. You can create it as secret so it doesn't fill up against your public gists but anyone with a direct link can still get to secret gists. If you accidentally include secret information in your gist, please delete it and create a new one (gist history can be seen by anyone) and update the link in the issue (issue history is not retained except by email - deleting the gist ensures that no one can get to it). Using gists this way also keeps accidental secrets from being shared in the issue in the first place as well.
We'll need the entire log output from the run, so please don't limit it down to areas you feel are relevant. You may miss some important details we'll need to know. This will help expedite issue triage.
It's helpful to include the version of Boxstarter, the version of the OS, whether running on physical or virtual hardware and the version of PowerShell - the debug script should capture all of those pieces of information.
Include screenshots and / or animated gifs whenever possible as they help show us exactly what the problem is.

Contributing

If you would like to contribute code or help squash a bug or two, that's awesome. Please familiarize yourself with CONTRIBUTING.

Committers

Committers, you should be very familiar with COMMITTERS.

crewAIInc/crewAI

2024-07-23T01:33:44Z

Framework for orchestrating role-playing, autonomous AI agents. By fostering collaborative intelligence, CrewAI empowers agents to work together seamlessly, tackling complex tasks.

crewAI

🤖 crewAI: Cutting-edge framework for orchestrating role-playing, autonomous AI agents. By fostering collaborative intelligence, CrewAI empowers agents to work together seamlessly, tackling complex tasks.

Homepage | Documentation | Chat with Docs | Examples | Discord

Why CrewAI?

The power of AI collaboration has too much to offer. CrewAI is designed to enable AI agents to assume roles, share goals, and operate in a cohesive unit - much like a well-oiled crew. Whether you're building a smart assistant platform, an automated customer service ensemble, or a multi-agent research team, CrewAI provides the backbone for sophisticated multi-agent interactions.

Getting Started

To get started with CrewAI, follow these simple steps:

1. Installation

pip install crewai

If you want to install the 'crewai' package along with its optional features that include additional tools for agents, you can do so by using the following command: pip install 'crewai[tools]'. This command installs the basic package and also adds extra components which require more dependencies to function."

pip install 'crewai[tools]'

2. Setting Up Your Crew

import os
from crewai import Agent, Task, Crew, Process
from crewai_tools import SerperDevTool

os.environ["OPENAI_API_KEY"] = "YOUR_API_KEY"
os.environ["SERPER_API_KEY"] = "Your Key" # serper.dev API key

# You can choose to use a local model through Ollama for example. See https://docs.crewai.com/how-to/LLM-Connections/ for more information.

# os.environ["OPENAI_API_BASE"] = 'http://localhost:11434/v1'
# os.environ["OPENAI_MODEL_NAME"] ='openhermes'  # Adjust based on available model
# os.environ["OPENAI_API_KEY"] ='sk-111111111111111111111111111111111111111111111111'

# You can pass an optional llm attribute specifying what model you wanna use.
# It can be a local model through Ollama / LM Studio or a remote
# model like OpenAI, Mistral, Antrophic or others (https://docs.crewai.com/how-to/LLM-Connections/)
#
# import os
# os.environ['OPENAI_MODEL_NAME'] = 'gpt-3.5-turbo'
#
# OR
#
# from langchain_openai import ChatOpenAI

search_tool = SerperDevTool()

# Define your agents with roles and goals
researcher = Agent(
  role='Senior Research Analyst',
  goal='Uncover cutting-edge developments in AI and data science',
  backstory="""You work at a leading tech think tank.
  Your expertise lies in identifying emerging trends.
  You have a knack for dissecting complex data and presenting actionable insights.""",
  verbose=True,
  allow_delegation=False,
  # You can pass an optional llm attribute specifying what model you wanna use.
  # llm=ChatOpenAI(model_name="gpt-3.5", temperature=0.7),
  tools=[search_tool]
)
writer = Agent(
  role='Tech Content Strategist',
  goal='Craft compelling content on tech advancements',
  backstory="""You are a renowned Content Strategist, known for your insightful and engaging articles.
  You transform complex concepts into compelling narratives.""",
  verbose=True,
  allow_delegation=True
)

# Create tasks for your agents
task1 = Task(
  description="""Conduct a comprehensive analysis of the latest advancements in AI in 2024.
  Identify key trends, breakthrough technologies, and potential industry impacts.""",
  expected_output="Full analysis report in bullet points",
  agent=researcher
)

task2 = Task(
  description="""Using the insights provided, develop an engaging blog
  post that highlights the most significant AI advancements.
  Your post should be informative yet accessible, catering to a tech-savvy audience.
  Make it sound cool, avoid complex words so it doesn't sound like AI.""",
  expected_output="Full blog post of at least 4 paragraphs",
  agent=writer
)

# Instantiate your crew with a sequential process
crew = Crew(
  agents=[researcher, writer],
  tasks=[task1, task2],
  verbose=2, # You can set it to 1 or 2 to different logging levels
  process = Process.sequential
)

# Get your crew to work!
result = crew.kickoff()

print("######################")
print(result)

In addition to the sequential process, you can use the hierarchical process, which automatically assigns a manager to the defined crew to properly coordinate the planning and execution of tasks through delegation and validation of results. See more about the processes here.

Key Features

Role-Based Agent Design: Customize agents with specific roles, goals, and tools.
Autonomous Inter-Agent Delegation: Agents can autonomously delegate tasks and inquire amongst themselves, enhancing problem-solving efficiency.
Flexible Task Management: Define tasks with customizable tools and assign them to agents dynamically.
Processes Driven: Currently only supports sequential task execution and hierarchical processes, but more complex processes like consensual and autonomous are being worked on.
Save output as file: Save the output of individual tasks as a file, so you can use it later.
Parse output as Pydantic or Json: Parse the output of individual tasks as a Pydantic model or as a Json if you want to.
Works with Open Source Models: Run your crew using Open AI or open source models refer to the Connect crewAI to LLMs page for details on configuring your agents' connections to models, even ones running locally!

Examples

You can test different real life examples of AI crews in the crewAI-examples repo:

Quick Tutorial

Connecting Your Crew to a Model

crewAI supports using various LLMs through a variety of connection options. By default your agents will use the OpenAI API when querying the model. However, there are several other ways to allow your agents to connect to models. For example, you can configure your agents to use a local model via the Ollama tool.

Please refer to the Connect crewAI to LLMs page for details on configuring you agents' connections to models.

How CrewAI Compares

Autogen: While Autogen does good in creating conversational agents capable of working together, it lacks an inherent concept of process. In Autogen, orchestrating agents' interactions requires additional programming, which can become complex and cumbersome as the scale of tasks grows.
ChatDev: ChatDev introduced the idea of processes into the realm of AI agents, but its implementation is quite rigid. Customizations in ChatDev are limited and not geared towards production environments, which can hinder scalability and flexibility in real-world applications.

CrewAI's Advantage: CrewAI is built with production in mind. It offers the flexibility of Autogen's conversational agents and the structured process approach of ChatDev, but without the rigidity. CrewAI's processes are designed to be dynamic and adaptable, fitting seamlessly into both development and production workflows.

Contribution

CrewAI is open-source and we welcome contributions. If you're looking to contribute, please:

Fork the repository.
Create a new branch for your feature.
Add your feature or improvement.
Send a pull request.
We appreciate your input!

Installing Dependencies

poetry lock
poetry install

Virtual Env

poetry shell

Pre-commit hooks

pre-commit install

Running Tests

poetry run pytest

Running static type checks

poetry run mypy

Packaging

poetry build

Installing Locally

pip install dist/*.tar.gz

Telemetry

CrewAI uses anonymous telemetry to collect usage data with the main purpose of helping us improve the library by focusing our efforts on the most used features, integrations and tools.

There is NO data being collected on the prompts, tasks descriptions agents backstories or goals nor tools usage, no API calls, nor responses nor any data that is being processed by the agents, nor any secrets and env vars.

Data collected includes:

Version of crewAI
- So we can understand how many users are using the latest version
Version of Python
- So we can decide on what versions to better support
General OS (e.g. number of CPUs, macOS/Windows/Linux)
- So we know what OS we should focus on and if we could build specific OS related features
Number of agents and tasks in a crew
- So we make sure we are testing internally with similar use cases and educate people on the best practices
Crew Process being used
- Understand where we should focus our efforts
If Agents are using memory or allowing delegation
- Understand if we improved the features or maybe even drop them
If Tasks are being executed in parallel or sequentially
- Understand if we should focus more on parallel execution
Language model being used
- Improved support on most used languages
Roles of agents in a crew
- Understand high level use cases so we can build better tools, integrations and examples about it
Tools names available
- Understand out of the publically available tools, which ones are being used the most so we can improve them

Users can opt-in sharing the complete telemetry data by setting the share_crew attribute to True on their Crews.

License

CrewAI is released under the MIT License.

neuml/txtai

2024-07-24T01:35:00Z

💡 All-in-one open-source embeddings database for semantic search, LLM orchestration and language model workflows

All-in-one embeddings database

txtai is an all-in-one embeddings database for semantic search, LLM orchestration and language model workflows.

Embeddings databases are a union of vector indexes (sparse and dense), graph networks and relational databases. This enables vector search with SQL, topic modeling, retrieval augmented generation (RAG) and more.

Embeddings databases can stand on their own and/or serve as a powerful knowledge source for large language model (LLM) prompts.

Summary of txtai features:

🔎 Vector search with SQL, object storage, topic modeling, graph analysis and multimodal indexing
📄 Create embeddings for text, documents, audio, images and video
💡 Pipelines powered by language models that run LLM prompts, question-answering, labeling, transcription, translation, summarization and more
↪️️ Workflows to join pipelines together and aggregate business logic. txtai processes can be simple microservices or multi-model workflows.
⚙️ Build with Python or YAML. API bindings available for JavaScript, Java, Rust and Go.
☁️ Run local or scale out with container orchestration

txtai is built with Python 3.8+, Hugging Face Transformers, Sentence Transformers and FastAPI. txtai is open-source under an Apache 2.0 license.

Interested in an easy and secure way to run hosted txtai applications? Then join the txtai.cloud preview to learn more.

Why txtai?

New vector databases, LLM frameworks and everything in between are sprouting up daily. Why build with txtai?

Up and running in minutes with pip or Docker

# Get started in a couple lines
import txtai

embeddings = txtai.Embeddings()
embeddings.index(["Correct", "Not what we hoped"])
embeddings.search("positive", 1)
#[(0, 0.29862046241760254)]

Built-in API makes it easy to develop applications using your programming language of choice

# app.yml
embeddings:
    path: sentence-transformers/all-MiniLM-L6-v2

CONFIG=app.yml uvicorn "txtai.api:app"
curl -X GET "http://localhost:8000/search?query=positive"

Run local - no need to ship data off to disparate remote services
Work with micromodels all the way up to large language models (LLMs)
Low footprint - install additional dependencies and scale up when needed
Learn by example - notebooks cover all available functionality

Use Cases

The following sections introduce common txtai use cases. A comprehensive set of over 50 example notebooks and applications are also available.

Semantic Search

Build semantic/similarity/vector/neural search applications.

Traditional search systems use keywords to find data. Semantic search has an understanding of natural language and identifies results that have the same meaning, not necessarily the same keywords.

Get started with the following examples.

Notebook	Description
Introducing txtai ▶️	Overview of the functionality provided by txtai
Similarity search with images	Embed images and text into the same space for search
Build a QA database	Question matching with semantic search
Semantic Graphs	Explore topics, data connectivity and run network analysis

LLM Orchestration

LLM chains, retrieval augmented generation (RAG), chat with your data, pipelines and workflows that interface with large language models (LLMs).

Chains

Integrate LLM chains (known as workflows in txtai), multiple LLM agents and self-critique.

See below to learn more.

Notebook	Description
Prompt templates and task chains	Build model prompts and connect tasks together with workflows
Integrate LLM frameworks	Integrate llama.cpp, LiteLLM and custom generation frameworks
Build knowledge graphs with LLMs	Build knowledge graphs with LLM-driven entity extraction

Retrieval augmented generation

Retrieval augmented generation (RAG) reduces the risk of LLM hallucinations by constraining the output with a knowledge base as context. RAG is commonly used to "chat with your data".

A novel feature of txtai is that it can provide both an answer and source citation.

Notebook	Description
Build RAG pipelines with txtai	Guide on retrieval augmented generation including how to create citations
How RAG with txtai works	Create RAG processes, API services and Docker instances
Advanced RAG with graph path traversal	Graph path traversal to collect complex sets of data for advanced RAG
Advanced RAG with guided generation	Retrieval Augmented and Guided Generation

Language Model Workflows

Language model workflows, also known as semantic workflows, connect language models together to build intelligent applications.

While LLMs are powerful, there are plenty of smaller, more specialized models that work better and faster for specific tasks. This includes models for extractive question-answering, automatic summarization, text-to-speech, transcription and translation.

Notebook	Description
Run pipeline workflows ▶️	Simple yet powerful constructs to efficiently process data
Building abstractive text summaries	Run abstractive text summarization
Transcribe audio to text	Convert audio files to text
Translate text between languages	Streamline machine translation and language detection

Installation

The easiest way to install is via pip and PyPI

pip install txtai

Python 3.8+ is supported. Using a Python virtual environment is recommended.

See the detailed install instructions for more information covering optional dependencies, environment specific prerequisites, installing from source, conda support and how to run with containers.

Model guide

See the table below for the current recommended models. These models all allow commercial use and offer a blend of speed and performance.

Component	Model(s)
Embeddings	all-MiniLM-L6-v2
Image Captions	BLIP
Labels - Zero Shot	BART-Large-MNLI
Labels - Fixed	Fine-tune with training pipeline
Large Language Model (LLM)	Mistral 7B OpenOrca
Summarization	DistilBART
Text-to-Speech	ESPnet JETS
Transcription	Whisper
Translation	OPUS Model Series

Models can be loaded as either a path from the Hugging Face Hub or a local directory. Model paths are optional, defaults are loaded when not specified. For tasks with no recommended model, txtai uses the default models as shown in the Hugging Face Tasks guide.

See the following links to learn more.

Powered by txtai

The following applications are powered by txtai.

Application	Description
txtchat	Retrieval Augmented Generation (RAG) powered search
paperai	Semantic search and workflows for medical/scientific papers
codequestion	Semantic search for developers
tldrstory	Semantic search for headlines and story text

In addition to this list, there are also many other open-source projects, published research and closed proprietary/commercial projects that have built on txtai in production.

Documentation

Full documentation on txtai including configuration settings for embeddings, pipelines, workflows, API and a FAQ with common questions/issues is available.

Contributing

For those who would like to contribute to txtai, please see this guide.

l-magnificence/Mime

2024-07-24T01:35:12Z

Machine learning-based integration model with elegant performance

Mime

The Mime package provides a user-friendly solution for constructing machine learning-based integration models from transcriptomic data.

With the widespread use of high-throughput sequencing technologies, understanding biology and cancer heterogeneity has been revolutionized. Mime streamlines the process of developing predictive models with high accuracy, leveraging complex datasets to identify critical genes associated with disease progression, patient outcomes, and therapeutic response.

It offers four main applications:

Establishing prognosis models using 10 machine learning algorithms.
Building binary response models with 7 machine learning algorithms.
Conducting core feature selection related to prognosis using 8 machine learning methods.
Visualizing the performance of each model.

Install

You can install the development version of Mime like so:

# options("repos"= c(CRAN="https://mirrors.tuna.tsinghua.edu.cn/CRAN/"))
# options(BioC_mirror="http://mirrors.tuna.tsinghua.edu.cn/bioconductor/")
if (!requireNamespace("BiocManager", quietly = TRUE)) install.packages("BiocManager")

depens<-c('GSEABase', 'GSVA', 'cancerclass', 'mixOmics', 'sparrow', 'sva' , 'ComplexHeatmap' )
for(i in 1:length(depens)){
  depen<-depens[i]
  if (!requireNamespace(depen, quietly = TRUE))  BiocManager::install(depen,update = FALSE)
}

if (!requireNamespace("CoxBoost", quietly = TRUE))
  devtools::install_github("binderh/CoxBoost")

if (!requireNamespace("fastAdaboost", quietly = TRUE))
  devtools::install_github("souravc83/fastAdaboost")

if (!requireNamespace("Mime", quietly = TRUE))
  devtools::install_github("l-magnificence/Mime")
  
library(Mime1)

Quick Start

This is a basic example which shows you how to use Mime:

Mime need multiple cohorts containing transcriptional sequencing data with information of survival or clinical response to therapy as well as a gene set as inputs. You can dowmload the example data in External data file to check the format of input.

load("./Example.cohort.Rdata")
list_train_vali_Data[["Dataset1"]][1:5,1:5]
#>               ID    OS.time OS   MT-CO1   MT-CO3
#>  TCGA.DH.A66B.01 1281.65322  0 13.77340 13.67931
#>  TCGA.HT.7607.01   96.19915  1 14.96535 14.31857
#>  TCGA.DB.A64Q.01  182.37755  0 13.90659 13.65321
#>  TCGA.DU.8167.01  471.97707  0 14.90695 14.59776
#>  TCGA.HT.7610.01 1709.53901  0 15.22784 14.62756

The first column ID is the sample ID, second to third column OS.time and OS are the survival time and status of patients, other columns are the gene expression level scaled with log2(x+1). Dataset1 is the training dataset, while other Datasets as validation.

load("./Example.ici.Rdata")
list_train_vali_Data[["training"]][1:5,1:5]
#>                                   ID Var      FTH1   EEF1A1      ACTB
#>                      SAMf2ce197162ce   N 10.114846 4.817746 11.230180
#>                           ERR2208915   Y  2.044180 5.038854  3.977902
#> G138701_RCCBMS-00141-T_v1_RNA_OnPrem   Y  5.406008 5.341635  5.366668
#>                      SAMe41b1e773582   N  9.215794 4.707360 11.412721
#>                      SAM5ffd7e4cd794   N  9.003710 3.908884 10.440559

The first column ID is the sample ID, second column Var is the theraputic response of patients (N: No response; Y: response), other columns are the gene expression level scaled with log2(x+1). training is the training dataset, while other Datasets as validation.

load("./genelist.Rdata")
#> [1] "MYC"    "CTNNB1" "JAG2"   "NOTCH1" "DLL1"   "AXIN2"  "PSEN2"  "FZD1"   "NOTCH4" "LEF1"   "AXIN1"  "NKD1"   "WNT5B" 
#>[14] "CUL1"   "JAG1"   "MAML1"  "KAT2A"  "GNAI1"  "WNT6"   "PTCH1"  "NCOR2"  "DKK4"   "HDAC2"  "DKK1"   "TCF7"   "WNT1"  
#>[27] "NUMB"   "ADAM17" "DVL2"   "PPARD"  "NCSTN"  "HDAC5"  "CCND2"  "FRAT1"  "CSNK1E" "RBPJ"   "FZD8"   "TP53"   "SKP2"  
#>[40] "HEY2"   "HEY1"   "HDAC11"

This gene set is associated with Wnt/β-catenin signalling from MSigDB.

We recommend training dataset with more than 100 samples and gene set with more than 50 genes.

1. Construct predicting models for prognosis

1.1 Select the optimal model

library(Mime)
load("./Example.cohort.Rdata")
load("./genelist.Rdata")
res <- ML.Dev.Prog.Sig(train_data = list_train_vali_Data$Dataset1,
                     list_train_vali_Data = list_train_vali_Data,
                     unicox.filter.for.candi = T,
                     unicox_p_cutoff = 0.05,
                     candidate_genes = genelist,
                     mode = 'all',nodesize =5,seed = 5201314 )

ML.Dev.Prog.Sig() provides three modes including all, single, and double. all means using all ten algorithms and the combinations. single means using only one of the ten algorithms. double means using the combination with two algorithms. In most casees, we will generally use all mode to analysis data.
If you set unicox.filter.for.candi as T (default), Mime will firstly perform univariable cox regression among provided genes in the training dataset to screen out the prognostic variables which are then used to construct models.

Plot C-index of each model:

cindex_dis_all(res,validate_set = names(list_train_vali_Data)[-1],order =names(list_train_vali_Data),width = 0.35)

We can find that StepCox[forward] + plsRcox have the highest C-index.

Plot C-index of specific model among different datasets:

cindex_dis_select(res,
                  model="StepCox[forward] + plsRcox",
                  order= names(list_train_vali_Data))

If input object res is from mode all used in ML.Dev.Prog.Sig(), you should define model as specific model name, while define model as SOD.

Plot survival curve of patients according to risk score calculated by specific model among different datasets:

survplot <- vector("list",2) 
for (i in c(1:2)) {
  print(survplot[[i]]<-rs_sur(res, model_name = "StepCox[forward] + plsRcox",dataset = names(list_train_vali_Data)[i],
                              #color=c("blue","green"),
                              median.line = "hv",
                              cutoff = 0.5,
                              conf.int = T,
                              xlab="Day",pval.coord=c(1000,0.9)))
}
aplot::plot_list(gglist=survplot,ncol=2)

1.2 Calculate AUC scores of each model

all.auc.1y <- cal_AUC_ml_res(res.by.ML.Dev.Prog.Sig = res,train_data = list_train_vali_Data[["Dataset1"]],
                            inputmatrix.list = list_train_vali_Data,mode = 'all',AUC_time = 1,
                            auc_cal_method="KM")
all.auc.3y <- cal_AUC_ml_res(res.by.ML.Dev.Prog.Sig = res,train_data = list_train_vali_Data[["Dataset1"]],
                            inputmatrix.list = list_train_vali_Data,mode = 'all',AUC_time = 3,
                            auc_cal_method="KM")
all.auc.5y <- cal_AUC_ml_res(res.by.ML.Dev.Prog.Sig = res,train_data = list_train_vali_Data[["Dataset1"]],
                            inputmatrix.list = list_train_vali_Data,mode = 'all',AUC_time = 5,
                            auc_cal_method="KM")

cal_AUC_ml_res() also provides three modes, which should be consistent with mode uesd by ML.Dev.Prog.Sig().
AUC_time for 1 year, 2 years, 3 years......, We recommend using the shortest survival time among all datasets.

Here, we only plot 1-year AUC predicted by all models:

auc_dis_all(all.auc.1y,
            dataset = names(list_train_vali_Data),
            validate_set=names(list_train_vali_Data)[-1],
            order= names(list_train_vali_Data),
            width = 0.35,
            year=1)

Plot ROC of specific model among different datasets:

roc_vis(all.auc.1y,
        model_name = "StepCox[forward] + plsRcox",
        dataset = names(list_train_vali_Data),
        order= names(list_train_vali_Data),
        anno_position=c(0.65,0.55),
        year=1)

Plot 1, 3, and 5-year AUC of specific model among different datasets:

auc_dis_select(list(all.auc.1y,all.auc.3y,all.auc.5y),
               model_name="StepCox[forward] + plsRcox",
               dataset = names(list_train_vali_Data),
               order= names(list_train_vali_Data),
               year=c(1,3,5))

1.3 Meta-analysis of univariate cox regression for specific model

unicox.rs.res <- cal_unicox_ml_res(res.by.ML.Dev.Prog.Sig = res,optimal.model = "StepCox[forward] + plsRcox",type ='categorical')
metamodel <- cal_unicox_meta_ml_res(input = unicox.rs.res)
meta_unicox_vis(metamodel,
                dataset = names(list_train_vali_Data))

type includes categorical and continuous. categorical means that the patients are divided into two subgroups based on the median of the risk score. continuous means performing the univariable Cox regression bu using the continuous risk score.

1.4 Comparison with previously pblished models

rs.glioma.lgg.gbm <- cal_RS_pre.prog.sig(use_your_own_collected_sig = F,type.sig = c('LGG','GBM','Glioma'),
                                        list_input_data = list_train_vali_Data)

cal_RS_pre.prog.sig() will calculate the risk score based on the signatures from previous papers.
If use_your_own_collected_sig is set as T, you should provide a data frame containing the information of the signatures. The column names of the data frame are model, PMID, Cancer, Author, Coef and symbol. The model consists of the first name of the first author and PMID of paper. Cancer uses abbreviations like the format of TCGA. Author is the first name of the first author. Coef is the coefficient of each variable. symbol is the gene name. Otherwise, we use our collected models of glioma.

Compare the HR of specific model with previously published models:

HR_com(rs.glioma.lgg.gbm,
       res,
       model_name="StepCox[forward] + plsRcox",
       dataset=names(list_train_vali_Data),
       type = "categorical")

cc.glioma.lgg.gbm <- cal_cindex_pre.prog.sig(use_your_own_collected_sig = F,type.sig = c('Glioma','LGG','GBM'),
                                            list_input_data = list_train_vali_Data)

cal_cindex_pre.prog.sig() will calculate the C-index based on the signatures from previous papers like the fuction cal_RS_pre.prog.sig().

Compare the C-index of specific model with previously published models:

cindex_comp(cc.glioma.lgg.gbm,
            res,
            model_name="StepCox[forward] + plsRcox",
            dataset=names(list_train_vali_Data))

auc.glioma.lgg.gbm.1 <- cal_auc_pre.prog.sig(use_your_own_collected_sig = F,
                                            type.sig = c('Glioma','LGG','GBM'),
                                            list_input_data = list_train_vali_Data,AUC_time = 1,
                                            auc_cal_method = 'KM')

cal_auc_pre.prog.sig() will calculate the AUC based on the signatures from previous papers like the fuction cal_RS_pre.prog.sig().
AUC_time is like the requirement by cal_AUC_ml_res().

Compare the AUC of specific model with previously published models:

auc_comp(auc.glioma.lgg.gbm.1,
         all.auc.1y,
         model_name="StepCox[forward] + plsRcox",
         dataset=names(list_train_vali_Data))

1.5 Immune infiltration analysis

After completing the risk grouping, users can perform downstream analysis on the grouped data. Here, we combine Mime with the R package immunedeconv to assist users in quickly previewing immune infiltration. If users require a more precise immune infiltration analysis, they can fine-tune the parameters themselves.

devo <- TME_deconvolution_all(list_train_vali_Data)

If you want to use this function, you should install package immunedeconv ahead.
TME_deconvolution_all() includes 10 deconvolution methods ("quantiseq", "xcell", "epic", "abis", "mcp_counter", "estimate", "cibersort", "cibersort_abs", "timer", "consensus_tme") from immunedeconv::deconvolution_methods. By default, deconvolution methods are set as ("xcell", "epic", "abis", "estimate", "cibersort", "cibersort_abs").

Show the results:

immuno_heatmap(res,
               devo,
               model_name="StepCox[backward] + plsRcox",
               dataset="Dataset1")

2. Construct predicting models for response

load("./Example.ici.Rdata")
load("./genelist.Rdata")
res.ici <- ML.Dev.Pred.Category.Sig(train_data = list_train_vali_Data$training,
                                      list_train_vali_Data = list_train_vali_Data,
                                      candidate_genes = genelist,
                                      methods = c('nb','svmRadialWeights','rf','kknn','adaboost','LogitBoost','cancerclass'),
                                      seed = 5201314,
                                      cores_for_parallel = 60
)

ML.Dev.Pred.Category.Sig() develop the predictive model for the binary variables with machine learning algorithms.

Plot AUC of different methods among different datasets:

auc_vis_category_all(res.ici,dataset = c("training","validation"),
                     order= c("training","validation"))

Plot ROC of specific method among different datasets:

plot_list<-list()
methods <- c('nb','svmRadialWeights','rf','kknn','adaboost','LogitBoost','cancerclass')
for (i in methods) {
  plot_list[[i]]<-roc_vis_category(res.ici,model_name = i,dataset = c("training","validation"),
                                   order= c("training","validation"),
                                   anno_position=c(0.4,0.25))
}
aplot::plot_list(gglist=plot_list,ncol=3)

Compared AUC with other published models associated with immunotherapy response:

auc.other.pre <- cal_auc_previous_sig(list_train_vali_Data = list_train_vali_Data,seed = 5201314,
                                      train_data = list_train_vali_Data$training,
                                      cores_for_parallel = 32)

cal_auc_previous_sig() will calculate the AUC based on the signatures from previous papers for immunotherapy response.
cores_for_parallel means the cores you can choose for parallel operation. If multi-cores condition is error, please set cores_for_parallel as 1.

Plot comparison results of specific model:

auc_category_comp(res.ici,
                  auc.other.pre,
                  model_name="svmRadialWeights",
                  dataset=names(list_train_vali_Data))

3. Core feature selection

load("./Example.cohort.Rdata")
load("./genelist.Rdata")
res.feature.all <- ML.Corefeature.Prog.Screen(InputMatrix = list_train_vali_Data$Dataset1,
                                            candidate_genes = genelist,
                                            mode = "all",nodesize =5,seed = 5201314 )

ML.Corefeature.Prog.Screen() provides three modes including all, single, and all_without_SVM. all mode means using all eight methods ("RSF", "Enet", "Boruta", "Xgboost", "SVM-REF", "Lasso", "CoxBoost', "StepCox") for selecting. single mode means using only one method for running. If you use single mode, single_ml should be specified among eight methods. Since SVM takes too long time, we define other seven methods used for selecting as all_without_SVM mode.
The output genes are closely associated with patient outcome and higher frequence of screening means more critical.

Upset plot of genes filtered by different methods:

core_feature_select(res.feature.all)

Plot the rank of genes filtered by different methods:

core_feature_rank(res.feature.all, top=20)

Here, we randomly select top two genes to analyze their correlation:

dataset_col<-c("#3182BDFF","#E6550DFF")
corplot <- list()
for (i in c(1:2)) {
  print(corplot[[i]]<-cor_plot(list_train_vali_Data[[i]],
                               dataset=names(list_train_vali_Data)[i],
                               color = dataset_col[i],
                               feature1="PSEN2",
                               feature2="WNT5B",
                               method="pearson"))
}
aplot::plot_list(gglist=corplot,ncol=2)

Plot survival curve of patients according to median expression level of specific gene among different datasets:

survplot <- vector("list",2) 
for (i in c(1:2)) {
  print(survplot[[i]]<-core_feature_sur("PSEN2", 
                                        InputMatrix=list_train_vali_Data[[i]],
                                        dataset = names(list_train_vali_Data)[i],
                                        #color=c("blue","green"),
                                        median.line = "hv",
                                        cutoff = 0.5,
                                        conf.int = T,
                                        xlab="Day",pval.coord=c(1000,0.9)))
}
aplot::plot_list(gglist=survplot,ncol=2)

Citations

If you use Mime in the study, please cite the following publication:

Liu H, Zhang W, Zhang Y, et al. Mime: A flexible machine-learning framework to construct and visualize models for clinical characteristics prediction and feature selection. Comput Struct Biotechnol J. 2024.

Contact

Any technical question please list in Issues section.

BitBoxSwiss/bitbox02-firmware

2024-07-23T01:34:15Z

Firmware code of the BitBox02 hardware wallet

The BitBox02 is a hardware wallet that simplifies secure handling of crypto coins through storing private keys and signing transactions. The content of this repository is the bootloader and firmware used on the device. The BitBox02 is meant to be used primarily with the BitBoxApp, although third party integration is possible through the BitBox02 API.

The main functionality of the firmware is the following:

Safely receive and send coins.
Interacting with the user through touch sliders and a display.
Back up the seed to a microSD card.
Back up the seed by displaying the BIP39 mnemonic encoding on the screen.
Import 12, 18 or 24 word BIP39 mnemonics
Generate a random seed from multiple strong sources of entropy.
Protect the seed from attackers.
Derive keys from the seed according to BIP39 and BIP32.
Return the extended public key for a keypath so that the app can find all unspent transaction outputs.
Display the receive address for the keypath, coin and script/address type.
Display the receive address, transaction amount and network fee and sign each input after confirmation.

Architecture

The main chip on the device is the microcontroller from Microchip (ATSAMD51J20A). This chip is used for communication to the BitBoxApp via USB, to the user via the sliders and to the secure element (ATECC608B) via I2C.

Sliders

The sliders along the edges of the device are used for user input. There are three input gestures:

Tap
Slide
Hold to confirm

USB

The USB communication is implemented using the request-response pattern with encrypted protobuf messages. The encryption protocol used is Noise with out-of-band authentication.

Hardware docs

PCB schematics v2.1

PCB bill of materials (BOM) v2.1

PCB x-ray v2.1

Contributing

The instructions for setting up a development environment can be found in BUILD.md. Please also read our CONTRIBUTING.md before filing issues and pull requests.

Installing/upgrading firmware

There are two main ways to install or upgrade firmware on a BitBox02:

by running the BitBoxApp
by running ./py/load_firmware.py after installing the bitbox02 Python package, e.g. ./py/load_firmware.py firmware-btc.v9.12.0.signed.bin.

Reporting a vulnerability

See our security policy.

barter-rs/barter-rs

2024-07-23T01:34:15Z

Open-source Rust framework for building event-driven live-trading & backtesting systems

Barter Ecosystem

Barter is an open-source ecosystem of Rust libraries for building live-trading and back-testing systems. It is made up of several easy-to-use, extensible crates:

Barter: Framework for building event-driven live-trading and back-testing systems. Algorithmic trade with the peace of mind that comes from knowing your strategies have been back-tested with a near-identical trading engine.
Barter-Data: High-performance WebSocket integration library for streaming public market data from leading cryptocurrency exchanges - batteries included.
Barter-Execution: Feature rich simulated exchange to assist with back-testing and dry-trading. Also provides a normalised trading interface capable of executing across different financial venues.
Barter-Integration: Low-level frameworks for flexible REST/WebSocket integrations.
Barter-Macro: Barter ecosystem macros.

See: Barter, Barter-Data, Barter-Integration, Barter-Execution & Barter-Macro for more comprehensive documentation.

Getting Help

Firstly, see if the answer to your question can be found in the API Documentation. If the answer is not there, I'd be happy to help via Chat and try answer your question via Discord.

Contributing

Thanks in advance for helping to develop the Barter ecosystem! Please do get hesitate to get touch via the Discord Chat to discuss development, new features, and the future roadmap.

Licence

This project is licensed under the MIT license.

Contribution

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in one of the Barter workspace crates by you, shall be licensed as MIT, without any additional terms or conditions.

Disclaimer

This software is for educational purposes only. Do not risk money which you are afraid to lose. USE THE SOFTWARE AT YOUR OWN RISK. THE AUTHORS AND ALL AFFILIATES ASSUME NO RESPONSIBILITY FOR YOUR TRADING RESULTS.

anandslab/docker-traefik

2024-07-23T01:34:31Z

Docker media and home server stack with Docker Compose, Traefik, Swarm Mode, Google OAuth2/Authelia, and LetsEncrypt

Description

This is the updated docker-compose repo of all the media, home, and web server apps described on SmartHomeBeginner.com.

Docker Server Series:

Ubuntu/Debian:

Ultimate Docker Server: Getting Started with OS Preparation [VIDEO] [2024]
Docker Media Server Ubuntu/Debian with 60+ Awesome Apps [2024]
ZeroTier VPN Ubuntu, Docker, Synology, Windows: Secure on-the-go access [coming soon]
Nginx Proxy Manager Docker Compose Guide: Simplest Reverse Proxy [coming soon]
Traefik Reverse Proxy
- Traefik v3: Ultimate Traefik v3 Docker Compose Guide [2024]: LE, SSL, Reverse Proxy [2024]
- Traefik v2: Ultimate Traefik Docker Compose Guide: LE, SSL, Reverse Proxy [2024]
Authelia Docker Compose Guide: Secure 2-Factor Authentication [2024]
Google OAuth Docker Compose Guide: Multi-Factor Authentication [2024]
Docker Security Practices for Homelab: Secrets, Firewall, and more
Cloudflare Settings for Docker Traefik Stacks
Implementing a Backup System for Docker Traefik Stack [coming soon]

Synology:

Ultimate Synology NAS Docker Compose Media Server 2022

Web Server:

WordPress on Docker with Nginx, Traefik, LE SSL, Security, and Speed

Automate the Process:

Auto-Traefik: Dead Simple Traefik Reverse Proxy Automator for Docker [VIDEO]

Support My Work

Documenting, writing guides, and keeping this repo update-to-date takes hundreds of hours of work. Please consider supporting my work to show your appreciation.

Did this Repo help you?

Join our Community

Do you need support or just want to chat with like-minded people. Join our discord.
The authors will try our best to help but support is not guaranteed. But you will find others who might have went through what you are going through and may be willing to pay it forward and help.

Supporting Guides

Security:

For security, I implemented CrowdSec multi-server setup in 2022. From the stats, it is blocking/mitigating well over 600 intrusion attempts per day on my servers. I will cover this in a separate guide later but you will find the docker-compose CrowdSec, Traefik Bouncer, and Cloudflare Bouncer Bouncers in my repo already.

Others:

Understanding This Repository

My Setup

I have 5 docker hosts. I sync all my Docker stacks using Syncthing and push the files to GitHub so I can share with the community.

docker-compose-hs.yml: Docker Compose for Home Server on Ubuntu Server Proxmox LXC Container.
docker-compose-mds.yml: Docker Compose for Media/Database Server on Ubuntu Server Proxmox LXC Container.
docker-compose-dns.yml: Docker Compose for AdBlock/ DNS Server on Raspberry Pi 4B.
docker-compose-ws.yml: Docker Compose for Web Server on Digital Ocean VPS, which powers this website.
docker-compose-ds918.yml: Docker Compose for Synology DS918+ NAS.

Syncing also allows me to have a backup of one system's configuration file in all the other hosts. For this reason, where applicable, I segregate or name files/folders with their hostname (for example: hs for Home Server).

Almost any app/service from the docker-compose files listed above can be copy-pasted to any other compose file in this repo.

What apps are included in this stack?

The apps I use are scattered around in several different docker-compose files. Click the links below for specific installation guides.

Some apps are used in more than one host and some on only one.

This is not an exhaustive list

FRONTENDS

Traefik - Reverse Proxy
Nginx Proxy Manager - Reverse Proxy
Docker Socket Proxy - Secure Proxy for Docker API
OAuth - Google OAuth 2 Forward Authentication
Authelia - Private Forward Authentication
Portainer - Container Management
Organizr - Dashboard for Apps
Heimdall - Dashboard for Apps
Homepage - Dashboard for Apps
Dashy - Dashboard for Apps
Autoindex - Plain text Index to All Files

SMART HOME

Home Assistant Core - Home Automation
HA-Dockermon - Manage Docker containers in Home Assistant
Mosquitto - MQTT Broker
MotionEye - Video Surveillance
Frigate - Video Surveillance
ZoneMinder - Video Surveillance
MiFlora - MiFlora MQTT Daemon (MiFlora Plant Sensors)

DATABASE

MariaDB - MySQL Database
phpMyAdmin - Database management
InfluxDB - Database for sensor data
Postgres - Database
Grafana - Graphical data visualization for InfluxDB data
Varken - Monitor Plex, Sonarr, Radarr, and Other Data
Redis - Key value store
Redis Commander - Redis management

DOWNLOADERS

jDownloader - Download management
TransmissionBT with VPN - Torrent Downloader.
SABnzbd - Binary newsgrabber, NZB downloader
Nzbget - Binary newsgrabber, NZB downloader
qBittorrent with Wireguard VPN from Surfshark - Torrent downloader

INDEXERS

NZBHydra2 - NZB meta search
Jackett - Torrent proxy
Prowlarr - Torrent proxy

PVRS

Lidarr - Music Management
Radarr - Movie management
Sonarr - TV Shows management
LazyLibrarian - Books Management
Readarr - Books Management

MEDIA SERVER

AirSonic Advanced - Music Server
NaviDrome - Music Server
FunkWhale - Music Server
Calibre - Ebook/Audiobook Server
Calibre-Web - Ebook/Audiobook Reader
Plex - Media Server
Emby - Media Server
Jellyfin - Media Server
Ombi - Media Requests
Tautulli - Previously PlexPy. Plex statistics and monitoring
Plex-Sync - For Syncing watched status between plex servers
PhotoShow - Personal Photo Gallery and viewer
TellyTv- IPTV proxy for Plex
xTeve- IPTV proxy for Plex

MEDIA FILE MANAGEMENT

Bazarr - Subtitle Management
Picard - Music Library Tagging and Management
Handbrake - Video Conversion, Transcoding, and Compression
MKVToolNix - Video Editing, Remuxing (changing media container while keeping original source quality)
MakeMKV - Video Editing (Ripping from Disks)
FileBot - File renamer
Tiny Media Manager - Media Files Management

UTILITIES

Firefox - Web Broswerstack
Glances - System Information
APCUPSD - APC UPS Management
Guacamole - Remote desktop, SSH, on Telnet on any HTML5 Browser
Guacamole Daemon - Needed for Guacamole
Dozzle - Docker logs viewer
qDirStat - Directory Statistics
StatPing - Status Page & Monitoring Server
SmokePing - Network Latency Monitoring
VS Code Server - Code Editor
Logarr - Log Management
Monitorr - Webfront to display the status of any webapp or service
Cloud Commander - Web File Manager
Cloud9 - Cloud IDE
SMTP To Telegram - Sends all incoming Email messages to Telegram
UniFi Controller - Controller for Ubiquiti UniFi Network Gear
Rclone - Mount Cloud/Google Drive
MergerFS - Merge local and remote file systems
Gluetun - VPN client for docker containers and more
DeUnhealth - Auto restart containers on VPN restart
AdGuard Home - DNS Sinkhole / Ad-blocker

WEB

Nginx - Web Server
php7 - PHP-FPM

MAINTENANCE

Watchtower - Automatic Docker Container Updates
Docker-GC - Automatic Docker Garbage Collection
Traefik Certificate Dumper - Extract Traefik SSL Certs
Cloudflare DDNS - Dynamic IP Updater
Cloudflare Companion - Automatic CNAME creation for services
WhoAmI - For testing.

Bash Aliases

I use bash_aliases to simplify starting and stopping containers/stack. Included in the repo is an example of bash_aliases I use (replace USER with your Linux username).

Download it to a known location (e.g. /home/user/docker/shared/config/). Then add the following code block to .bashrc file in the user's home folder.

if [ -f "$HOME/docker/shared/config/bash_aliases" ]; then
    . $HOME/docker/shared/config/bash_aliases
fi

Here are some example alias commands:

dcup - Start Docker Traefik 2 stack
dcdown - Stop Docker Traefik 2 stack
dcrec - Start or recreate a specific service or the full stack
dcstop - Stop a specific service or the full stack
dcrestart - Restart a specific service or the full stack
dclogs - See real-time logs for the corresponding stack or service
dcpull - Pull new images for the corresponding stack or service

calimarkus/JDStatusBarNotification

2024-07-23T01:34:55Z

Highly customizable & feature rich notifications. Interactive dismiss. Custom Views. SwiftUI. Tap-to-hold. Progress. Written in Swift, compatible for ObjC!

JDStatusBarNotification

Highly customizable & feature rich notifications displayed below the status bar / the notch.

Customizable colors, fonts & animations with multiple built-in styles
Interactive & interuptable Drag-to-Dismiss
Adaptive, dynamic layout
- Built-in pill-style or full-width layouts
- Pill width matches the presented text (customizable)
- Works on notch and no-notch devices
- Works in landscape & portrait
Built-in features (automatic layout):
- Title, subtitle and left-hand-views (e.g. Icons)
- An activity indicator
- A progress bar
- Custom views (UIView or SwiftUI View)

Written in Swift, compatible for Obj-C!

Please open a Github issue, if you think anything is missing or wrong.

Here's some examples of the possibilities (the pill style is the default):

Full-Width styles in action (the pill styles support the same features / animations):

Drag to dismiss	Activity & Progress Bars	Custom styles

Landscape apps (device rotation also supported)

Installation

SPM (Swift Package Manager):
- Xcode -> File -> Add packages: git@github.com:calimarkus/JDStatusBarNotification.git
- Importing:
  - In Swift: import JDStatusBarNotification
  - In ObjC: @import JDStatusBarNotification;
CocoaPods:
- pod 'JDStatusBarNotification'
Carthage:
- github "calimarkus/JDStatusBarNotification"
Manually:
- Copy the JDStatusBarNotification/JDStatusBarNotification folder into your project.

Documentation

Find the class documentation hosted on Github.

Changelog

See CHANGELOG.md

Getting started

NotificationPresenter is a singleton. You don't need to initialize it anywhere. All examples here are written in Swift. But everything can be called from Objective-C too.

Also checkout the example project, which has many examples and includes a convenient style editor.

Here's some usage examples:

Showing a text notification

NotificationPresenter.shared.present("Hello World")

// with completion
NotificationPresenter.shared.present("Hello World") { presenter in
   // ...
}

Showing a SwiftUI based notification

NotificationPresenter.shared.presentSwiftView {
    Text("Hi from Swift!")
}

// with completion
NotificationPresenter.shared.presentSwiftView {
    Text("Hi from Swift!")
} completion: { presenter in
   // ...
}

Dismissing a notification

NotificationPresenter.shared.dismiss()

// with completion
NotificationPresenter.shared.dismiss(after: 0.5) { presenter in
   // ...
}

Showing activity

NotificationPresenter.shared.present("")
NotificationPresenter.shared.displayActivityIndicator(true)

Showing a custom left view

let image = UIImageView(image: UIImage(systemName: "gamecontroller.fill"))
NotificationPresenter.shared.present("Player II", subtitle: "Connected")
NotificationPresenter.shared.displayLeftView(image)

Showing progress

NotificationPresenter.shared.present("Animating Progress…") { presenter in
  presenter.animateProgressBar(to: 1.0, duration: 0.75) { presenter in
    presenter.dismiss()
  }
}

// or set an explicit percentage manually (without animation)
NotificationPresenter.shared.displayProgressBar(at: 0.0)

Using other included styles

There's a few included styles you can easily use with the following API:

NotificationPresenter.shared.present("Yay, it works!",
                                     includedStyle: .success)

Using a custom UIView

If you want full control over the notification content and styling, you can use your own custom UIView.

// present a custom view
let button = UIButton(type: .system, primaryAction: UIAction { _ in
  NotificationPresenter.shared.dismiss()
})
button.setTitle("Dismiss!", for: .normal)
NotificationPresenter.shared.presentCustomView(button)

Light Mode	Dark Mode

Customization

You have the option to easily create & use fully customized styles.

The PrepareStyleClosure provides a copy of the default style, which can then be modified. See the StatusBarNotificationStyle API for all options.

// update default style
NotificationPresenter.shared.updateDefaultStyle { style in
   style.backgroundStyle.backgroundColor = .red
   style.textStyle.textColor = .white
   style.textStyle.font = UIFont.preferredFont(forTextStyle: .title3)
   // and many more options
   return style
}

// set a named custom style
NotificationPresenter.shared.addStyle(named: "xxx") { style in
   // ...
   return style
}

Style Editor

Or checkout the example project, which contains a full style editor. You can tweak all customization options within the app, see the changes live and even export the configuration code for the newly created style to easily use it in your app.

Background Styles

There's two supported background styles:

/// The background is a floating pill around the text. The pill size and appearance can be customized. This is the default.
StatusBarNotificationBackgroundType.pill
/// The background covers the full display width and the full status bar + navbar height.
StatusBarNotificationBackgroundType.fullWidth

Animation Types

The supported animation types:

/// Slide in from the top of the screen and slide back out to the top. This is the default.
StatusBarNotificationAnimationType.move,
/// Fade-in and fade-out in place. No movement animation.
StatusBarNotificationAnimationType.fade,
/// Fall down from the top and bounce a little bit, before coming to a rest. Slides back out to the top.
StatusBarNotificationAnimationType.bounce,

Troubleshooting

No notifications are showing up

If your app uses a UIWindowScene the NotificationPresenter needs to know about it before you present any notifications. The library attempts to find the correct WindowScene automatically, but that might fail. If it fails no notifications will show up at all. You can explicitly set the window scene to resolve this:

NotificationPresenter.shared().setWindowScene(windowScene)

Twitter

I'm @calimarkus on Twitter. Feel free to post a tweet, if you like JDStatusBarNotification.

Credits

Originally based on KGStatusBar by Kevin Gibbon

rothgar/awesome-tuis

2024-07-23T01:28:40Z

List of projects that provide terminal user interfaces

elementary/wingpanel-indicator-network

2024-07-23T01:35:19Z

Wingpanel Network Indicator

GitHub 1C Enterprise Daily Trending

ComposioHQ/composio

Production Ready Toolset for AI Agents

Equip your agent with high-quality tools & integrations without worrying about authentication, accuracy, and reliability in a single line of code!

📋 Table of contents

🤔 Why Composio?

🔥 Key Features

🚀 Getting Started with Python

1. Installation

2. Testing Composio in Action

🚀 Getting Started with Javascript

1. Install the Composio SDK:

2. Setup the OpenAI and Composio Tool Set:

3. Run your script:

💡 Examples

Competitor Researcher

Todolist to Calendar

Github to Trellox

Star History

📋 Read Our Code Of Conduct

🤗 Contributions

🔗 Links

🛡️ License

💪 Thanks To All Contributors

openstatusHQ/openstatus

✨️ Overview

Captcha Solver

☕ Buy me coffee

📕 background

💡 Concept

☀️ Features and Highlights

🎇 Powerful self-developed core

🎇 Highlighted features

🖐🏻 Disclaimer

ZuodaoTech/everyone-can-use-english

AI 是当今世界上最好的外语老师，Enjoy 做 AI 最好的助教。

安装及使用

预览

开发

相关阅读

一千小时（2024）

人人都能用英语（2010）

tony9402/baekjoon

코딩테스트 대비 문제집 with Baekjoon

코딩테스트 문제집

집단지성 프로젝트

백준 코딩테스트 문제집

최근 기업 코딩테스트 알고리즘 분류 정리

각 알고리즘 문제집

❈ 중요❗️❗️ ❈

모의 문제집

Contributors

업데이트 로그

TODO

microsoft/ebpf-for-windows

eBPF for Windows

New to eBPF?

Architectural Overview

Getting Started

Frequently Asked Questions

1. Is this a fork of eBPF?

2. Does this provide app compatibility with eBPF programs written for Linux?

3. Will eBPF work with HyperVisor-enforced Code Integrity (HVCI)?

viti95/FastDoom

FastDOOM

FastDOOM vs Original

DEMO

Build instructions (FastDOOM)

Build instructions (FDSETUP)

Contributors

Star History

Contributing

Aikoyori/ProgrammingVTuberLogos

See: Official Demo | Read: Official Docs Page

Understrap WordPress Theme Framework

About

Documentation

Questions

Changelog

Basic Features