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.

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.

• TODO

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

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

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

🎯 SDL2 support
🎯 ImGUI support

Comparison between 1 vs 4 threads:

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

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:

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.

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.

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 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.

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!

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

• Mocha tests
• Chai assertion library
• Sinon spies
• ESlint

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

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

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

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

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.

Install Lerna globally.

npm install --global lerna

Install Yarn globally.

npm install --global yarn

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

cd typescript-monorepo-example
lerna bootstrap

cd typescript-monorepo-example
yarn test

cd typescript-monorepo-example
yarn lint

cd typescript-monorepo-example
yarn build

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.

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.

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.)

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.

Make sure the ESLint plugin is installed in VS Code.

Material Icon Theme makes looking at workspaces nicer.

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.

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

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

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

lerna exec -- yarn outdated

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

lerna exec -- yarn audit

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

This is a project from The Odin Project.

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

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

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

1. 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

2. 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.

3. 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

4. @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.

5. Overall, it was a very fun project, probably the most complex for me to date.

• 👔 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:

• REST API with PYTHON – FLASK

• REST API with PYTHON – DJANGO – RESTFRAMEWORK

• REST API with PYTHON – FASTAPI + LLAMA

• REST API with GO – MUX

• REST API with GO – GIN

• REST API with NodeJS – EXPRESS

• REST API with NodeJS – EXPRESS- JWT – SEQUELlZE

• REST API with PHP – OOPS

• REST API with LARAVEL – PASSPORT

• GRAPHQL API with RATE Limiting and Pagination – Docker

• SOAP API With PHP – MYSQL

• GENAI – DeepSeek Code Companion Chat Bot: OLLAMA, Langchain, Deepseek R1

• APACHE SPARK: Big Data, Data Analysis, Transformation, and Visualisation with PySpark

• APACHE SPARK: MACHINE LEARNING WITH MLlib TO ANALYZE RESTAURANT TIPS DATA

• NLP – Amazon Product Reviews Sentiment Analysis in Python

• TENSORFLOW AND KERAS: SENTIMENT ANALYSIS USING RNN

• TENSORFLOW: CREATE YOUR OWN CHATBOT

• PYTORCH: PYTORCH-BASED DIABETES PREDICTION MODEL USING ANN

• KERAS: Heart Attack Prediction Using Machine Learning

• Netflix Clone with AstraDB, GraphQL, React, Next, Nodejs

• Airbnb Clone with Sanity, GraphQL, Next, React, Nodejs

• Disney Clone using GraphCMS, GraphQL, NEXT, React, Nodejs

• Web Scraping using Nodejs, Axios, Cheerio

• Flipkart Scraping using Python

• KAFKA – Implementation with Node.js & Kafkajs

• KAFKA – Implementation on Amazon EC2 for Streaming Data to S3 with AWS Glue and Athena

• TERRAFORM – Infrastructre As Code(IAC)

• NFT Marketplace Built With Polygon, Solidity, IPFS & Next.js

• Create your own crypto currency

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
  • Prerequisites
  • Local Development Guide
• Need Support?
• Reporting Security Vulnerabilities and Security Bugs
• Contributing

This section provides supporting steps and documentation for developing locally.

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

1. Local development should be done from a UNIX-based machine – use Linux, MacOS, or WSL2 if you’re on a Windows machine.

2. GitHub access should be managed through an SSH key in your UNIX environment. If you’re unfamiliar with this process start here.

3. pre-commit should be installed globally on your machine for linting and validating your code prior to pushing up to GitHub.

4. Rust should be installed globally on your machine for compiling and running code.

5. Optionally, the Rust-Analyzer extension can be installed in VS Code for a better development experience.

6. 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

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

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

2. Navigate into the repository directory.

   cd rust-yew-tailwind

3. Ensure pre-commit is enabled for this repository.

   pre-commit install

4. Enable node version manager.

   source ~/.nvm/nvm.sh  # activate nvm
   
   nvm use v18.13.0  # use node

5. Setup the project.

   cd client
   
   npm run setup

6. Run the project.

   npm run dev

7. Visit http://localhost:8080.

File an issue via GitHub Issues.

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.

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).

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.

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

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();
}

Cross-browser storage for all use cases, used across the web.

Store.js has been around since 2010 (first commit, v1 release). It is used in production on tens of thousands of websites, such as cnn.com, dailymotion.com, & many more.

Store.js provides basic key/value storage functionality (get/set/remove/each) as well as a rich set of plug-in storages and extra functionality.

1. Basic Usage
   • All you need to get started
   • API
   • Installation
2. Supported Browsers
   • All of them, pretty much 🙂
   • List of supported browsers
3. Plugins
   • Additional common functionality
   • List of all Plugins
   • Using Plugins
   • Write your own Plugin
4. Builds
   • Choose which build is right for you
   • List of default Builds
   • Make your own Build
5. Storages
   • Storages provide underlying persistence
   • List of all Storages
   • Storages limits
   • Write your own Storage

All you need to know to get started:

store.js exposes a simple API for cross-browser local storage:

// Store current user
store.set('user', { name:'Marcus' })

// Get current user
store.get('user')

// Remove current user
store.remove('user')

// Clear all keys
store.clearAll()

// Loop over all stored values
store.each(function(value, key) {
	console.log(key, '==', value)
})

Using npm:

npm i store

// Example store.js usage with npm
var store = require('store')
store.set('user', { name:'Marcus' })
store.get('user').name == 'Marcus'

Using script tag (first download one of the builds):

All of them, pretty much 🙂

To support all browsers (including IE 6, IE 7, Firefox 4, etc.), use require('store') (alias for require('store/dist/store.legacy')) or store.legacy.min.js.

To save some kilobytes but still support all modern browsers, use require('store/dist/store.modern') or store.modern.min.js instead.

• Tested on IE6+
• Tested on iOS 8+
• Tested on Android 4+
• Tested on Firefox 4+
• Tested on Chrome 27+
• Tested on Safari 5+
• Tested on Opera 11+
• Tested on Node (with https://github.com/coolaj86/node-localStorage)

Plugins provide additional common functionality that some users might need:

• all.js: All the plugins in one handy place.
• defaults.js: Declare default values. Example usage
• dump.js: Dump all stored values. Example usage
• events.js: Get notified when stored values change. Example usage
• expire.js: Expire stored values at a given time. Example usage
• observe.js: Observe stored values and their changes. Example usage
• operations.js: Useful operations like push, shift & assign. Example usage
• update.js: Update a stored object, or create it if null. Example usage
• v1-backcompat.js: Full backwards compatibility with store.js v1. Example usage

With npm:

// Example plugin usage:
var expirePlugin = require('store/plugins/expire')
store.addPlugin(expirePlugin)

If you’re using script tags, you can either use store.everything.min.js (which has all plugins built-in), or clone this repo to add or modify a build and run make build.

A store.js plugin is a function that returns an object that gets added to the store. If any of the plugin functions overrides existing functions, the plugin function can still call the original function using the first argument (super_fn).

// Example plugin that stores a version history of every value
var versionHistoryPlugin = function() {
	var historyStore = this.namespace('history')
	return {
		set: function(super_fn, key, value) {
			var history = historyStore.get(key) || []
			history.push(value)
			historyStore.set(key, history)
			return super_fn()
		},
		getHistory: function(key) {
			return historyStore.get(key)
		}
	}
}
store.addPlugin(versionHistoryPlugin)
store.set('foo', 'bar 1')
store.set('foo', 'bar 2')
store.getHistory('foo') == ['bar 1', 'bar 2']

Let me know if you need more info on writing plugins. For the moment I recommend taking a look at the current plugins. Good example plugins are plugins/defaults, plugins/expire and plugins/events.

Choose which build is right for you!

• store.everything.min.js: All the plugins, all the storages. Source
• store.legacy.min.js: Full support for all tested browsers. Add plugins separately. Source
• store.modern.min.js: Full support for all modern browsers. Add plugins separately. Source
• store.v1-backcompat.min.js: Full backwards compatibility with store.js v1. Source

If you’re using npm you can create your own build:

// Example custom build usage:
var engine = require('store/src/store-engine')
var storages = [
	require('store/storages/localStorage'),
	require('store/storages/cookieStorage')
]
var plugins = [
	require('store/plugins/defaults'),
	require('store/plugins/expire')
]
var store = engine.createStore(storages, plugins)
store.set('foo', 'bar', new Date().getTime() + 3000) // Using expire plugin to expire in 3 seconds

Store.js will pick the best available storage, and automatically falls back to the first available storage that works:

• all.js All the storages in one handy place.
• localStorage.js Store values in localStorage. Great for all modern browsers.
• sessionStorage.js Store values in sessionStorage.
• cookieStorage.js Store values in cookies. Useful for Safari Private mode.
• memoryStorage.js Store values in memory. Great fallback to ensure store functionality at all times.
• oldFF-globalStorage.js Store values in globalStorage. Only useful for legacy Firefox 3+.
• oldIE-userDataStorage.js Store values in userData. Only useful for legacy IE 6+.

Each storage has different limits, restrictions and overflow behavior on different browser. For example, Android has has a 4.57M localStorage limit in 4.0, a 2.49M limit in 4.1, and a 4.98M limit in 4.2… Yeah.

To simplify things we provide these recommendations to ensure cross browser behavior:

Chances are you won’t ever need another storage. But if you do…

See storages/ for examples. Two good examples are memoryStorage and localStorage.

Basically, you just need an object that looks like this:

// Example custom storage
var storage = {
	name: 'myStorage',
	read: function(key) { ... },
	write: function(key, value) { ... },
	each: function(fn) { ... },
	remove: function(key) { ... },
	clearAll: function() { ... }
}
var store = require('store').createStore(storage)

This is a Haskell implementation of q command.

brew install itchyny/tap/qhs

stack install qhs

In the beginning, qhs [QUERY] is the basic usage.

 $ wc * > wc_out.txt
 $ qhs "SELECT * FROM ./wc_out.txt"
66 471 3131 File.hs
118 649 4962 Main.hs
61 258 2346 Option.hs
51 366 2564 Parser.hs
45 273 1769 SQL.hs
341 2017 14772 total

You can specify the file name for the table name.
The column names are automatically assigned as c1, c2 and so on.

 $ qhs "SELECT c4,c1 FROM ./wc_out.txt WHERE c4 <> 'total' ORDER BY c1 DESC"
Main.hs 118
File.hs 66
Option.hs 61
Parser.hs 51
SQL.hs 45

The qhs command can read the table from the standard input as well.

 $ wc * | qhs "SELECT c4,c1 FROM - WHERE c4 <> 'total' ORDER BY c1 DESC"
Main.hs 118
File.hs 66
Option.hs 61
Parser.hs 51
SQL.hs 45

You can use -H flag to make qhs regard the head line as the row of column names.

 $ cat basic.csv
foo,bar,baz
a0,1,a2
b0,3,b2
c0,,c2
 $ qhs -H "SELECT * FROM basic.csv WHERE bar IS NOT NULL"
a0 1 a2
b0 3 b2

You can use the basic SQL operations; GROUP BY, ORDER BY, LIMIT and COUNT(*).

 $ ps -ef | qhs -H -O "SELECT UID,COUNT(*) cnt FROM - GROUP BY UID ORDER BY cnt DESC LIMIT 3"
UID cnt
503 102
0 86
89 3

You can also use other SQL operations like JOIN, UNION and sub-query.
The command helps you deal with multiple CSV files.

Please refer to qhs --help for further options.
The command respects the behaviour of the original q command.

 $ qhs --help
qhs - SQL queries on CSV and TSV files

Usage: qhs [-H|--skip-header] [-O|--output-header] [-d|--delimiter DELIMITER]
           [-t|--tab-delimited] [-p|--pipe-delimited]
           [-D|--output-delimiter OUTPUT_DELIMITER] [-T|--tab-delimited-output]
           [-P|--pipe-delimited-output] [-k|--keep-leading-whitespace]
           [-z|--gzipped] [-q|--query-filename QUERY_FILENAME] [QUERY]

Available options:
  -h,--help                Show this help text
  -v,--version             Show the version of the command.
  -H,--skip-header         Skip the header row for row input and use it for
                           column names instead.
  -O,--output-header       Output the header line.
  -d,--delimiter DELIMITER Field delimiter. If not specified, automatically
                           detected.
  -t,--tab-delimited       Same as -d $'\t'.
  -p,--pipe-delimited      Same as -d '|'.
  -D,--output-delimiter OUTPUT_DELIMITER
                           Field delimiter for output. If not specified, the
                           argument of -d DELIMITER is used.
  -T,--tab-delimited-output
                           Same as -D $'\t'.
  -P,--pipe-delimited-output
                           Same as -D '|'.
  -k,--keep-leading-whitespace
                           Keep leading whitespace in values. The leading
                           whitespaces are stripped off by default.
  -z,--gzipped             Assuming the gzipped input.
  -q,--query-filename QUERY_FILENAME
                           Read query from the provided filename.

itchyny (https://github.com/itchyny)

This software is released under the MIT License, see LICENSE.