Public
Edited
Nov 30
1 star
atom2 = atomise({
source, format,
mode:'DFS', // breadth or depth first
dist: true, // get leaf distributions
tree: true, // build an XML-like tree
depth: 7, // maximum iteration depth
cycle: false, // ignore nested cycles
})
atom = atomise({
source, format,
mode:'DFS', // breadth or depth first
dist: true, // get leaf distributions
tree: true, // build an XML-like tree
depth: 7, // maximum iteration depth
cycle: false, // ignore nested cycles
query: (`Object:has([content*=http])`), // typed cssselector query
meta: ()=> ({time:performance.now()}) // callback for each entry
})
filtered = atomise({
d3, format, // optional DOM formatter
dist: true, // get leaf distributions
// tree: true,
depth: 5,
filter: (key, child, parent)=> (parent.own =='Class' && child.own == 'Function'),
// query: (`Class[sub="1"]:has([sub="2"])`),
})
atomise({d3,depth:3,mode:'BFS',filter:key=>key.includes('x')})
function atomise({
mode = 'BFS', depth = 5, slots = 2 ** 15,
dist = false, cycle = false , tree = false, split = 2,
query = (``), filter = (k,c,p) => true, take = Infinity, separator = '.', meta,
format = (v)=> v , parse = (v) => v, leaves = null, prefix = '@', ... rest } = {}) {
/* -------- */
let iters = -1;
let object = rest;
let outer = [], queue = [];
let t1 = performance.now();
let maxDepth = depth;
let prior = new Set(),
cache = new Map(),
nodes = new Map(),
types = new Map();
/* ---------------- */
let its = (prop) => Object.prototype.toString.call(prop);
let any = (prop, ...types) => types.some((type) => its(prop) === its(type));
let not = (prop, ...types) => !any(prop,...types) ;
let see = (prop) => ext(prop) ? 'Class' : its(prop).slice(1,-1).split(' ')[1]
let ext = (prop) => its(prop).includes('Func') && Function.prototype.toString.call(prop).startsWith('class')
let end = (prop) => leaves === null ? ~leaves : leaves ^ typeof prop === typeof {};
let bin = (item) => Object.fromEntries(Object.entries(item).map(d=>[d[0],'']));
let get = (path) => path.slice(1).reduce((path,item)=> path && path[item] || null,
(object))
/* ---------------- */
let sum = (list, all = {}) => {
if ( list.length ) {
for ( let [ key, val ] of list)
{ let type = types.get(val) ?? see(val?.value || val);
types.set(val,type); all[type.concat('s')] = (all[type.concat('s')] || 0) + 1}}
return [all,list.length] }
/* ---------------- */
let sep = (types, left = '', right = '') => {
for ( let [key,val] of types)
{
if ( key.length > split && !isFinite(key)) {
left += key + '|' } else { right += key + '|' }}
return [ left.slice(0,-1), right.slice(0,-1) ] }
/* ---------------- */
let add = (item) => {
let node = document.createElement(item.own);
Object.defineProperty(node,'out',{
get:()=>decodeURI(format(node.outerHTML))})
Object.entries(item)
.filter(([key, val], i, f) => ["key", "cid","sub","dim","sig","all","ext"].includes(key) && val)
.forEach(([key, val]) => any(val, Object())
? Object.entries(val).forEach(([key,val])=> node.setAttribute(key,val))
: node.setAttribute(key, val));
if(not(item.val, Array(),Object(),Symbol())) { node.setAttribute('content', encodeURI(item.val.toString().replaceAll(/\n+/g,'')))}
return node };
/* ---------------- */
function getProp(object, depth = 0) {
let chain = [], forward; queue.push([object, chain, depth]);
switch (mode) {
case "BFS": forward = true , mode = "shift" ; break;
case "DFS": forward = false , mode = "pop" ; break;}
while ( queue.length )
{[ object , chain , depth ] = queue[mode](); // console.log(chain);
for ( let [ key, val ] of forward ? spy(object) : spy(object).reverse().sort((a,b)=>parseInt(a[0]) - parseInt(b[0]))) { ++iters;
if ( outer.length > take - 1 )
continue
let own = types.get(val) ?? see(val) , set, sig, all, dim, child ; types.set(val,own);
let entry = { key, own, val,
cid: (val?.name ?? val?.constructor?.name)?.toString().replace // escape reserved rgx chars
(new RegExp(`^${[own,key.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')].join('|')}$`),''),
set, sig, sub:depth, dim, pad:chain,all };
if( typeof meta == 'function' )
{ Object.assign(entry, { ext:meta({...entry},iters)}) }
Object.defineProperties(entry , {
parse: { value:()=>not(val, Object(),Symbol()) ? parse(val.toString()) : {}},
path: { get:()=>(prop)=>entry.pad.map(d=>d[prop||'key'])}})
if ( dist ) {
let counts = cache.get(val)
if( counts === undefined )
{ counts = spy(val); [ set , sig , all, dim ] = sep(counts).concat(sum(counts));
cache.set(val , [ set , sig , all, dim ])} else {[ set , sig , all , dim ] = counts};
Object.assign(entry, { set , sig , all, dim })}
if ( tree || query.length > 0 ) {
let parentPath = chain.map(d=>d.key),
childsPath = parentPath.concat(key),
parent = nodes.get(parentPath.join(separator)) ;
child = nodes.get(childsPath.join(separator)) ?? add(entry);
nodes.set(childsPath.join(separator),child)
parent?.appendChild(child) }
if ( filter(key, entry, chain.at(-1) ?? bin(entry)) && end(val))
{ outer.push( Object.defineProperties(
{ [[prefix].concat(entry.path()).join(separator)]: key, above:chain.at(-1), below:entry, chain, child, iters,depth },
{ out: { get:()=>child.out}, path:{ get:()=>entry.path }}))
if ( tree || query.length > 0 ){ child.setAttribute('include', true)}}
if ((typeof val == 'object' ? prior.has(val) : prior.has(key)) && !cycle || prior.size > slots - 1 )
{ continue }
if ((typeof val == 'object' || typeof val == 'function') && depth < maxDepth)
{ prior.add(val); queue.push([val, [...chain, entry], depth + 1]) }
else { prior.add(key); }
}
}
}
getProp(object);
let root = nodes.values().next().value;
if ( query.length > 0 ) { let result = root.querySelectorAll(query);
for ( let i = 0; i < result.length; ++i)
{ result[i].setAttribute('select', true) }
outer = outer.filter(d=>{
let inc = d.child.getAttribute('select') ;
return inc })}
Object.defineProperties(outer,{
ticks: { get:()=> performance.now() - t1 },
root: { get:()=> root },
crop: { get:()=>
{ nodes.forEach(node=> {
if (!node.getAttribute('include') || (!node.getAttribute('select') && query.length > 0) )
{ node.replaceWith(...node.children) }
else { node.removeAttribute('include');
node.removeAttribute('select') }});
root.removeAttribute('include');root.removeAttribute('select');
return root?.out }},
out: { get:()=> root?.out }
})
return outer
}
function spy(object) { /*
* ------ enumerate keys names, methods
*/ var list = [], props,
current = object;
do {
try { props = Object.entries( current?.prototype ?
Object.getOwnPropertyDescriptors(current.prototype) : typeof current === 'string' ? [] : current )}
catch { props = [] }
for ( let [ key , item ] of props )
{ if ( item !== undefined && list.indexOf([key, item]) === -1
&&! [ "constructor", "__proto__","writable","enumerable","configurable",].includes(key)
&&! ( item?.location && item.location == window.location)
&&! ( item?.value?.toString && item?.value?.toString().includes("native code") || item?.toString && item?.toString().includes("native code")))
{ list.push([key, item?.value ?? item ]) }}}
while ( current &&
( current = Object.getPrototypeOf(current))); return list }
atomise({
format,
root:JSON.parse(JSON.stringify(code)) ,
mode:'BFS', // breadth or depth first
dist: true, // get leaf distributions
tree: true, // build an XML-like tree
depth: 2, // maximum iteration depth
cycle: false, // ignore nested cycles
meta: (entry,i)=>{
entry.own = 'o'+entry.key
mutable temp.push(entry), mutable temp = mutable temp, i+1
}
}).out
mutable temp = []
code = ps.parseSource(`package com.twitter.ann.annoy
import com.twitter.ann.common.RuntimeParams
import com.twitter.ann.common.thriftscala.AnnoyIndexMetadata
import com.twitter.bijection.Injection
import com.twitter.mediaservices.commons.codec.ThriftByteBufferCodec
import com.twitter.ann.common.thriftscala.{AnnoyRuntimeParam, RuntimeParams => ServiceRuntimeParams}
import scala.util.{Failure, Success, Try}
object AnnoyCommon {
private[annoy] lazy val MetadataCodec = new ThriftByteBufferCodec(AnnoyIndexMetadata)
private[annoy] val IndexFileName = "annoy_index"
private[annoy] val MetaDataFileName = "annoy_index_metadata"
private[annoy] val IndexIdMappingFileName = "annoy_index_id_mapping"
val RuntimeParamsInjection: Injection[AnnoyRuntimeParams, ServiceRuntimeParams] =
new Injection[AnnoyRuntimeParams, ServiceRuntimeParams] {
override def apply(scalaParams: AnnoyRuntimeParams): ServiceRuntimeParams = {
ServiceRuntimeParams.AnnoyParam(
AnnoyRuntimeParam(
scalaParams.nodesToExplore
)
)
}
override def invert(thriftParams: ServiceRuntimeParams): Try[AnnoyRuntimeParams] =
thriftParams match {
case ServiceRuntimeParams.AnnoyParam(annoyParam) =>
Success(
AnnoyRuntimeParams(annoyParam.numOfNodesToExplore)
)
case p => Failure(new IllegalArgumentException(s"Expected AnnoyRuntimeParams got $p"))
}
}
}
case class AnnoyRuntimeParams(
/* Number of vectors to evaluate while searching. A larger value will give more accurate results, but will take longer time to return.
* Default value would be numberOfTrees*numberOfNeigboursRequested
*/
nodesToExplore: Option[Int])
extends RuntimeParams {
override def toString: String = s"AnnoyRuntimeParams( nodesToExplore = $nodesToExplore)"
}`)
Purpose-built for displays of data
Observable is your go-to platform for exploring data and creating expressive data visualizations. Use reactive JavaScript notebooks for prototyping and a collaborative canvas for visual data exploration and dashboard creation.
