GitHub 1C Enterprise Daily Trending

usebruno/bruno

2023-10-04T01:24:45Z

Efficient Streaming Language Models with Attention Sinks

Efficient Streaming Language Models with Attention Sinks [paper]

https://github.com/mit-han-lab/streaming-llm/assets/40906949/2bd1cda4-a0bd-47d1-a023-fbf7779b8358

TL;DR

We deploy LLMs for infinite-length inputs without sacrificing efficiency and performance.

Abstract

Deploying Large Language Models (LLMs) in streaming applications such as multi-round dialogue, where long interactions are expected, is urgently needed but poses two major challenges. Firstly, during the decoding stage, caching previous tokens' Key and Value states (KV) consumes extensive memory. Secondly, popular LLMs cannot generalize to longer texts than the training sequence length. Window attention, where only the most recent KVs are cached, is a natural approach --- but we show that it fails when the text length surpasses the cache size. We observe an interesting phenomenon, namely attention sink, that keeping the KV of initial tokens will largely recover the performance of window attention. In this paper, we first demonstrate that the emergence of attention sink is due to the strong attention scores towards initial tokens as a ``sink'' even if they are not semantically important. Based on the above analysis, we introduce StreamingLLM, an efficient framework that enables LLMs trained with a finite length attention window to generalize to infinite sequence length without any fine-tuning. We show that StreamingLLM can enable Llama-2, MPT, Falcon, and Pythia to perform stable and efficient language modeling with up to 4 million tokens and more. In addition, we discover that adding a placeholder token as a dedicated attention sink during pre-training can further improve streaming deployment. In streaming settings, StreamingLLM outperforms the sliding window recomputation baseline by up to 22.2x speedup.

Usage

Environment Setup

conda create -yn streaming python=3.8
conda activate streaming

pip install torch torchvision torchaudio
pip install transformers==4.33.0 accelerate datasets evaluate wandb scikit-learn scipy sentencepiece

python setup.py develop

Run Streaming Llama Chatbot

CUDA_VISIBLE_DEVICES=0 python examples/run_streaming_llama.py  --enable_streaming

FAQ

What does "working on infinite-length inputs" imply for LLMs?

Handling infinite-length text with LLMs presents challenges. Notably, storing all previous Key and Value (KV) states demands significant memory, and models might struggle to generate text beyond their training sequence length. StreamingLLM addresses this by retaining only the most recent tokens and attention sinks, discarding intermediate tokens. This enables the model to generate coherent text from recent tokens without a cache reset — a capability not seen in earlier methods.
Is the context window of LLMs expanded?

No. The context window remains unchanged. Only the most recent tokens and attention sinks are retained, discarding middle tokens. This means the model can only process the latest tokens. The context window remains constrained by its initial pre-training. For instance, if Llama-2 is pre-trained with a context window of 4096 tokens, then the maximum cache size for StreamingLLM on Llama-2 remains 4096.
Can I input an extensive text, like a book, into StreamingLLM for summarization?

While you can input a lengthy text, the model will only recognize the latest tokens. Thus, if a book is an input, StreamingLLM might only summarize the concluding paragraphs, which might not be very insightful. As emphasized earlier, we neither expand the LLMs' context window nor enhance their long-term memory. StreamingLLM's strength lies in generating fluent text from recent tokens without needing a cache refresh.
What is the ideal use case for StreamingLLM?

StreamingLLM is optimized for streaming applications, such as multi-round dialogues. It's ideal for scenarios where a model needs to operate continually without requiring extensive memory or dependency on past data. An example is a daily assistant based on LLMs. StreamingLLM would let the model function continuously, basing its responses on recent conversations without needing to refresh its cache. Earlier methods would either need a cache reset when the conversation length exceeded the training length (losing recent context) or recompute KV states from recent text history, which can be time-consuming.
How does StreamingLLM relate to recent works on context extension?

StreamingLLM is orthogonal to recent context extension methods and can be integrated with them. In StreamingLLM's context, "context extension" refers to the possibility of using a larger cache size to store more recent tokens. For a practical demonstration, refer to Figure 9 in our paper, where we implement StreamingLLM with models like LongChat-7B-v1.5-32K and Llama-2-7B-32K-Instruct.

TODOs

We will release the code and data in the following order, please stay tuned!

Release core code of StreamingLLM, including Llama-2, MPT, Falcon, and Pythia.
Release perplexity evaluation code
Release Streaming Llama Chatbot demo.
Release StreamEval dataset and evaluation code.

Citation

If you find StreamingLLM useful or relevant to your project and research, please kindly cite our paper:

@article{xiao2023streamingllm,
        title={Efficient Streaming Language Models with Attention Sinks},
        author={Xiao, Guangxuan and Tian, Yuandong and Chen, Beidi and Han, Song and Lewis, Mike},
        journal={arXiv},
        year={2023}
        }

phitronio/Batch-4-Introduction-to-C-Programming

2023-10-04T01:24:45Z

localpilot

Use GitHub Copilot locally on your Macbook with one-click!

Demo Video

https://github.com/danielgross/localpilot/assets/279531/3259981b-39f7-4bfa-8a45-84bde6d4ba4c

This video is not sped up or slowed down.

Installation

First, open VS Code Settings and add the following to your settings.json file:

"github.copilot.advanced": {
    "debug.testOverrideProxyUrl": "http://localhost:5001",
    "debug.overrideProxyUrl": "http://localhost:5001"
}

Create a virtualenv to run this Python process, install the requirements, and download the models.

virtualenv venv
source venv/bin/activate
pip install -r requirements.txt
# First setup run. This will download several models to your ~/models folder.
python app.py --setup

Run it!

python app.py

Enjoy your on-device Copilot!

Caveat FAQ

Is the code as good as GitHub Copilot?

For simple line completions yes. For simple function completions, mostly. For complex functions... maybe.

Is it as fast as GitHub Copilot?

On my Macbook Pro with an Apple M2 Max, the 7b models are roughly as fast. The 34b models are not. Please consider this repo a demonstration of a very inefficient implementation. I'm sure we can make it faster; please do submit a pull request if you'd like to help. For example, I think we need debouncer because sometimes llama.cpp/GGML isn't fast at interrupting itself when a newer request comes in.

Can this be packaged as a simple Mac app?

Yes!, I'm sure it can be, I just haven't had the time. Please do submit a pull request if you're into that sort of thing!

Should there be a meta-model that routes to a 1b for autocomplete, 7b for more complex autocomplete, and a 34b for program completion?

Hmm, that seems like an interesting idea.

OK, but in summary, is it good?

Only if your network is bad. I don't think it's competitive if you have fast Internet. But it sure is awesome on airplanes and while tethering!

TheAlgorithms/Java

2023-10-04T01:24:45Z

Hacktoberfest 2023 OPEN FIRST Pull Request - FREE T-SHIRT🎉

HacktoberFest 2023 `OPEN FIRST` Pull Request 🎉

Contributors of `Hacktoberfest 2023`

This Project Is Perfect For Your First Pull Request

🗣 Hacktoberfest encourages participation in the open source community, which grows bigger every year.

📢 Register here for Hacktoberfest and make four pull requests (PRs) between October 1st-31st to grab free DIGITAL-SWAGS 🔥.

INSTRUCTIONS-

Fork this Repository using the button at the top on right corner.
Clone your forked repository to your pc ( git clone "url from clone option.)
Create a new branch for your modifications (ie. git branch new-user and check it out git checkout new-user or simply do git checkout -b new-user)
Add your profile image in static/images/ ( use drag and drop option or upload by commands.)
Add your profile data in content/participant/
Add your files (git add -A), commit (git commit -m "added myself") and push (git push origin new-user)
Create a pull request
Star this repository

How To Make Your First Pull Request

Replace <YOUR-USERNAME> with your GitHub username in this guide.

1. Add your profile picture to the folder

Add a picture picture of your choice in static/images/. Accepted files are png and jpg, should be squared and minimum size 544x544 pixels. Ex.

static/images/<YOUR-USERNAME>.png

2. Add your profile information

Create a markdown file in your folder following the convention content/participant/<YOUR-USERNAME>.md. Ex.

content/participant/<YOUR-USERNAME>.md

Copy the next template into your file, delete the boilerplate data and fill the information with yours.

---
name: YOURNAME
institution/company: INSTITUTION_NAME
github:USERNAME
---

OR

3. Create / Upload Your Code / Algorithms

Create/Upload your code in folder following the convention Add Code Here

Choose an exact lanaguage folder and drop your code
Below is an example to add file properly
You can follow up any languages

Add Code Here/PYTHON/<YOUR-FILERNAME>.py

Add Code Here/C++/<YOUR-FILERNAME>.cpp

You can follow any pathway a code or profile information

4. Wait for Pull Request to merge

5. Celebrate - you've done your first pull request!!

'''
Always make more then 4 pull requests.
Lets say you have made only 4 pull request to different projects,
but one project is excluded from hackoctoberfest event then your pull request will not be counted and 
then you have remaining 3 valid pull requests if these projects is not excluded.
If you fail to make 4 pull requests then you can't get digital-swags.
I will recommend you to make pull request to your own repo which is very very safest side for you..
keep in mind that repo has hacktoberfest topic..
'''

+ Follow Me : } Quick Approval of Pull Request

'''
To get approval of the pull request much quicker and faster (`Follow Me`)🚀
'''

_{Ossama Mehmood}

luamfb/intro_x86-64

2023-10-05T01:24:56Z

Introduction to x86-64 assembly

botamochi/avr-multi-task-test

2023-10-05T01:24:56Z

Lissy93/git-into-open-source

2023-10-04T01:25:31Z

🫶 Everything you need to get started with open source. 🎃 Hacktoberfest contributions accepted here!

acalcutt/Vistumbler

2023-10-05T01:25:07Z

A wireless network scanner written in AutoIT for Windows 10, 8, 7, and vista. VistumblerMDB is the current version of Vistumbler.

taku-nm/auto-cli

2023-10-04T01:25:48Z

a simple script to automate the usage of revanced cli

dotnet/intro-to-dotnet-web-dev

2023-10-04T01:26:20Z

Get Started as a Web Developer with .NET, C#, and ASP.NET Core

Intro to Web Development with .NET

Welcome to the Intro to Web Development with .NET GitHub repository! We’re excited to take you along with us as we build awesome projects and learn all about the wonderful world of web development.

Here, you'll find a 6-part series of lessons and projects to get you started building web applications with .NET!

Note The content in this repo is part of a free, 6-part e-mail series that will teach you something new every week. The e-mails include introductions to the content in these lessons. If you came here directly and haven't signed up for the e-mails, you can do that here: https://aka.ms/WebLearningSeries/signup

Video Introduction

🎥 Click the image above for a video about the series!

How-to

To use this curriculum on your own, fork the entire repo and go into the numbered folders to access the lessons and projects. This series is designed to take 6 weeks, about 1 week per lesson, but feel free to complete it at your own pace.

Codespace

You can also complete the lesson from your browser using GitHub Codespaces. To open a Codespace, simply select the green Code button. Then click the + to create a Codespace on the main branch.

Lessons

	Lesson Name	Learning Objectives	Linked Lesson
01	Welcome	Introduction to C#, .NET, and web development with .NET	Welcome to the Intro to Web Dev with .NET series
02	C#	A quick runthrough of C# attributes, syntax, and OOP	C# Crash Course
03	Razor Pages	Learn about ASP.NET Core, Razor Pages, and build a pizza website 🍕	Build a Pizza Website with Razor Pages
04	Minimal APIs	Build a Minimal API backend for your pizza website	Build an HTTP backend with Minimal APIs
05	Blazor	Learn Blazor and build an interactive Connect Four game	Introducing Blazor Web Applications
06	Publish to Azure	Learn how to publish your project to the cloud☁️	Publish your Web App to Azure

Open in Codespaces

You can open this repo in GitHub Codespaces without installing anything on your computer.

Help Resources

There's a few places you can go for help and more information on the topics covered in this repository.

Documentation

Beginner Video Series

How to leave feedback

To leave us feedback on this learning series, please fill out our survey or file an issue in this repository.

Learn More & Connect with us

Start a .NET Learning Path

Find a .NET user group & join a .NET events at our Community Page.

.NET Foundation

.NET Interactive Notebooks for C# is a .NET Foundation project.

There are many .NET related projects on GitHub.

.NET home repo - links to 100s of .NET projects, from Microsoft and the community.
ASP.NET Core home - the best place to start learning about ASP.NET Core.

This project has adopted the code of conduct defined by the Contributor Covenant to clarify expected behavior in our community. For more information, see the .NET Foundation Code of Conduct.

Sergio0694/ComputeSharp

2023-10-04T01:26:20Z

A .NET library to run C# code in parallel on the GPU through DX12, D2D1, and dynamically generated HLSL compute and pixel shaders, with the goal of making GPU computing easy to use for all .NET developers! 🚀

What is it? 🚀

ComputeSharp is a .NET library to run C# code in parallel on the GPU through DX12, D2D1, and dynamically generated HLSL compute and pixel shaders. The available APIs let you access GPU devices, allocate GPU buffers and textures, move data between them and the RAM, write compute shaders entirely in C# and have them run on the GPU. The goal of this project is to make GPU computing easy to use for all .NET developers!

What can it actually do? ✨

Since a video is worth a thousand words, here's a showcase of some pixel shaders (originally from shadertoy.com), ported from GLSL to C# and running with ComputeSharp in a WinUI 3 sample app. You can use this library to create all sorts of things from scientific simulations, to animated backgrounds, audio visualizers and more!

https://user-images.githubusercontent.com/10199417/126792509-c11feb11-a609-4fab-86b3-426d43df6d90.mp4

Where is it being used? ✈️

ComputeSharp is production ready, and it's being used by several projects running on millions of devices!

Here's a showcase of some of them:

Screenshot	Project
	The Microsoft Store is a first party application that ships with Windows and allows users to discover, search and download digital content such as apps, games, movies and more. Starting from the January 2023 release, it is using ComputeSharp.D2D1.Uwp to leverage custom effects and pixel shaders to power several graphics elements in the application, such as the new app cards.
	Paint.NET is an image and photo editing application for Windows. Starting from its 5.0 release, it is using ComputeSharp.D2D1 as a core component of its architecture (in fact, ComputeSharp.D2D1 was initially developed specifically to support Paint.NET!). The library is used both internally to accelerate dozens of built-in effects using custom D2D1 pixel shaders, as well as for external plugins.

Screenshot

Project

The Microsoft Store is a first party application that ships with Windows and allows users to discover, search and download digital content such as apps, games, movies and more. Starting from the January 2023 release, it is using ComputeSharp.D2D1.Uwp to leverage custom effects and pixel shaders to power several graphics elements in the application, such as the new app cards.

Paint.NET is an image and photo editing application for Windows. Starting from its 5.0 release, it is using ComputeSharp.D2D1 as a core component of its architecture (in fact, ComputeSharp.D2D1 was initially developed specifically to support Paint.NET!). The library is used both internally to accelerate dozens of built-in effects using custom D2D1 pixel shaders, as well as for external plugins.

Try out the sample app! 💻

The sample app is available in the Microsoft Store, showcasing several pixel shaders all powered by ComputeSharp!

Available packages 📦

Name	Description
ComputeSharp	The main library, with compiled shaders support
ComputeSharp.Dynamic	An extension for ComputeSharp, enabling dynamic shader compilation at runtime and shader metaprogramming
ComputeSharp.D3D12MemoryAllocator	An extension for ComputeSharp, adding D3D12MA as the memory allocator for graphics resources.
ComputeSharp.Pix	An extension library for ComputeSharp, enabling PIX support to produce debugging information
ComputeSharp.Uwp	A UWP library (targeting .NET Standard 2.0) with controls to render DX12 shaders powered by ComputeSharp
ComputeSharp.WinUI	A WinUI 3 library (targeting .NET 6) with controls to render DX12 shaders powered by ComputeSharp
ComputeSharp.D2D1	A library to write D2D1 pixel shaders entirely with C# code, and to easily register and create ID2D1Effect-s from them

Preview builds are available at https://pkgs.computesharp.dev/index.json (as well as GitHub Packages).

Documentation 📖

All the documentation for ComputeSharp is available in the wiki pages. That includes a recap of everything in this readme, as well as info and detailed samples on all features and APIs from the available packages. Make sure to go through it to get familiar with this library!

Sponsors 🎁

Huge thanks to these sponsors for directly supporting my work on ComputeSharp, it means a lot! 🙌

Special thanks

ComputeSharp was originally based on some of the code from the DX12GameEngine project by Amin Delavar.

Additionally, ComputeSharp uses NuGet packages from the following repositories:

win-acme/win-acme

2023-10-05T01:25:51Z

A simple ACME client for Windows (for use with Let's Encrypt et al.)

Windows ACME Simple (WACS)

A simple ACME client for Windows - for use with Let's Encrypt. (Formerly known as letsencrypt-win-simple (LEWS))

Overview

Please check our website for an up-to-date overview, documentation and downloads.

Community support

If you run into trouble you can open an issue. First please check to see if your issue is covered in the manual or reference. If you can't find a solition that way, describe the exact steps that you are taking and try to provide as much relevant information as possible, preferably including logging.

Professional support / sponsorship

Is your business relying on this program to secure customer websites and perhaps even critical infrastructure? Then maybe it would be good for your peace of mind then to sponsor one of its core developers, to gain guaranteed future support and good karma at the same time. I offer my help quickly, discreetly and professionally via Patreon.

Donations

Do you like the program and want to buy me a beer and discuss the future of the program in private? My Patreon also has some simple "Thank you" tiers, or if you prefer to do a one-time donation you can use Paypal.

ShahjalalShohag/code-library

2023-10-04T01:26:34Z

You can upload programming ques and projects here for Hacktoberfest 2023

hacktoberfest-2023

You can checkout https://hacktoberfest.com for all info on hacktoberfest 2023.

Star and fork this repository to start contributing !!

Make your first PR! Add your profile, a blog, or any program under any language (hello-world program to anything) or update the existing one. Just make sure to add the file under the correct directory. Happy Coding!

Mandatory Step :

You have to star ⭐ this repository
Follow github if you find this project interesting😁!(optional)

Steps to Contribute

Fork the repo(You can see fork option at top right of this repo

Clone your forked repository using terminal

git clone https://github.com/<YOUR USER NAME>/hacktoberfest.git

Make changes like adding files in your clonned repo
Add the changes
```
git add .
```
Commit the changes
```
 git commit -m "<any commit name>"
```
Push to repository
```
git push -u origin main
```
Create Pull Request

At this point, you are ready to make a pull request to the original repository.

Navigate to your forked repository, and press the “New pull request” button on your left-hand side of your Repo page.

Avoid Conflicts {Syncing your fork}

An easy way to avoid conflicts is to add an 'upstream' for your git repo, as other PR's may be merged while you're working on your branch/fork.

git remote add upstream https://github.com/prashant0664/hacktoberfest

You can verify that the new remote has been added by typing

git remote -v

To pull any new changes from your parent repo simply run

git merge upstream/main

Note:

Don't Create Pull Request to update "readme.md" File.
Upload or Create File in Specified Language Folder.
If Specified Language Folder not Found then Create Folder and then Upload or Create File.
Please mention the extention of files while creating them (e.g if file is of java language create file named "xyz.java").

Our Contributors of `hacktoberfest`

Saikat2407/DSA_Hacktoberfest2023

2023-10-04T01:26:34Z

This Repo will Accept all the quality Hacktoberfest 2023 Contribution ⚡️✅🎉

Hacktober Fest 2023⚡️✨

All Contributors are requested to star this repo and follow me for a successful merge of pull request.🙂

👉 Add any project, algorithm or leetcode solution in any programming language..
-🚀 C
-🚀 C++
-🚀 C#
-🚀 PHP
-🚀 Java
-🚀 Python
-🚀 Javascript

In each respective folder on any topic, don't forget to read the rules below to get your pull request accepted.

👷‍♂️ Contribute anything to this repo and earn rewards!

⚙️ Visit The Hacktoberfest website for more information Hacktoberfest 2023

🛠 Welcome to Hacktobefest 2023 Event

How To Contribute

⌛️ In order to do successful contribution you must read the rules at the bottom; all pull requests will be accepted by those who correctly submitted their PR.

Star the repository

⌛️ Patience is key! If the pull request is not merged, tell me in the comment section!

Getting started

Fork this repository (Click the Fork button in the top right of this page, click your Profile Image)
Clone your fork down to your local machine

git clone https://github.com/your-username/DSA_Hacktoberfest2023.git

Create a branch

git checkout -b branch-name

Make your changes (choose from any task below)
Commit and push

git add .
git commit -m 'Commit message'
git push origin branch-name

Create a new pull request from your forked repository (Click the New Pull Request button located at the top of your repo)
Wait for your PR review and merge approval!
Star this repository

🛡 Rules

⚔️ Add link of the problem as comments in the code if contributing solution of any problems from Leetcode, GeekForGeeks, Codechef or Codeforces, etc. No need to add entire main function.
⚔️ Dont forget to star this repository and follow me for successful merge.
⚔️ Add the proper extension to your code file. Examples: .c, .js, .cpp , .py or .java.
⚔️ Give your file a proper name related to your program in snake_case.
⚔️ Put your files in correct folder like .cpp file in c++ folder or .py file in python folder.
⚔️ If folder is not present for your language create new with name of your programming language like C++ , Python etc
⚔️ Make repo well maintained if topic not present in which you want to contribute create new folder for it in their paricular section or language

🛡 Notice

⚔️ All contributors who have followed above rules correctly will meet merge pull request successfully.

⚔️ For any further issues, you can contact me in the comments

⚔️ Always make more than 4 total pull requests for hacktoberfest for safer side.

🖥️ Happy Coding 🔥 Happy Hacking...

DavidGQK/mython_interpreter

2023-10-05T01:26:07Z

Mython

Mython - Python-like interpreter. Language is dynamically typed, supports classes and inheritance.

How it works

Prepare code file with extension *.my

Start terminal in folder which contains Mython.exe

Enter following command Mython <you_file_with_code.my> <output_filename.txt>

Syntax

Examples of all available features you can find in test_it/test.my

Compilation and Installation

For compilation you need to have Cmake

Create folder for compilation e.g. mython_cmake

Copy whole github repository to that folder and rename it e.g. mython

Create another folder build in mython_cmake and go there

Start terminal in build folder

For compilation enter cmake ../mython

To turn tests off, add following key "-DTESTING=OFF" to the previous command

Enter following command for building cmake --build . --verbose

Enter ctest for launching tests if you want

After building completed go to Debug folder where you can find Mython.exe

phitronio/Batch-4-Introduction-to-C-Programming

2023-10-04T01:26:13Z

Warning > P1P/S 01.04.00.00 LAN Mode Bug

Introduction

The xtouch screen is a revolutionary addition to your BambuLab Printer, enhancing the user experience and providing advanced control and monitoring capabilities. This detailed README.md guide will walk you through the product's features, installation process, and the functionality of different screens.

Required Hardware

Currently, it has only been tested on the affordable 2.8-inch ESP32-2432S028R board, which is available for purchase here: Aliexpress Affiliate Link

Optional Hardware

DS18B20 Temperature Sensor: For printers that do not have an integrated chamber temperature sensor, you have the option to add an external DS18B20 temperature sensor. This sensor will provide accurate chamber temperature readings and enhance the functionality of your xtouch screen. Connector on the screen is 1.25 MZ JST 4P.
DS18B20 P1P/P1S Chamber Temp Enclosure: Additionally, we have created a 3D model that allows you to easily integrate the DS18B20 Temperature Sensor inside your P1P/P1S printer. You can find the 3D model here.

Features

Advanced Touch Screen: A touch screen interface for intuitive printer control.
Status Indicators: Top bar indicating WiFi connectivity, camera status, timelapse recording, and AMS status.
Temperature Monitoring: Real-time display of nozzle, bed, and chamber temperatures.
Printing Control: Full control over your print job, including the ability to change print speed during printing.
Precise Control: Control your printer's XYZ position with adjustable head movement steps (1mm and 10mm).
Filament Handling: Load, unload, extrude, and retract filament (Note: Filament handling available only for printers without AMS initially).
Switch Between Printers: With a single xtouch screen, you can seamlessly switch between different printers. The access code for linked printers is saved for future use, making it convenient to switch printer connections.
Customizable Settings: Access a wide range of LCD and printer-related settings.
OTA Updates: Enable over-the-air updates for firmware enhancements.

Installation

Install Drivers

Install CH340 Drivers

Prepare the SD card

Before you begin the installation process for the xtouch screen, it's essential to properly initialize your SD card with the necessary configuration for connecting to your WiFi network. Follow these steps carefully:

Format the SD Card in FAT32:
- Ensure your SD card is formatted with the FAT32 file system. You can use your computer's built-in formatting tools or third-party software to format the card if needed.
Create a Configuration File:
- On the root directory of the SD card, create a JSON configuration file named wifi.json. You can use a plain text editor to create this file.
Edit the Configuration File:
- Open the wifi.json file in a text editor and replace the following placeholders with the actual information for your WiFi network:
```
{
  "ssid": "your_ssid_name",
  "pwd": "your_ssid_password"
}
```
Replace "your_ssid_name" with your WiFi network's SSID (name) and "your_ssid_password" with your WiFi network's password.

Warning If you are unsure how to create the wifi.json file, you can use the Online wifi.json Form for step-by-step instructions.
Save the Configuration File:

Save the changes you made to the wifi.json file.

Your SD card is now properly initialized with the required WiFi configuration. This configuration will enable the xtouch screen to connect to your WiFi network during the installation process. Ensure that the SD card is securely inserted into the touch screen before proceeding with the installation steps outlined in the previous sections of this README.md file.

Online Web Installer

To set up your xtouch screen, you will need to use the Online Web Installer. Follow these steps to complete the installation:

Open a Web Browser:
- Open your preferred web browser on a computer.
Enter the Web Installer URL:
- In the browser's address bar, enter the following URL:
```
https://xperiments.in/xtouch-bin
```
Connect Button:
- On the web page, locate and click the "Connect" button to establish a connection between your computer and the xtouch screen.
Select xtouch serial Port:
- After clicking "Connect," a list of available serial ports will be displayed. Choose the one asigned to your xtouch so establish a connection with the touch screen.
Install xtouch:
- Once you've selected the correct serial port, click the "Install xtouch"sbutton on the web page. This will initiate the installation process.
Installation Completion:
- Wait for the installation to complete. You will receive a confirmation message or indication on the web page once the installation process finishes.
Power Off the Screen:
- Turn off the xtouch screen.
Power On the Screen:
- Turn on the xtouch screen. It will now be fully initialized and ready for use with your 3D printer.

Linking Printer

During the installation process, you will need to link your xtouch screen with your 3D printer. Follow these steps to successfully establish the connection:

Searching for Printers:
- After powering on the touch screen, you will be greeted with a "Searching for printers" screen. The touch screen will scan the network for available printers.
Select a Printer to Link:
- Once the scanning process is complete, you will be presented with a listing of the printers that were found on the network. Select the printer you wish to link.
Click the Checkmark Button:
- After selecting the desired printer, click the green checkmark button to initiate the linking process.
Enter the Access Code:
- You will be prompted to enter the access code for the selected printer. Provide the correct access code and proceed.
Connecting to the Printer:
- The xtouch screen will attempt to establish a connection with the selected printer. If the connection is unsuccessful, the process will restart, allowing you to try again.
Success and Main Screen:
- Upon successfully linking the touch screen with the printer, you will be redirected to the Main Screen. Your printer and touch screen are now connected and ready for use.
Saving Access Code:
- The access code for the linked printer will be saved for future use. This means that for subsequent printer links (if the printer is the same), you will not be asked for the access code again. You can clear these saved access codes in the Settings Screen if needed.

By following these steps, you will be able to link your xtouch screen with your 3D printer seamlessly, ensuring a smooth user experience and easy access to all the features of the touch screen.

Please ensure that the access code is kept secure and that you clear the access code cache in the Settings Screen if you wish to unlink the printer or start the linking process for a different printer.

Screens

Main Screen

Top Bar: Displays WiFi, camera, timelapse, and AMS status.
Light Control: Toggle the printer's light on/off.
Temperature Indicators: Real-time nozzle, bed, and chamber temperature indicators.
Status Area: The Status Area on the touch screen serves two main purposes:
- Idle State: When the printer is not in use, it displays a "Ready" message with the main logo.
- Printing State: During printing, it provides pause/stop buttons, a progress bar, layer info, and a print speed selector for real-time control and monitoring.

Temperature / Fan Screen

On this screen, you'll find four buttons, each representing the temperature or fan speed of a specific sensor. Tapping any of these buttons will direct you to a numeric keyboard screen where you can easily adjust the corresponding temperature or speed value. After making your changes, you can return to the initial screen with a simple tap.

Control Screen

This screen provides essential controls for managing your printer:

Homing: Initiates printer homing procedure.
XYZ Position Control: Enables precise control of the print head's XYZ position.
Step Size: Allows you to toggle between 1mm and 10mm head movement increments for finer or quicker adjustments.

Filament Screen

Filament Handling: Load, unload, extrude, and retract filament (Note: Filament handling available only for printers without AMS initially).

Settings Screen

LCD

Change Backlight: In the "Change Backlight" settings, you can adjust the screen backlight to your preferred brightness level.
Set Screen Sleep Time: Set Screen Sleep Time: Adjusts the screen's inactivity timer. When the screen is idle for the specified time (in minutes), it enters sleep mode to save power. Set to 0 to keep the screen always active. During an active print job, the screen stays on for real-time monitoring.
Invert Screen Colors: Toggle to reverse screen colors. Useful for addressing compatibility issues with certain devices.
Flip Screen: Flip the screen orientation.

PRINTERS

Unlink Printer: Disconnect the current printer from the touch screen. This allows you to switch between different printers seamlessly.
Clear Access Code Cache: Erases stored printer serial numbers and access codes. Requires reestablishing printer pair connections.

XTOUCH

AUX FAN: Enable the auxiliary fan for printers that initially lack it.
CHAMBER Temp: Enable chamber temperature monitoring for printers without it.
OTA Update: Enable OTA upgrades for firmware updates.

OTA Update Procedure

The xtouch screen supports Over-The-Air (OTA) firmware updates, making it easy to keep your device up to date with the latest features and improvements. To enable and utilize OTA updates, follow these steps:

Access the Settings Screen:
- Navigate to the Settings Screen on your xtouch screen.
Enable OTA Updates:
- In the Settings Screen, locate the OTA Update section. You will find an option to enable OTA updates. Toggle this option to "ON" to enable automatic firmware update checks.
Automatic Update Check on Boot:
- With OTA updates enabled, your touch screen will automatically check for firmware updates every time it boots up.
Download and Apply Updates:
- If an update is available, the touch screen will automatically download the latest firmware and apply the upgrade. This process is seamless and requires no manual intervention.

By enabling OTA updates in the Settings Screen, you ensure that your xtouch screen stays current with the latest software enhancements and bug fixes without the need for manual updates. This convenient feature ensures that you always have access to the best performance and functionality that the device can offer.

Standard Firmware Update

If you prefer to manually update the firmware of your xtouch screen or if OTA updates are not enabled, you can follow this procedure:

Download the Update Firmware File:
- Visit the official xtouch sebsite or the designated firmware update source to download the latest firmware update file. Ensure that you download the file with the firmware.bin name.
Copy the Firmware File to the Root of the SD Card:
- Insert the SD card into your computer's card reader.
- Copy the downloaded firmware update file firmware.bin to the root directory of the SD card. Do not place it in any subdirectories.
Reboot the xtouch screen:
- Insert the SD card containing the firmware update file into the xtouch screen if it's not already inserted.
- Reboot the touch screen. You can do this by turning it off and then turning it back on.
Apply the Firmware Update:
- Once the touch screen has booted up, it will detect the presence of the firmware update file on the SD card.
- The touch screen will apply the firmware update.
- The update process may take a few minutes to complete. Do not turn off the touch screen or remove the SD card during this time.
Completion and Verification:
- After the firmware update is successfully applied, the touch screen will notify you that the update is complete.
- You can verify the firmware version in the touch screen's settings section to ensure that it matches the latest version.

By following these steps, you can manually update the firmware of your xtouch screen to the latest version, ensuring that you have access to all the latest features and improvements.

Troubleshooting

If you encounter issues during the installation or operation of your BambuLab Printers Touch Screen, you can refer to the following troubleshooting steps to resolve common problems:

Use a Data Cable:
- Ensure that you are using a data cable (not just a charging cable) to connect your touch screen to your computer during the installation process. A data cable is required for proper communication.
SD Card Compatibility:
- Keep in mind that SD cards from different manufacturers may behave differently. While many SD cards work seamlessly, some may not be fully compatible with the touch screen. If you experience issues with an SD card, consider trying a different brand or model to see if it resolves the problem.
WiFi Connection Loop:
- In some cases, users have reported that after confirming their WiFi credentials are correct, the device enters into a continuous loop without establishing a connection. This issue can sometimes be resolved by adjusting the WiFi connection timeout.
- To do this, modify the wifi.json file and include a numerical parameter for the timeout. Increasing the timeout value can help address this issue.
Example wifi.json with a timeout parameter:
```
{
  "ssid": "your_ssid_name",
  "pwd": "your_ssid_password",
  "timeout": 5000
}
```
- In the above example, the timeout value is set to 5000 milliseconds 5s. Adjust this value as needed to ensure a stable WiFi connection. Save the changes to the wifi.json file and proceed with the installation.
Warning If you are unsure how to create the wifi.json file, you can use the Online wifi.json Form for step-by-step instructions.
Endless Reboots in Printer Startup:
- Sometimes, users may encounter an issue where the printer and xtouch screen go through an endless reboot cycle during the device's power-on process, preventing xtouch from becoming ready. This problem can often be resolved by adjusting the "coldboot" value within the "wifi.json" configuration file.
- To address this issue, open the "wifi.json" file and include a numerical parameter for the "coldboot" parameter. This parameter specifies the duration in milliseconds the system should wait for initialization after a cold boot. By increasing the "coldboot" value, you provide the system with more time to complete the startup process successfully.
Example "wifi.json" with an adjusted "coldboot" parameter:
```
{
  "ssid": "your_ssid_name",
  "pwd": "your_ssid_password",
  "coldboot": 10000
}
```
- In the above example, the "coldboot" value is set to 10000 milliseconds (10 seconds). You can modify this value according to your requirements to ensure the printer initializes correctly after a cold boot. After making the changes, save the "wifi.json" file and proceed with the printer setup.
Note If you're unsure about how to modify the "wifi.json" file, you can use the Online wifi.json Form for step-by-step instructions.
Recalibrating the Screen:

If you encounter touch screen calibration issues or misalignment, you can recalibrate the screen by removing the touch.json file located in the xtouch directory on the SD card. Follow these steps:
- Power off the xtouch screen.
- Remove the SD card from the touch screen.
- Insert the SD card into your computer.
- Navigate to the xtouch directory on the SD card.
- Delete the touch.json file.
- Safely eject the SD card from your computer.
- Reinsert the SD card into the touch screen.
- Power on the touch screen.
The touch screen will automatically perform a recalibration process upon startup.
P1P/S 01.04.00.00 LAN Mode Bug:

P1P/S 01.04.00.00 LAN Mode Bug

In firmware version 1.4 of the printer, a critical bug has been identified that prevents the successful use of LAN mode. This bug disrupts the connection between the printer and BambuStudio, causing frequent disconnections and rendering LAN mode unusable.

Impact

The impact of this bug is significant, as LAN mode is a preferred choice for many users for its reliability and speed advantages. Disconnections disrupt the seamless interaction between the printer and BambuStudio, making it difficult to monitor and control print jobs effectively.

Possible Solutions

To address the LAN mode bug in firmware version 1.4, users can consider the following possible solutions:
1. Change to Cloud Mode:
  - Users can switch from LAN mode to Cloud mode, where the bug does not exist. Cloud mode enables remote monitoring and control of the printer through the BambuStudio cloud platform. While this solution maintains connectivity, it may require an active internet connection.
2. Revert Firmware to Version 1.3:
  - Another option is to revert the printer's firmware to version 1.3, where the LAN mode bug is not present. This solution allows users to continue using LAN mode without disruptions while avoiding the bug associated with version 1.4.
  - However, downgrading firmware versions should be performed carefully, following the manufacturer's instructions, as firmware changes can have their own implications.

bucanero/pkgi-psp

2023-10-04T01:26:13Z

A PlayStation Portable (PSP) package download tool

PKGi PSP

PKGi PSP is a PlayStation Portable port of pkgi-ps3.

This homebrew app allows to download and install .pkg files directly on your PSP.

Comments, ideas, suggestions? You can contact me on Twitter and on my website.

Features

easy to use: list available downloads, including searching, filtering, and sorting.
standalone: no PC required, everything happens directly on the PSP.
automatic downloads: just choose an item, and it will be downloaded by the app to your Memory Stick (ms0:/PKG/).
resumes interrupted downloads: you can stop a download at any time, switch applications, and come back to resume the download later.
localization support: Finnish, French, German, Indonesian, Italian, Polish, Portuguese, Spanish, Turkish

Notes:

content activation: downloaded content requires a valid license to run. If your PSP hasn't been activated, you can use one of the following plugins:
- npdrm_free_mod plugin (PSP/PS1 games only)
- npdrm_free plugin (PSP/PS1 games and DLCs)
- nploader_mod (PSP DLCs only)

Download

Get the latest version here.

Changelog

See the latest changes here.

Setup instructions

You need to create a pkgi.txt file in ms0:/PSP/GAME/PKGI/ that contains the items available for installation. The text database format is user customizable. Check this section to learn how to define your own custom DB format.

Multiple databases

You can also load additional database files:

pkgi_games.txt
pkgi_dlcs.txt
pkgi_themes.txt
pkgi_avatars.txt
pkgi_demos.txt
pkgi_updates.txt
pkgi_emulators.txt
pkgi_apps.txt
pkgi_tools.txt

Items on each of these files will be auto-categorized to the file content type. Note: The app assumes that every database file has the same format, as defined in dbformat.txt.

Online DB update

You can refresh and sync an online database by adding the DB URL(s) to the config.txt file in ms0:/PSP/GAME/PKGI/.

For example:

url http://www.mysite.com/mylist.csv
url_demos http://www.demos.com/otherlist.csv
url_emulators http://www.example.com/emulators.csv

Using this setup, pkgi.txt will be updated with mylist.csv, pgi_demos.txt with otherlist.csv , and pkgi_emulators.txt with emulators.csv.

Next time you open the app, you'll have an additional menu option called Refresh. When you select it, the local databases will be syncronized with the defined URLs.

DB formats

The application needs a text database that contains the items available for installation, and it must follow the default format definition, or have a custom format definition file.

Default DB format

The default database file format uses a very simple CSV format where each line means one item in the list:

contentid,type,name,description,rap,url,size,checksum

where:

Column	Description
`contentid`	is the full content id of the item, for example: `UP0000-NPXX99999_00-0000112223333000`.
`type`	is a number for the item's content type. See the table below for details. (set it to 0 if unknown)
`name`	is a string for the item's name.
`description`	is a string for the item's description.
`rap`	the 16 hex bytes for a RAP file, if needed by the item (`.rap` files will be created on `/dev_hdd0/exdata`). Leave empty to skip the `.rap` file.
`url`	is the HTTP/HTTPS/FTP/FTPS URL where to download the `.pkg` file.
`size`	is the size in bytes of the `.pkg` file, or 0 if unknown.
`checksum`	is a SHA256 digest of the `.pkg` file (as 32 hex bytes) to make sure the file is not tampered with. Leave empty to skip the check.

Note: name and description cannot contain newlines or commas.

Sample DB file

An example pkgi.txt file following the contentid,type,name,description,rap,url,size,checksum format:

EP0001-FILEMANAG_00-0000000000000000,8,FileManager v1.40,File Manager,,http://github.com/Zarh/ManaGunZ/releases/download/1.40/FileManager_v1.40.pkg,12171120,FAF680636B18AD0B70AA61F48A78C5E42D6972F795F1B82CC434BE3DDE60F00F
UP0001-IRISMAN00_00-VER4880000000000,8,IRISMAN 4.88.1,Backup Manager,,http://github.com/aldostools/IRISMAN/releases/download/4.88/IRISMAN_4.88.pkg,29411984,E6EF607F0002B31BFB148BE4FC9BDBACB4E53110751F0E667C701D40B5290570
EP0001-MANAGUNZ0_00-0000000000000000,8,ManaGunZ v1.40,Backup Manager,,http://github.com/Zarh/ManaGunZ/releases/download/1.40/ManaGunZ_v1.40.pkg,17563040,CE0E4036903E881C08259FD69E777F6BC9CD24E823B471A7B15C88FDDBB2E330
UP0001-PS3SFM001_00-0000000000000000,8,Simple file manager v0.5.2,File Manager,,http://github.com/lmirel/fm_psx/releases/download/v0.5.2/sfm_ps3.pkg,1098800,301F64CC94E9BC442FDAC9199BFB8153AC2430A5E47331C6CF8A25B7881648A6
EP0001-UPDWEBMOD_00-0000000000000000,9,webMAN MOD v1.47.36,Backup Manager,,http://github.com/aldostools/webMAN-MOD/releases/download/1.47.36/webMAN_MOD_1.47.36_Installer.pkg,13580448,

Content types

Type value	Content type	DB File
0	Unknown
1	Game	`pkgi_games.txt`
2	DLC	`pkgi_dlcs.txt`
3	Theme	`pkgi_themes.txt`
4	Avatar	`pkgi_avatars.txt`
5	Demo	`pkgi_demos.txt`
6	Update	`pkgi_updates.txt`
7	Emulator	`pkgi_emulators.txt`
8	Application	`pkgi_apps.txt`
9	Tool	`pkgi_tools.txt`

User-defined DB format

To use a custom database format, you need to create a dbformat.txt file, and save it on ms0:/PSP/GAME/PKGI/.

The dbformat.txt definition file is a 2-line text file:

Line 1: the custom delimiter character (e.g.: ;, ,, |, etc.)
Line 2: the column names for every column in the custom database, delimited by the proper delimiter defined in line 1

Note: For the columns to be properly recognized, use the column tag names defined in the table above.

All the columns are optional. Your database might have more (or less) columns, so any unrecognized column will be skipped.

Example

Example dbformat.txt, for a database using semi-colon (;) as separator:

;
name;TITLE ID;REGION;description;AUTHOR;TYPE;url;rap;size

Result: only the name,description,url,rap,size fields will be used.

Example

Example dbformat.txt, for a database using character pipe (|) as separator:

|
REGION|TITLE|name|url|rap|contentid|DATE|PKG FILENAME|size|checksum

Result: only the name,url,rap,contentid,size,checksum fields will be used.

Usage

Using the application is simple and straight-forward:

Move UP/DOWN to select the item you want to download, and press .
To see the item's details, press .
To sort/filter/search press . It will open the context menu. Press again to confirm the new settings, or press to cancel any changes.
Press left or right trigger buttons L1/R1 to move pages up or down.
Press LEFT/RIGHT buttons to switch between categories.

Notes

RAP data: if the item has .rap data, the file will be saved in the ms0:/PKG/RAP/ folder.

Q&A

Where to get a rap string?

You can use a tool like RIF2RAP to generate a .rap from your existing .rif files. Then you can use a tool like hexdump to get the hex byte string.
Where to get .pkg links?

You can use PSDLE to find .pkg URLs for the games you own. Then either use the original URL, or host the file on your own web server.
Where to remove interrupted/failed downloads to free up disk space?

Check the ms0:/PKG/ folder - each download will be in a separate .pkg file by its content ID. Simply delete the file and start again.
Download speed is too slow!

Optimization is still pending. (Optional) Set Power Save Settings -> WLAN Power save -> OFF , if you want to speed up the download process.

Credits

Bucanero: Project developer

Acknowledgements

Building

You need to have installed:

PSP SDK
mbedTLS library
cURL library
Mini18n library
dbglogger library (only required for debug logging)

Run cmake . && make to create a release build. If you want to create a .zip file, run make createzip.

Debugging

To enable debug logging, pass -DPKGI_ENABLE_DEBUG=ON argument to cmake. The application will send debug messages to UDP multicast address 239.255.0.100:30000. To receive them you can use socat on your computer:

$ socat udp4-recv:30000,ip-add-membership=239.255.0.100:0.0.0.0 -

You can also set the PSPIP environment variable to your PSP's IP address, and use make send to upload EBOOT.PBP directly to the ms0:/PSP/GAME/PKGI folder.

License

pkgi-psp is released under the MIT License.

heysaiyad/Hacktoberfest2023-DSA

2023-10-04T01:26:13Z

Repo oficial do He4rtoberfest da He4rt Developers 2023

He4rtoberfest 2023 (COMEÇA NO DIA 02/10/2023 AS 23:00)

Sobre o Projeto

Sejam todos bem-vindos a terceira edição do He4rtoberfest, evento da He4rt Developers para incentivar novos desenvolvedores a participar do Hacktoberfest pela DigitalOcean, ILLA Cloud e Appwrite, aprendendo um pouco mais sobre a ideia e filosofia do open-source.

A ideia da He4rt Developers sempre foi a inclusão de iniciantes na área, por isso, vamos focar em trazer essa inclusão para o Hacktoberfest! Se liga:

O objetivo é trazer exercícios (para entrega de resoluções em formatos de algoritmos), desde o mais simples até o mais completo, demonstrando as possibilidades de resolução das mais variadas formas em diversas linguagens de programação, assim, disponibilizando uma biblioteca gigantesca de conteúdo para novos desenvolvedores, universitários e estudantes do geral. Para se inscrever e começar a contribuir não se esqueça de acessar o portal oficial da MLH (Major League Hacking).

Exercicios disponíveis

Na lista abaixo estarão todos os exercicios que iremos aceitar nas pull requests.

Caso você queira dar sugestões de desafios ou tirar suas dúvidas, por favor, utilize a área de discussões do repositório ou contate algum moderador no Discord da He4rt.

Como participar

Contribuições fazem com que a comunidade open-source seja um lugar incrível para aprender, inspirar e criar, por isso, todas as contribuições são extremamente apreciadas!

Porém, como neste caso estamos falando de um evento, haverão algumas regras para serem seguidas permitindo que sua resolução seja aprovada, mas, não é nada complexo! Entenda:

Para que você tenha um pull request (PR) aprovado vinculado ao Hacktoberfest, você terá que fazer um PR do desafio 0 (Hello World);
Caso você faça os outros desafios e não faça o Hello World, seu PR não será aprovado enquanto não fizer o desafio inicial.

A ideia do desafio 0 é deixar registrado todos os participantes do He4rtoberfest, por isso será obrigatório.

Para criar realizar sua contribução abrindo uma pull request da sua branch, você deverá seguir o exemplo abaixo:

Realize um fork do projeto
Vá até o repositório do fork no seu GitHub e na área code copie o link para cloná-lo (HTTPS, SSH ou utilize o CLI do GitHub)
Abra o terminal, escolha uma pasta de sua preferência e clone o repositório com o comando git clone <link_do_repositorio>
Crie uma pasta da linguagem que você escolheu no diretório challenges/id_challenge/lang/ (caso já exista uma pasta com o nome da linguagem, apenas vamos para o próximo passo e reutilizá-la)
Depois dentro desta pasta da linguagem crie uma pasta com seu nickname, parecido com algo como challenges/id_challenge/lang/nickname
Resolva o desafio
Copie o model.md dentro de challenges para a sua pasta criada anteriormente, preenchendo com as informações descritas e depois renomeie o arquivo para README.md
Crie uma branch com o desafio seguindo o modelo ao lado git checkout -b challenges/id_challenge/lang/nickname
O exemplo acima ficaria assim do desafio 0 feito em PHP para o usuário danielhe4rt: git checkout -b challenges/0-hello-world/php/danielhe4rt
Depois adicione suas modificações com o comando git add .
Realize o commit com o comando git commit -m 'Finalizando o desafio'
Realize o push na branch, enviando suas modificações com o comando git push origin challenges/id_challenge/lang/nickname (não se esqueça de colocar as suas informações)
Abra um pull request e aguarde a revisão

Revisão de Pull Requests

Como o nosso objetivo será dar a melhor experiência possível para o participante, iremos ter algumas regras básicas de revisão de código para que exista uma boa interpretação geral ao usuário que vai revisar sua PR e claro para que você se sinta mais confortável, sendo elas:

Reforçar uma leitura de código e tipagem quando possível;
Erros de digitação/gramaticais e nomes de variáveis sem um contexto, tais como [a,b,c,x,y,z] deverão ser pedidas alterações;
Isolamento de funções quando necessário também poderá ser requisitado.

Qualquer dúvida, poderá ir o nosso banco de dúvidas e abrir uma issue com a sua dúvida, assim, vamos responder o mais rápido possível.

Atualizando o seu fork

Caso esse repositório seja atualizado com novos exercícios você precisa atualizar seu fork, por isso, siga os passos abaixo:

# 1. Mudar para a branch main
git checkout main
# 2. Checar se sua cópia local tem o link do original
git remote -v
# 3. Se não, adicione o link do original
git remote add upstream git@github.com:he4rt/he4rtoberfest-2023.git
# ou
git remote add upstream https://github.com/he4rt/he4rtoberfest-2023.git
# 4. Confirme se o link foi adicionado
git remote -v
# 5. Agora você pode fazer o fetch com o repo original, assumindo que o nome do link é 'upstream'
git fetch upstream
# 6. Fazer merge dos updates para sua branch main
git merge upstream/main main
# 7. Realizar o push para seu fork com as novas mudanças
git push origin main

Materiais complementares

mdippery/stackim

2023-10-04T01:27:05Z

URL shortener for Stack Overflow profiles

OneKeePass/desktop

2023-10-04T01:27:05Z

A secure password manager for macOS,Linux and Windows platforms

petejohanson/blank-slate-zmk-config

2023-10-05T01:26:42Z

ZMK configuration for the Blank Slate keyboard

luncliff/vcpkg-registry

2023-10-05T01:26:42Z

vcpkg registry maintained by @luncliff

lindelwa122/Hacktoberfest-Introduction-To-Programming

2023-10-04T01:27:12Z

Hacktoberfest repository for beginners. Learn programming and how to approach problems.

qualiabyte/postgres-nest-transaction

2023-10-05T01:26:48Z

Nest transactions easily with PostgreSQL and Node.js.

limenet/hexaflip-clock

2023-10-05T01:26:48Z

Making a live clock with the hexaflip plugin by Codrops

TreeRex/cl-marc

2023-10-04T01:27:18Z

Library for reading Z39.2 / MARC files

Minimal support for reading MARC (ISO2709 / ANSI Z39.2) records.

Support in progress for MARC-21, UNIMARC, CMARC, CNMARC, and KORMARC.

parag477/Amazing-Webdev-Components

2023-10-04T01:27:39Z

Make your first Pull Request on Hacktoberfest 2023. Don't forget to spread love and if you like don't forget to give us a star⭐️

📑 Introduction

A curatedcollection of Amazing Web Development Components for the ones participating in hacktoberfest 2023. This repository aims for helping web developers by providing the styled components in single place only resulting in saving time for developers.

👨🏻‍💻 How to get started?

You can refer to the following articles on _basics of Git and Github:

📝 How to Contribute?

Take a look at Contributing Guide
Take a look at the Existing Issues or create your own Issues!
Wait for the Issue to be assigned to you after which you can start working on it.
Fork the Repo and create a Branch for any Issue that you are working upon.
Create a Pull Request which will be promptly reviewed and suggestions would be added to improve it.
Add Screenshots to help us know what this Script is all about.

📝 Swags of Hacktoberfest

Many of the candidates get attracted towards hacktoberfest to get swags . So, after 4 successfully merged pull request you will be eligible to get a Hacktoberfest 2k23 T-shirt and some cool stickers on your doorstep.

✨ Contributors

Thanks to these Wonderful People 👨🏻‍💻: 🚀 Contributions of any kind are welcome!

❓ Frequently Asked Questions

Who all can contribute?
- Anyone with a github account and who is signed up for hacktoberfest :)
Are you getting paid for this?
- Sadly no. But we think we should. This is 100% unofficial and we do it for fun, fame and glory.
How many pull request (PR) must be made, if I want to get an awesome tshirt from Hacktoberfest 2022?
- 4 pull requests are required to be eligible for the tshirt
How do I track my progress to get an awesome shirt from Hacktoberfest 2022?
- go to :. (Check Out Your Progress there)
What is the duration of Hacktoberfest 2023?
- It is from 1st october to 31st october 2023...
What is the event for?
- For the open source community engagement

Happy Hacktoberfest 2k23 👨‍💻

TryGhost/Source

2023-10-05T01:27:13Z

The default theme for Ghost

Source

The default theme for Ghost. This is the latest development version of Source! If you're just looking to download the latest release, head over to the releases page.

First time using a Ghost theme?

Ghost uses a simple templating language called Handlebars for its themes.

This theme has lots of code comments to help explain what's going on just by reading the code. Once you feel comfortable with how everything works, we also have full theme API documentation which explains every possible Handlebars helper and template.

The main files are:

default.hbs - The parent template file, which includes your global header/footer
home.hbs - The homepage
index.hbs - The main template to generate a list of posts
post.hbs - The template used to render individual posts
page.hbs - Used for individual pages
tag.hbs - Used for tag archives, eg. "all posts tagged with news"
author.hbs - Used for author archives, eg. "all posts written by Jamie"

One neat trick is that you can also create custom one-off templates by adding the slug of a page to a template file. For example:

page-about.hbs - Custom template for an /about/ page
tag-news.hbs - Custom template for /tag/news/ archive
author-ali.hbs - Custom template for /author/ali/ archive

Development

Source styles are compiled using Gulp/PostCSS to polyfill future CSS spec. You'll need Node, Yarn and Gulp installed globally. After that, from the theme's root directory:

# install dependencies
yarn install

# run development server
yarn dev

Now you can edit /assets/css/ files, which will be compiled to /assets/built/ automatically.

The zip Gulp task packages the theme files into dist/<theme-name>.zip, which you can then upload to your site.

# create .zip file
yarn zip

PostCSS Features Used

Autoprefixer - Don't worry about writing browser prefixes of any kind, it's all done automatically with support for the latest 2 major versions of every browser.

SVG Icons

Source uses inline SVG icons, included via Handlebars partials. You can find all icons inside /partials/icons. To use an icon just include the name of the relevant file, eg. To include the SVG icon in /partials/icons/rss.hbs - use {{> "icons/rss"}}.

You can add your own SVG icons in the same manner.

Copyright & License

debrajrout/Dev.HFest

2023-10-05T01:27:13Z

This repository has been created as part of the Hacktoberfest event, where open-source enthusiasts come together to contribute to various projects and learn from each other.

HacktoberFest

Welcome to the Dev.HFest I am excited to have you contribute to this project, whether it's through code or non-code contributions.

Register Here

https://dev-hfest-m4zbc6xeb-debrajrout.vercel.app/

❗ FOLLOW ME AND GIVE A ⭐ IN ORDER TO MERGE YOUR PR❗

You can Create Your own issue and work on that

What is Hacktoberfest?

Hacktoberfest is an annual event that encourages open-source contributions during the month of October. By participating, you can earn cool swag and get involved in the open-source community.

Getting Started

1. Fork this Repository

To get started, fork this repository to your GitHub account. Click the "Fork" button at the top right of this page.

2. Clone your Fork

Clone your forked repository to your local machine using the following command:

3. Create a Branch

Create a new branch to work on your contributions. Be sure to give it a descriptive name related to the contribution you're making.

4. Contribution Rules📚:

Now you're ready to make your contributions:

Code Contributions

If you're a developer, you can contribute code in the following ways:

Add a new project in any language(HTML.CSS,java, python etc.)
Fix a bug
Improve existing code

Non-Code Contributions

Non-developers can also contribute in various ways, such as:

Writing blog posts or articles
Designing graphics or logos
Creating or updating documentation

Give a Star ⭐ this repository, and Follow me in order to get Hacktoberfest-selected Label

Happy Hacking...

Thank you for contributing to Hacktoberfest! Your contributions help make open source better for everyone. If you have any questions, feel free to reach out to me (https://www.linkedin.com/in/debarajrout/).

Happy hacking!

Our Top Contributors

AjayBrahmakshatriya/AjayCXX_OptimizeCuda

2023-10-04T01:27:35Z

SankethBK/diaryvault

2023-10-04T01:28:04Z

A personal diary application written in Flutter

Diary Vault

A FOSS, offline first personal diary application written in Flutter

Key Features

Rich text editor with support for images and videos
Your data is securely preserved on your Google Drive / Dropbox account, ensuring complete ownership and privacy
Sync data between multiple devices
Fingerprint login on supported devices
Multiple Themes

Libraries used

Flutter bloc for state management
FlutterQuill for rich text editor
Flutter Local Auth Invisible for fingerprint login
Dartz for functional programming
SQFLite as local database

Screenshots

Motivation for building this app

As someone who enjoys writing in a diary, I've tried out many diary apps on Google Play. Through my own experiences and by reading what others have shared in their reviews, I've gained a better understanding of the issues that current diary apps face.

Requires premium subscription for seemingly simple features
Lack of proper authentication: In some cases, users have to enter their password every time they log in, as there is no support for fingerprint authentication
Ads are the last thing you want to encounter while writing; just picture yourself composing a thought-provoking entry, and an ad suddenly appears, disrupting your train of thought
No support for images
No automatic saving: People don't want to lose their lengthy notes just because they ran out of battery, received a phone call or clicked on a notification
No font customization for overall app and individual note level
No customizable sorting: Not everyone wants to sort by date

🌟 If you like what we're building, please consider starring our repository on GitHub to show your support. It means a lot to us! ⭐

Feature Roadmap Table

Feature	Timeline	Issue
1. Support for tags	Planned for October release	#19
2. Support for customizable sort order	Planned for October release	#28
3. Auto save for every "x" seconds	Planned for October release	#29
4. Export data to text file	Planned for October release	#26
5. Support for daily reminders	Planned for October release	#24
6. Support for customizable fonts	Planned for November release	#31
7. Support for folder organization	Planned for November release	#30
8. Export data to PDF	Planned for November release	#25
9. Introduce "todos" within rich text editor	Planned for December release	#20
10. Add support for embedding audio files in rich text editor	Planned for December release	#21

Support

If you have any questions or doubts, join our Discord server.

Contributions

For local setup and contribution guidelines, please visit CONTRIBUTING.md.

Documentation

The entire project is structured in this way:

The features directory carries a folder for each of the major features.

These are the major features as of now:

1. Auth

DiaryVault is designed to work fully offline (internet connection is required during signup).

Signup: We only support username + password during signup. After a successful signup, the data is stored in firebase and then in local SQFlite table named Users.

Login: We support username+password and fingerprint login (if enabled).

When a username+password login is attempted, it first gets validated with data stored in Users table. On success, user is logged in.
If there is password mismatch in local Users table, firebase login would be attempted (because there is a possibility that password was changed from some other device and local data is stale). If firebase login is successful, data in local Users table is updated and user would be logged in.
Fingerprint login is disabled by default, it can be enabled in app settings. We store the id of last logged in user in shared preferences. If fingerprint login is attempted and successful, user with lastLoggedInUserId would be logged in.

Login as Guest: Guest login will allow users to use the app without creating account. lastLoggedInUserId will be hardcoded to guest_user_id to distinguish guest user from an actual user. Set of functionality will be limited for guest user, as some features require user account to work.

Other features like forgot password, reset email and reset password are supported with the help of Firebase.

2. Notes

Notes folder has the logic for CRUD operations for notes. FlutterQuill is used as rich text editor.

This is the schema of the notes entity:

Notes {
  final String id;
  final DateTime createdAt;
  final String title;
  final String body;
  final String hash;
  final DateTime lastModified;
  final String plainText;
  final List<NoteAsset> assetDependencies;
  final bool deleted;
  final String? authorId;
}

id: An UUID will be generated when a new note is created. It will be used as unique identifier for a note. After cloud-sync ID of a note will remain same across multiple devices.
createdAt: Indicates the timestamp at which note was created. Can be set by user during note-creation. Its shown in home page and read-only page.
title: Title of note.
body: Output of FlutterQuill's controller stored in the form of JSON. Indicates the contents of rich-text editor.
hash: The hash value is SHA1 hash of note's title + note's body + note's created_at timestamp. This hash serves as a digital fingerprint, if either note's title, body or created_at changes, then note's SHA1 hash changes and it will be synced to cloud.
lastModified: Will hold the last modified timestamp of a note. Is used during cloud-syncup to determine which copy of note is newest.
plainText: All contents of rich-text editor are also stored as plain text. Is used for search functionality.
assetDependencies: Holds details of external assets associated with a note, like images and videos. We store the path names of each external assets in Note_dependencies table, as we also need to sync external assets during cloud-syncup.
deleted: Will indicate if a note is deleted. When user deletes a note, all external assets, title and body of a note are set to null or empty text and deleted is set to true. Because we also need to delete that note in cloud.
authorId: Stores the user ID generated by firebase. In case multiple accounts are registered on same device, it will be used to isolate the notes of one user from another.

3. Sync

The Sync feature plays a pivotal role in ensuring that your diary app seamlessly integrates with Google Drive / Dropbox, allowing users to effortlessly manage their notes across multiple devices. Underpinning this functionality is a streamlined synchronization algorithm, which is a minimal version of syncing algorithms used in distributed systems.

Here's an in-depth explanation of how it works:

1. Hash-Based Note Comparison

Each note within the app is associated with a unique hash value. The hash value is SHA1 hash of note's title + note's body + note's created_at timestamp. This hash serves as a digital fingerprint, allowing us to quickly determine whether a note has been altered.

2. Initial Cloud Upload and Index File Creation

During the initial upload of data to the cloud, an index file is generated and stored in the cloud. This index file, in the form of a text file, contains vital information such as the note's ID, its hash value, creation timestamp, last modification timestamp, and a flag indicating whether the note has been deleted.
The app then compares this cloud-based index file with the local Notes table. If any note IDs present in the cloud's index are missing locally, the app initiates a download operation to fetch these missing notes from the cloud.
Conversely, if a note ID exists locally but not in the cloud, the app uploads it to the cloud.
When a note ID is found in both the local and cloud indexes, and their respective hash values differ, the app uses the timestamps of the notes' last modifications to determine the appropriate action. If the local version is more recent, it gets uploaded to the cloud; if the cloud version is newer, it gets downloaded to the local device.
If a note ID exists both locally and in the cloud, and their hash values are identical, no further action is taken, as the notes are already synchronized.

3. Ensuring Atomic Operations

All synchronization operations are designed to be atomic. This means that even if a user encounters a sudden loss of internet connectivity during the sync process, it will not result in an unstable or inconsistent state in either the local or cloud storage.

Theming

All of the theme related info can be found in this folder lib/app/themes. Currently we have three themes Coral Bubbles (light theme), Lush Green (light theme) and Cosmic (dark theme).

We are heavily using Flutter Theme Extensions as the color palette provided by standard ThemeData object is not sufficient.

In order to add a new theme, first step is to chose whether it's a light theme or dark theme. Then create a file similar to lib/app/themes/coral_bubble_theme.dart. After that, generate a background image and pick a color palette in accordance to the background image. There are lot of properties used in ThemeData object, but most of them can be copy pasted either from coral_bubbles.dart for light themes or cosmic.dart for dark themes.

paschalcs/pardus

2023-10-04T01:28:29Z

alpine based devcontainer image

duckietown/book-opmanual-duckiebot

2023-10-04T01:28:29Z

The Duckiebot operation manual

Template: template-book

This template provides a boilerplate repository for books in Duckietown.

What to change

These are the fields you must update to create your book.

Placeholders in `src/_config.yml`

This file configures the build of the book. Replace the placeholder string BOOK_NAME_HERE (there should be two separate instances of it) with the name of the repository hosting your book (e.g., book-devmanual-docs).

Structure in `src/_toc.yml`

Use the instructions here to learn how to structure your book using the Table of Contents file _toc.yml. A simple example is already provided by this template. Adapt it to your needs.

Logo in `src/logo.png`

There is a default logo in src/logo.png. This is the book's logo, change it with something that reflects the scope of your book. Transparent PNGs are recommended.

Build

You can build this book by running the command,

dts docs build

earthly/lib

2023-10-05T01:28:31Z

Slongod/Slongod.github.io

2023-10-04T01:29:07Z

xward/phoenix_ddos

2023-10-05T01:28:46Z

ddos protection for elixir phoenix project

hidsh/elisp

2023-10-04T01:29:16Z

The necessities of my life; included .emacs

popup.el

Overview

popup.el is a visual popup user interface library for Emacs. This provides a basic API and common UI widgets such as popup tooltips and popup menus.

Screenshots

Tooltip

Popup Menu

Popup Cascade Menu

Installation

Install popup.el into your load-path directory. If you have install-elisp or auto-install, you also be able to install popup.el like:

;; install-elisp
(install-elisp "https://github.com/m2ym/popup-el/raw/master/popup.el")
;; auto-install
(auto-install-from-url "https://github.com/m2ym/popup-el/raw/master/popup.el")

popwin is tested under GNU Emacs 22 or later.

Popup Items

Elements of popup-list have to be popup items. A popup item is substantially a string but it may involve some text-properties. There are two ways to make popup items. One is just using strings. Another is to use the popup-make-item function, which just returns the string after adding text-properties of its keywords. Effective text-properties are:

value -- This represents the real value of the item. This will be used when returning the value but not the item (or string) from some synchronous functions such as popup-menu*.
face -- The background face of the item. The value of popup-face will be overridden.
selection-face -- The selection face of the item. The value of popup-selection-face will be overridden.
document -- The documentation string or function of the item.
summary -- The summary string of the item. This will be shown inline with the item.
symbol -- The symbol character of the item.
sublist -- The sublist of the item. This is effective only with popup-cascade-menu.

All of properties can be accessed by popup-item-<property> utility function.

Function: `popup-item-propertize`

popup-item-propertize item &rest properties => item

Same as propertize except that this avoids overriding existed value with nil property.

Function: `popup-make-item`

popup-make-item name &key value popup-face selection-face sublist
document symbol summary => item

The utility function of popup-item-propertize.

Popups

This section describes the basic data structures and operations of popups.

Struct: `popup`

Any instance of popup structure has the following fields (some unimportant fields are not listed):

point
row -- The line number.
column
width -- Max width of popup instance.
height -- Max height of popup instance.
min-height
current-height
direction -- Positive number means forward, negative number means backward.
parent -- The parent of popup instance.
face -- The background face.
selection-face
margin-left
margin-right
scroll-bar -- Non-nil means popup instance has a scroll bar.
symbol -- Non-nil means popup instance has a space for displaying symbols of item.
cursor -- The current position of list.
scroll-top -- The offset of scrolling.
list -- The contents of popup instance in a list of items (strings).
original-list -- Same as list except that this is not filtered.

All of these fields can be accessed by popup-<field> function.

Function: `popup-create`

popup-create point width height &key min-height around face
selection-face scroll-bar margin-left margin-right symbol parent
parent-offset => popup

Create a popup instance at POINT with WIDTH and HEIGHT.

MIN-HEIGHT is the minimal height of the popup. The default value is 0.

If AROUND is non-nil, the popup will be displayed around the point but not at the point.

FACE is the background face of the popup. The default value is popup-face.

SELECTION-FACE is the foreground (selection) face of the popup The default value is popup-face.

If SCROLL-BAR is non-nil, the popup will have a scroll bar at the right.

If MARGIN-LEFT is non-nil, the popup will have a margin at the left.

If MARGIN-RIGHT is non-nil, the popup will have a margin at the right.

SYMBOL is a single character which indicates the kind of the item.

PARENT is the parent popup instance. If PARENT is omitted, the popup will be a root instance.

PARENT-OFFSET is a row offset from the parent popup.

Here is an example:

(setq popup (popup-create (point) 10 10))
(popup-set-list popup '("Foo" "Bar" "Baz"))
(popup-draw popup)
;; do something here
(popup-delete popup)

Function: `popup-delete`

popup-delete popup

Delete the POPUP.

Function: `popup-live-p`

popup-live-p popup => boolean

Function: `popup-set-list`

popup-set-list popup list

Set the contents of the POPUP. LIST has to be popup items.

Function: `popup-draw`

popup-draw popup

Draw the contents of the POPUP.

Function: `popup-hide`

popup-hide popup

Hide the POPUP. To show again, call popup-draw.

Function: `popup-hidden-p`

popup-hidden-p popup

Return non-nil if the POPUP is hidden.

Function: `popup-select`

popup-select popup index

Select the item of INDEX of the POPUP.

Function: `popup-selected-item`

popup-selected-item popup => item

Return the selected item of the POPUP.

Return non-nil if the POPUP is still alive.

Function: `popup-next`

popup-next popup

Select the next item of the POPUP.

Function: `popup-previous`

popup-previous popup

Select the next item of the POPUP.

Function: `popup-scroll-down`

popup-scroll-down popup n

Scroll down N items of the POPUP. This won't wrap.

Function: `popup-scroll-up`

popup-scroll-up popup n

Scroll up N items of the POPUP. This won't wrap.

Function: `popup-isearch`

popup-isearch popup &key cursor-color keymap callback help-delay
=> boolean

Enter incremental search event loop of POPUP.

Tooltips

A tooltip is an useful visual UI widget for displaying information something about what cursor points to.

Function: `popup-tip`

popup-tip string &key point around width height min-height
truncate margin margin-left margin-right scroll-bar parent
parent-offset nowait prompt

Show a tooltip with message STRING at POINT. This function is synchronized unless NOWAIT specified. Almost all arguments are same as popup-create except for TRUNCATE, NOWAIT, and PROMPT.

If TRUNCATE is non-nil, the tooltip can be truncated.

If NOWAIT is non-nil, this function immediately returns the tooltip instance without entering event loop.

PROMPT is a prompt string used when reading events during the event loop.

Here is an example:

(popup-tip "Hello, World!")
;; reach here after the tooltip disappeared

Popup Menus

Popup menu is an useful visual UI widget for prompting users to select an item of a list.

Function: `popup-menu*`

popup-menu* list &key point around width height margin margin-left
margin-right scroll-bar symbol parent parent-offset keymap
fallback help-delay nowait prompt isearch isearch-cursor-color
isearch-keymap isearch-callback => selected-value

Show a popup menu of LIST at POINT. This function returns the value of the selected item. Almost all arguments are same as popup-create except for KEYMAP, FALLBACK, HELP-DELAY, PROMPT, ISEARCH, ISEARCH-CURSOR-COLOR, ISEARCH-KEYMAP, and ISEARCH-CALLBACK.

If KEYMAP is provided, it is a keymap which is used when processing events during event loop.

If FALLBACK is provided, it is a function taking two arguments; a key and a command. FALLBACK is called when no special operation is found on the key. The default value is popup-menu-fallback, which does nothing.

HELP-DELAY is a delay of displaying helps.

If NOWAIT is non-nil, this function immediately returns the menu instance without entering event loop.

PROMPT is a prompt string when reading events during event loop.

If ISEARCH is non-nil, do isearch as soon as displaying the popup menu.

ISEARCH-CURSOR-COLOR is a cursor color during isearch. The default value is `popup-isearch-cursor-color'.

ISEARCH-KEYMAP is a keymap which is used when processing events during event loop. The default value is popup-isearch-keymap.

ISEARCH-CALLBACK is a function taking one argument. popup-menu calls ISEARCH-CALLBACK, if specified, after isearch finished or isearch canceled. The arguments is whole filtered list of items.

Here is an example:

(popup-menu* '("Foo" "Bar" "Baz"))
;; => "Baz" if you select Baz
(popup-menu* (list (popup-make-item "Yes" :value t)
                   (popup-make-item "No" :value nil)))
;; => t if you select Yes

Function: `popup-cascade-menu`

Same as popup-menu except that an element of LIST can be also a sub-menu if the element is a cons cell formed (ITEM . SUBLIST) where ITEM is an usual item and SUBLIST is a list of the sub menu.

Here is an example:

(popup-cascade-menu '(("Top1" "Sub1" "Sub2") "Top2"))

auramo/emacs-osx-finnish-keyboard-fix

2023-10-05T01:28:53Z

Instructions and borrowed elisp-code to use left alt (option) as meta key without major issues

Finnish keyboard relief for OSX Emacs

If you want to use alt (option) key as meta and also use Finnish keyboard layout, it can get quite frustrating. Same problem exists in many other european keyboard layouts as well.

You can get a bigger picture of the issue by reading this StackOverflow question and answers:

http://stackoverflow.com/questions/500602/os-x-terminal-meta-key-alt-functionality-at-t he-same-time

The solution which I find bearable is borrowing few files from Aquamacs and making a few tweaks in your emacs init file.

Here's what I've done:

(defun aq-binding (any) nil)
(load  "~/.emacs.d/aquamacs-tools.el")    
(load  "~/.emacs.d/emulate-mac-keyboard-mode.el")
(setq emulate-mac-finnish-keyboard-mode t)
(setq mac-right-option-modifier nil)

Not sure what the first line is doing, second and third are self-explanatory and the last line makes your right alt to behave as a normal alt in case your fancy new meta/alt key fails to produce characters in some corner cases.

The files emulate-mac-keyboard-mode.el and aquamacs-tools.el are borrowed into this repository from the Aquamacs repository (https://github.com/davidswelt/aquamacs-emacs).

djfiander/elisp

2023-10-05T01:28:53Z

Bits of emacs lisp

elisp

Bits of emacs lisp

erlef/oidcc

2023-10-04T01:29:32Z

OpenId Connect client library in Erlang & Elixir

fslaborg/FSharp.Stats

2023-10-05T01:29:07Z

statistical testing, linear algebra, machine learning, fitting and signal processing in F#

FSharp.Stats is a multipurpose project for statistical testing, linear algebra, machine learning, fitting and signal processing.

Amongst others, following functionalities are covered:

Descriptive statistics

Fitting

Interpolation

Signal processing

Linear Algebra

Singular value decomposition

Machine learning

PCA
Clustering
Surprisal analysis

Optimization

Brent minimization
Bisection
Nelder Mead

Statistical testing

Documentation

Indepth explanations, tutorials and general information about the project can be found here or at fslab. The documentation and tutorials for this library are automatically generated (using the F# Formatting) from *.fsx and *.md files in the docs folder. If you find a typo, please submit a pull request!

Contributing

Please refer to the Contribution guidelines.

Development

to build the project, run either build.cmd or build.sh depending on your OS.

build targets are defined in the modules of /build/build.fsproj.

Some interesting targets may be:

./build.cmd runtests will build the project and run tests
./build.cmd watchdocs will build the project, run tests, and build and host a local version of the documentation.
./build.cmd release will start the full release pipeline.

Library license

The library is available under Apache 2.0. For more information see the License file in the GitHub repository.

Citation

FSharp.Stats can be cited using its zenodo record.

Benedikt Venn, Lukas Weil, Kevin Schneider, David Zimmer & Timo Mühlhaus. (2022). fslaborg/FSharp.Stats. Zenodo. https://doi.org/10.5281/zenodo.6337056

crystal-bit/input-overlay

2023-10-04T01:30:05Z

Addon useful for tutorial makers. Shows an input overlay inside the editor screens

Maran23/script-ide

2023-10-05T01:29:40Z

newjoker6/Horizontal-Filesystem-Like-Unity

2023-10-05T01:29:40Z

Converts the vertical file system to a horizontal one that Unity users are used to.

allegro/handlebars-spring-boot-starter

2023-10-04T01:30:55Z

Spring Boot auto-configuration for Handlebars

jonolo6/Addressbook

2023-10-05T01:30:28Z

Griffon Tutorial Project.

byorgey/BlogLiterately

2023-10-05T01:30:38Z

Command-line tool for formatting and publishing blog posts.

Write blog posts in Markdown format, then use BlogLiterately to do syntax highlighting, format ghci sessions, and upload to any blog supporting the metaWeblog API (such as Wordpress).

To get started, use the provided executable BlogLiterately; see http://byorgey.wordpress.com/blogliterately/ for complete documentation.

To make further customization possible, the internals of the executable are made available as a library. In particular, it is easy to create your own executable which adds extra custom transformations; see Text.BlogLiterately.Run.

Mac installation instructions

The following instructions for installing BlogLiterately on a new Mac (with apple silicon M2 processor and Ventura) were kindly provided by Chris Reade.

After installing ghc and cabal using ghcup, there are two more things needed: pkg-config and openssl. Install both of these using homebrew, and set the paths as instructed.

Finally, edit ~/.cabal/config so that it provides locations for the openssl lib and include files. For example:

extra-include-dirs: /opt/homebrew/opt/openssl@3/include
extra-lib-dirs: /opt/homebrew/opt/openssl@3/lib

Finally, cabal install BlogLiterately.

schubergphilis/terraform-aws-mcaf-s3

2023-10-04T01:31:21Z

Terraform module to create an AWS s3 bucket

Raghupatik/Azure-tf

2023-10-04T01:31:21Z

Azure Modules

RetroBat-Official/retrobat-setup

2023-10-05T01:30:50Z

Configure and build the RetroBat Setup

Karamraj/hacktoberfest2023

2023-10-04T01:31:31Z

Hacktoberfest 2023 PR Tutorial

HacktoberFest 2023 `OPEN FIRST` Pull Request

This wont count towards your PR. But will help you understand the process!

This Project Is Perfect For Your First Pull Request

🗣 Hacktoberfest encourages participation in the open-source community, which grows bigger every year. Complete the challenge and get a tree planted on your name showing your love towards mother Earth 🌍

📢 Register here for Hacktoberfest and make four pull requests (PRs) between October 1st-31st 🔥.

INSTRUCTIONS-

Fork this Repository using the button at the top on the right corner.
Clone your forked repository to your PC ( git clone "url from clone option.)
Create a new branch for your modifications (ie. git branch new-user and check it out git checkout new-user or simply do git checkout -b new-user)
Add your profile image in static/images/ ( use drag and drop option or upload by commands.)
Add your profile data in content/participant/
Add your files (git add -A), commit (git commit -m "added myself") and push (git push origin new-user)
Create a pull request
Star this repository

How To Make Your First Pull Request

1. Create / Upload Your Code / Algorithms

You can contribute by sending writing "Hello World" in any language and make sure you put in right folder.

2. Wait for Pull Request to merge

3. Celebrate - you've done your first pull request!!

'''
Always make more than 4 pull requests.
Let's say you have made only 4 pull requests to different projects,
but one project is excluded from hackoctoberfest event then your pull request will not be counted and 
then you have the remaining 3 valid pull requests if these projects are not excluded.
If you fail to make 4 pull requests then you can't get swags or t-shirts.
I will recommend you make a pull request to your own repo which is very very safe for you.
Keep in mind that the repo has hacktoberfest topic.
'''

+ Follow Me : } Quick Approval of Pull Request

'''
To get approval of the pull request much quicker and faster (`Follow Me`)🚀
'''

_{Karamraj Singh Anand}

jimmy-byte/-HactoberFest2023-For_All_Beginers-

2023-10-04T01:31:31Z

Raise Genuine PRs, Your PRs will be accepted, Star This Repo, You aren't allowed to Update README.md

HactoberFest2020-For_All_Beginers

Event details :

Hacktoberfest® is open to everyone in our global community. Whether you’re a developer, student learning to code, event host, or company of any size, you can help drive growth of open source and make positive contributions to an ever-growing community. All backgrounds and skill levels are encouraged to complete the challenge.
Hacktoberfest is a celebration open to everyone in our global community.
Pull requests can be made in any GitHub-hosted repositories/projects.
You can sign up anytime between October 1 and October 31.

HacktoberFest Rules :

To earn your Hacktoberfest tee or tree reward, you must register and make four valid pull requests (PRs) between October 1-31 (in any time zone). PRs can be made to any public repo on GitHub, not only the ones with issues labeled Hacktoberfest. If a maintainer reports your pull request as spam or behavior not in line with the project’s code of conduct, you will be ineligible to participate. This year, the first 70,000 participants who successfully complete the challenge will be eligible to receive a prize.

Link To HacktoberFest 2020

Whether it’s your first or fiftieth pull request, there’s always more to learn! We’ve put together a few resources that can help you create quality pull requests, keep your repositories pristine, and build on your open source knowledge.

Join Discord Conversation

Rules To Contribute To This Repo

Use any language.
C, C++, JAVA, Data Structure and Algorithms, HTML, CSS.
Anything valuable.

Steps For Contribution

1. Fork this repo
2. Star this repo
3. Add a file
4. commit the code
5. Make pull request

Thank You

laviii123/Btecky

2023-10-04T01:31:31Z

Templates for Appwrite Functions ⚡️🌩️

📚 Appwrite Templates

Templates for Appwrite Functions. These templates can be used as starters for your functions, or for learning purposes.

List of Templates

Template	Node.js	Python	PHP	Dart	Bun	C++	Deno	.NET	Java	Kotlin	Node.js (TypeScript)	Ruby	Swift
Starter	✅	✅	✅	✅	✅	✅	✅	✅	✅	✅	✅	✅	✅
Prompt ChatGPT	✅	✅	✅	✅	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️
Censor with Redact	✅	✅	🏗️	✅	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️
Email Contact Form	✅	✅	✅	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️
Sync with Algolia	✅	✅	✅	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️
Discord Command Bot	✅	✅	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️
Analyze with PerspectiveAPI	✅	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️
Generate PDF	✅	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️
Github Issue Bot	✅	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️
Payments with Stripe	✅	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️
Push Notification with FCM	✅	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️
Subscriptions with Stripe	✅	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️
Sync with Meilisearch	✅	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️
URL Shortener	✅	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️
WhatsApp with Vonage	✅	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️	🏗️

✅ = Done - Function is implemented in this runtime.

🏗️ = Missing - Function isn't implemented in this runtime yet. Contributions are welcomed.

Contributing

All code contributions - including those of people having commit access - must go through a pull request and be approved by a core developer before being merged. This is to ensure a proper review of all the code.

All functions should have the exactly same functionality as their other language counterparts and if possible you should avoid using any third-party libraries to keep the functions simple and secure.

We truly ❤️ pull requests! If you wish to help, you can learn more about how you can contribute to this project in the contribution guide.

Security

For security issues, kindly email us at security@appwrite.io instead of posting a public issue on GitHub.

Discord Server

Join our live Discord server for more help, ideas, and discussions.

License

This repository is available under the MIT License.

sanyarnd/java-course-2023

2023-10-04T01:32:17Z

Spring Boot 3 : Rest API - Alura

tsaol/Web3-serverless-analytics-on-aws

2023-10-04T01:32:17Z

Web3 Serverless Analytics on AWS

Web3 无服务分析中文版本

Goals

It is a workshop for use Ethereum analysis use case to walk you through how to use aws serverless services to analyze blockchain data. this workshop provides the following:

Host an Ethereum full node on AWS EC2.
Process data using Lambda from Ethereum full node and then write into kinesis.
Streaming data ingestion from kinesis to data warehouse RedShift.
Visual analysis of Ethereum transaction data stored in RedShift.

AWS Services Including

EC2 Graviton
Kinesis Data Stream
RedShift Serverless
QuickSight
Lambda

Architecture Diagram

step-by-step

Set up an Ethereum FullNode on EC2 for sync Ethereum Mainnet data.
Extract bock data to kinesis using Ethereum ETL.
Process the data using lambda and deliver processed message to another kinesis.
Ingestion data from kinesis data stream to RedShift Serverless using streaming ingestion.
Query data using QuickSight.

1. Fetching Ethereum Block Data

Ethereum from Proof of Work (PoW) to Proof of Stake (PoS) on September 2022. In order to deploy full nodes we need both execution client and consensus client.

* **Instance Type** : m6g.2xlarge
* **OS**: Ubuntu 20 TSL
* **Geth** : v1.11.6 stable-ea9e62ca-linux-arm64
* **Lighthouse** : lighthouse-v4.1.0-aarch64-linux-gnu

1.1 execution client: Geth

Installing Geth on Ubuntu

sudo add-apt-repository ppa:ethereum/ethereum
sudo apt-get update -y
sudo apt-get upgrade -y
sudo apt-get install ethereum -y

Start Geth process

/usr/bin/geth --authrpc.addr localhost --authrpc.port 8551 --authrpc.vhosts localhost --authrpc.jwtsecret /tmp/jwtsecret --syncmode snap --http --http.api personal,eth,net,web3,txpool --http.corsdomain *

1.2 consensus client:lighthouse

cd ~ curl -LO https://github.com/sigp/lighthouse/releases/download/v4.0.1/lighthouse-v4.0.1-x86_64-unknown-linux-gnu.tar.gz 
tar -xvf lighthouse-v4.0.1-x86_64-unknown-linux-gnu.tar.gz`

Start Lighthouse process

lighthouse bn --network mainnet --execution-endpoint http://localhost:8551 --execution-jwt /tmp/jwtsecret --checkpoint-sync-url=https://mainnet.checkpoint.sigp.io  --disable-deposit-contract-sync

1.3 interacting with the Geth

 geth attach <datadir>/geth.ipc

1.4 check eth.syncing status

eth.syncing

1.5 eth.syncing

When the synchronization is complete, the terminal can query the last blocknumber

> eth.blockNumber

2. Extract block data to kinesis

2.1 Create Kinesis Data Streaming

Create Kinesis
- blockchain-kinesis-t
- blockchain-kinesis 2.2 Process data using lambda(python 3.8)

import json
import time
import base64
import boto3
import datetime;
kinesis_client = boto3.client('kinesis')

def lambda_handler(event, context):
    result_records=[]
    start_time = time.time() 
    for record in event['Records']:
        #Kinesis data is base64 encoded so decode here
        payload=base64.b64decode(record["kinesis"]["data"])
        b_value = json.loads(payload)       
        pk = str(datetime.datetime.now().timestamp())
        print ("pk is " + str(pk))
        result_event = json.dumps(b_value).encode('utf8')
        #print(result_event)        
        package_data = {'Data' :result_event,'PartitionKey':pk}
        result_records.append(package_data)
        
        
    response = kinesis_client.put_records(
        StreamName='blockchain-kinesis',
        Records=result_records
    )

Installing Ethereum ETL

sudo apt install python3-pip

Extract data from nodes to Kinesis using EthereumETL

2.2 Ethereum ETL

Extract data to kiniesis

ethereumetl stream  -e block,transaction,token_transfer  --start-block 17277219 \
--provider-uri file:///home/ubuntu/.ethereum/geth.ipc \
--output=kinesis://blockchain-kinesis-t

2.2 Query the data entered into kinesis

3. ingestion data to RedShift

3.1 Create a materialized view for streaming ingestion Create an external schema to map the data from Kinesis Data Streams to an Amazon Redshift :

CREATE EXTERNAL SCHEMA kdsblockchain
FROM KINESIS
IAM_ROLE 'arn:aws:iam::0123456789:role/blockchain-ana-redshift-role'

Create the materialized view for data ingestion

CREATE MATERIALIZED VIEW blocks_view AUTO REFRESH YES AS
SELECT approximate_arrival_timestamp,
refresh_time,
JSON_EXTRACT_PATH_TEXT(FROM_VARBYTE(kinesis_data, 'utf-8'),'type')::TEXT as type,
JSON_EXTRACT_PATH_TEXT(FROM_VARBYTE(kinesis_data, 'utf-8'),'number')::BIGINT as number,
JSON_EXTRACT_PATH_TEXT(FROM_VARBYTE(kinesis_data, 'utf-8'),'hash')::TEXT as hash,
JSON_EXTRACT_PATH_TEXT(FROM_VARBYTE(kinesis_data, 'utf-8'),'parent_hash')::TEXT as parent_hash,
JSON_EXTRACT_PATH_TEXT(FROM_VARBYTE(kinesis_data, 'utf-8'),'nonce')::TEXT as nonce,
JSON_EXTRACT_PATH_TEXT(FROM_VARBYTE(kinesis_data, 'utf-8'),'sha3_uncles')::TEXT as sha3_uncles,
JSON_EXTRACT_PATH_TEXT(FROM_VARBYTE(kinesis_data, 'utf-8'),'logs_bloom')::TEXT as logs_bloom,
JSON_EXTRACT_PATH_TEXT(FROM_VARBYTE(kinesis_data, 'utf-8'),'transactions_root')::TEXT as transactions_root,
JSON_EXTRACT_PATH_TEXT(FROM_VARBYTE(kinesis_data, 'utf-8'),'state_root')::TEXT as state_root,
JSON_EXTRACT_PATH_TEXT(FROM_VARBYTE(kinesis_data, 'utf-8'),'receipts_root')::TEXT as receipts_root,
JSON_EXTRACT_PATH_TEXT(FROM_VARBYTE(kinesis_data, 'utf-8'),'miner')::TEXT as miner,
JSON_EXTRACT_PATH_TEXT(FROM_VARBYTE(kinesis_data, 'utf-8'),'difficulty')::NUMERIC(38) as difficulty,
JSON_EXTRACT_PATH_TEXT(FROM_VARBYTE(kinesis_data, 'utf-8'),'total_difficulty')::NUMERIC(38) as total_difficulty,
JSON_EXTRACT_PATH_TEXT(FROM_VARBYTE(kinesis_data, 'utf-8'),'size')::BIGINT as size,
JSON_EXTRACT_PATH_TEXT(FROM_VARBYTE(kinesis_data, 'utf-8'),'extra_data')::TEXT as extra_data,
JSON_EXTRACT_PATH_TEXT(FROM_VARBYTE(kinesis_data, 'utf-8'),'gas_limit')::BIGINT as gas_limit,
JSON_EXTRACT_PATH_TEXT(FROM_VARBYTE(kinesis_data, 'utf-8'),'gas_used')::BIGINT as gas_used,
JSON_EXTRACT_PATH_TEXT(FROM_VARBYTE(kinesis_data, 'utf-8'),'timestamp')::INT as timestamp,
JSON_EXTRACT_PATH_TEXT(FROM_VARBYTE(kinesis_data, 'utf-8'),'transaction_count')::BIGINT as transaction_count,
JSON_EXTRACT_PATH_TEXT(FROM_VARBYTE(kinesis_data, 'utf-8'),'item_id')::TEXT as item_id,
JSON_EXTRACT_PATH_TEXT(FROM_VARBYTE(kinesis_data, 'utf-8'),'item_timestamp')::TEXT as item_timestamp
FROM kdsblockchain."blockchain-kinesis" where JSON_EXTRACT_PATH_TEXT(FROM_VARBYTE(kinesis_data, 'utf-8'),'type') in ('block');

Data is ingested to RedShfit using Redshfit Stream Ingestion

3.3 Query Data through Redshfit Query editor

4. Query data using QuickSight

Current block height.
Popular erc20 addresses in time window.
Blocks per minute and gas consumption.
top 10 transfer out address.
top 10 transfer in address .

NextAlone/Nagram

2023-10-04T01:32:17Z

JVector: the most advanced embedded vector search engine

JVector

JVector is a pure Java, zero dependency, embedded vector search engine, used by DataStax Astra DB and (soon) Apache Cassandra.

What is JVector?

Algorithmic-fast. JVector uses state of the art graph algorithms inspired by DiskANN and related research that offer high recall and low latency.
Implementation-fast. JVector uses the Panama SIMD API to accelerate index build and queries.
Memory efficient. JVector compresses vectors using product quantization so they can stay in memory during searches. (As part of our PQ implementation, our SIMD-accelerated kmeans class is 5x faster than the one in Apache Commons Math.)
Disk-aware. JVector’s disk layout is designed to do the minimum necessary iops at query time.
Concurrent. Index builds scale linearly to at least 32 threads. Double the threads, half the build time.
Incremental. Query your index as you build it. No delay between adding a vector and being able to find it in search results.
Easy to embed. API designed for easy embedding, by people using it in production.

JVector performance, visualized

JVector vs Lucene searching the Deep100M dataset (about 35GB of vectors and 25GB index):

JVector scales updates linearly to at least 32 threads:

JVector basics

Adding to your project. Replace ${latest-version} with . Example <version>1.0.1</version>:

<dependency>        
    <groupId>io.github.jbellis</groupId>          
    <artifactId>jvector</artifactId>
    <!-- Use the latest version from https://central.sonatype.com/artifact/io.github.jbellis/jvector -->
    <version>${latest-version}</version>
</dependency>

Building the index:

GraphIndexBuilder is the entry point for building a graph. You will need to implement RandomAccessVectorValues to provide vectors to the builder; ListRandomAccessVectorValues is a good starting point.
If all your vectors are in the provider up front, you can just call build() and it will parallelize the build across all available cores. Otherwise you can call addGraphNode as you add vectors; this is non-blocking and can be called concurrently from multiple threads.
Call GraphIndexBuilder.complete when you are done adding vectors. This will optimize the index and make it ready to write to disk. (Graphs that are in the process of being built can be searched at any time; you do not have to call complete first.)

Searching the index:

GraphSearcher is the entry point for searching. Results come back as a SearchResult object that contains node IDs and scores, in descending order of similarity to the query vector. GraphSearcher objects are re-usable, so unless you have a very simple use case you should use GraphSearcher.Builder to create them; GraphSearcher::search is also available with simple defaults, but calling it will instantiate a new GraphSearcher every time so performance will be worse.
JVector represents vectors in the index as the ordinal (int) corresponding to their index in the RandomAccessVectorValues you provided. You can get the original vector back with GraphIndex.getVector, if necessary, but since this is a disk-backed index you should design your application to avoid doing so if possible.

DiskANN and Product Quantization

JVector implements DiskANN-style search, meaning that vectors can be compressed using product quantization so that searches can be performed using the compressed representation that is kept in memory. You can enable this with the following steps:

Create a ProductQuantization object with your vectors using ProductQuantization.compute. This will take some time to compute the codebooks.
Use ProductQuantization::encode or encodeAll to encode your vectors.
Create a CompressedVectors object from the encoded vectors.
Create a NeighborSimilarity.ApproximateScoreFunction for your query that uses the ProductQuantization object and CompressedVectors to compute scores, and pass this to the GraphSearcher.search method.

Saving and loading indexes

OnDiskGraphIndex and CompressedVectors have write() methods to save state to disk. They initialize from disk using their constructor and load() methods, respectively. Writing just requires a DataOutput, but reading requires an implementation of RandomAccessReader and the related ReaderSupplier to wrap your preferred i/o class for best performance. See SimpleMappedReader and SimpleMappedReaderSupplier for an example.
Building a graph does not technically require your RandomAccessVectorValues object to live in memory, but it will perform much better if it does. OnDiskGraphIndex, by contrast, is designed to live on disk and use minimal memory otherwise.
You can optionally wrap OnDiskGraphIndex in a CachingGraphIndex to keep the most commonly accessed nodes (the ones nearest to the graph entry point) in memory.

Sample code

The SiftSmall class demonstrates how to put all of the above together to index and search the "small" SIFT dataset of 10,000 vectors.
The Bench class performs grid search across the GraphIndexBuilder parameter space to find the best tradeoffs between recall and throughput. You can use plot_output.py to graph the pareto-optimal points found by Bench.

Some sample KNN datasets for testing based on ada-002 embeddings generated on wikipedia data are available in ivec/fvec format for testing at:

aws s3 ls s3://astra-vector/wikipedia/ --no-sign-request 
                           PRE 100k/
                           PRE 1M/
                           PRE 4M/

download them with the aws s3 cli as follows:

aws s3 sync s3://astra-vector/wikipedia/100k ./ --no-sign-request

Developing and Testing

This project is organized as a multimodule Maven build. The intent is to produce a multirelease jar suitable for use as a dependency from any Java 11 code. When run on a Java 20+ JVM with the Vector module enabled, optimized vector providers will be used. In general, the project is structured to be built with JDK 20+, but when JAVA_HOME is set to Java 11 -> Java 19, certain build features will still be available.

Base code is in jvector-base and will be built for Java 11 releases, restricting language features and APIs appropriately. Code in jvector-twenty will be compiled for Java 20 language features/APIs and included in the final multirelease jar targetting supported JVMs. jvector-multirelease packages jvector-base and jvector-twenty as a multirelease jar for release. jvector-examples is an additional sibling module that uses the reactor-representation of jvector-base/jvector-twenty to run example code.

You can run SiftSmall and Bench directly to get an idea of what all is going on here. Bench requires some datasets to be downloaded from https://github.com/erikbern/ann-benchmarks. The files used by SiftSmall can be found in the siftsmall directory in the project root.

To run either class, you can use the Maven exec-plugin via the following incantations:

mvn compile exec:exec@bench

or for Sift:

mvn compile exec:exec@sift

To run Sift/Bench without the JVM vector module available, you can use the following invocations:

mvn -Pjdk11 compile exec:exec@bench

mvn -Pjdk11 compile exec:exec@sift

The ... -Pjdk11 invocations will also work with JAVA_HOME pointing at a Java 11 installation.

To release, configure ~/.m2/settings.xml to point to OSSRH and run mvn -Prelease clean deploy.

KudoAI/chatgpt.js

2023-10-04T01:32:31Z

🤖 A powerful, open source client-side JavaScript library for ChatGPT

English | 简体中文 | 繁體中文 | 日本 | 한국인 | हिंदी | Deutsch | Español | Français | Italiano | Nederlands | Português | Việt

🤖 A powerful client-side JavaScript library for ChatGPT

About

chatgpt.js is a powerful JavaScript library that allows for super easy interaction w/ the ChatGPT DOM.

Feature-rich
Object-oriented
Easy-to-use
Lightweight (yet optimally performant)

⚡ Importing the library

ES6:

(async () => {
    await import('https://code.chatgptjs.org/chatgpt-latest.min.js');
    // Your code here...
})();

ES5:

var xhr = new XMLHttpRequest();
xhr.open('GET', 'https://code.chatgptjs.org/chatgpt-latest.min.js');
xhr.onload = function () {
    if (xhr.status === 200) {
        var chatgptJS = document.createElement('script');
        chatgptJS.textContent = xhr.responseText;
        document.head.appendChild(chatgptJS);
        yourCode(); // runs your code
    }
};
xhr.send();

function yourCode() {
    // Your code here...
}

Greasemonkey:

Note To use a starter template: kudoai/chatgpt.js-greasemonkey-starter

Userscript repositories like Greasy Fork maintain a whitelist of pre-approved CDNs (such as commit-specific references from cdn.jsdelivr.net) so the import URL is substantially lengthier to preserve publishability to these sites:

...
// @require https://cdn.jsdelivr.net/gh/kudoai/chatgpt.js@2535c87dc1204a4dbe464b69450bfff6197d3d99/dist/chatgpt-2.3.5.min.js
// ==/UserScript==

// Your code here...

If you don't plan on publishing to these repos, the simpler https://code.chatgptjs.org/chatgpt-latest.min.js can be used instead to import the latest minified release.

Chrome:

Note To use a starter template: kudoai/chatgpt.js-chrome-starter

Since Google will eventually phase out Manifest V2, remote code will no longer be allowed, so importing chatgpt.js locally is ideal:

Save https://raw.githubusercontent.com/kudoai/chatgpt.js/main/chatgpt.js to a subdirectory (lib in this example)
Add ES6 export statement to end of lib/chatgpt.js

...
export { chatgpt }

In project's (V3) manifest.json, add lib/chatgpt.js as a web accessible resource

    "web_accessible_resources": [{
        "matches": ["<all_urls>"],
        "resources": ["lib/chatgpt.js"]
    }],

In scripts that need chatgpt.js (foreground/background alike), import it like so:

(async () => {
    const { chatgpt } = await import(chrome.runtime.getURL('lib/chatgpt.js'));
    // Your code here...
})();

💻 Usage

chatgpt.js was written w/ ultra flexibility in mind.

For example:

chatgpt.getLastResponse();
chatgpt.getLastReply();
chatgpt.response.getLast();
chatgpt.get('reply', 'last');

Each call equally fetches the last response. If you think it works, it probably will... so just type it!

If it didn't, check out the extended userguide, or simply submit an issue or PR and it will be integrated, ezpz!

🤖 Made with chatgpt.js

https://github.com/KudoAI/chatgpt.js/assets/10906554/f53c740f-d5e0-49b6-ae02-3b3140b0f8a4

Autoclear ChatGPT History

Auto-clear your ChatGPT query history for maximum privacy.
Install / Readme / Discuss

Automatic ChatGPT DAN

Automatically send DAN prompts to ChatGPT.
Install / Readme / Discuss

BraveGPT

Display ChatGPT answers in Brave Search sidebar (powered by GPT-4!)
Install / Readme / Discuss

ChatGPT Auto-Continue ⏩

Automatically continue generating multiple ChatGPT responses.
Install / Readme / Discuss

ChatGPT Auto Refresh ↻

Keeps ChatGPT sessions fresh to eliminate network errors + Cloudflare checks.
Install / Readme / Discuss

DuckDuckGPT

Display ChatGPT answers in DuckDuckGo sidebar (powered by GPT-4!)
Install / Readme / Discuss

If you've made something w/ chatgpt.js you want to share, email showcase@chatgptjs.org or just open a pull request!

🧠 Contributors

This library exists thanks to code, translations, issues & ideas from the following contributors:

🤝 Partners

chatgpt.js is funded in part by:

Consider giving this repo a ⭐ if it helped you!

Releases / Userguide / Discuss / Back to top ↑

SyedImtiyaz-1/PreciousServices

2023-10-04T01:32:31Z

Make your first Pull Request on this Repo. Don't forget to spread love and give us a ⭐️

Precious IT Services 🚀

THIS REPO IS READY FOR HacktoberFest-23 You can start contributing !!!

Use this project to make your first contribution to an open source project on GitHub. Practice making your first pull request to a public repository before doing the real thing!

Builds With : HTML, CSS, Javascript, Node.js, Express.js, MongoDB

This repository is open to all members of the GitHub community. Any member can contribute to this project.

➡ https://github.com/SyedImtiyaz-1/hacktoberfest/

New to Open Source ? No worries I will teach you how to contribute :

Join a 1:1 session with me ➡ https://topmate.io/syedimtiyazali

What is Hacktoberfest?

A month-long celebration from October 1st - 31st sponsored by Digital Ocean and GitHub to get people involved in Open Source. Create your very first pull request to any public repository on GitHub and contribute to the open source developer community.

https://hacktoberfest.digitalocean.com/

How to contribute to this project

Here are 3 quick ways to contribute to this project:

Star the Project.
Connect with Project Admin on Linkedin : https://linkedin.com/in/imtiyaz-sde/
Add your name to the CONTRIBUTORS.md file.

Make a pull request and wait for it to be merged!

Getting started

Fork this repository (Click the Fork button in the top right of this page, click your Profile Image)
Clone your fork down to your local machine

git clone https://github.com/SyedImtiyaz-1/PreciousServices-

Create a branch

git checkout -b "<your_branch_name>"

Make your changes (choose from any task below)
Commit and push

git add .
git commit -m 'Commit message'
git push origin <your_branch_name>

Starting Point of the Project :

The index.html which is the main starting point of the website. You can run it with Live Server.

Create a new pull request from your forked repository (Click the New Pull Request button located at the top of your repo)
Wait for your PR review and merge approval!
Star this repository if you had fun!

Add your name

Add your name to the CONTRIBUTORS.md file using the below convention:

#### Name: [YOUR NAME](GitHub link)
- Place: City, State, Country
- Bio: Who are you?
- GitHub: [GitHub account name](GitHub link)

note : Fill CONTRIBUTING.md only if you're contributed earlier or currently contributing to this project

BONUS!

See profiles submitted by fellow coders from around the globe.
Discover some obscure to new and trending languages.

New to Open Source ? No worries I will teach you how to contribute :

Join a 1:1 session with me ➡ https://topmate.io/syedimtiyazali

Connect with Project Admin on Linkedin : https://linkedin.com/in/imtiyaz-sde/

Our Contributors :

novuhq/hacksquad-website

2023-10-04T01:32:31Z

Site for Meshery, the cloud native manager

Meshery.io

Preview of Meshery.io Website

Visit Meshery.io to learn more!

What is Meshery?

Meshery is a self-service engineering platform - the open source, cloud native manager that enables the design and management of all Kubernetes-based infrastructure and applications. Among other features, Meshery manages multi-cluster Kubernetes deployments. As an extensible platform, Meshery offers visual and collaborative GitOps, freeing you from the chains of YAML.

For further information, refer to the Meshery Docs.

Join the Meshery community!

Our projects are community-built and welcome collaboration. 👍 Be sure to see the Newcomers' Guide for a tour of resources available to you and jump into our Slack to engage!

Find your MeshMate

MeshMates are experienced Layer5 community members, who will help you learn your way around, discover live projects and expand your community network. Become a Meshtee today!

Find out more about the Layer5 community.

✔️ Join any or all of the weekly meetings on the community calendar.
✔️ Watch community meeting recordings.
✔️ Access the Community Drive-by completing a community Member Form.
✔️ Discuss in the Community Forum.
✔️ RSVP to the CNCF Meshery Community meetings.

Not sure where to start? Grab an open issue with the help-wanted label.

Contributing to the Meshery.io Website

Before contributing, please review the Contribution Flow. In the following steps, you will setup your development environment, fork and clone the repository, run the site locally, and finally commit, sign off, and push any changes made for review.

1. Set up your development environment

The Meshery site is built using Jekyll - a simple static site generator! You can learn more about Jekyll and setting up your development environment in the Jekyll Docs.
First install Ruby, then install Jekyll and Bundler. ( Note : Install the same version of Ruby as mentioned in the Gemfile )

2. Get the code

Fork and then clone the Meshery.io repository

$ git clone https://github.com/YOUR-USERNAME/meshery.io

cd into project using
```
$ cd meshery.io
```

3. Serve the site

Serve the code locally
```
$ make site
```
Note: From the Makefile, this command is actually running $ bundle install; bundle exec jekyll serve --drafts --livereload

4. Create a Pull Request

After making changes, don't forget to commit with the sign-off flag (-s)!
```
$ git commit -s -m “my commit message w/signoff”
```
Once all changes have been committed, push the changes.
```
$ git push origin <branch-name>
```
Then on Github, navigate to the Meshery.io repository and create a pull request from your recently pushed changes!

License

This repository and site are available as open source under the terms of the Apache 2.0 License.

org-arl/ProtocolDataUnits.jl

2023-10-05T01:32:29Z

Encoders and decoders for Protocol Data Units

VirtualPlantLab/PlantGraphs.jl

2023-10-05T01:32:29Z

Dynamic graphs for simulating plant growth and development

XiaojingGeorgeZhang/OBCA

2023-10-05T01:32:29Z

Optimization-Based Collision Avoidance - a path planner for autonomous navigation

zero-to-mastery/file-io

2023-10-05T01:32:32Z

Create a Spotify Data Logger

Create a data processing file I/O script that reads data from a CSV file containing Spotify data and performs some analysis to complete one or more of the challenges outlined below.

The project is flexible enough to work with nearly any backend programming language. This README provides an overview of the project and explains how to adapt it to your chosen programming language.

Project Overview

The project consists of a script that reads data from a CSV file (spotify-2023.csv) and performs the following tasks.

Load Spotify data from the CSV file.
Create a folder for your project with your github handler.
Complete at least one of the challenges below.
Add your folder with your project to the submissions folder of this repo.
Include the script that runs your file.

Note: the project must successfully complete one of the challenges below to qualify for as a submission.

Challenges

Write a script to identify the number of songs in the file.
Write a script that identify the number of songs in the key of E.
Count the occurrences of values in a specified column (e.g., artist names) and determine the most common value.

Prerequisites

Before adapting this project to your chosen programming language, ensure that you have the following prerequisites:

Backend programming language of your choice.
A library or method for reading and parsing CSV files, if not built-in to your language of choice.
The CSV file (spotify-2023.csv) containing Spotify data that you want to analyze. Make sure to adjust the filename and path as needed.
The script that will run your file to output the results.

Getting Started

The usage instructions will vary depending on your chosen programming language. Below are the general steps to adapt this project:

Clone or Download: Clone or download this repository to your local machine.

Choose Your Backend Language: Open the project directory. In the submissions folder, create a new script or file in your chosen backend programming language.

Prerequisites: Ensure you have the required prerequisites for your chosen programming language, such as libraries for file I/O and CSV parsing.

Create Your File I/O Project: Use the programming language of your choice to create your project and read the data from the CSV file (spotify-2023.csv) and write a script to complete the challenges.

CSV Parsing: Use a CSV parsing library or method available in your programming language.

Data Processing: Write a script in your chosen programming language that creates methods, processes the data, and adds logic to successfully complete one or more of the coding challenges.

Run Your Script: Execute your adapted script using the appropriate command or method for your backend programming language.

License

This project is licensed under the MIT License - see the LICENSE file for details. You are free to modify and distribute the adapted code as needed for your own projects.

mlsanigeria/AI-Hacktober-MLSA

2023-10-05T01:32:32Z

Contributing to cutting-edge open-source projects in Machine Learning hosted my MLSA Nigeria

Hacktoberfest Open Source Challenge

Welcome to the Hacktoberfest Open Source Challenge organized by the Microsoft Learn Student Ambassadors Community! We're thrilled to have you on board for this exciting journey of collaboration and open-source contributions.

🛈 About the Challenge

This challenge focuses on two main tracks:

Pure Machine Learning (ML) Projects: Dive into the world of ML without relying on any cloud services. We aim to build innovative ML solutions from the ground up.
Microsoft-Powered Projects: Leverage the power of Microsoft products and tools to create impactful open-source solutions.

❓ How to Participate

Register for Hacktoberfest: Head over to the Hacktoberfest website to register, so your contributions to this repository can also be recorded towards Hacktoberfest.
Fork the Repository: Start by forking the repository to your GitHub account.
Choose a Project: Browse our projects and choose one that interests you. You can contribute to both tracks if you'd like!
Make Contributions: Make meaningful contributions by fixing bugs, adding new features, improving documentation, or addressing issues. Check out the Contribution Guidelines.
Submit a Pull Request: Submit your contributions as pull requests. Please follow our contribution guidelines outlined in the project's README.

Still confused about how to get started? 🤔 Watch the recording of our info session on how to participate in this challenge on Youtube.

🏆 Leaderboard

We maintain a leaderboard to track your contributions and their impact on our projects. The more you contribute, the higher you'll climb on the leaderboard.

Top 10 Contributors

Rank	Contributor	Merged PRs
1	ayoni02	3
2	Leommm-byte	1
2	andrefpoliveira	1

Thank you to all our fantastic contributors for their hard work and dedication!

Check out the full leaderboard here.

🥇 Prizes

We have exciting prizes for our top contributors, including LinkedIn Premium vouchers and more. Your contributions could earn you valuable rewards and recognition within the community.

💬 Get in Touch

If you have questions, need assistance, or want to discuss the projects, feel free to reach out to us:

Join our community on Whatsapp.
Connect with us on Twitter.

📣 Help Us Spread the Word

Help us make this initiative a success by sharing it with your network! Use the hashtag #Hacktoberfest to spread the word and encourage others to join.

Happy Hacking!🎉

Thank you for being part of the Hacktoberfest Open Source Challenge. Your contributions make a difference, and together, we can create amazing open-source solutions. Let's code, collaborate, and celebrate open source! 🚀

microsoft/OptiGuide

2023-10-05T01:32:32Z

Large Language Models for Supply Chain Optimization

OptiGuide: Large Language Models for Supply Chain Optimization

Supply chain operations traditionally involve a variety of complex decision making problems. Over the last few decades, supply chains greatly benefited from advances in computation, which allowed the transition from manual processing to automation and cost-effective optimization. Nonetheless, business operators still need to spend substantial efforts in explaining and interpreting the optimization outcomes to stakeholders. Motivated by the recent advances in Large Language Models (LLMs), we study how this disruptive technology can help bridge the gap between supply chain automation and human comprehension and trust thereof. We design OptiGuide – a framework that accepts as input queries in plain text, and outputs insights about the underlying optimization outcomes. Our framework does not forgo the state-of-the-art combinatorial optimization technology, but rather leverages it to quantitatively answer what-if scenarios (e.g., how would the cost change if we used supplier B instead of supplier A for a given demand?). Importantly, our design does not require sending proprietary data over to LLMs, which can be a privacy concern in some circumstances. We demonstrate the effectiveness of our framework on a real server placement scenario within Microsoft’s cloud supply chain. Along the way, we develop a general evaluation benchmark, which can be used to evaluate the accuracy of the LLM output in other scenarios.

This repository includes the following material to open source the OptiGuide project:

Research code base for the OptiGuide framework in the optiguide/optiguide.py file.
A demo notebook of the OptiGuide framework notebook/optiguide_example.ipynb
Benchmarks (dataset) in benchmark/ for evaluating language models for supply chain applications
Benchmark utils for future evaluation.
Create a GitHub release for the benchmark.

Citation

Please cite the paper if you use this code in your own work:

@article{li2023large,
  title={Large Language Models for Supply Chain Optimization},
  author={Li, Beibin and Mellou, Konstantina and Zhang, Bo and Pathuri, Jeevan and Menache, Ishai},
  journal={arXiv preprint arXiv:2307.03875},
  year={2023}
}

Setup for the OptiGuide Code

Installation

Once Python is installed, just run pip install optiguide to install OptiGuide.

Here is the Pypi page for more information.

Tutorial Option 1: Run from Colab Directly

Check the Colab Notebook:
Create a OAI_CONFIG_LIST file inside the Colab environment, so that it can connect to the OpenAI service.

[
    {
        "model": "gpt-4",
        "api_key": "Your API Key Comes Here",
        "api_type": "azure",
        "api_base": "The API base URL",
        "api_version": "2023-03-15-preview"
    }
]

Now, you can run the Colab Code.

Tutorial Option 2: Run Locally

Install Python and Python packages pip install optiguide
Install and setup "Gurobi Optimizer" from Gurobi's official website, and you can get a trial license for academic use. Make sure the license is setup correctly.
Run OptiGuide example, you can setup the OpenAI API (key and secret) and then test the code with Jupyter notebook example. Example notebook/OAI_CONFIG_LIST file

[
    {
        "model": "gpt-4",
        "api_key": "Your API Key Comes Here",
        "api_type": "azure",
        "api_base": "The API base URL",
        "api_version": "2023-03-15-preview"
    }
]

For Benchmark Evaluation

Install Python and Python packages pip install optiguide gurobipy requests beautifulsoup4
Download the Gurobi examples python download.py

Implementation

OptiGuide Implementation

We re-implemented OptiGuide for research purposes using autogen, a framework that enables the development of LLM applications with multiple agents that can converse with each other to solve tasks.

Evaluation Implementation

We simplified the evaluation process by using Gurobi and Gurobi examples, as detailed below.

Benchmark Dataset

We have gathered several Python applications from Gurobi's example code. These applications are copyrighted by Gurobi. The specific examples we are using include:

diet.py
facility.py
netflow.py
tsp.py
workforce1.py

Subsequently, we manually crafted questions and provided the ground truth answer code for each question. These labeled questions and answers can be found in the benchmark/macro folder.

To download the dataset from Gurobi and automatically edit the source code, execute python download.py. The source code for the benchmarked applications will then be saved in the benchmark/application folder.

Ensure you have the necessary packages installed using: pip install requests beautifulsoup4

Additionally, we developed a Coffee application to showcase the OptiGuide framework as described in our paper.

We acknowledge that both human and machine may contain errors while generating this benchmark. If you identify any inaccuracies, feel free to open an issue or submit a pull request for correction.

Responsible AI Considerations

The integration of Large Language Models (LLMs) into supply chain management has improved efficiency and offered human-like understanding. However, it's crucial to actively consider the ethical and responsible aspects of AI to ensure its application is both beneficial and free from unexpected consequences.

Since we use publicly available language models, our framework naturally adopts both the strengths and weaknesses of the underlying model. Aware of these challenges, we've implemented a safeguard mechanism to ensure the fairness and safety of the results. Yet, despite these safeguards, the complex nature of AI and its inherent flaws can give rise to issues like model biases, adversarial attacks, and other anomalies.

Researchers must critically assess and interpret these AI models, maintaining a comprehensive understanding of both the advantages and challenges of LLMs. By responsibly utilizing the capabilities of these models, we can achieve groundbreaking progress in supply chain practices and optimization, all while upholding ethical and unbiased principles.

Prohibitions

Due to the specialized nature of this repository, which includes both benchmark data and source code designed for evaluating data-oriented models and pipelines, we expressly prohibit the following:

Scraping the content of this repository for the purpose of training machine learning models, deep learning architectures, data science algorithms, large language models, or any other data-driven computational models. Utilizing this repository's content for such purposes could introduce bias and invalidate the evaluation metrics of the trained models. You are, however, permitted to use this repository for the evaluation of models and pipelines.
Violating the licensing terms in this repository.

Contributing

This project welcomes contributions and suggestions. Most contributions require you to agree to a Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us the rights to use your contribution. For details, visit https://cla.opensource.microsoft.com.

When you submit a pull request, a CLA bot will automatically determine whether you need to provide a CLA and decorate the PR appropriately (e.g., status check, comment). Simply follow the instructions provided by the bot. You will only need to do this once across all repos using our CLA.

This project has adopted the Microsoft Open Source Code of Conduct. For more information see the Code of Conduct FAQ or contact opencode@microsoft.com with any additional questions or comments.

Trademarks

This project may contain trademarks or logos for projects, products, or services. Authorized use of Microsoft trademarks or logos is subject to and must follow Microsoft's Trademark & Brand Guidelines. Use of Microsoft trademarks or logos in modified versions of this project must not cause confusion or imply Microsoft sponsorship. Any use of third-party trademarks or logos are subject to those third-party's policies.

auth0/Auth0.Android

2023-10-04T01:33:35Z

Android toolkit for Auth0 API

Note As part of our ongoing commitment to best security practices, we have rotated the signing keys used to sign previous releases of this SDK. As a result, new patch builds have been released using the new signing key. Please upgrade at your earliest convenience.

While this change won't affect most developers, if you have implemented a dependency signature validation step in your build process, you may notice a warning that past releases can't be verified. This is expected, and a result of the key rotation process. Updating to the latest version will resolve this for you.

📚 Documentation • 🚀 Getting Started • 💬 Feedback

Documentation

Getting Started

Requirements

Android API version 31 or later and Java 8+.

⚠ Applications targeting Android SDK version 30 and below should use version 2.9.0.

Here’s what you need in build.gradle to target Java 8 byte code for Android and Kotlin plugins respectively.

android {
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }

    kotlinOptions {
        jvmTarget = '1.8'
    }
}

Installation

To install Auth0.Android with Gradle, simply add the following line to your build.gradle file:

dependencies {
    implementation 'com.auth0.android:auth0:2.10.1'
}

Permissions

Open your app's AndroidManifest.xml file and add the following permission.

<uses-permission android:name="android.permission.INTERNET" />

Configure the SDK

First, create an instance of Auth0 with your Application information

val account = Auth0("{YOUR_CLIENT_ID}", "{YOUR_DOMAIN}")

Using Java

Auth0 account = new Auth0("{YOUR_CLIENT_ID}", "{YOUR_DOMAIN}");

Configure using Android Context

Alternatively, you can save your Application information in the strings.xml file using the following names:

<resources>
    <string name="com_auth0_client_id">YOUR_CLIENT_ID</string>
    <string name="com_auth0_domain">YOUR_DOMAIN</string>
</resources>

You can then create a new Auth0 instance by passing an Android Context:

val account = Auth0(context)

Authentication with Universal Login

First go to the Auth0 Dashboard and go to your application's settings. Make sure you have in Allowed Callback URLs a URL with the following format:

https://{YOUR_AUTH0_DOMAIN}/android/{YOUR_APP_PACKAGE_NAME}/callback

⚠️ Make sure that the application type of the Auth0 application is Native.

Replace {YOUR_APP_PACKAGE_NAME} with your actual application's package name, available in your app/build.gradle file as the applicationId value.

Next, define the Manifest Placeholders for the Auth0 Domain and Scheme which are going to be used internally by the library to register an intent-filter. Go to your application's build.gradle file and add the manifestPlaceholders line as shown below:

apply plugin: 'com.android.application'

android {
    compileSdkVersion 30
    defaultConfig {
        applicationId "com.auth0.samples"
        minSdkVersion 21
        targetSdkVersion 30
        //...

        //---> Add the next line
        manifestPlaceholders = [auth0Domain: "@string/com_auth0_domain", auth0Scheme: "https"]
        //<---
    }
    //...
}

It's a good practice to define reusable resources like @string/com_auth0_domain, but you can also hard-code the value.

The scheme value can be either https or a custom one. Read this section to learn more.

Declare the callback instance that will receive the authentication result and authenticate by showing the Auth0 Universal Login:

val callback = object : Callback<Credentials, AuthenticationException> {
    override fun onFailure(exception: AuthenticationException) {
        // Failure! Check the exception for details
    }

    override fun onSuccess(credentials: Credentials) {
        // Success! Access token and ID token are presents
    }
}

WebAuthProvider.login(account)
    .start(this, callback)

Using coroutines

try {
    val credentials = WebAuthProvider.login(account)
        .await(requireContext())
    println(credentials)    
} catch(e: AuthenticationException) {
    e.printStacktrace()
}

Using Java

Callback<Credentials, AuthenticationException> callback = new Callback<Credentials, AuthenticationException>() {
    @Override
    public void onFailure(@NonNull AuthenticationException exception) {
        //failed with an exception
    }

    @Override
    public void onSuccess(@Nullable Credentials credentials) {
        //succeeded!
    }
};

WebAuthProvider.login(account)
    .start(this, callback);

The callback will get invoked when the user returns to your application. There are a few scenarios where this may fail:

When the device cannot open the URL because it doesn't have any compatible browser application installed. You can check this scenario with error.isBrowserAppNotAvailable.
When the user manually closed the browser (e.g. pressing the back key). You can check this scenario with error.isAuthenticationCanceled.
When there was a server error. Check the received exception for details.

If the redirect URL is not found in the Allowed Callback URLs of your Auth0 Application, the server will not make the redirection and the browser will remain open.

A note about App Deep Linking:

If you followed the configuration steps documented here, you may have noticed the default scheme used for the Callback URI is https. This works best for Android API 23 or newer if you're using Android App Links, but in previous Android versions this may show the intent chooser dialog prompting the user to choose either your application or the browser. You can change this behaviour by using a custom unique scheme so that the OS opens directly the link with your app.

Update the auth0Scheme Manifest Placeholder on the app/build.gradle file or update the intent-filter declaration in the AndroidManifest.xml to use the new scheme.
Update the Allowed Callback URLs in your Auth0 Dashboard application's settings.
Call withScheme() in the WebAuthProvider builder passing the custom scheme you want to use.

WebAuthProvider.login(account)
    .withScheme("myapp")
    .start(this, callback)

Note that the schemes can only have lowercase letters.

Clearing the session

To log the user out and clear the SSO cookies that the Auth0 Server keeps attached to your browser app, you need to call the logout endpoint. This can be done in a similar fashion to how you authenticated before: using the WebAuthProvider class.

Make sure to revisit this section to configure the Manifest Placeholders if you still cannot authenticate successfully. The values set there are used to generate the URL that the server will redirect the user back to after a successful log out.

In order for this redirection to happen, you must copy the Allowed Callback URLs value you added for authentication into the Allowed Logout URLs field in your application settings. Both fields should have an URL with the following format:

https://{YOUR_AUTH0_DOMAIN}/android/{YOUR_APP_PACKAGE_NAME}/callback

Remember to replace {YOUR_APP_PACKAGE_NAME} with your actual application's package name, available in your app/build.gradle file as the applicationId value.

Initialize the provider, this time calling the static method logout.

//Declare the callback that will receive the result
val logoutCallback = object: Callback<Void?, AuthenticationException> {
    override fun onFailure(exception: AuthenticationException) {
        // Failure! Check the exception for details
    }

    override fun onSuccess(result: Void?) {
        // Success! The browser session was cleared
    }
}

//Configure and launch the log out
WebAuthProvider.logout(account)
        .start(this, logoutCallback)

Using coroutines

try {
    WebAuthProvider.logout(account)
        .await(requireContext())
    println("Logged out")
} catch(e: AuthenticationException) {
    e.printStacktrace()
}

Using Java

//Declare the callback that will receive the result
Callback<Void, AuthenticationException> logoutCallback = new Callback<Void, AuthenticationException>() {
    @Override
    public void onFailure(@NonNull Auth0Exception exception) {
        //failed with an exception
    }

    @Override
    public void onSuccess(@Nullable Void payload) {
        //succeeded!
    }
};

//Configure and launch the log out
WebAuthProvider.logout(account)
    .start(MainActivity.this, logoutCallback);

The callback will get invoked when the user returns to your application. There are a few scenarios where this may fail:

When the device cannot open the URL because it doesn't have any compatible browser application installed. You can check this scenario with error.isBrowserAppNotAvailable.
When the user manually closed the browser (e.g. pressing the back key). You can check this scenario with error.isAuthenticationCanceled.

If the returnTo URL is not found in the Allowed Logout URLs of your Auth0 Application, the server will not make the redirection and the browser will remain open.

Trusted Web Activity (Experimental Release)

⚠️ Warning: Trusted Web Activity support in Auth0.Android is still experimental and can change in the future.

Please test it thoroughly in all the targeted browsers and OS variants and let us know your feedback.

Trusted Web Activity is a feature provided by some browsers to provide a native look and feel.

To use this feature, there are some additional steps you must take:

We need the SHA256 fingerprints of the app’s signing certificate. To get this, you can run the following command on your APK:

keytool -printcert -jarfile sample-debug.apk

The fingerprint has to be updated in the Auth0 Dashboard under Applications > Specific Application > Settings > Advanced Settings > Device Settings > Key Hashes
The app's package name has to be entered in the field above

Once the above prerequisites are met, you can call your login method as shown below to open your web authentication in Trusted Web Activity.

WebAuthProvider.login(account)
    .withTrustedWebActivity()
    .await(this)

Credentials Manager

This library ships with two additional classes that help you manage the Credentials received during authentication.

Basic

The basic version supports asking for Credentials existence, storing them and getting them back. If the credentials have expired and a refresh_token was saved, they are automatically refreshed. The class is called CredentialsManager.

Usage

Instantiate the manager: You'll need an AuthenticationAPIClient instance to renew the credentials when they expire and a Storage object. We provide a SharedPreferencesStorage class that makes use of SharedPreferences to create a file in the application's directory with Context.MODE_PRIVATE mode.

val authentication = AuthenticationAPIClient(account)
val storage = SharedPreferencesStorage(this)
val manager = CredentialsManager(authentication, storage)

Using Java

AuthenticationAPIClient authentication = new AuthenticationAPIClient(account);
Storage storage = new SharedPreferencesStorage(this);
CredentialsManager manager = new CredentialsManager(authentication, storage);

Save credentials: The credentials to save must have expires_at and at least an access_token or id_token value. If one of the values is missing when trying to set the credentials, the method will throw a CredentialsManagerException. If you want the manager to successfully renew the credentials when expired you must also request the offline_access scope when logging in in order to receive a refresh_token value along with the rest of the tokens. i.e. Logging in with a database connection and saving the credentials:

authentication
    .login("info@auth0.com", "a secret password", "my-database-connection")
    .setScope("openid email profile offline_access")
    .start(object : Callback<Credentials, AuthenticationException> {
        override fun onFailure(exception: AuthenticationException) {
            // Error
        }

        override fun onSuccess(credentials: Credentials) {
            //Save the credentials
            manager.saveCredentials(credentials)
        }
    })

Using coroutines

try {
    val credentials = authentication
        .login("info@auth0.com", "a secret password", "my-database-connection")
        .setScope("openid email profile offline_access")
        .await()
    manager.saveCredentials(credentials)
} catch (e: AuthenticationException) {
    e.printStacktrace()
}

Using Java

authentication
    .login("info@auth0.com", "a secret password", "my-database-connection")
    .setScope("openid email profile offline_access")
    .start(new BaseCallback<Credentials, AuthenticationException>() {
        @Override
        public void onSuccess(Credentials payload) {
            //Save the credentials
            manager.saveCredentials(credentials);
        }

        @Override
        public void onFailure(AuthenticationException error) {
            //Error!
        }
    });

Note: This method has been made thread-safe after version 2.8.0.

Check credentials existence: There are cases were you just want to check if a user session is still valid (i.e. to know if you should present the login screen or the main screen). For convenience, we include a hasValidCredentials method that can let you know in advance if a non-expired token is available without making an additional network call. The same rules of the getCredentials method apply:

val authenticated = manager.hasValidCredentials()

Using Java

boolean authenticated = manager.hasValidCredentials();

Retrieve credentials: Existing credentials will be returned if they are still valid, otherwise the refresh_token will be used to attempt to renew them. If the expires_at or both the access_token and id_token values are missing, the method will throw a CredentialsManagerException. The same will happen if the credentials have expired and there's no refresh_token available.

manager.getCredentials(object : Callback<Credentials, CredentialsManagerException> {
    override fun onFailure(exception: CredentialsManagerException) {
        // Error
    }

    override fun onSuccess(credentials: Credentials) {
        // Use the credentials
    }
})

Using coroutines

try {
    val credentials = manager.awaitCredentials()
    println(credentials)
} catch (e: CredentialsManagerException) {
    e.printStacktrace()
}

Using Java

manager.getCredentials(new BaseCallback<Credentials, CredentialsManagerException>() {
    @Override
    public void onSuccess(Credentials credentials){
        //Use the Credentials
    }

    @Override
    public void onFailure(CredentialsManagerException error){
        //Error!
    }
});

Note: In the scenario where the stored credentials have expired and a refresh_token is available, the newly obtained tokens are automatically saved for you by the Credentials Manager. This method has been made thread-safe after version 2.8.0.

Clear credentials: When you want to log the user out:

manager.clearCredentials()

Feedback

Contributing

We appreciate feedback and contribution to this repo! Before you get started, please see the following:

Raise an issue

To provide feedback or report a bug, please raise an issue on our issue tracker.

Vulnerability Reporting

Please do not report security vulnerabilities on the public Github issue tracker. The Responsible Disclosure Program details the procedure for disclosing security issues.

Auth0 is an easy to implement, adaptable authentication and authorization platform. To learn more checkout Why Auth0?

This project is licensed under the MIT license. See the LICENSE file for more info.

Afterdie/octops

2023-10-05T01:33:05Z

Octops: An open-source Python/Kivy-based point-and-click puzzle game inspired by CS 1.6. Features four screens: Site A (3x3 button grid), Site B (hint-based), Doors (numeric puzzle), and Spawn (sliders). Solve puzzles to defuse the bomb. Join our open-source community to enhance gameplay, UI, and storytelling.

PatrickMassot/GlimpseOfLean

2023-10-04T01:33:48Z

An introduction to theorem proving in Lean for the impatient.

nvimtools/none-ls.nvim

2023-10-04T01:34:11Z

null-ls.nvim reloaded / Use Neovim as a language server to inject LSP diagnostics, code actions, and more via Lua.

none-ls.nvim

null-ls.nvim Reloaded, maintained by the community.

Only the repo name is changed for compatibility concerns. All the API and future changes will keep in place as-is.

Migration

Replace jose-elias-alvarez/null-ls.nvim with nvimtools/none-ls.nvim in your choice of package manager.

That's it.

Community

Open a pull request to become a collaborator. If you have contributed to null-ls.nvim before, simply open an issue or comment on that commit.

If you want to make changes, open a new a pull request. Find another collaborator to review your changes, as a review is required for the PR to be merged by yourself (subject to change if there are more collaborators in the future).

null-ls.nvim

Use Neovim as a language server to inject LSP diagnostics, code actions, and more via Lua.

Motivation

Neovim's LSP ecosystem is growing, and plugins like telescope.nvim and trouble.nvim make it a joy to work with LSP features like code actions and diagnostics.

Unlike the VS Code and coc.nvim ecosystems, Neovim doesn't provide a way for non-LSP sources to hook into its LSP client. null-ls is an attempt to bridge that gap and simplify the process of creating, sharing, and setting up LSP sources using pure Lua.

null-ls is also an attempt to reduce the boilerplate required to set up general-purpose language servers and improve performance by removing the need for external processes.

Status

null-ls is in beta status. Please see below for steps to follow if something doesn't work the way you expect (or doesn't work at all).

null-ls is developed on and tested against the latest stable version of Neovim. Support for versions built from HEAD is provided on a best-effort basis, and users are encouraged to contribute fixes to any issues exclusive to these versions.

Features

null-ls sources are able to hook into the following LSP features:

Code actions
Diagnostics (file- and project-level)
Formatting (including range formatting)
Hover
Completion

null-ls includes built-in sources for each of these features to provide out-of-the-box functionality. See BUILTINS for a list of available built-in sources and BUILTIN_CONFIG for instructions on how to set up and configure these sources.

null-ls also provides helpers to streamline the process of spawning and transforming the output of command-line processes into an LSP-friendly format. If you want to create your own source, either for personal use or for a plugin, see HELPERS for details.

Setup

Install null-ls using your favorite package manager. The plugin depends on plenary.nvim, which you are (probably) already using.

To get started, you must set up null-ls and register at least one source. See BUILTINS for a list of available built-in sources and CONFIG for information about setting up and configuring null-ls.

local null_ls = require("null-ls")

null_ls.setup({
    sources = {
        null_ls.builtins.formatting.stylua,
        null_ls.builtins.diagnostics.eslint,
        null_ls.builtins.completion.spell,
    },
})

Documentation

The definitive source for information about null-ls is its documentation, which contains information about how null-ls works, how to set it up, and how to create sources.

Contributing

Contributions to add new features and built-ins for any language are always welcome. See CONTRIBUTING for guidelines.

Examples

Parsing buffer content

The following example demonstrates a diagnostic source that will parse the current buffer's content and show instances of the word really as LSP warnings.

local null_ls = require("null-ls")

local no_really = {
    method = null_ls.methods.DIAGNOSTICS,
    filetypes = { "markdown", "text" },
    generator = {
        fn = function(params)
            local diagnostics = {}
            -- sources have access to a params object
            -- containing info about the current file and editor state
            for i, line in ipairs(params.content) do
                local col, end_col = line:find("really")
                if col and end_col then
                    -- null-ls fills in undefined positions
                    -- and converts source diagnostics into the required format
                    table.insert(diagnostics, {
                        row = i,
                        col = col,
                        end_col = end_col + 1,
                        source = "no-really",
                        message = "Don't use 'really!'",
                        severity = vim.diagnostic.severity.WARN,
                    })
                end
            end
            return diagnostics
        end,
    },
}

null_ls.register(no_really)

Parsing CLI program output

null-ls includes helpers to simplify the process of spawning and capturing the output of CLI programs. This example shows how to pass the content of the current buffer to markdownlint via stdin and convert its output (which it sends to stderr) into LSP diagnostics:

local null_ls = require("null-ls")
local helpers = require("null-ls.helpers")

local markdownlint = {
    method = null_ls.methods.DIAGNOSTICS,
    filetypes = { "markdown" },
    -- null_ls.generator creates an async source
    -- that spawns the command with the given arguments and options
    generator = null_ls.generator({
        command = "markdownlint",
        args = { "--stdin" },
        to_stdin = true,
        from_stderr = true,
        -- choose an output format (raw, json, or line)
        format = "line",
        check_exit_code = function(code, stderr)
            local success = code <= 1

            if not success then
                -- can be noisy for things that run often (e.g. diagnostics), but can
                -- be useful for things that run on demand (e.g. formatting)
                print(stderr)
            end

            return success
        end,
        -- use helpers to parse the output from string matchers,
        -- or parse it manually with a function
        on_output = helpers.diagnostics.from_patterns({
            {
                pattern = [[:(%d+):(%d+) [%w-/]+ (.*)]],
                groups = { "row", "col", "message" },
            },
            {
                pattern = [[:(%d+) [%w-/]+ (.*)]],
                groups = { "row", "message" },
            },
        }),
    }),
}

null_ls.register(markdownlint)

FAQ

Something isn't working! What do I do?

NOTE: If you run into issues when using null-ls, please follow the steps below and do not open an issue on the Neovim repository. null-ls is not an actual LSP server, so we need to determine whether issues are specific to this plugin before sending anything upstream.

Make sure your configuration is in line with the latest version of this document.
Enable debug mode and check the output of your source(s). If the CLI program is not properly configured or is otherwise not running as expected, that's an issue with the program, not null-ls.
Check the documentation for available configuration options that might solve your issue.
If you're having trouble configuring null-ls or want to know how to achieve a specific result, open a discussion.
If you believe the issue is with null-ls itself or you want to request a new feature, open an issue and provide the information requested in the issue template.

My `:checkhealth` output is wrong! What do I do?

Checking whether a given command is executable is tricky, and null-ls' health check doesn't handle all cases. null-ls' internal command resolution is independent of its health check output, which is for informational purposes.

If you're not sure whether a given command is running as expected, enable debug mode and check your log.

How do I format files?

Use vim.lsp.buf.format(). See :help vim.lsp.buf.format() for usage instructions.

How do I format files on save?

See this wiki page.

How do I stop Neovim from asking me which server I want to use for formatting?

See this wiki page.

How do I view project-level diagnostics?

For a built-in solution, use :lua vim.diagnostic.setqflist(). You can also use a plugin like trouble.nvim.

How do I enable debug mode and get debug output?

Set debug flag to true in your config:

require("null-ls").setup({
    debug = true,
})

Use :NullLsLog to open your debug log in the current Neovim instance or :NullLsInfo to get the path to your debug log.

As with LSP logging, debug mode will slow down Neovim. Make sure to disable the option after you've collected the information you're looking for.

Does it work with (other plugin)?

In most cases, yes. null-ls tries to act like an actual LSP server as much as possible, so it should work seamlessly with most LSP-related plugins. If you run into problems, please try to determine which plugin is causing them and open an issue.

This wiki page mentions plugins that require specific configuration options / tweaks to work with null-ls.

How does it work?

Thanks to hard work by @folke, the plugin wraps the mechanism Neovim uses to spawn language servers to start a client entirely in-memory. The client attaches to buffers that match defined sources and receives and responds to requests, document changes, and other events from Neovim.

Will it affect my performance?

More testing is necessary, but since null-ls uses pure Lua and runs entirely in memory without any external processes, in most cases it should run faster than similar solutions. If you notice that performance is worse with null-ls than with an alternative, please open an issue!

I am seeing a formatting `timeout` error message

This issue occurs when a formatter takes longer than the default timeout value. This is an automatic mechanism and controlled by Neovim. You might want to increase the timeout in your call:

vim.lsp.buf.format({ timeout_ms = 2000 })

Tests

The test suite includes unit and integration tests and depends on plenary.nvim. Run make test in the root of the project to run the suite or FILE=filename_spec.lua make test-file to test an individual file.

To avoid a dependency on any plugin managers, the test suite will set up its plugin runtime under the ./tests directory to always have a plenary version available.

If you run into plenary-related issues while running the tests, make sure you have an up-to-date version of the plugin by clearing that cache with: make clean.

All tests expect to run on the latest release version of Neovim and are not guaranteed to work on versions built from HEAD.

Alternatives

efm-langserver and diagnostic-languageserver: general-purpose language servers that can provide formatting and diagnostics from CLI output.
nvim-lint: a Lua plugin that focuses on providing diagnostics from CLI output.
formatter.nvim: a Lua plugin that (surprise) focuses on formatting.
hover.nvim: Hover plugin framework for Neovim.

shagu/pfQuest-turtle

2023-10-05T01:33:34Z

A TurtleWoW DB extension for pfQuest

pfQuest (turtle)

This AddOn is a pfQuest extension, which adds support for the TurtleWoW Private Server. In order to run this extension, the latest version of pfQuest is always required and only enUS-Gameclients are supported.

Notice: Issues and bugs like "please add quest XYZ" and all other content requests will be silently ignored. This is, because the data is not manually added, but depends on the Turtle-WoW team to release their database to a trusted person that can produce pfQuest-turtle builds.

If you wish to contribute, please feel free to send a Pull Requests.

Install

The latest version of pfQuest is required for this module to work.

Download pfQuest-turtle
Unpack the Zip file
Rename the folder "pfQuest-turtle-master" to "pfQuest-turtle"
Copy "pfQuest-turtle" into Wow-Directory\Interface\AddOns
Restart Wow

shagu/pfUI

2023-10-05T01:33:34Z

A User Interface Replacement for World of Warcraft: Vanilla & TBC

pfUI

An AddOn for World of Warcraft: Vanilla (1.12.1) and The Burning Crusade (2.4.3), which aims to be a full replacement for the original interface. The design is inspired by several screenshots I've seen from TukUI, ElvUI and others. This addon delivers modern features and a minimalistic style that's easy to use right from the start. It is entirely written from scratch without any inclusion of third-party addons or libraries.

This is not an addon-pack like ShaguUI, however, there is support for external addons like MobHealth3, DPSMate and others, but they will never be shipped within the package.

Please do not re-upload or distribute outdated versions of this project. However, you are more than welcome to fork or link to the official github page.

Screenshots

Installation (Vanilla)

Download Latest Version
Unpack the Zip file
Rename the folder "pfUI-master" to "pfUI"
Copy "pfUI" into Wow-Directory\Interface\AddOns
Restart Wow

Installation (The Burning Crusade)

Download Latest Version
Unpack the Zip file
Rename the folder "pfUI-master" to "pfUI-tbc"
Copy "pfUI-tbc" into Wow-Directory\Interface\AddOns
Restart Wow

Commands

/pfui         Open the configuration GUI
/share        Open the configuration import/export dialog
/gm           Open the ticket Dialog
/rl           Reload the whole UI
/farm         Toggles the Farm-Mode
/pfcast       Same as /cast but for mouseover units
/focus        Creates a Focus-Frame for the current target
/castfocus    Same as /cast but for focus frame
/clearfocus   Clears the Focus-Frame
/swapfocus    Toggle Focus and Target-Frame
/abp          Addon Button Panel

Languages

pfUI supports and contains language specific code for the following gameclients.

English (enUS)
Korean (koKR)
French (frFR)
German (deDE)
Chinese (zhCN)
Spanish (esES)
Russian (ruRU)

Recommended Addons

pfQuest A simple database and quest helper
WIM, WIM (continued) Give whispers an instant messenger feel

Plugins

pfUI-eliteoverlay Add elite dragons to unitframes
pfUI-fonts Additional fonts for pfUI
pfUI-CustomMedia Additional textures for pfUI
pfUI-Gryphons Add back the gryphons to your actionbars

FAQ

What does "pfUI" stand for?
The term "pfui!" is german and simply stands for "pooh!", because I'm not a big fan of creating configuration UI's, especially not via the Wow-API (you might have noticed that in ShaguUI).

How can I donate?
You can donate via GitHub or Ko-fi

How do I report a Bug?
Please provide as much information as possible in the Bugtracker. If there is an error message, provide the full content of it. Just telling that "there is an error" won't help any of us. Please consider adding additional information such as: since when did you got the error, does it still happen using a clean configuration, what other addons are loaded and which version you're running. When playing with a non-english client, the language might be relevant too. If possible, explain how people can reproduce the issue.

How can I contribute?
Report Errors, Issues and Feature Requests in the Bugtracker. Please make sure to have the latest version installed and check for conflicting addons beforehand.

I have bad performance, what can I do?
There's only one known performance issue: that is while using "Frame Shadows". Make sure to disable those in the pfUI settings (Settings -> Appearance -> Enable Frame Shadows). If you still have a low performance, it's most likely a combination with another addon. Disable all AddOns but pfUI and then enable one-by-one, till the performance problem occurs again. Make sure to report the identified AddOn and what you did to reproduce via the Bugtracker.

Where is the happiness indicator for pets?
The pet happiness is shown as the color of your pet's frame. Depending on your skin, this can either be the text or the background color of your pet's healthbar:

Green = Happy
Yellow = Content
Red = Unhappy

Since version 4.0.7 there is also an additional icon that can be enabled from the pet unit frame options.

Can I use Clique with pfUI?
This addon already includes support for clickcasting. If you still want to make use of clique, all pfUI's unitframes are already compatible to Clique-TBC. For Vanilla, a pfUI compatible version can be found Here. If you want to keep your current version of Clique, you'll have to apply this Patch.

Where is the Experience Bar?
The experience bar shows up on mouseover and whenever you gain experience, next to left chatframe by default. There's also an option to make it stay visible all the time.

How do I show the Damage- and Threatmeter Dock?
If you enabled the "dock"-feature for your external (third-party) meters such as DPSMate or KTM, then you'll be able to toggle between them and the Right Chat by clicking on the ">" symbol on the bottom-right panel.

Why is my chat always resetting to only 3 lines of text?
You need to disable the "Simple Chat" in blizzards interface settings (Advanced Options). Then relog and reset/run the firstrun wizard again.

How can I enable mouseover cast?
On Vanilla, create a macro with "/pfcast SPELLNAME". If you also want to see the cooldown, You might want to add "/run if nil then CastSpellByName("SPELLNAME") end" on top of the macro. For The Burning Crusade, just use the regular mouseover macros.

Will there be pfUI for Activision's "Classic" remakes?
No, it would require an entire rewrite of the AddOn since the game is now a different one. The AddOn-API has evolved during the last 15 years and the new "Classic" versions are based on a current retail gameclient. I don't plan to play any of those new versions, so I won't be porting any of my addons to it.

Everything from scratch?! Are you insane?
Most probably, yes.

lukas-reineke/ci-template.nvim

2023-10-05T01:33:54Z

A template for Neovim plugin CI with GitHub actions

cfayehc/EGSC110-Data

2023-10-05T01:33:57Z

LGUG2Z/nixos-wsl-starter

2023-10-04T01:35:39Z

A sane, batteries-included starter template for running NixOS on WSL

jonmircha/amerike-template-eleventy-3dev

2023-10-05T01:35:05Z

tihmstar/micSpy

2023-10-04T01:35:54Z

zendesk/chat_providers_sdk_ios

2023-10-04T01:35:56Z

Zendesk Chat Providers SDK

⚠ Use of this software is subject to important terms and conditions as set forth in the License file ⚠

Zendesk Chat Providers SDK for iOS

Zendesk Chat Providers SDK for mobile. Use the Chat Providers SDK to build your own Chat UI with our API providers.

Documentation

You can find our documentation on https://developer.zendesk.com/embeddables.

Feature requests and issues

All feature requests and issues are welcomed. Please see our contributing guidelines to find out how to contact us.

Copyright and license

By downloading or using the Zendesk Chat Providers SDK, You agree to the Zendesk Master Subscription Agreement https://www.zendesk.com/company/customers-partners/#master-subscription-agreement and Application Developer and API License Agreement https://www.zendesk.com/company/customers-partners/#application-developer-api-license-agreement and acknowledge that such terms govern Your use of and access to the Chat Providers SDK.

If You make any Contributions (defined below) to the Zendesk Chat Providers SDK, You hereby grant Zendesk a royalty-free, worldwide, transferable, sub-licensable, irrevocable and perpetual license to incorporate into the Service or the Zendesk API or otherwise use and commercially exploit any Contributions. “Contribution” shall mean any work of authorship, including any modifications or additions to the Mobile SDK or derivative works thereof, that is submitted to Zendesk by You.

jliendro/itbaworks

2023-10-04T01:35:56Z

university ITBA works

itbaworks

university ITBA works

dmmulroy/ocaml-playlist-transfer

2023-10-05T01:35:35Z

Transfer playlists seamlessly between spotify and apple music

RedPRL/asai

2023-10-05T01:35:35Z

🩺 A library for compiler diagnostics

trentleslie/bioinfo_class

2023-10-04T01:37:22Z

Bag of semi-useful things

bag

Bag of semi-useful things

spatie/opening-hours

2023-10-05T01:36:12Z

Query and format a set of opening hours

A helper to query and format a set of opening hours

With spatie/opening-hours you create an object that describes a business' opening hours, which you can query for open or closed on days or specific dates, or use to present the times per day.

spatie/opening-hours can be used directly on Carbon thanks to cmixin/business-time so you can benefit opening hours features directly on your enhanced date objects.

A set of opening hours is created by passing in a regular schedule, and a list of exceptions.

// Add the use at the top of each file where you want to use the OpeningHours class:
use Spatie\OpeningHours\OpeningHours;

$openingHours = OpeningHours::create([
    'monday'     => ['09:00-12:00', '13:00-18:00'],
    'tuesday'    => ['09:00-12:00', '13:00-18:00'],
    'wednesday'  => ['09:00-12:00'],
    'thursday'   => ['09:00-12:00', '13:00-18:00'],
    'friday'     => ['09:00-12:00', '13:00-20:00'],
    'saturday'   => ['09:00-12:00', '13:00-16:00'],
    'sunday'     => [],
    'exceptions' => [
        '2016-11-11' => ['09:00-12:00'],
        '2016-12-25' => [],
        '01-01'      => [],                // Recurring on each 1st of January
        '12-25'      => ['09:00-12:00'],   // Recurring on each 25th of December
    ],
]);

// This will allow you to display things like:

$now = new DateTime('now');
$range = $openingHours->currentOpenRange($now);

if ($range) {
    echo "It's open since ".$range->start()."\n";
    echo "It will close at ".$range->end()."\n";
} else {
    echo "It's closed since ".$openingHours->previousClose($now)->format('l H:i')."\n";
    echo "It will re-open at ".$openingHours->nextOpen($now)->format('l H:i')."\n";
}

The object can be queried for a day in the week, which will return a result based on the regular schedule:

// Open on Mondays:
$openingHours->isOpenOn('monday'); // true

// Closed on Sundays:
$openingHours->isOpenOn('sunday'); // false

It can also be queried for a specific date and time:

// Closed because it's after hours:
$openingHours->isOpenAt(new DateTime('2016-09-26 19:00:00')); // false

// Closed because Christmas was set as an exception
$openingHours->isOpenOn('2016-12-25'); // false

It can also return arrays of opening hours for a week or a day:

// OpeningHoursForDay object for the regular schedule
$openingHours->forDay('monday');

// OpeningHoursForDay[] for the regular schedule, keyed by day name
$openingHours->forWeek();

// Array of day with same schedule for the regular schedule, keyed by day name, days combined by working hours
$openingHours->forWeekCombined();

// OpeningHoursForDay object for a specific day
$openingHours->forDate(new DateTime('2016-12-25'));

// OpeningHoursForDay[] of all exceptions, keyed by date
$openingHours->exceptions();

On construction you can set a flag for overflowing times across days. For example, for a night club opens until 3am on Friday and Saturday:

$openingHours = \Spatie\OpeningHours\OpeningHours::create([
    'overflow' => true,
    'friday'   => ['20:00-03:00'],
    'saturday' => ['20:00-03:00'],
], null);

This allows the API to further at yesterdays data to check if the opening hours are open from yesterdays time range.

You can add data in definitions then retrieve them:

$openingHours = OpeningHours::create([
    'monday' => [
        'data' => 'Typical Monday',
        '09:00-12:00',
        '13:00-18:00',
    ],
    'tuesday' => [
        '09:00-12:00',
        '13:00-18:00',
        [
            '19:00-21:00',
            'data' => 'Extra on Tuesday evening',
        ],
    ],
    'exceptions' => [
        '2016-12-25' => [
            'data' => 'Closed for Christmas',
        ],
    ],
]);

echo $openingHours->forDay('monday')->getData(); // Typical Monday
echo $openingHours->forDate(new DateTime('2016-12-25'))->getData(); // Closed for Christmas
echo $openingHours->forDay('tuesday')[2]->getData(); // Extra on Tuesday evening

In the example above, data are strings but it can be any kind of value. So you can embed multiple properties in an array.

For structure convenience, the data-hours couple can be a fully-associative array, so the example above is strictly equivalent to the following:

$openingHours = OpeningHours::create([
    'monday' => [
        'hours' => [
            '09:00-12:00',
            '13:00-18:00',
        ],
        'data' => 'Typical Monday',
    ],
    'tuesday' => [
        ['hours' => '09:00-12:00'],
        ['hours' => '13:00-18:00'],
        ['hours' => '19:00-21:00', 'data' => 'Extra on Tuesday evening'],
    ],
    // Open by night from Wednesday 22h to Thursday 7h:
    'wednesday' => ['22:00-24:00'], // use the special "24:00" to reach midnight included
    'thursday' => ['00:00-07:00'],
    'exceptions' => [
        '2016-12-25' => [
            'hours' => [],
            'data'  => 'Closed for Christmas',
        ],
    ],
]);

The last structure tool is the filter, it allows you to pass closures (or callable function/method reference) that take a date as a parameter and returns the settings for the given date.

$openingHours = OpeningHours::create([
    'monday' => [
       '09:00-12:00',
    ],
    'filters' => [
        function ($date) {
            $year         = intval($date->format('Y'));
            $easterMonday = new DateTimeImmutable('2018-03-21 +'.(easter_days($year) + 1).'days');
            if ($date->format('m-d') === $easterMonday->format('m-d')) {
                return []; // Closed on Easter Monday
                // Any valid exception-array can be returned here (range of hours, with or without data)
            }
            // Else the filter does not apply to the given date
        },
    ],
]);

If a callable is found in the "exceptions" property, it will be added automatically to filters so you can mix filters and exceptions both in the exceptions array. The first filter that returns a non-null value will have precedence over the next filters and the filters array has precedence over the filters inside the exceptions array.

Warning: We will loop on all filters for each date from which we need to retrieve opening hours and can neither predicate nor cache the result (can be a random function) so you must be careful with filters, too many filters or long process inside filters can have a significant impact on the performance.

It can also return the next open or close DateTime from a given DateTime.

// The next open datetime is tomorrow morning, because we’re closed on 25th of December.
$nextOpen = $openingHours->nextOpen(new DateTime('2016-12-25 10:00:00')); // 2016-12-26 09:00:00

// The next open datetime is this afternoon, after the lunch break.
$nextOpen = $openingHours->nextOpen(new DateTime('2016-12-24 11:00:00')); // 2016-12-24 13:00:00


// The next close datetime is at noon.
$nextClose = $openingHours->nextClose(new DateTime('2016-12-24 10:00:00')); // 2016-12-24 12:00:00

// The next close datetime is tomorrow at noon, because we’re closed on 25th of December.
$nextClose = $openingHours->nextClose(new DateTime('2016-12-25 15:00:00')); // 2016-12-26 12:00:00

Read the usage section for the full api.

Spatie is a webdesign agency based in Antwerp, Belgium. You'll find an overview of all our open source projects on our website.

Support us

We invest a lot of resources into creating best in class open source packages. You can support us by buying one of our paid products.

We highly appreciate you sending us a postcard from your hometown, mentioning which of our package(s) you are using. You'll find our address on our contact page. We publish all received postcards on our virtual postcard wall.

Installation

You can install the package via composer:

composer require spatie/opening-hours

Usage

The package should only be used through the OpeningHours class. There are also three value object classes used throughout, Time, which represents a single time, TimeRange, which represents a period with a start and an end, and openingHoursForDay, which represents a set of TimeRanges which can't overlap.

`Spatie\OpeningHours\OpeningHours`

`OpeningHours::create(array $data, $timezone = null, $toutputTimezone = null): Spatie\OpeningHours\OpeningHours`

Static factory method to fill the set of opening hours.

$openingHours = OpeningHours::create([
    'monday' => ['09:00-12:00', '13:00-18:00'],
    // ...
]);

If no timezone is specified, OpeningHours will just assume you always pass DateTime objects that have already the timezone matching your schedule.

If you pass a $timezone as a second argument or via the array-key 'timezone' (it can be either a DateTimeZone object or a string), then passed dates will be converted to this timezone at the beginning of each method, then if the method return a date object (such as nextOpen, nextClose, previousOpen, previousClose, currentOpenRangeStart or currentOpenRangeEnd), then it's converted back to original timezone before output so the object can reflect a moment in user local time while OpeningHours can stick in its own business timezone.

Alternatively you can also specify both input and output timezone (using second and third argument) or using an array:

$openingHours = OpeningHours::create([
    'monday' => ['09:00-12:00', '13:00-18:00'],
    'timezone' => [
        'input' => 'America/New_York',
        'output' => 'Europe/Oslo',
    ],
]);

`OpeningHours::mergeOverlappingRanges(array $schedule) : array`

For safety sake, creating OpeningHours object with overlapping ranges will throw an exception unless you pass explicitly 'overflow' => true, in the opening hours array definition. You can also explicitly merge them.

$ranges = [
  'monday' => ['08:00-11:00', '10:00-12:00'],
];
$mergedRanges = OpeningHours::mergeOverlappingRanges($ranges); // Monday becomes ['08:00-12:00']

OpeningHours::create($mergedRanges);
// Or use the following shortcut to create from ranges that possibly overlap:
OpeningHours::createAndMergeOverlappingRanges($ranges);

Not all days are mandatory, if a day is missing, it will be set as closed.

`OpeningHours::fill(array $data): Spatie\OpeningHours\OpeningHours`

The same as create, but non-static.

$openingHours = (new OpeningHours)->fill([
    'monday' => ['09:00-12:00', '13:00-18:00'],
    // ...
]);

`OpeningHours::forWeek(): Spatie\OpeningHours\OpeningHoursForDay[]`

Returns an array of OpeningHoursForDay objects for a regular week.

$openingHours->forWeek();

`OpeningHours::forWeekCombined(): array`

Returns an array of days. Array key is first day with same hours, array values are days that have the same working hours and OpeningHoursForDay object.

$openingHours->forWeekCombined();

`OpeningHours::forWeekConsecutiveDays(): array`

Returns an array of concatenated days, adjacent days with the same hours. Array key is first day with same hours, array values are days that have the same working hours and OpeningHoursForDay object.

Warning: consecutive days are considered from Monday to Sunday without looping (Monday is not consecutive to Sunday) no matter the days order in initial data.

$openingHours->forWeekConsecutiveDays();

`OpeningHours::forDay(string $day): Spatie\OpeningHours\OpeningHoursForDay`

Returns an OpeningHoursForDay object for a regular day. A day is lowercase string of the english day name.

$openingHours->forDay('monday');

`OpeningHours::forDate(DateTimeInterface $dateTime): Spatie\OpeningHours\OpeningHoursForDay`

Returns an OpeningHoursForDay object for a specific date. It looks for an exception on that day, and otherwise it returns the opening hours based on the regular schedule.

$openingHours->forDate(new DateTime('2016-12-25'));

`OpeningHours::exceptions(): Spatie\OpeningHours\OpeningHoursForDay[]`

Returns an array of all OpeningHoursForDay objects for exceptions, keyed by a Y-m-d date string.

$openingHours->exceptions();

`OpeningHours::isOpenOn(string $day): bool`

Checks if the business is open (contains at least 1 range of open hours) on a day in the regular schedule.

$openingHours->isOpenOn('saturday');

If the given string is a date, it will check if it's open (contains at least 1 range of open hours) considering both regular day schedule and possible exceptions.

$openingHours->isOpenOn('2020-09-03');
$openingHours->isOpenOn('09-03'); // If year is omitted, current year is used instead

`OpeningHours::isClosedOn(string $day): bool`

Checks if the business is closed on a day in the regular schedule.

$openingHours->isClosedOn('sunday');

`OpeningHours::isOpenAt(DateTimeInterface $dateTime): bool`

Checks if the business is open on a specific day, at a specific time.

$openingHours->isOpenAt(new DateTime('2016-26-09 20:00'));

`OpeningHours::isClosedAt(DateTimeInterface $dateTime): bool`

Checks if the business is closed on a specific day, at a specific time.

$openingHours->isClosedAt(new DateTime('2016-26-09 20:00'));

`OpeningHours::isOpen(): bool`

Checks if the business is open right now.

$openingHours->isOpen();

`OpeningHours::isClosed(): bool`

Checks if the business is closed right now.

$openingHours->isClosed();

`OpeningHours::nextOpen`

OpeningHours::nextOpen(
    ?DateTimeInterface $dateTime = null,
    ?DateTimeInterface $searchUntil = null,
    ?DateTimeInterface $cap = null,
) : DateTimeInterface`

Returns next open DateTime from the given DateTime ($dateTime or from now if this parameter is null or omitted).

If a DateTimeImmutable object is passed, a DateTimeImmutable object is returned.

Set $searchUntil to a date to throw an exception if no open time can be found before this moment.

Set $cap to a date so if no open time can be found before this moment, $cap is returned.

$openingHours->nextOpen(new DateTime('2016-12-24 11:00:00'));

`OpeningHours::nextClose`

OpeningHours::nextClose(
    ?DateTimeInterface $dateTime = null,
    ?DateTimeInterface $searchUntil = null,
    ?DateTimeInterface $cap = null,
) : DateTimeInterface`

Returns next close DateTime from the given DateTime ($dateTime or from now if this parameter is null or omitted).

If a DateTimeImmutable object is passed, a DateTimeImmutable object is returned.

Set $searchUntil to a date to throw an exception if no closed time can be found before this moment.

Set $cap to a date so if no closed time can be found before this moment, $cap is returned.

$openingHours->nextClose(new DateTime('2016-12-24 11:00:00'));

`OpeningHours::previousOpen`

OpeningHours::previousOpen(
    ?DateTimeInterface $dateTime = null,
    ?DateTimeInterface $searchUntil = null,
    ?DateTimeInterface $cap = null,
) : DateTimeInterface`

Returns previous open DateTime from the given DateTime ($dateTime or from now if this parameter is null or omitted).

If a DateTimeImmutable object is passed, a DateTimeImmutable object is returned.

Set $searchUntil to a date to throw an exception if no open time can be found after this moment.

Set $cap to a date so if no open time can be found after this moment, $cap is returned.

$openingHours->previousOpen(new DateTime('2016-12-24 11:00:00'));

`OpeningHours::previousClose`

OpeningHours::previousClose(
    ?DateTimeInterface $dateTime = null,
    ?DateTimeInterface $searchUntil = null,
    ?DateTimeInterface $cap = null,
) : DateTimeInterface`

Returns previous close DateTime from the given DateTime ($dateTime or from now if this parameter is null or omitted).

If a DateTimeImmutable object is passed, a DateTimeImmutable object is returned.

Set $searchUntil to a date to throw an exception if no closed time can be found after this moment.

Set $cap to a date so if no closed time can be found after this moment, $cap is returned.

$openingHours->nextClose(new DateTime('2016-12-24 11:00:00'));

`OpeningHours::diffInOpenHours(DateTimeInterface $startDate, DateTimeInterface $endDate) : float`

Return the amount of open time (number of hours as a floating number) between 2 dates/times.

$openingHours->diffInOpenHours(new DateTime('2016-12-24 11:00:00'), new DateTime('2016-12-24 16:34:25'));

`OpeningHours::diffInOpenMinutes(DateTimeInterface $startDate, DateTimeInterface $endDate) : float`

Return the amount of open time (number of minutes as a floating number) between 2 dates/times.

`OpeningHours::diffInOpenSeconds(DateTimeInterface $startDate, DateTimeInterface $endDate) : float`

Return the amount of open time (number of seconds as a floating number) between 2 dates/times.

`OpeningHours::diffInClosedHours(DateTimeInterface $startDate, DateTimeInterface $endDate) : float`

Return the amount of closed time (number of hours as a floating number) between 2 dates/times.

$openingHours->diffInClosedHours(new DateTime('2016-12-24 11:00:00'), new DateTime('2016-12-24 16:34:25'));

`OpeningHours::diffInClosedMinutes(DateTimeInterface $startDate, DateTimeInterface $endDate) : float`

Return the amount of closed time (number of minutes as a floating number) between 2 dates/times.

`OpeningHours::diffInClosedSeconds(DateTimeInterface $startDate, DateTimeInterface $endDate) : float`

Return the amount of closed time (number of seconds as a floating number) between 2 dates/times.

`OpeningHours::currentOpenRange(DateTimeInterface $dateTime) : false | TimeRange`

Returns a Spatie\OpeningHours\TimeRange instance of the current open range if the business is open, false if the business is closed.

$range = $openingHours->currentOpenRange(new DateTime('2016-12-24 11:00:00'));

if ($range) {
    echo "It's open since ".$range->start()."\n";
    echo "It will close at ".$range->end()."\n";
} else {
    echo "It's closed";
}

`OpeningHours::currentOpenRangeStart(DateTimeInterface $dateTime) : false | DateTime`

Returns a DateTime instance of the date and time since when the business is open if the business is open, false if the business is closed.

Note: date can be the previous day if you use night ranges.

$date = $openingHours->currentOpenRangeStart(new DateTime('2016-12-24 11:00:00'));

if ($date) {
    echo "It's open since ".$date->format('H:i');
} else {
    echo "It's closed";
}

`OpeningHours::currentOpenRangeEnd(DateTimeInterface $dateTime) : false | DateTime`

Returns a DateTime instance of the date and time until when the business will be open if the business is open, false if the business is closed.

Note: date can be the next day if you use night ranges.

$date = $openingHours->currentOpenRangeEnd(new DateTime('2016-12-24 11:00:00'));

if ($date) {
    echo "It will close at ".$date->format('H:i');
} else {
    echo "It's closed";
}

`OpeningHours::asStructuredData(strinf $format = 'H:i', string|DateTimeZone $timezone) : array`

Returns a OpeningHoursSpecification as an array.

$openingHours->asStructuredData();
$openingHours->asStructuredData('H:i:s'); // Customize time format, could be 'h:i a', 'G:i', etc.
$openingHours->asStructuredData('H:iP', '-05:00'); // Add a timezone
// Timezone can be numeric or string like "America/Toronto" or a DateTimeZone instance
// But be careful, the time is arbitrary applied on 1970-01-01, so it does not handle daylight
// saving time, meaning Europe/Paris is always +01:00 even in summer time.

`Spatie\OpeningHours\OpeningHoursForDay`

This class is meant as read-only. It implements ArrayAccess, Countable and IteratorAggregate so you can process the list of TimeRanges in an array-like way.

`Spatie\OpeningHours\TimeRange`

Value object describing a period with a start and an end time. Can be cast to a string in a H:i-H:i format.

`Spatie\OpeningHours\Time`

Value object describing a single time. Can be cast to a string in a H:i format.

Adapters

OpenStreetMap

You can convert OpenStreetMap format to OpeningHours object using osm-opening-hours (thanks to mgrundkoetter)

Changelog

Please see CHANGELOG for more information about what has changed recently.

Testing

composer test

Contributing

Please see CONTRIBUTING for details.

Security

If you've found a bug regarding security please mail security@spatie.be instead of using the issue tracker.

Postcardware

You're free to use this package, but if it makes it to your production environment we highly appreciate you sending us a postcard from your hometown, mentioning which of our package(s) you are using.

Our address is: Spatie, Kruikstraat 22, 2018 Antwerp, Belgium.

We publish all received postcards on our company website.

Credits

License

The MIT License (MIT). Please see License File for more information.

FlipsideCrypto/crosschain-models

2023-10-05T01:36:41Z

oracle-samples/oracle-db-examples

2023-10-05T01:36:42Z

Examples of applications and tool usage for Oracle Database

CodingTrain/Creative-Coding-Processing-Full-Course

2023-10-04T01:38:16Z

Full Course: Creative Coding with Processing 4!

reddit/redditsans

2023-10-04T01:38:37Z

Reddit Sans. The typeface of the internet.

purescript/spago

2023-10-04T01:38:39Z

🍝 PureScript package manager and build tool

Qiskit/qiskit

2023-10-04T01:38:45Z

Qiskit is an open-source SDK for working with quantum computers at the level of extended quantum circuits, operators, and primitives.

Qiskit

Qiskit is an open-source SDK for working with quantum computers at the level of extended quantum circuits, operators, and primitives.

This library is the core component of Qiskit, which contains the building blocks for creating and working with quantum circuits, quantum operators, and primitive functions (sampler and estimator). It also contains a transpiler that supports optimizing quantum circuits and a quantum information toolbox for creating advanced quantum operators.

For more details on how to use Qiskit, refer to the documentation located here:

https://qiskit.org/documentation/

Installation

We encourage installing Qiskit via pip:

pip install qiskit

Pip will handle all dependencies automatically and you will always install the latest (and well-tested) version.

To install from source, follow the instructions in the documentation.

Create your first quantum program in Qiskit

Now that Qiskit is installed, it's time to begin working with Qiskit. The essential parts of a quantum program are:

Define and build a quantum circuit that represents the quantum state
Define the classical output by measurements or a set of observable operators
Depending on the output, use the primitive function sampler to sample outcomes or the estimator to estimate values.

Create an example quantum circuit using the QuantumCircuit class:

import numpy as np
from qiskit import QuantumCircuit

# 1. A quantum circuit for preparing the quantum state |000> + i |111>
qc_example = QuantumCircuit(3)
qc_example.h(0)          # generate superpostion
qc_example.p(np.pi/2,0)  # add quantum phase
qc_example.cx(0,1)       # 0th-qubit-Controlled-NOT gate on 1st qubit
qc_example.cx(0,2)       # 0th-qubit-Controlled-NOT gate on 2nd qubit

This simple example makes an entangled state known as a GHZ state $(|000\rangle + |111\rangle)/\sqrt{2}$. It uses the standard quantum gates: Hadamard gate (h), Phase gate (p), and CNOT gate (cx).

Once you've made your first quantum circuit, choose which primitive function you will use. Starting with sampler, we use measure_all(inplace=False) to get a copy of the circuit in which all the qubits are measured:

# 2. Add the classical output in the form of measurement of all qubits
qc_measured = qc_example.measure_all(inplace=False)

# 3. Execute using the Sampler primitive
from qiskit.primitives.sampler import Sampler
sampler = Sampler()
job = sampler.run(qc_measured, shots=1000)
result = job.result()
print(f" > Quasi probability distribution: {result.quasi_dists}")

Running this will give an outcome similar to {0: 0.497, 7: 0.503} which is 000 50% of the time and 111 50% of the time up to statistical fluctuations.
To illustrate the power of Estimator, we now use the quantum information toolbox to create the operator $XXY+XYX+YXX-YYY$ and pass it to the run() function, along with our quantum circuit. Note the Estimator requires a circuit without measurement, so we use the qc_example circuit we created earlier.

# 2. define the observable to be measured 
from qiskit.quantum_info import SparsePauliOp
operator = SparsePauliOp.from_list([("XXY", 1), ("XYX", 1), ("YXX", 1), ("YYY", -1)])

# 3. Execute using the Estimator primitive
from qiskit.primitives import Estimator
estimator = Estimator()
job = estimator.run(qc_example, operator, shots=1000)
result = job.result()
print(f" > Expectation values: {result.values}")

Running this will give the outcome 4. For fun, try to assign a value of +/- 1 to each single-qubit operator X and Y and see if you can achieve this outcome. (Spoiler alert: this is not possible!)

Using the Qiskit-provided qiskit.primitives.Sampler and qiskit.primitives.Estimator will not take you very far. The power of quantum computing cannot be simulated on classical computers and you need to use real quantum hardware to scale to larger quantum circuits. However, running a quantum circuit on hardware requires rewriting them to the basis gates and connectivity of the quantum hardware. The tool that does this is the transpiler and Qiskit includes transpiler passes for synthesis, optimization, mapping, and scheduling. However, it also includes a default compiler which works very well in most examples. The following code will map the example circuit to the basis_gates = ['cz', 'sx', 'rz'] and a linear chain of qubits $0 \rightarrow 1 \rightarrow 2$ with the coupling_map =[[0, 1], [1, 2]].

from qiskit import transpile
qc_transpiled = transpile(qc_example, basis_gates = ['cz', 'sx', 'rz'], coupling_map =[[0, 1], [1, 2]] , optimization_level=3)

For further examples of using Qiskit you can look at the tutorials in the documentation here:

https://qiskit.org/documentation/tutorials.html

Executing your code on real quantum hardware

Qiskit provides an abstraction layer that lets users run quantum circuits on hardware from any vendor that provides a compatible interface. The best way to use Qiskit is with a runtime environment that provides optimized implementations of sampler and estimator for a given hardware platform. This runtime may involve using pre- and post-processing, such as optimized transpiler passes with error suppression, error mitigation, and, eventually, error correction built in. A runtime implements qiskit.primitives.BaseSampler and qiskit.primitives.BaseEstimator interfaces. For example, some packages that provide implementations of a runtime primitive implementation are:

https://github.com/Qiskit/qiskit-ibm-runtime

Qiskit also provides a lower-level abstract interface for describing quantum backends. This interface, located in qiskit.providers, defines an abstract BackendV2 class that providers can implement to represent their hardware or simulators to Qiskit. The backend class includes a common interface for executing circuits on the backends; however, in this interface each provider may perform different types of pre- and post-processing and return outcomes that are vendor-defined. Some examples of published provider packages that interface with real hardware are:

You can refer to the documentation of these packages for further instructions on how to get access and use these systems.

Contribution Guidelines

If you'd like to contribute to Qiskit, please take a look at our contribution guidelines. By participating, you are expected to uphold our code of conduct.

We use GitHub issues for tracking requests and bugs. Please join the Qiskit Slack community for discussion, comments, and questions. For questions related to running or using Qiskit, Stack Overflow has a qiskit. For questions on quantum computing with Qiskit, use the qiskit tag in the Quantum Computing Stack Exchange (please, read first the guidelines on how to ask in that forum).

Authors and Citation

Qiskit is the work of many people who contribute to the project at different levels. If you use Qiskit, please cite as per the included BibTeX file.

Changelog and Release Notes

The changelog for a particular release is dynamically generated and gets written to the release page on Github for each release. For example, you can find the page for the 0.9.0 release here:

https://github.com/Qiskit/qiskit-terra/releases/tag/0.9.0

The changelog for the current release can be found in the releases tab: The changelog provides a quick overview of notable changes for a given release.

Additionally, as part of each release detailed release notes are written to document in detail what has changed as part of a release. This includes any documentation on potential breaking changes on upgrade and new features. For example, you can find the release notes for the 0.9.0 release in the Qiskit documentation here:

https://qiskit.org/documentation/release_notes.html#terra-0-9

Acknowledgements

We acknowledge partial support for Qiskit development from the DOE Office of Science National Quantum Information Science Research Centers, Co-design Center for Quantum Advantage (C2QA) under contract number DE-SC0012704.

License

Apache License 2.0

goauthentik/authentik

2023-10-04T01:38:45Z

The authentication glue you need.

What is authentik?

authentik is an open-source Identity Provider that emphasizes flexibility and versatility. It can be seamlessly integrated into existing environments to support new protocols. authentik is also a great solution for implementing sign-up, recovery, and other similar features in your application, saving you the hassle of dealing with them.

Installation

For small/test setups it is recommended to use Docker Compose; refer to the documentation.

For bigger setups, there is a Helm Chart here. This is documented here.

Screenshots

Light	Dark

Development

See Developer Documentation

Security

See SECURITY.md

Adoption and Contributions

Your organization uses authentik? We'd love to add your logo to the readme and our website! Email us @ hello@goauthentik.io or open a GitHub Issue/PR! For more information on how to contribute to authentik, please refer to our CONTRIBUTING.md file.

ckan/ckan

2023-10-04T01:38:45Z

Welcome to the new nnU-Net!

Click here if you were looking for the old one instead.

Coming from V1? Check out the TLDR Migration Guide. Reading the rest of the documentation is still strongly recommended ;-)

What is nnU-Net?

Image datasets are enormously diverse: image dimensionality (2D, 3D), modalities/input channels (RGB image, CT, MRI, microscopy, ...), image sizes, voxel sizes, class ratio, target structure properties and more change substantially between datasets. Traditionally, given a new problem, a tailored solution needs to be manually designed and optimized - a process that is prone to errors, not scalable and where success is overwhelmingly determined by the skill of the experimenter. Even for experts, this process is anything but simple: there are not only many design choices and data properties that need to be considered, but they are also tightly interconnected, rendering reliable manual pipeline optimization all but impossible!

nnU-Net is a semantic segmentation method that automatically adapts to a given dataset. It will analyze the provided training cases and automatically configure a matching U-Net-based segmentation pipeline. No expertise required on your end! You can simply train the models and use them for your application.

Upon release, nnU-Net was evaluated on 23 datasets belonging to competitions from the biomedical domain. Despite competing with handcrafted solutions for each respective dataset, nnU-Net's fully automated pipeline scored several first places on open leaderboards! Since then nnU-Net has stood the test of time: it continues to be used as a baseline and method development framework (9 out of 10 challenge winners at MICCAI 2020 and 5 out of 7 in MICCAI 2021 built their methods on top of nnU-Net, we won AMOS2022 with nnU-Net)!

Please cite the following paper when using nnU-Net:

Isensee, F., Jaeger, P. F., Kohl, S. A., Petersen, J., & Maier-Hein, K. H. (2021). nnU-Net: a self-configuring 
method for deep learning-based biomedical image segmentation. Nature methods, 18(2), 203-211.

What can nnU-Net do for you?

If you are a domain scientist (biologist, radiologist, ...) looking to analyze your own images, nnU-Net provides an out-of-the-box solution that is all but guaranteed to provide excellent results on your individual dataset. Simply convert your dataset into the nnU-Net format and enjoy the power of AI - no expertise required!

If you are an AI researcher developing segmentation methods, nnU-Net:

offers a fantastic out-of-the-box applicable baseline algorithm to compete against
can act as a method development framework to test your contribution on a large number of datasets without having to tune individual pipelines (for example evaluating a new loss function)
provides a strong starting point for further dataset-specific optimizations. This is particularly used when competing in segmentation challenges
provides a new perspective on the design of segmentation methods: maybe you can find better connections between dataset properties and best-fitting segmentation pipelines?

What is the scope of nnU-Net?

nnU-Net is built for semantic segmentation. It can handle 2D and 3D images with arbitrary input modalities/channels. It can understand voxel spacings, anisotropies and is robust even when classes are highly imbalanced.

nnU-Net relies on supervised learning, which means that you need to provide training cases for your application. The number of required training cases varies heavily depending on the complexity of the segmentation problem. No one-fits-all number can be provided here! nnU-Net does not require more training cases than other solutions - maybe even less due to our extensive use of data augmentation.

nnU-Net expects to be able to process entire images at once during preprocessing and postprocessing, so it cannot handle enormous images. As a reference: we tested images from 40x40x40 pixels all the way up to 1500x1500x1500 in 3D and 40x40 up to ~30000x30000 in 2D! If your RAM allows it, larger is always possible.

How does nnU-Net work?

Given a new dataset, nnU-Net will systematically analyze the provided training cases and create a 'dataset fingerprint'. nnU-Net then creates several U-Net configurations for each dataset:

2d: a 2D U-Net (for 2D and 3D datasets)
3d_fullres: a 3D U-Net that operates on a high image resolution (for 3D datasets only)
3d_lowres → 3d_cascade_fullres: a 3D U-Net cascade where first a 3D U-Net operates on low resolution images and then a second high-resolution 3D U-Net refined the predictions of the former (for 3D datasets with large image sizes only)

Note that not all U-Net configurations are created for all datasets. In datasets with small image sizes, the U-Net cascade (and with it the 3d_lowres configuration) is omitted because the patch size of the full resolution U-Net already covers a large part of the input images.

nnU-Net configures its segmentation pipelines based on a three-step recipe:

Fixed parameters are not adapted. During development of nnU-Net we identified a robust configuration (that is, certain architecture and training properties) that can simply be used all the time. This includes, for example, nnU-Net's loss function, (most of the) data augmentation strategy and learning rate.
Rule-based parameters use the dataset fingerprint to adapt certain segmentation pipeline properties by following hard-coded heuristic rules. For example, the network topology (pooling behavior and depth of the network architecture) are adapted to the patch size; the patch size, network topology and batch size are optimized jointly given some GPU memory constraint.
Empirical parameters are essentially trial-and-error. For example the selection of the best U-net configuration for the given dataset (2D, 3D full resolution, 3D low resolution, 3D cascade) and the optimization of the postprocessing strategy.

How to get started?

Read these:

Additional information:

Competitions:

AutoPET II

Where does nnU-Net perform well and where does it not perform?

nnU-Net excels in segmentation problems that need to be solved by training from scratch, for example: research applications that feature non-standard image modalities and input channels, challenge datasets from the biomedical domain, majority of 3D segmentation problems, etc . We have yet to find a dataset for which nnU-Net's working principle fails!

Note: On standard segmentation problems, such as 2D RGB images in ADE20k and Cityscapes, fine-tuning a foundation model (that was pretrained on a large corpus of similar images, e.g. Imagenet 22k, JFT-300M) will provide better performance than nnU-Net! That is simply because these models allow much better initialization. Foundation models are not supported by nnU-Net as they 1) are not useful for segmentation problems that deviate from the standard setting (see above mentioned datasets), 2) would typically only support 2D architectures and 3) conflict with our core design principle of carefully adapting the network topology for each dataset (if the topology is changed one can no longer transfer pretrained weights!)

What happened to the old nnU-Net?

The core of the old nnU-Net was hacked together in a short time period while participating in the Medical Segmentation Decathlon challenge in 2018. Consequently, code structure and quality were not the best. Many features were added later on and didn't quite fit into the nnU-Net design principles. Overall quite messy, really. And annoying to work with.

nnU-Net V2 is a complete overhaul. The "delete everything and start again" kind. So everything is better (in the author's opinion haha). While the segmentation performance remains the same, a lot of cool stuff has been added. It is now also much easier to use it as a development framework and to manually fine-tune its configuration to new datasets. A big driver for the reimplementation was also the emergence of Helmholtz Imaging, prompting us to extend nnU-Net to more image formats and domains. Take a look here for some highlights.

Acknowledgements

nnU-Net is developed and maintained by the Applied Computer Vision Lab (ACVL) of Helmholtz Imaging and the Division of Medical Image Computing at the German Cancer Research Center (DKFZ).

ONLYOFFICE/DocSpace-buildtools

2023-10-05T01:38:25Z

rage-rb/rage

2023-10-05T01:38:42Z

Fast web framework compatible with Rails.

Rage

Inspired by Deno and built on top of Iodine, this is a Ruby web framework that is based on the following design principles:

Rails compatible API - Rails' API is clean, straightforward, and simply makes sense. It was one of the reasons why Rails was so successful in the past.
High performance - some think performance is not a major metric for a framework, but it's not true. Poor performance is a risk, and in today's world, companies refuse to use risky technologies.
API-only - the only technology we should be using to create web UI is JavaScript. Check out Vite if you don't know where to start.
Acceptance of modern Ruby - the framework includes a fiber scheduler, which means your code never blocks while waiting on IO.

Installation

Install the gem:

$ gem install rage-rb

Create a new app:

$ rage new my_app

Switch to your new application and install dependencies:

$ cd my_app
$ bundle

Start up the server and visit http://localhost:3000.

$ rage s

Start coding!

Getting Started

This gem is designed to be a drop-in replacement for Rails in API mode. Public API is mostly expected to match Rails, however, sometimes it's a little bit more strict.

Check out in-depth API docs for more information:

Also, see the changelog and upcoming-releases for currently supported and planned features.

Example

A sample controller could look like this:

require "net/http"

class PagesController < RageController::API
  rescue_from SocketError do |_|
    render json: { message: "error" }, status: 500
  end

  before_action :set_metadata

  def show
    page = Net::HTTP.get(URI("https://httpbin.org/json"))
    render json: { page: page, metadata: @metadata }
  end

  private

  def set_metadata
    @metadata = { format: "json", time: Time.now.to_i }
  end
end

Apart from RageController::API as a parent class, this is mostly a regular Rails controller. However, the main difference is under the hood - Rage runs every request in a separate fiber. During the call to Net::HTTP.get, the fiber is automatically paused, enabling the server to process other requests. Once the HTTP request is finished, the fiber will be resumed, potentially allowing to process hundreds of requests simultaneously.

To make this controller work, we would also need to update config/routes.rb. In this case, the file would look the following way:

Rage.routes.draw do
  get "page", to: "pages#show"
end

ℹ Note: Rage will automatically pause a fiber and continue to process other fibers on HTTP, PostgreSQL, and MySQL calls. Calls to Thread.join and Ractor.join will also automatically pause the current fiber.

Additionally, Fiber.await can be used to run several requests in parallel:

require "net/http"

class PagesController < RageController::API
  def index
    pages = Fiber.await(
      Fiber.schedule { Net::HTTP.get(URI("https://httpbin.org/json")) },
      Fiber.schedule { Net::HTTP.get(URI("https://httpbin.org/html")) },
    )

    render json: { pages: pages }
  end
end

ℹ Note: When using Fiber.await, it is important to wrap any instance of IO into a fiber using Fiber.schedule.

Benchmarks

hello world

class ArticlesController < ApplicationController
  def index
    render json: { hello: "world" }
  end
end

waiting on IO

require "net/http"

class ArticlesController < ApplicationController
  def index
    Net::HTTP.get(URI("<endpoint-that-responds-in-one-second>"))
    head :ok
  end
end

Upcoming releases

Version	Changes
0.2 ✅	Gem configuration by env. Add `skip_before_action`. Add `rescue_from`. Router updates: • make the `root` helper work correctly with `scope`; • support the `defaults` option;
0.3	CLI updates: • `routes` task; • `console` task; Support the `:if` and `:unless` options in `before_action`. Allow to set response headers.
0.4	Expose the `params` object. Support header authentication with `authenticate_with_http_token`. Router updates: • add the `resources` route helper; • add the `namespace` route helper; • support regexp constraints;
0.5	Implement Iodine-based equivalent of `ActionController::Live`. Use `ActionDispatch::RemoteIp`.
0.6	Expose the `cookies` object. Expose the `send_data` and `send_file` methods. Support conditional get with `etag` and `last_modified`.
0.7	Add request logging.
0.8	Collect app metrics.
0.9	Automatic code reloading in development.

Development

After checking out the repo, run bin/setup to install dependencies. Then, run rake spec to run the tests. You can also run bin/console for an interactive prompt that will allow you to experiment.

To install this gem onto your local machine, run bundle exec rake install. To release a new version, update the version number in version.rb, and then run bundle exec rake release, which will create a git tag for the version, push git commits and the created tag, and push the .gem file to rubygems.org.

Contributing

Bug reports and pull requests are welcome on GitHub at https://github.com/rage-rb/rage. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the code of conduct.

License

The gem is available as open source under the terms of the MIT License.

Code of Conduct

Everyone interacting in the Rage project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the code of conduct.

rails/solid_cache

2023-10-05T01:38:42Z

A database-backed ActiveSupport::Cache::Store

Solid Cache

Solid Cache is a database-backed Active Support cache store implementation.

Using SQL databases backed by SSDs we can have caches that are much larger and cheaper than traditional memory only Redis or Memcached backed caches.

Testing on HEY shows that reads and writes are 25%-50% slower than with a Redis cache (1.2ms vs 0.8-1ms per single-key read), but this is not a significant percentage of the overall request time.

If cache misses are expensive (up to 50x the cost of a hit on HEY), then there are big advantages to caches that can hold months rather than days of data.

Usage

To set Solid Cache as your Rails cache, you should add this to your environment config:

config.cache_store = :solid_cache_store

Solid Cache is a FIFO (first in, first out) cache. While this is not as efficient as an LRU cache, this is mitigated by the longer cache lifespans.

A FIFO cache is much easier to manage:

We don't need to track when items are read
We can estimate and control the cache size by comparing the maximum and minimum IDs.
By deleting from one end of the table and adding at the other end we can avoid fragmentation (on MySQL at least).

Installation

Add this line to your application's Gemfile:

gem "solid_cache"

And then execute:

$ bundle

Or install it yourself as:

$ gem install solid_cache

Add the migration to your app:

$ bin/rails solid_cache:install:migrations

Then run it:

$ bin/rails db:migrate

Configuration

Engine configuration

There are two options that can be set on the engine:

executor - the Rails executor used to wrap asynchronous operations, defaults to the app executor
connects_to - a custom connects to value for the abstract SolidCache::Record active record model. Requires for sharding and/or using a separate cache database to the main app.

These can be set in your Rails configuration:

Rails.application.configure do
  config.solid_cache.connects_to = {
    shards: {
      shard1: { writing: :cache_primary_shard1 },
      shard2: { writing: :cache_primary_shard2 }
    }
  }
end

Cache configuration

Solid Cache supports these options in addition to the standard ActiveSupport::Cache::Store options.

error_handler - a Proc to call to handle any ActiveRecord::ActiveRecordErrors that are raises (default: log errors as warnings)
expiry_batch_size - the batch size to use when deleting old records (default: 100)
expiry_method - what expiry method to use thread or job (default: thread)
max_age - the maximum age of entries in the cache (default: 2.weeks.to_i)
max_entries - the maximum number of entries allowed in the cache (default: nil, meaning no limit)
cluster - a Hash of options for the cache database cluster, e.g { shards: [:database1, :database2, :database3] }
clusters - and Array of Hashes for multiple cache clusters (ignored if :cluster is set)
active_record_instrumentation - whether to instrument the cache's queries (default: true)
clear_with - clear the cache with :truncate or :delete (default truncate, except for when Rails.env.test? then delete)
max_key_bytesize - the maximum size of a normalized key in bytes (default 1024)

For more information on cache clusters see Sharding the cache

Cache expiry

Solid Cache tracks writes to the cache. For every write it increments a counter by 1. Once the counter reaches 80% of the expiry_batch_size it adds a task to run on a background thread. That task will:

Check if we have exceeded the max_entries value (if set) by subtracting the max and min IDs from the SolidCache::Entry table (this is an estimate that ignores any gaps).
If we have it will delete expiry_batch_size entries
If not it will delete up to expiry_batch_size entries, provided they are all older than max_age.

Expiring when we reach 80% of the batch size allows us to expire records from the cache faster than we write to it when we need to reduce the cache size.

Only triggering expiry when we write means that the if the cache is idle, the background thread is also idle.

If you want the cache expiry to be run in a background job instead of a thread, you can set expiry_method to :job. This will enqueue a SolidCache::ExpiryJob.

Using a dedicated cache database

Add database configuration to database.yml, e.g.:

development:
  cache:
    database: cache_development
    host: 127.0.0.1
    migrations_paths: "db/cache/migrate"

Create database:

$ bin/rails db:create

Install migrations:

$ bin/rails solid_cache:install:migrations

Move migrations to custom migrations folder:

$ mkdir -p db/cache/migrate
$ mv db/migrate/*.solid_cache.rb db/cache/migrate

Set the engine configuration to point to the new database:

Rails.application.configure do
  config.solid_cache.connects_to = { default: { writing: :cache } }
end

Run migrations:

$ bin/rails db:migrate

Sharding the cache

Solid Cache uses the Maglev consistent hashing scheme to shard the cache across multiple databases.

To shard:

Add the configuration for the database shards to database.yml
Configure the shards via config.solid_cache.connects_to
Pass the shards for the cache to use via the cluster option

For example:

# config/database.yml
production:
  cache_shard1:
    database: cache1_production
    host: cache1-db
  cache_shard2:
    database: cache2_production
    host: cache2-db
  cache_shard3:
    database: cache3_production
    host: cache3-db


# config/environment/production.rb
Rails.application.configure do
  config.solid_cache.connects_to = {
    shards: {
      cache_shard1: { writing: :cache_shard1 },
      cache_shard2: { writing: :cache_shard2 },
      cache_shard3: { writing: :cache_shard3 },
    }
  }

  config.cache_store = [ :solid_cache_store, cluster: { shards: [ :cache_shard1, :cache_shard2, :cache_shard3 ] } ]
end

Secondary cache clusters

You can add secondary cache clusters. Reads will only be sent to the primary cluster (i.e. the first one listed).

Writes will go to all clusters. The writes to the primary cluster are synchronous, but asyncronous to the secondary clusters.

To specific multiple clusters you can do:

Rails.application.configure do
  config.solid_cache.connects_to = {
    shards: {
      cache_primary_shard1: { writing: :cache_primary_shard1 },
      cache_primary_shard2: { writing: :cache_primary_shard2 },
      cache_secondary_shard1: { writing: :cache_secondary_shard1 },
      cache_secondary_shard2: { writing: :cache_secondary_shard2 },
    }
  }

  primary_cluster = { shards: [ :cache_primary_shard1, :cache_primary_shard2 ] }
  secondary_cluster = { shards: [ :cache_primary_shard1, :cache_primary_shard2 ] }
  config.cache_store = [ :solid_cache_store, clusters: [ primary_cluster, secondary_cluster ] ]
end

Named shard destinations

By default, the node key used for sharding is the name of the database in database.yml.

It is possible to add names for the shards in the cluster config. This will allow you to shuffle or remove shards without breaking consistent hashing.

Rails.application.configure do
  config.solid_cache.connects_to = {
    shards: {
      cache_primary_shard1: { writing: :cache_primary_shard1 },
      cache_primary_shard2: { writing: :cache_primary_shard2 },
      cache_secondary_shard1: { writing: :cache_secondary_shard1 },
      cache_secondary_shard2: { writing: :cache_secondary_shard2 },
    }
  }

  primary_cluster = { shards: { cache_primary_shard1: :node1, cache_primary_shard2: :node2 } }
  secondary_cluster = { shards: { cache_primary_shard1: :node3, cache_primary_shard2: :node4 } }
  config.cache_store = [ :solid_cache_store, clusters: [ primary_cluster, secondary_cluster ] ]
end

Enabling encryption

Add this to an initializer:

ActiveSupport.on_load(:solid_cache_entry) do
  encrypts :value
end

Index size limits

The Solid Cache migrations try to create an index with 1024 byte entries. If that is too big for your database, you should:

Edit the index size in the migration
Set max_key_bytesize on your cache to the new value

Development

Run the tests with bin/rails test. By default, these will run against SQLite.

You can also run the tests against MySQL and PostgreSQL. First start up the databases:

$ docker compose up -d

Next, setup the database schema:

$ TARGET_DB=mysql bin/rails db:setup
$ TARGET_DB=postgres bin/rails db:setup

Then run the tests for the target database:

$ TARGET_DB=mysql bin/rails test
$ TARGET_DB=postgres bin/rails test

License

Solid Cache is licensed under MIT.

huytd/goxkey

2023-10-05T01:38:54Z

Bộ gõ tiếng Việt không có chức năng gì ngoài gõ tiếng Việt...

Gõkey - A Vietnamese input method editor.

⚡ Excellent performance (Gen Z translation: Blazing fast!)
🦀 Written completely in Rust.
⌨ Supported both Telex and VNI input method.
✨ Focused on typing experience and features that you will use.

About

This is my attempt to build an input method editor using only Rust. It's not the first, and definitely not the last.

The goal is to create an input method editor that enable users to type Vietnamese text on the computer using either VNI or TELEX method. Other than that, no other features are planned.

How to install

There are 2 options to download GõKey at this moment: Build from source or Download the Nightly build.

Option 1: Download the Nightly Build

Nightly build is the prebuilt binary that automatically bundled everytime we merged the code to the main branch.

You can download it at the Release page here: https://github.com/huytd/goxkey/releases/tag/nightly-build

Option 2: Build from source

The source code can be compiled easily:

Get the latest stable version of the Rust compiler (see here)
Install the cargo-bundle extension, this is necessary for bundling macOS apps

Checkout the source code of the gõkey project

git clone https://github.com/huytd/goxkey && cd goxkey

Run the bundle command:
```
cargo bundle
```

After that, you'll find the Gõ Key.app file in the target/debug/bundle folder. Copy it to your /Applications folder.

(Important!): Before you run the app, make you you already allowed Accessibility access for the app. Follow the guide in the Wiki to do so.

Without this step, the app will crash and can't be use.

Dependencies

core-foundation, core-graphics: for event handling on macOS
vi-rs: the Vietnamese Input Engine

Want to support the project?

It would be much appreciated if you want to make a small donation to support my work!

Your name will be put on a special place in the application as a thank you gesture from the development team!

orhun/daktilo

2023-10-05T01:38:54Z

Turn your keyboard into a typewriter! 📇

daktilo ("typewriter" in Turkish, pronounced "duck-til-oh", derived from the Ancient Greek word δάκτυλος for "finger") is a small command-line program that plays typewriter sounds every time you press a key. It also offers the flexibility to customize keypress sounds to your liking. You can use the built-in sound presets to create an enjoyable typing experience, whether you're crafting emails or up to some prank on your boss.

✨ Inspiration: "Taking notes in class with my typewriter"

Now you can recreate this moment without the actual need for a physical typewriter!

Table of Contents

Getting Started

Simply run daktilo for the classic typewriter effect.

There are also different presets available:

Preset Name	Description
`default`	the classic typewriter effect
`basic`	an alternative and more basic typewriter effect
`musicbox`	plays random notes like a music box
`ducktilo`	quack quack 🦆
`drumkit`	dum, tss, cha! 🥁

To list the presets:

daktilo --list

To use a preset:

daktilo --preset musicbox

Supported Platforms

Linux
- X11
- Wayland*
Windows
MacOS

Installation

Packaging status

Cargo

daktilo can be installed from crates.io:

cargo install daktilo

The minimum supported Rust version is 1.70.0.

On Linux, the following packages should be installed:

Arch Linux: alsa-lib libxtst libxi
Alpine Linux: alsa-lib-dev libxi-dev libxtst-dev
Debian/Ubuntu: libasound2-dev libxi-dev libxtst-dev

Arch Linux

daktilo can be installed from the official repositories using pacman:

pacman -S daktilo

Alpine Linux

daktilo is available for Alpine Edge. It can be installed via apk after enabling the testing repository.

apk add daktilo

Binary releases

See the available binaries for different targets from the releases page.

Build from source

Clone the repository.

git clone https://github.com/orhun/daktilo && cd daktilo/

Build.

CARGO_TARGET_DIR=target cargo build --release

Binary will be located at target/release/daktilo.

Usage

daktilo [OPTIONS]

Options:

-v, --verbose          Enables verbose logging [env: VERBOSE=]
-p, --preset <PRESET>  Sets the name of the sound preset to use [env: PRESET=]
-l, --list             Lists the available presets
-c, --config <PATH>    Sets the configuration file [env: DAKTILO_CONFIG=]
-i, --init             Writes the default configuration file
-h, --help             Print help
-V, --version          Print version

Configuration

daktilo can be configured with a configuration file using the TOML format.

The path of the configuration file can be specified via --config argument or DAKTILO_CONFIG environment variable.

It can also be placed in one of the following global locations:

<config_dir> / daktilo.toml
<config_dir> / daktilo/daktilo.toml
<config_dir> / daktilo/config

<config_dir> depends on the platform as shown in the following table:

Platform	Value	Example
Linux	`$XDG_CONFIG_HOME` or `$HOME`/.config	/home/orhun/.config
macOS	`$HOME`/Library/Application Support	/Users/Orhun/Library/Application Support
Windows	`{FOLDERID_RoamingAppData}`	C:\Users\Orhun\AppData\Roaming

See daktilo.toml for the default configuration options.

You can also create the default configuration file in the current directory with --init flag:

daktilo --init

Adding custom presets

The configuration file consists of an array of sound_preset entries.

To define an array in TOML, you can create different sections as follows:

[[sound_preset]]
name = "custom"
key_config = []

[[sound_preset]]
name = "another_custom"
key_config = []
disabled_keys = []

As shown above, sound_preset consists of 2 entries:

name: The name of the preset. It will be used in conjunction with --preset flag. e.g. --preset custom
key_config: An array of key press/release events for assigning audio files to the specified keys. It can also be used to control the volume etc.
disabled_keys: An array of keys that will not be used for playback.

Click for the list of available keys.

Alt, AltGr, Backspace, CapsLock, ControlLeft, ControlRight, Delete, DownArrow, End, Escape, F1, F10, F11, F12, F2, F3, F4, F5, F6, F7, F8, F9, Home, LeftArrow, MetaLeft, MetaRight, PageDown, PageUp, Return, RightArrow, ShiftLeft, ShiftRight, Space, Tab, UpArrow, PrintScreen, ScrollLock, Pause, NumLock, BackQuote, Num1, Num2, Num3, Num4, Num5, Num6, Num7, Num8, Num9, Num0, Minus, Equal, KeyQ, KeyW, KeyE, KeyR, KeyT, KeyY, KeyU, KeyI, KeyO, KeyP, LeftBracket, RightBracket, KeyA, KeyS, KeyD, KeyF, KeyG, KeyH, KeyJ, KeyK, KeyL, SemiColon, Quote, BackSlash, IntlBackslash, KeyZ, KeyX, KeyC, KeyV, KeyB, KeyN, KeyM, Comma, Dot, Slash, Insert, KpReturn, KpMinus, KpPlus, KpMultiply, KpDivide, Kp0, Kp1, Kp2, Kp3, Kp4, Kp5, Kp6, Kp7, Kp8, Kp9, KpDelete, Function, Unknown

As an example, here is how you can configure key_config:

key_config = [
  { event = "press", keys = "Return", files = [{ path = "ding.mp3", volume = 1.0 }] },
]

event: "press" or "release"
keys: A regular expression (regex) for matching the keys.
files: An array of files.
- path: The absolute path of the file. If the file is embedded in the binary (i.e. if it is inside sounds/ directory) then it is the name of the file without full path.
- volume: The volume of the sound. The value 1.0 is the "normal" volume (unfiltered input). Any value other than 1.0 will multiply each sample by this value.

If you have defined multiple files for a key event, you can also specify a strategy for how to play them:

key_config = [
  { event = "press", keys = ".*", files = [{ path = "1.mp3" }, { path = "2.mp3" }], strategy = "random" },
]

Currently supported strategies are:

strategy = "random": pick a random file from the list and play it.
strategy = "sequential": play the files sequentially.

Here is how you can combine everything together:

[[sound_preset]]
# Custom sound preset named "custom"
name = "custom"

# Key configurations for various events
key_config = [
  # When a key starting with "Key" is pressed, play 1.mp3, 2.mp3, and 3.mp3 sequentially
  { event = "press", keys = "Key*", files = [
    { path = "1.mp3" },
    { path = "2.mp3" },
    { path = "3.mp3" },
  ], strategy = "sequential" },

  # When a key starting with "Key" is released, play 4.mp3
  { event = "release", keys = "Key*", files = [
    { path = "4.mp3" },
  ] },

  # When a key starting with "Num" is pressed, play num.mp3 at a very high volume (10.0)
  { event = "press", keys = "Num*", files = [
    { path = "num.mp3", volume = 10.0 },
  ] },

  # When any key is pressed, play a random sound from cat.mp3, dog.mp3, or bird.mp3
  { event = "press", keys = ".*", files = [
    { path = "cat.mp3" },
    { path = "dog.mp3" },
    { path = "bird.mp3" },
  ], strategy = "random" },
]

# Disabled keys that won't trigger any sound events
disabled_keys = ["CapsLock", "NumLock"]

Similar Projects

bucklespring: Nostalgia bucklespring keyboard sound
selectric-mode: Make your Emacs sound like a proper typewriter

Acknowledgements

Huge thanks to H. Arda Güler for giving me the idea for this project, sharing the inspiration behind it and implementing the first iteration in Python.

Kudos! 👾

Donations

If you find daktilo and/or other projects on my GitHub useful, consider supporting me on GitHub Sponsors or becoming a patron!

Contributing

See our Contribution Guide and please follow the Code of Conduct in all your interactions with the project.

Also, see how you can add new presets here.

License

Licensed under either of Apache License Version 2.0 or The MIT License at your option.

🦀 ノ( º _ º ノ) - respect crables!

Copyright

pathikrit/scalgos

2023-10-04T01:40:28Z

algorithms in scala

Goals

Learn Scala
Text book implementations of common algorithms in idiomatic functional Scala
No external dependencies (except specs2 for tests)
Good tests and documentation

Building

Install git, scala and sbt: brew install git scala sbt
Clone project: git clone https://github.com/pathikrit/scalgos.git; cd scalgos
Build and run tests: sbt test

hmrc/ctc-presentation-notification-frontend

2023-10-04T01:40:28Z

ctc-presentation-notification-frontend

This is a placeholder README.md for a new repository

License

This code is open source software licensed under the Apache 2.0 License.

jinyus/related_post_gen

2023-10-04T01:40:47Z

Data Processing benchmark featuring Rust, Go, Swift, Zig etc.

Generate related posts based on tags. Sort by the number of shared tags.

Steps:

Read the posts JSON file.
Iterate over the posts and populate a map containing: tag -> List<Post> that has that tag
Iterate over the posts and for each post:
- Create a map: Post -> int to track the number of shared tags
- For each tag, Iterate over the posts that have that tag
- For each post, increment the shared tag count in the map.
Sort the related posts by the number of shared tags.
Write the top 5 related posts for each post to a new JSON file.

Run Benchmark

./run.sh go | rust | python | all

Rules

No:

FFI (including assembly inlining)
Unsafe code blocks
Custom benchmarking
Disabling runtime checks (bounds etc)

Must:

Parse json at runtime
Not hardcore number of posts
Support up to 100 tags
Use a stable release of the compiler/runtime

Updated Results from github workflow (raw data)

Language	Processing Time	Total (PT + I/O)
Go Concurrent	19.40 ms	58.7 ms
Rust Rayon	22.32 ms	42.7 ms
Go	36.83 ms	73.2 ms
Rust	39.83 ms	60.5 ms
Java (GraalVM)	56.00 ms	96.4 ms
Crystal	66.93 ms	131.1 ms
Vlang	70.18 ms	454.2 ms
Swift	77.43 ms	562.9 ms
Odin	85.18 ms	381.9 ms
Dart VM	125.75 ms	681.0 ms
Dart AOT	169.25 ms	335.4 ms
Zig	213.00 ms	262.0 ms
Fsharp	214.14 ms	1.095 s
JS (Deno)	219.80 ms	330.5 ms
JS (Node)	246.20 ms	337.7 ms
Java (JIT)	292.15 ms	610.2 ms
Julia v2	667.50 ms	5.821 s
JS (Bun)	915.60 ms	1.004 s
Numpy	1.02 s	1.228 s
Python	3.23 s	3.315 s

Old Results with details (on my machine)

Language	Processing Time	Total (+ I/O)	Details
Rust	-	4.5s	Initial
Rust v2	-	2.60s	Replace std HashMap with fxHashMap by phazer99
Rust v3	-	1.28s	Preallocate and reuse map and unstable sort by vdrmn and Darksonn
Rust v4	-	0.13s	Use Post index as key instead of Pointer and Binary Heap by RB5009
Rust v5	38ms	52ms	Rm hashing from loop and use vec[count] instead of map[index]count by RB5009
Rust v6	23ms	36ms	Optimized Binary Heap Ops by scottlamb
Rust Rayon	9ms	22ms	Parallelize by masmullin2000
Rust Rayon	8ms	22ms	Remove comparison out of hot loop
⠀	⠀	⠀	⠀
Go	-	1.5s	Initial
Go v2	-	80ms	Add rust optimizations
Go v3	56ms	70ms	Use goccy/go-json
Go v3	34ms	55ms	Use generic binaryheap by DrBlury
Go v4	26ms	50ms	Replace binary heap with custom priority queue
Go v5	20ms	43ms	Remove comparison out of hot loop
Go Con	10ms	33ms	Go concurrency by tirprox and DrBlury
Go Con v2	5ms	29ms	Use arena, use waitgroup, rm binheap by DrBlury
⠀	⠀	⠀	⠀
Python	-	7.81s	Initial
Python v2	1.35s	1.53s	Add rust optimizations by dave-andersen
Numpy	0.57s	0.85s	Numpy implementation by Copper280z
⠀	⠀	⠀	⠀
Crystal	50ms	96ms	Inital w/ previous optimizations
Crystal v2	33ms	72ms	Replace binary heap with custom priority queue
⠀	⠀	⠀	⠀
Odin	110ms	397ms	Ported from golang code
Odin v2	104ms	404ms	Remove comparison out of hot loop
⠀	⠀	⠀	⠀
Dart VM	125ms	530ms	Ported frog golang code
Dart bin	274ms	360ms	Compiled executable
⠀	⠀	⠀	⠀
Vlang	339ms	560ms	Ported from golang code
⠀	⠀	⠀	⠀
Zig	80ms	110ms	Provided by akhildevelops

tracelabs/tlosint-vm

2023-10-04T01:40:47Z

Trace Labs OSINT VM

Introduction

The repository includes a recipe file to build a Linux OSINT Distribution for Trace Labs based on the Kali Linux kali-vm script - https://gitlab.com/kalilinux/build-scripts/kali-vm

Releases

These are pre-generated bundles that can either import in to Virtualbox or VMWare. They are generated with the code in the Main branch of this repo with no interference from us. The goal here is to produce a finished product but give the users insight in to the "recipe" used to build it.

After you've downloaded the release that applies to you, it should be as simple as importing it in to your hypervisor.

https://github.com/tracelabs/tlosint-vm/releases

Login Credntials

osint osint

Obsidian

Note taking app Obsidian comes bundled with the VM. There is an icon on the desktop to launch Obisidian or you can run the appimage located in the home directory. We've already set up a vault for you called "TL Vault" that lives on the Desktop. The first time you run Obsidian open that vault folder. The default theme is the Trace Labs theme.

Build

If you'd rather build your own from source or modify the version we've released then building your own is as straight forward as: (Note: You don't need to do this if you've already downloaded a release and imported to hypervisor)

From a Kali Linux machine run the following commands:

git clone https://github.com/tracelabs/tlosint-vm
sudo apt -y install debos p7zip qemu-utils zerofree
cd tlosint-vm
chmod +x scripts/tl/*.sh
chmod +x scripts/*.sh
chmod +x *.sh
sudo ./build.sh
Locate the OVA in the images/ directory

Applications

The majority of OSINT tools no longer come pre-packaged with the VM. There is an option to download them via a script on the desktop though. This keeps the size of the release small enough to build and host on Github. If you want to install the tools in the script then:

Open a terminal
Navigate to the Desktop folder
Execute the install script with ./install-tools.sh

Resources

Reporting

TJ Null's OSINT Joplin template

Browsers

Data Analysis

Domains

Downloaders

Email

Frameworks

Phone Numbers

Social Media

Usernames

Other Tools

Configuration Settings

Firefox

Delete cookies/history on shutdown
Block geo tracking
Block mic/camera detection
Block Firefox tracking
Preload OSINT Bookmarks

Contributing

Are you interested in the VM development? Join us on Discord in #osint-vm channel.

PRs are welcome. We ask that you PR in to the Dev branch.

tvore/helm-lab

2023-10-04T01:41:10Z

code-423n4/2023-10-zksync

2023-10-04T01:41:19Z

Optimized token mixer for Ethereum utilizing zkSNARKs. 500% cheaper than Tornado cash

serial-coder/solidity-security-by-example

2023-10-04T01:41:19Z

Learn Solidity Smart Contract Security By Examples

KumaCrypto/MetaTrustCTFSolutions

2023-10-04T01:41:19Z

Solutions for Solidity challenges in MetaTrust CTF September 2023.

Purple-CSGO/CSGO-Config-Presets

2023-10-05T01:40:15Z

🎉 Presets of Config files for many scenarios in CS:GO and CS2 (Limited Test)

nown1ne/ezmail

2023-10-04T01:41:46Z

SavageCore/pd3-vault-cracker

2023-10-04T01:41:46Z

Generates vault code possibilities from fingerprints

ivoronin/TomatoBar

2023-10-04T01:41:53Z

🍅 World's neatest Pomodoro timer for macOS menu bar

TomatoBar

Overview

Have you ever heard of Pomodoro? It’s a great technique to help you keep track of time and stay on task during your studies or work. Read more about it on Wikipedia.

TomatoBar is world's neatest Pomodoro timer for the macOS menu bar. All the essential features are here - configurable work and rest intervals, optional sounds, discreet actionable notifications, global hotkey.

TomatoBar is fully sandboxed with no entitlements.

Download the latest release here or install using Homebrew:

$ brew install --cask tomatobar

If the app doesn't start, install using the --no-quarantine flag:

$ brew install --cask --no-quarantine tomatobar

Integration with other tools

Event log

TomatoBar logs state transitions in JSON format to ~/Library/Containers/com.github.ivoronin.TomatoBar/Data/Library/Caches/TomatoBar.log. Use this data to analyze your productivity and enrich other data sources.

Starting and stopping the timer

TomatoBar can be controlled using tomatobar:// URLs. To start or stop the timer from the command line, use open tomatobar://startStop.

Older versions

Touch bar integration and older macOS versions (earlier than Big Sur) are supported by TomatoBar versions prior to 3.0

Licenses

Timer sounds are licensed from buddhabeats

BachiLi/balboa_public

2023-10-05T01:41:17Z

balboa

UCSD CSE 167 codebase https://cseweb.ucsd.edu/~tzli/cse167/

Build

All the dependencies are included. Use CMake to build.

git clone --recurse-submodules https://github.com/BachiLi/balboa_public mkdir build
cd build
cmake ..
make -j

It requires compilers that support C++17 (gcc version >= 8, clang version >= 7, Apple Clang version >= 11.0, MSVC version >= 19.14).

For Windows users:

Install Visual Studio 2022 and Visual Studio Code. Choose "Desktop development with C++" and check "C++ CMake tools for Windows" on the recipe.
git clone --recurse-submodules https://github.com/BachiLi/balboa_public
cd balboa_public; mkdir build; cd build
cmake ..
At this point, you can either open up the balboa.sln in build folder and use Visual Studio as your IDE, or work with Visual Studio Code.

(optional) To build, run, and debug in VS Code:

In the bottom bar, configure CMake as follows (from left to right):
- Build variant: RelWithDebInfo.
- Active kit: Visual Studio ... x64, choose the appropriate one depending on your architecture.
- Default build target: balboa.

Create a launch.json in .vscode folder:

{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "hw1_1", 
            "type": "cppvsdbg", 
            "request": "launch", 
            "program": "${workspaceFolder}/build/${command:cmake.buildType}/balboa.exe",
            "cwd": "${workspaceFolder}/build/${command:cmake.buildType}", 
            "args": ["-hw", "1_1"]
        }
    ]
}

You can pass arguments using args.

Press Ctrl+Shift+D to start the debugger. You can set breakpoints, inspect variables, and trace callstack, etc.

Run

Try

cd build
./balboa -hw 1_1

This will generate an image "hw1_1.png".

Acknowledgement

stb_image, stb_image_write, json, tinyply, GLFW, and glad

We use stb_image and stb_image_write for reading & writing images.

We use json to parse JSON files.

We use tinyply for parsing PLY files.

We use glfw and glad for the OpenGL homeworks.

3D models and textures: Stanford 3D Scanning Repository, KickAir_8p, and Texturemontage.

robjhyndman/weird

2023-10-05T01:41:17Z

That's weird: Anomaly detection using R

That's weird

Anomaly and outlier detection using R

giellalt/lang-fit

2023-10-05T01:41:24Z

Finite state and Constraint Grammar based analysers and proofing tools, and language resources for the Meänkieli (Tornedalen Finnish) language

DataTech-Solutions/ECOLAB3D

2023-10-05T01:41:36Z

CrowdDotDev/crowd.dev

2023-10-04T01:42:44Z

⚡️ The developer data platform to centralize community, product, and customer data

Effortlessly centralize community, product, and customer data

🌐 Cloud version (beta) · 📖 Docs · ❤️ Discord · 📣 Newsletter · 🗺️ Roadmap

About crowd.dev

crowd.dev is the developer data platform (DDP) that lets companies centralize all touch points developers have with their product and brand - be it in community (e.g. Stack Overflow or Reddit), product (open-source or SaaS), or commercial channels (e.g. HubSpot). The platform pulls data from a variety of different sources, normalizes it, matches identities across platforms, and enriches it with 3rd party data. The result is a unified 360-view of who the developers are that engage with your product and community, which companies they work for, and where they stand in their personal customer journey.

crowd.dev is open-source, built with developers in mind, available for both hosted and self-hosted deployments, open to extensions, and offers full control over your data.

To our users:

You can get actively involved, contribute to our roadmap, and turn crowd.dev into the tool you always wanted.
We are open regarding what we are building, allowing you to take a look inside, and making sure we handle your data in a privacy-preserving way.
You will never be locked in by us. Our interests as a company are aligned with yours and we need to make sure that we always deliver enough value to your with our commercial offering in relation to our pricing.

To our developer community:

You can self-host crowd.dev to centralize data for your community or company while keeping full control over your data.
Our product is build for extensibilty. If you can think of any use cases that you want to build with the data we collect and store for you, please go ahead and build it! We will be here to help out if you need us.
You can actively contribute to crowd.dev (e.g. integrations), and we will be supporting you along the journey. Just take a look at our Contributing guide.

✨ Features

Plug & play integrations to tie all relevant platforms - like GitHub, Discord, Slack, or LinkedIn - together. (all integrations)
Identity resolution & automated segmentation to effortlessly understand activities and profiles across platforms.
Opinionated analytics & reports on topics like product-market-fit and open-source community activity to further inform your GTM strategy.
Workflows automation with webhooks.
2-way CRM sync & Slack alerts to get notified about intent events in real-time. [cloud only]
User enrichment with 25+ attributes, including emails, social profiles, work experience, and technical skills. [cloud only]
Organization enrichment with 50+ attributes, including industry, headcount, and revenue. [cloud only]
Sentiment analysis and conversation detection to stay on top of what's going on in your open source community. [cloud only]
Eagle Eye: Monitor dev-focussed community platforms to find relevant content to engage with, helping you to gain developers’ mindshare and grow your community organically [cloud only]

🚀 Getting started

Cloud version

Our cloud version is a fast, easy and free way to get started with crowd.dev.

Self-hosted version

To get started with self-hosting, take a look at our self-hosting docs.

Deployment with Kubernetes

Our services can be deployed using Kubernetes, as well as a lightweight development environment using Docker. You can read more about it in our self-hosting docs.

Integrations

We currently support all our integrations for self-hosting. For each one of them you will need to create your own application. You can see the steps for each integration in our self-hosting integrations guide.

Development environment

Requirements

Node v16.16.0
Docker and docker-compose

Getting started

Get the mono repo from GitHub

git clone git@github.com:CrowdDotDev/crowd.dev.git

Run the start script

cd scripts
./cli start

For hot reloading, you can run

cd scripts
./cli clean-start-dev

App will be available at http://localhost:8081

For more information on development, you can check our docs.

🗺️ Roadmap

You can find more features on our public roadmap. Feel free to also open an issue for anything you're missing.

🔔 Stay up-to-date

crowd.dev is still in beta and we ship new features every week. To stay in the loop, leave us a star and subscribe to our monthly newsletter. Thanks a lot! ❤️

✍️ Contribution

There are many ways you can contribute to crowd.dev! Here are a few options:

Star this repo
Create issues every time you feel something is missing or goes wrong
Upvote issues with 👍 reaction so we know what's the demand for particular issue to prioritize it within roadmap

If you would like to contribute to the development of the project, please refer to our Contributing guide.

All contributions are highly appreciated. 🙏

⚖️ License

Distributed under the Apache 2.0 License. See LICENSE for more information.

Our self-hosted version can be run and deployed by default following the permissive Apache 2.0 license. All premium components will be hidden and inactive with the default configuration. You can run, deploy, and contribute to the app without fearing to violate the premium license. Check out the premium self-hosted features docs to know more about the premium self-hosted features.

🔒 Security

We take security very seriously. If you come across any security vulnerabilities, please disclose them by sending an email to security@crowd.dev. We appreciate your help in making our platform as secure as possible and are committed to working with you to resolve any issues quickly and efficiently.

📞 Book a call

Call with a crowd.dev team member to learn more about our product and make sure you get the most out of it.

wasp-lang/wasp

2023-10-04T01:42:44Z

The fastest way to develop full-stack web apps with React & Node.js.

Web page | Docs

Wasp (Web Application Specification) is a Rails-like framework for React, Node.js and Prisma.
Build your app in a day and deploy it with a single CLI command!

Why is Wasp awesome

🚀 Quick start: Due to its expressiveness, you can create and deploy a production-ready web app from scratch with very few lines of concise, consistent, declarative code.
😌 No boilerplate: By abstracting away complex full-stack features, there is less boilerplate code. That means less code to maintain and understand! It also means easier upgrades.
🔓 No lock-in: You can deploy Wasp app anywhere you like. There is no lock-in into specific providers, you have full control over the code (and can actually check it out in .wasp/ dir if you are interested ).

Features

🔒 Full-stack Auth, 🖇️ RPC (Client <-> Server), 🚀 Simple Deployment, ⚙ ️Jobs, ✉️ Email Sending, 🛟 Full-stack Type Safety, ...

Code example

Simple Wasp config file in which you describe the high-level details of your web app:

// file: main.wasp

app todoApp {
  title: "ToDo App",  // visible in the browser tab
  wasp: { version: "^0.11.0" },
  auth: { // full-stack auth out-of-the-box
    userEntity: User, methods: { email: {...} }
  }
}

route RootRoute { path: "/", to: MainPage }
page MainPage {
  authRequired: true, // Limit access to logged in users.
  component: import Main from "@client/Main.tsx" // Your React code.
}

query getTasks {
  fn: import { getTasks } from "@server/tasks.js", // Your Node.js code.
  entities: [Task] // Automatic cache invalidation.
}

entity Task {=psl  // Your Prisma data model.
    id          Int     @id @default(autoincrement())
    description String
    isDone      Boolean @default(false)
psl=}

The rest of the code you write in React / Node.js / Prisma and just reference it from the .wasp file.

▶ Check out TodoApp example for the complete code example. ◀

How it works

Given a simple .wasp configuration file that describes the high-level details of your web app, and .js(x)/.css/..., source files with your unique logic, Wasp compiler generates the full source of your web app in the target stack: front-end, back-end and deployment.

This unique approach is what makes Wasp "smart" and gives it its super powers!

For more information about Wasp, check docs.

Get started

Run

curl -sSL https://get.wasp-lang.dev/installer.sh | sh

to install Wasp on OSX/Linux/WSL(Win). From there, just follow the instructions to run your first app in less than a minute!

For more details check out the docs.

This repository

This is the main repo of the Wasp universe, containing core code (mostly waspc - Wasp compiler) and the supporting materials.

Project status

Currently, Wasp is in beta, with most features flushed out and working well. However, there are still a lot of improvements and additions that we have in mind for the future, and we are working on them constantly, so you can expect a lot of changes and improvements in the future.

While the idea is to support multiple web tech stacks in the future, right now we are focusing on the specific stack: React + react-query, NodeJS + ExpressJS, Prisma.

Contributing

Any way you want to contribute is a good way :)!

The best place to start is to check out waspc/, where you can find detailed steps for the first time contributors + technical details about the Wasp compiler.

Core of Wasp is built in Haskell, but there is also a lot of non-Haskell parts of Wasp, so you will certainly be able to find something for you!

Even if you don't plan to submit any code, just joining the discussion on discord and giving your feedback is already great and helps a lot (motivates us and helps us figure out how to shape Wasp)!

You can also:

⭐ Star this repo to show your interest/support.
📫 Stay updated by subscribing to our email list.
💬 Join the discussion at https://github.com/wasp-lang/wasp/discussions .

Careers

Check our careers page for a list of currently opened positions!

aidenybai/pattycake

2023-10-04T01:42:44Z

All your services in one place, built by the community

Ferdium

Ferdium

🤴🏽 Hard-fork of Franz, adding awesome features and removing unwanted ones.

Ferdium is a desktop app that helps you organize how you use your favourite apps by combining them into one application. It is based on Franz - a software already used by thousands of people - with the difference that Ferdium gives you many additional features and doesn't restrict its usage! Furthermore, Ferdium is compatible with your existing Franz account, so you can continue right where you left off. Please find out more about Ferdium and its features on ferdium.org.

Screenshots

Toggle screenshots

"Keep all your messaging services in one place." "Order your services with Ferdium Workspaces." "Always keep your Todos list open with Ferdium Todos." "Supporting all your services."

Download

👉 ferdium.org/download

Assets made available via GitHub releases.

Find answers to frequently asked questions on ferdium.org/faq.

Migrating from Ferdi

If you are a pre-existing user of Ferdi, and are thinking of switching to Ferdium, you might want to run the following scripts to migrate your existing Ferdi profile such that Ferdium can pick up the configurations. (.ps1 for PowerShell/Windows users and .sh for UNIX (Linux and MacOS users). For a more detailed explanation, please see MIGRATION.md

Styling

You can style Ferdium's UI with the USER_DATA/Ferdium/config/custom.css file.

Note

USER_DATA's location depends on your platform:

Windows: %APPDATA%

Linux: $XDG_CONFIG_HOME or ~/.config/

MacOS: ~/Library/Application Support

Contributing

Please read the contributing guidelines to setup your development machine and proceed.

Contributors ✨

Thanks goes to these wonderful people (emoji key):

This project follows the all-contributors specification. Contributions of any kind welcome!

systemdesignfightclub/SDFC

2023-10-04T01:24:45Z

Aprenda Elixir em 4 Pull Requests!

OtacilioN/awesome-hacktoberfest

2023-10-04T01:24:45Z

⏩ NeoHaskell is a dialect of Haskell that is focused on newcomer-friendliness and productivity.

free-educa/free-livros

2023-10-04T01:24:45Z

Educação é um direito de todos

CoverGo/HiringFullstackTemplate

2023-10-04T01:43:20Z

🧊 WebGL上车指南，带你从零开始体系化学习 WebGL。

hakadao/BewlyBewly

2023-10-04T01:43:20Z

Improve your Bilibili homepage by redesigning it, adding more features, and personalizing it to match your preferences.

realstoman/vuejs-tailwindcss-portfolio

2023-10-04T01:43:20Z

A simple multipage and responsive Vue.js & Tailwind CSS portfolio theme with dark mode.

giellalt/lang-fkv

2023-10-04T01:43:54Z

Finite state and Constraint Grammar based analysers and proofing tools, and language resources for the Kven Finnish language

GitHub 1C Enterprise Daily Trending

usebruno/bruno

Efficient Streaming Language Models with Attention Sinks [paper]

TL;DR

Abstract

Usage

Environment Setup

Run Streaming Llama Chatbot

FAQ

TODOs

Citation

phitronio/Batch-4-Introduction-to-C-Programming

localpilot

Demo Video

Installation

Caveat FAQ

TheAlgorithms/Java

HacktoberFest 2023 OPEN FIRST Pull Request 🎉

Contributors of Hacktoberfest 2023

This Project Is Perfect For Your First Pull Request

INSTRUCTIONS-

How To Make Your First Pull Request

1. Add your profile picture to the folder

2. Add your profile information

OR

3. Create / Upload Your Code / Algorithms

4. Wait for Pull Request to merge

5. Celebrate - you've done your first pull request!!

+ Follow Me : } Quick Approval of Pull Request

luamfb/intro_x86-64

botamochi/avr-multi-task-test

Lissy93/git-into-open-source

acalcutt/Vistumbler

taku-nm/auto-cli

dotnet/intro-to-dotnet-web-dev

Intro to Web Development with .NET

Video Introduction

How-to

Codespace

Lessons

Open in Codespaces

Help Resources

Documentation

Beginner Video Series

How to leave feedback

Learn More & Connect with us

.NET Foundation

Sergio0694/ComputeSharp

What is it? 🚀

What can it actually do? ✨

Where is it being used? ✈️

Try out the sample app! 💻

Available packages 📦

Documentation 📖

Sponsors 🎁

Special thanks

win-acme/win-acme

Windows ACME Simple (WACS)

Overview

Community support

Professional support / sponsorship

Donations

ShahjalalShohag/code-library

hacktoberfest-2023

Star and fork this repository to start contributing !!

Mandatory Step :

Steps to Contribute

Avoid Conflicts {Syncing your fork}

Note:

Our Contributors of hacktoberfest

Saikat2407/DSA_Hacktoberfest2023

Hacktober Fest 2023⚡️✨

👉 Add any project, algorithm or leetcode solution in any programming language.. -🚀 C -🚀 C++ -🚀 C# -🚀 PHP -🚀 Java -🚀 Python -🚀 Javascript In each respective folder on any topic, don't forget to read the rules below to get your pull request accepted.

🛠 Welcome to Hacktobefest 2023 Event

How To Contribute

Star the repository

Getting started

🛡 Rules

🛡 Notice

🖥️ Happy Coding 🔥 Happy Hacking...

HacktoberFest 2023 `OPEN FIRST` Pull Request 🎉

Contributors of `Hacktoberfest 2023`

Our Contributors of `hacktoberfest`

👉 Add any project, algorithm or leetcode solution in any programming language..
-🚀 C
-🚀 C++
-🚀 C#
-🚀 PHP
-🚀 Java
-🚀 Python
-🚀 Javascript

In each respective folder on any topic, don't forget to read the rules below to get your pull request accepted.