ctrl+shift+p filters: :st2 :st3 :win :osx :linux
Browse

Mini​Py

by vim-zz ST3

Sublime Text 3 plugin - inline python evaluation

Labels minipy, inline, engine, parser

Details

Installs

  • Total 2K
  • Win 943
  • Mac 563
  • Linux 386
Jul 27 Jul 26 Jul 25 Jul 24 Jul 23 Jul 22 Jul 21 Jul 20 Jul 19 Jul 18 Jul 17 Jul 16 Jul 15 Jul 14 Jul 13 Jul 12 Jul 11 Jul 10 Jul 9 Jul 8 Jul 7 Jul 6 Jul 5 Jul 4 Jul 3 Jul 2 Jul 1 Jun 30 Jun 29 Jun 28 Jun 27 Jun 26 Jun 25 Jun 24 Jun 23 Jun 22 Jun 21 Jun 20 Jun 19 Jun 18 Jun 17 Jun 16 Jun 15 Jun 14 Jun 13
Windows 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0
Mac 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
Linux 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0

Readme

Source
raw.​githubusercontent.​com

MiniPy

Sublime Text 3 plugin - inline python evaluation.

Functionality

As a calculator

For example you can write 3.14*0.6 and get the result 1.884 in your text. It also supports multiple selection.

Incremnt counter at cursor positions

Another feature is the use of $ as accumolation variable, e.g. having the following multipe selection:

arr[$]
arr[$]
arr[$]

will result with

arr[1]
arr[2]
arr[3]

similarly:

arr[0 ]      arr[0]
arr[$+2]  -> arr[3]
arr[$*3]     arr[6]

General Python evalueator

Besides that, you have the following imports avaiable:

from math import *
from random import *
from collections import Counter
import datetime
import re  # though you should probably use the build in regex features of ST instead.

So you can do:

Counter(('Ann', 'Bob', 'Bob', 'Michael'))                                     -> Counter({'Bob': 2, 'Ann': 1, 'Michael': 1})
Counter(('Ann', 'Bob', 'Bob', 'Michael', 'michael'))                          -> Counter({'Bob': 2, 'Ann': 1, 'michael': 1, 'Michael': 1})
Counter(name.title() for name in ('Ann', 'Bob', 'Bob', 'Michael', 'michael')) -> Counter({'Bob': 2, 'Michael': 2, 'Ann': 1})

Computing checksums

And the functions md5 and sha1 returns the correspondingly hex-digest of the stringified version of the inputs, e.g. md5(['foo', 'bar', 'baz']) = dbb432a3f0ac1a2687911715dfbf7502. Notice that it's possible to hash the list because it's the string-representation of the list which are being hashed!

The python hashlib.md5 and hashlib.sha1 functions are avaiable under the names _md5 and _sha1.

Inserting datatimes

The functions dnow, tnow and dtnow return respectively the current string-formatted date, time and datetime:

dnow()  -> 03/05/2017
tnow()  -> 09:36:03
dtnow() -> 03/05/2017 09:36:03

Notice that you need to have parenthesis after the function name to invoke the function call.

Computing with sets

While you can just use the regular python to do set computations, there's a few functions included for convinience: set_intersect, set_difference and set_symdiff.

The functions takes two iterable arguments, which are turned into sets, and the computations are performed:

set_intersect('foo bar', 'foo baz')  -> {'b', ' ', 'a', 'f', 'o'}
set_intersect('foo baz', 'foo bar')  -> {'b', 'a', ' ', 'o', 'f'}
set_difference('foo baz', 'foo bar') -> {'z'}
set_difference('foo bar', 'foo baz') -> {'r'}
set_symdiff('foo baz', 'foo bar')    -> {'z', 'r'}
set_symdiff('foo bar', 'foo baz')    -> {'z', 'r'}

Computing cumulative sums and products

Compute the cumulative sum of an iterable:

cumsum([1,2,3,4,5]) -> [1, 3, 6, 10, 15]
cumsum([0.02809, 0.05619, 0.08646, 0.11919, 0.15192, 0.18465, 1.31694]) -> [0.02809, 0.08428, 0.17074, 0.28993, 0.44185, 0.6265000000000001, 1.94344]

And a cumulative product

cumprod([1, 2, 3, 4, 5]) -> [1, 2, 6, 24, 120]
cumprod([0.02809, 0.05619, 0.08646, 0.11919, 0.15192, 0.18465, 1.31694]) -> [0.02809, 0.0015783771, 0.000136466484066, 1.626544023582654e-05, 2.471045680626768e-06, 4.5627858492773275e-07, 6.008915196347284e-07]

But doing products of a lot of small numbers are prone to errors, so we can use a math trick:
, where A is the iterable. This will increase the numerical stability, as seen in this example:

cumprod([1e-8, 1e-9, 1e-10, 1e-11, 1e-12, 1e-13, 1e-14]) -> [1e-08, 1e-17, 1e-27, 1e-38, 9.999999999999999e-51, 9.999999999999999e-64, 1e-77]
cumprod([1e-8, 1e-9, 1e-10, 1e-11, 1e-12, 1e-13, 1e-14], use_logsum=True) -> [9.999999999999982e-09, 9.99999999999999e-18, 1.0000000000000022e-27, 9.999999999999936e-39, 9.999999999999944e-51, 1.0000000000000049e-63, 9.999999999999967e-78]
cumprod([1e-8, 1e-9, 1e-10, 1e-11, 1e-12, 1e-13, 1e-14], use_logsum=True) -> # same result as above.

Formatting numbers

The function formatnum formats numbers, and takes two mandatory and an optional argument:

num : The number bieng formatted.

digits : The number of desired digits in the formatted number.

scientificNotation : Wether of not to use scientific notation. : Can be True, False or int, where int is the threshold for how many characters the number may contain when formatted un-scientifically, before switching to scientific notation. : This is the default behaviour, and it's set to 8.

Example usage:

formatnum(0.123456789, 4)                -> 0.1235
formatnum(0.123456789, 9)                -> 1.234567890e-01
formatnum(123456789.0, 9)                -> 1.234567890e+08
formatnum(123456789.0, 2)                -> 1.23e+08
formatnum(123.456789, 12)                -> 1.234567890000e+02
formatnum(123.456789, 12, False)         -> 123.456789000000
formatnum(123.456789, 3)                 -> 123.457
formatnum(3.14159, 4)                    -> 3.1416
formatnum(3.14159, 3)                    -> 3.142
formatnum(3.14159, 2)                    -> 3.14
formatnum(3.14159, 2, True)              -> 3.14e+00
formatnum(3.141592653589793238462643, 3) -> 3.142

Convert Timestamp to human readable time

The function ts transform timestamp as unix time, which is seconds since epoch to string using supplied format

ts(1478002058.368)               ->  2016-11-01T12:07:38.368000+0000
ts(1478002058.368, '%Y%m%d')     ->  20161101

Usage

To evaluate term, highlight and:

Super + Shift + X for Mac OS X
Ctrl + Shift + X for Windows/Linux