Author: rmeuydosk8nt

fuzzycomplete Extension for DuckDB

This fuzzycomplete extension serves as an alternative to DuckDB’s autocomplete extension, with several key differences:

Algorithm: Unlike the autocomplete extension, which uses edit distance as its metric, the fuzzycomplete extension employs a fuzzy string matching algorithm derived from Visual Studio Code. This provides more intuitive and flexible completion suggestions.

Scope: The fuzzycomplete extension can complete table names across different databases and schemas. It respects the current search path and offers suggestions accordingly, even when multiple databases are attached.

It may not yet be the best solution for SQL completion, but it has proven to be useful to the author.

Installation

fuzzycomplete is a DuckDB Community Extension.

You can now use this by using this SQL:

install fuzzycomplete from community;
load fuzzycomplete;

Details of the fuzzy matching algorithm

This extension uses the Rust crate code-fuzzy-match

The algorithm ensures that characters in the query string appear in the same order in the target string. It handles substring queries efficiently, allowing searches within the middle of the target string without significantly impacting the match score. The algorithm prioritizes matches that occur at the beginning of words, where words are defined as they commonly appear in code (e.g., letters following a separator or in camel case). Sequential matches are also given preference.

In addition to the basic matching algorithm, matches then scored using this criteria if they have an equal score from code-fuzzy-match:

In the event of a tie in the match score, completion results are first ordered by the number of pseudo-words in the candidate strings, favoring shorter completions.
A standard lexical sorting is then applied.

When would I use this?

If you’re looking to try a different completion algorithm or need to complete table names from various databases and schemas, you might find this extension beneficial.

Build Architecture

For the DuckDB extension to call the Rust code a tool called cbindgen is used to write the C++ headers for the exposed Rust interface.

The headers can be updated by running make rust_binding_headers.

Build steps

Now to build the extension, run:

make

The main binaries that will be built are:

./build/release/duckdb
./build/release/test/unittest
./build/release/extension/fuzzycomplete/fuzzycomplete.duckdb_extension

duckdb is the binary for the duckdb shell with the extension code automatically loaded.
unittest is the test runner of duckdb. Again, the extension is already linked into the binary.
fuzzycomplete.duckdb_extension is the loadable binary as it would be distributed.

Running the extension

To run the extension code, simply start the shell with ./build/release/duckdb.

Now we can use the features from the extension directly in DuckDB.

Installing the deployed binaries

To install your extension binaries from S3, you will need to do two things. Firstly, DuckDB should be launched with the
allow_unsigned_extensions option set to true. How to set this will depend on the client you’re using. Some examples:

CLI:

duckdb -unsigned

Python:

con = duckdb.connect(':memory:', config={'allow_unsigned_extensions' : 'true'})

NodeJS:

db = new duckdb.Database(':memory:', {"allow_unsigned_extensions": "true"});

Secondly, you will need to set the repository endpoint in DuckDB to the HTTP url of your bucket + version of the extension
you want to install. To do this run the following SQL query in DuckDB:

SET custom_extension_repository='bucket.s3.us-east-1.amazonaws.com/fuzzycomplete/latest';

Note that the /latest path will allow you to install the latest extension version available for your current version of
DuckDB. To specify a specific version, you can pass the version instead.

After running these steps, you can install and load your extension using the regular INSTALL/LOAD commands in DuckDB:

INSTALL fuzzycomplete
LOAD fuzzycomplete

typin README

typin is a Type Inferencer for understanding what types of objects are flowing through your Python code. It observes your code dynamically and can record all the types that each function sees, returns or raises. typin can then use this information to create Python’s type annotations or __doc__ strings to insert into your code.

typin is currently proof-of-concept and a very early prototype. It is Python 3 only at the moment. There is a forthcoming project https://github.com/paulross/pytest-typin which turns typin into a pytest plugin so that your unit tests can generate type annotations and documentation strings.

Example

Lets say you have a function that creates a repeated string, like this:

def function(s, num):
    if num < 1:
        raise ValueError('Value must be > 0, not {:d}'.format(num))
    lst = []
    while num:
        lst.append(s)
        num -= 1
    return ' '.join(lst)

You can exercise this under the watchful gaze of typin:

from typin import type_inferencer

with type_inferencer.TypeInferencer() as ti:
    assert function('Hi', 2) == 'Hi Hi'

You can then get the types that typin has observed as a string suitable for a stub file:

ti.stub_file_str(__file__, '', 'function')
# returns: 'def function(s: str, num: int) -> str: ...'

Then adding code that provokes the exception we can track that as well:

from typin import type_inferencer

with type_inferencer.TypeInferencer() as ti:
    assert function('Hi', 2) == 'Hi Hi' # As before
    try:
        function('Hi', 0)
    except ValueError:
        pass

Exception specifications are not part of Python’s type annotation but they are part of of the Sphinx documentation string standard and typin can provide that, and the line number where it should be inserted:

line_number, docstring = ti.docstring(__file__, '', 'function', style='sphinx')
docstring
"""
<insert documentation for function>

:param s: <insert documentation for argument>
:type s: ``str``

:param num: <insert documentation for argument>
:type num: ``int``

:returns: ``str`` -- <insert documentation for return values>

:raises: ``ValueError``
"""
# Insert template docstrings into the source code.
new_src = ti.insert_docstrings(__file__, style='sphinx')
with open(__file__, 'w') as f:
    for line in new_src:
        f.write(line)

Sadly typin is not smart enough to write the documentation text for you 🙂

There is a CLI interface typin_cli that is an entry point to typin/src/typin/typin_cli.py. This executes arbitrary python code using compile() and exec() like the following example. Note use of -- followed by Python script then the arguments for that script surrounded by quotes:

$ python typin_cli.py --stubs=stubs/ --write-docstrings=docstrings/ -- example.py 'foo bar baz'

This will compile()/exec() example.py with the arguments foo bar baz write the stub files ('.pyi' files) to stubs/ and the source code with the docstrings inserted to docstrings/.

typin_cli.py help:

$ python typin_cli.py --help
usage: typin_cli.py [-h] [-l LOGLEVEL] [-d] [-t] [-e EVENTS_TO_TRACE]
                    [-s STUBS] [-w WRITE_DOCSTRINGS]
                    [--docstring-style DOCSTRING_STYLE] [-r ROOT]
                    program argstring

typin_cli - Infer types of Python functions.
  Created by Paul Ross on 2017-10-25. Copyright 2017. All rights reserved.
  Version: v0.1.0 Licensed under MIT License
USAGE

positional arguments:
  program               Python target file to be compiled and executed.
  argstring             Argument as a string to give to the target. Prefix
                        this with '--' to avoid them getting consumed by
                        typin_cli.py

optional arguments:
  -h, --help            show this help message and exit
  -l LOGLEVEL, --loglevel LOGLEVEL
                        Log Level (debug=10, info=20, warning=30, error=40,
                        critical=50) [default: 30]
  -d, --dump            Dump results on stdout after processing. [default:
                        False]
  -t, --trace-frame-events
                        Very verbose trace output, one line per frame event.
                        [default: False]
  -e EVENTS_TO_TRACE, --events-to-trace EVENTS_TO_TRACE
                        Events to trace (additive). [default: []] i.e. every
                        event.
  -s STUBS, --stubs STUBS
                        Directory to write stubs files. [default: ]
  -w WRITE_DOCSTRINGS, --write-docstrings WRITE_DOCSTRINGS
                        Directory to write source code with docstrings.
                        [default: ]
  --docstring-style DOCSTRING_STYLE
                        Style of docstrings, can be: 'google', 'sphinx'.
                        [default: sphinx]
  -r ROOT, --root ROOT  Root path of the Python packages to generate stub
                        files for. [default: .]

Python type inferencing.

Free software: MIT license
Documentation: https://typin.readthedocs.io.

Features

TODO

Credits

This package was created with Cookiecutter and the audreyr/cookiecutter-pypackage project template.

fraCtal

fraCtal generates fractals of any dimension that you want. It can generate fractals belonging at two sets: Mandelbrot and Julia.

Supported features:

✅ multithreading support
✅ initial support to custom color palette
✅ color can be personalized
✅ image saved as a PNG file (using lodepng)

Future plans:

🎯 SDL2 support
🎯 ImGUI support

Comparison between 1 vs 4 threads:

1-thread	4-thread	(x0, x1, y0, y1)
166.30s	57.37s	(0.37, 0.40, 0.21, 0.16)
198.322s	111.56s	(0.37, 0.40, 0.21, 0.26)
46.11s	21.60s	(2.0, -2.0, 1.7, -1.7)

You can specify another number of threads in main.c.

The New Colors Algorithm

There are a lot a change in the color algorithm, and you can change some parameters to make it more or less interesting. A special thanks goes to BrutPitt for the precious hints.

// Blue and red from 0.00 to 255.0
double blue_a = 0.0, blue_b = 255.0;
double red_a  = 0.0, red_b  = 255.0;

// Fractal must be red on x axis and blue on y axis
double rstepx = (red_b - red_a) / coords->w;
double bstepy = (blue_b - blue_a) / coords->h;

The way the green channel get computed is the following:

int val_in = 0, val_out = 0;
int g = 0;
if(k >= 32) {
    g = (int)(255.0 - ((((double)k + val_in)) / (coords->max_iterations + val_in) * (255.0-val_out)));
}

Below you can see how the fractal looks like:

With val_out = 0 and without attenuation (eg. you can comment the attenuation computation or set it to 1.0):

With:

int val_in = 32, val_out = 150;
int g = 0;
if(k >= 32) {
    g = (int)(255.0 - ((((double)k + val_in)) / (coords->max_iterations + val_in) * (255.0-val_out)));
}

and without attenuation:

Without attenuation:

int val_in = 32, val_out = 0;
int g = 0;
if(k >= 0) {
    g = (int)(255.0 - ((((double)k + val_in)) / (coords->max_iterations + val_in) * (255.0-val_out)));
}

With:

double blue_a = 255.0, blue_b = 255.0;
double red_a  = 0.0, red_b  = 255.0;

int val_in = 32, val_out = 32;
int g = 0;
if(k >= 32) {
g = (int)(255.0 - ((((double)k + val_in)) / (coords->max_iterations + val_in) * (255.0-val_out)));
}

double atten = ((double)k / coords->max_iterations);
atten = 1.0 - (atten*atten);

r = (int)((double)r * atten);
b = (int)((double)b * atten);

The image will be:

Color Palette

Last but not least, now is possible load colors (R,G,B) from a text file with the following format:

size (number of lines)
r,g,b
r,g,b
.....

as an example, consider the image on Wikipedia: this are the colors:

16
66,30,15
25,7,26
9,1,47
4,4,73
0,7,100
12,44,138
24,82,177
57, 125,209
134,181,229
211,236,248
241,233,191
248,201,95
255,170,0
204,128,0
153,87,0
106,52,3

you can find it the palette.txt file. As a result we get:

Uncomment PALETTE in mandelbrot.h if you want use them.

Mathematical formula and explanation

On the web there are a lot of explanations about this formula so I don’t want to be boring or maybe not totally precise.

Z and C are two complex numbers. Complex numbers are composed by two parts: a real part, and a imaginary part. The formula tell to us that if the value of the function Zn for the value c is not infinite when n approaches infinity, then c belongs to the set. If C belongs to the set, then we choose the black color; otherwise the color will be white.

Besides mathematics: the code

To determine which will be the color (eg. black or not) we can’t obviously iterate to infinity. Luckily maths tell that for definition if the absolute value of Z gets bigger of 2 it will never return closer to 2. So thanks to that we can iterate N times; N could be little but it depends from the number of pixels of the image.

This is my code:

double y = info.y1 + (((double)j * (info.y0-info.y1)) / (double)info.h);
double x = info.x1 + (((double)i * (info.x0-info.x1)) / (double)info.w);

Here x and y are the coords of the 2D plan (scaled). In this manner y and x are the imaginary part and the real part of the complex number C seen before (the point that we need to know if belong or not to the set).

The N number is chosen by user. We must just iterate till this value is reached or break the loop if the square root of the abs value is greater then 2; we can simplify this operation removing the sqrt and check for 4.

Here the code:

for(i = 0; i < info.depth; i++)
{
    z    = complex_sum(complex_mul(z, z), c);
    *abs = complex_abs(z);

    if(*abs > 4.0) {
        break;
    }
}

Just to summarize: if abs is greater than 4, the C point is not part of the set and it will be left white (but is common give another color based on the amount of iterations); if the value is below 4 then the common color is black because is part of the set.

The Area

The area is determined by x0, x1, y0 and y1. They represent the cartesian plane and they are the real part and imaginary part. This four numbers are important because – how we will see – we can use them to zoomin or zoomout in the fractal.

The Colors

In the first part of this README I had talked about the Zn function and his result that tell to us if the value C belongs to the set or not. When C not belongs to the set we can set a color based on the numbers of the iterations. The intensity of the color differ based on the number of iterations.

If you want to change the primary color (eg, make the fractal red, green or blue or whatever) you must edit the code.

Here some examples; all the images are generated using the same “zoom” (default zooming): x0=2.0, x1=-2.0, y0=2.0, y1=-2.0 and the same iterations, 2.000:

For example, to get this blue, you must use:

int r =  iteration>>2;
int g =  iteration>>1;
int b =  iteration<<3;

r = (r>128) ? 128 : r;
g = (g>128) ? 128 : g;
b = (b>255) ? 255 : b;

For the green version, you must change the code in this way:

int r =  iteration>>1;
int g =  iteration<<3;
int b =  iteration>>1;

r = (r>128) ? 128 : r;
g = (g>255) ? 255 : g;
b = (b>128) ? 128 : b;

For the red/orange version:

int r =  iteration<<2;
int g =  iteration>>1;
int b =  iteration>>2;

r = (r>255) ? 255 : r;
g = (g>128) ? 128 : g;
b = (b>128) ? 128 : b;

Obviously this is not the only way to set a color.

We can also zoom in, how I said before. Let’s take a look here, x0=0.37, x1=0.40, y0=0.21, y1=0.26 using the same red color:

How you can see the color make the difference!

Gallery

$fractal$

TypeScript Monorepo Example

This is just a quick example of how you can setup VS Code to work with a Lerna monorepo, along with working examples of:

Effectively, this is what I wish I had when I first got started and it is my hope to save anyone else some frustration.

Project Structure

packages/app

A semi-functional, contrived TypeScript application based on two Lerna dependencies:

packages/url-fetch
packages/eslint-config-typescript

packages/url-fetch

An example TypeScript dependency that’s purpose is to fetch webpage with a redirect and return the new url.

packages/eslint-config-typescript

An example dependency that’s contain a common set of TypeScript ESlint configuration that extends and overrides the package eslint-config-airbnb-typescript so that each Lerna package does not have to have its .eslint.yaml be separately maintained.

Getting started

Install Lerna

Install Lerna globally.

npm install --global lerna

Install Yarn

Install Yarn globally.

npm install --global yarn

Clone this package locally

git clone https://github.com/abd1tus/typescript-monorepo-example.git

bootstrap Lerna

cd typescript-monorepo-example
lerna bootstrap

Run tests on all packages with the command line

cd typescript-monorepo-example
yarn test

Lint all packages with the command line

cd typescript-monorepo-example
yarn lint

Build all packages with the command line

cd typescript-monorepo-example
yarn build

Publishing with Lerna

The beauty behind Lerna is its ability make editing interdependent packages together much easier by automatically updating package versions for you as needed, as well as committing those changes to git, and publishing to npm (or other, if configured).

cd typescript-monorepo-example
lerna publish

or to force updates of all Lerna tracked packages.

cd typescript-monorepo-example
lerna publish --force-publish

If you are not publishing packages to npm:

cd typescript-monorepo-example
lerna publish -skip-npm

Note, packages in the project are marked as private in package.json so that they cannot be accidentally published to npmjs.com (or any others). In your own project you may want to choose to leave some packages public, and others marked as private that do not need to be packaged – such as AWS lambda functions that don’t get re-used anywhere.

Working with a Lerna monorepo in VS Code

The lerna bootstrap command sets up symbolic links between packages so that updates to one package (after a build) can be seen by other packages without the need to push to git or re-deploy custom npm packages.

Important: If libraries fall out of sync and you need to refresh VS Code, open the command palette (Ctrl + Shift + P, if you are on Windows; Cmd + Shift + P, if you are on a Mac) and run Developer: Reload Window.

Loading the workspace in VS Code

In VS Code, using File -> Open Workspace… open the file typescript-monorepo-example/workspace.code-workspace found in the project root. This will create separate directories within the VS Code workspace window. If the entire typescript-monorepo-example repo was loaded as a single folder within VS Code then problems occur with parsing and working with the ESlint files. (If anyone knows a workaround for this, please contact me so I can update this example.)

tcs watch task

One of the problems I’ve run into with VS Code is it won’t show you errors in files that aren’t open, especially in monorepos. A way around this is to run tsc watch tasks, which will compile code automatically when changes occur, even across packages, and highlight errors. tsc watch tasks are included in tin .vscode/tasks.json in the package folders.

Note: these watch tasks have to be started manually once the workspace is loaded. However, they are configured with "runOn": "folderOpen", so running Tasks: Allow Automatic Tasks in Folder from the command palette will allow them to launch anytime the project is opened without needing to manually start them.

ESLint

Make sure the ESLint plugin is installed in VS Code.

Optional Plugins

Material Icon Theme makes looking at workspaces nicer.

Debugging

Debugger configurations are setup for packages/app and packages/url-fetch so that debugging can be run from VS Code during tests. Unfortunately a limitation of having packages/app and packages/url-fetch be open across separate VS Code folders within a workspace is that you cannot debug from one package to another, so focused tests should be written in each package as needed. These debugger configurations can be found in .vscode/launch.json in the package folders.

Other cool things to do with lerna

The entire use of Lerna is beyond the scope of this project, but here are some cool highlights:

Remove a file from all packages in parallel

lerna exec --parallel -- rm bad-file.txt

Remove a file from all packages in parallel

lerna exec --parallel -- rm bad-file.txt

Find outdated packages ordered by dependency usage

lerna exec -- yarn outdated

Find packages with security vulnerabilities

(Note this won’t work on this repo since its packages are not published in npm.)

lerna exec -- yarn audit

Mastermind Project

Check out my command line version of the game Mastermind built with Ruby!

This is a project from The Odin Project.

Installation

Open your Terminal/Command Line. Navigate to the directory where your version will live. Type in the following:

$ git clone https://github.com/JonathanYiv/mastermind.git
$ cd mastermind
$ bundle install
$ ruby mastermind.rb

Pre-Project Thoughts

I will need to figure out how to colorize the command line from a ruby script.

Thoughts on Structure

class Mastermind
	instance variables:
		gameboard
	methods:
		initialize: takes a parameter to decide whether human/computer picks the code
		play: starts the game
			instructions: prints the instructions

class GameBoard = one instance
	instance variables: 
		solution as a colorcode object
		array of colorcode objects for display
		array of hint objects for display
	methods:
		display: displays the entire board
		refresh: given a new colorcode, adds it to the display, and evaluates the hints
		evalute: based on the colorcode, provide a hint

class ColorCode = instances include a solution instance and a guess instance 
	instance variables: 
		color1
		color2
		color3
		color4
	methods:
		initialize: takes four parameters to create a set of colors or defaults to a randomly selected set of color

class Hint = instances of the hints with red/white/black
	instance variables:
		color1
		color2
		color3
		color4
	methods:
		initialize: takes five parameters (including the colorcode solution) and sets its four colors accordingly

class Computer
	instance variables:
		included colors
	methods:
		algorithms to solve mastermind

Post-Project Thoughts

To include color in the project, I found the ruby gem “colorize.” I also read about ANSI Escape Codes (see below) which were a little too intense for the scope of this project. See below.

class String
	def black;          "\e[30m#{self}\e[0m" end
	def red;            "\e[31m#{self}\e[0m" end
	def green;          "\e[32m#{self}\e[0m" end
	def brown;          "\e[33m#{self}\e[0m" end
	def blue;           "\e[34m#{self}\e[0m" end
	def magenta;        "\e[35m#{self}\e[0m" end
	def cyan;           "\e[36m#{self}\e[0m" end
	def gray;           "\e[37m#{self}\e[0m" end

	def bg_black;       "\e[40m#{self}\e[0m" end
	def bg_red;         "\e[41m#{self}\e[0m" end
	def bg_green;       "\e[42m#{self}\e[0m" end
	def bg_brown;       "\e[43m#{self}\e[0m" end
	def bg_blue;        "\e[44m#{self}\e[0m" end
	def bg_magenta;     "\e[45m#{self}\e[0m" end
	def bg_cyan;        "\e[46m#{self}\e[0m" end
	def bg_gray;        "\e[47m#{self}\e[0m" end
end

The computer AI was rather complex to implement; I spent the most time on that portion specifically. I only managed to get it to a 20% win-rate for now. I will come back and update it later with the wikipedia supplied algorithm that guarantees a solution in five moves.
My last project, Tic-Tac-Toe followed poor practices regarding separating classes into different files. This project does better in that regard. However, several methods are overly complex and have too much responsibi
@benjaminapetersen and the Odinites found three issues.
1. The text sanitizer only ran each check once, so if you passed the first test but failed the second test, it would only check for the second test onwards. I fixed it by pulling it all into a large loop with redo statements if tests fail.
2. The project requires the gem ‘colorize’ which I had not previously set up for users, causing an error. I set up a Gemfile and added an instruction with bundler in the installation instructions.
3. Ruby has a syntax of two spaces per indent. I adjusted my text editor’s settings to reflect this, so all future ruby files will be indented accordingly.
Overall, it was a very fun project, probably the most complex for me to date.

APIBuilder PYTHON, GO, RUST, Node, REACT, PHP 🖐️

👔 Working with Browntape Technologies Prior – Travjury Software 🇮🇳,openhotelier 🇲🇻.
💻 Hands-on: Python, GO, RUST, PHP, Vue, React, Next, Node, Solidity, Flutter, Dart
🥽 AI/ ML: In the ever-evolving market, I specialize in delivering state-of-the-art AI/ML solutions:
– Core Frameworks & Models: TensorFlow, PyTorch, Keras, OLLAMA, GPT*, DeepSeek R1
– Advanced Systems: RAG Systems, Generative AI
– Applications: Chatbots, Prediction Engines, Rank Engines, Recommendation Engines
🎯 ASK Anything about Scalable and Distributed System Design, Microservices, APIs, and Integrations….
✏️ Write ultimatesystemsdesign.medium.com

Languages:

BUILD REST/ GRAPHQL/ SOAP API and White-Label Business using Most Trending Technology & Frameworks

You are JUST 5 minutes away to create Your First API, what YOU are waiting for? Lets START..

AI/ ML

Clone trending Apps using GraphQL, Nodejs, Reactjs, Nextjs in 1 Hour…

Web Scraping using Python, Nodejs in 30 mins…

KAFKA – Implementation with Node.js & Kafkajs – Order Management System / Inventory management System in 1 Hour..

TERRAFORM – Infrastructure as code

TERRAFORM – Infrastructre As Code(IAC)

WEB3/ DAPPS/ CRYPTO/ NFT

Show some ❤️

Rust + Yew + Tailwind CSS

This repository contains a Rust (Yew) frontend that leverages Tailwind CSS for theming and styling. Additionally, this repository implements state management using the bounce library – similar to zustand as it relates to Redux state management in ReactJS.

Getting Started

This section provides supporting steps and documentation for developing locally.

Prerequisites

Before jumping into the code, there are a few prerequisites.

Local development should be done from a UNIX-based machine – use Linux, MacOS, or WSL2 if you’re on a Windows machine.
GitHub access should be managed through an SSH key in your UNIX environment. If you’re unfamiliar with this process start here.
pre-commit should be installed globally on your machine for linting and validating your code prior to pushing up to GitHub.
Rust should be installed globally on your machine for compiling and running code.
Optionally, the Rust-Analyzer extension can be installed in VS Code for a better development experience.
Node Version Manager should be installed on your machine for managing node versions for current and future maintenance of UI packages. This project is currently using v18.13.0.
```
source ~/.nvm/nvm.sh  # activate nvm once installed

nvm install v18.13.0  # install node

nvm use v18.13.0  # use node
```

Local Development Guide

Clone the repository (if this is your first time).

git clone git@github.com:dgonzo27/rust-yew-tailwind.git

Navigate into the repository directory.
```
cd rust-yew-tailwind
```
Ensure pre-commit is enabled for this repository.
```
pre-commit install
```

Enable node version manager.

source ~/.nvm/nvm.sh  # activate nvm

nvm use v18.13.0  # use node

Setup the project.
```
cd client

npm run setup
```
Run the project.
```
npm run dev
```
Visit http://localhost:8080.

Need Support?

File an issue via GitHub Issues.

Reporting Security Vulnerabilities and Security Bugs

Security vulnerabilities and bugs should be reported privately, via email, to the maintainers of this repository. Please contact Dylan Gonzales. For more information, visit the security guidelines.

Contributing

Before contributing to this repository, please review the code of conduct.

Contributions and suggestions are welcomed. However, there is a level of responsibility placed on the contributor to follow best-practices, provide thorough testing, follow the branching strategy, use the pull request template, and maintain a positive and coachable attitude when receiving feedback or questions on your code. For more details on these responsibilities, please visit the contributing guide.

When contributing, you are granting the maintainers of this repository the rights to use your contribution(s).

Dart Image Library

Overview

The Dart Image Library provides the ability to load, save, and manipulate images in a variety of image file formats.

The library can be used with both dart:io and dart:html, for command-line, Flutter, and web applications.

NOTE: 4.0 is a major revision from the previous version of the library.

Documentation

Supported Image Formats

Read/Write

JPG
PNG / Animated PNG
GIF / Animated GIF
BMP
TIFF
TGA
PVR
ICO

Read Only

WebP / Animated WebP
PSD
EXR
PNM (PBM, PGM, PPM)

Write Only

CUR

Examples

Create an image, set pixel values, save it to a PNG.

import 'dart:io';
import 'package:image/image.dart' as img;
void main() async {
  // Create a 256x256 8-bit (default) rgb (default) image.
  final image = img.Image(width: 256, height: 256);
  // Iterate over its pixels
  for (var pixel in image) {
    // Set the pixels red value to its x position value, creating a gradient.
    pixel..r = pixel.x
    // Set the pixels green value to its y position value.
    ..g = pixel.y;
  }
  // Encode the resulting image to the PNG image format.
  final png = img.encodePng(image);
  // Write the PNG formatted data to a file.
  await File('image.png').writeAsBytes(png);
}

To asynchronously load an image file, resize it, and save it as a thumbnail:

import 'package:image/image.dart' as img;

void main(List<String> args) async {
  final path = args.isNotEmpty ? args[0] : 'test.png';
  final cmd = img.Command()
    // Decode the image file at the given path
    ..decodeImageFile(path)
    // Resize the image to a width of 64 pixels and a height that maintains the aspect ratio of the original. 
    ..copyResize(width: 64)
    // Write the image to a PNG file (determined by the suffix of the file path). 
    ..writeToFile('thumbnail.png');
  // On platforms that support Isolates, execute the image commands asynchronously on an isolate thread.
  // Otherwise, the commands will be executed synchronously.
  await cmd.executeThread();
}

Author: rmeuydosk8nt

fuzzycomplete Extension for DuckDB

Installation

Details of the fuzzy matching algorithm

When would I use this?

Build Architecture

Build steps

Running the extension

Installing the deployed binaries

typin README

Example

Features

Credits

fraCtal

Supported features:

Future plans:

The New Colors Algorithm

Color Palette

Mathematical formula and explanation

Besides mathematics: the code

The Area

The Colors

Gallery

TypeScript Monorepo Example

Project Structure

packages/app

packages/url-fetch

packages/eslint-config-typescript

Getting started

Install Lerna

Install Yarn

Clone this package locally

bootstrap Lerna

Run tests on all packages with the command line

Lint all packages with the command line

Build all packages with the command line

Publishing with Lerna

Working with a Lerna monorepo in VS Code

Loading the workspace in VS Code

tcs watch task

ESLint

Optional Plugins

Debugging

Other cool things to do with lerna

Remove a file from all packages in parallel

Remove a file from all packages in parallel

Find outdated packages ordered by dependency usage

Find packages with security vulnerabilities

Mastermind Project

Installation

Pre-Project Thoughts

Thoughts on Structure

Post-Project Thoughts

APIBuilder PYTHON, GO, RUST, Node, REACT, PHP 🖐️

You are JUST 5 minutes away to create Your First API, what YOU are waiting for? Lets START..

AI/ ML

Clone trending Apps using GraphQL, Nodejs, Reactjs, Nextjs in 1 Hour…

Web Scraping using Python, Nodejs in 30 mins…

KAFKA – Implementation with Node.js & Kafkajs – Order Management System / Inventory management System in 1 Hour..

TERRAFORM – Infrastructure as code

WEB3/ DAPPS/ CRYPTO/ NFT

Show some ❤️

Rust + Yew + Tailwind CSS

Table of Contents

Getting Started

Prerequisites

Local Development Guide

Need Support?

Reporting Security Vulnerabilities and Security Bugs

Contributing

Dart Image Library

Overview

Examples