joocer

# memory_pool.pyx
from libc.stdlib cimport malloc, free
from libc.string cimport memcpy
from cpython.bytes cimport PyBytes_AsString, PyBytes_FromStringAndSize
from threading import Lock
from orso.tools import random_int
from libcpp.vector cimport vector

cdef struct MemorySegment:
    int start

joocer

"""
LRU-K evicts the page whose K-th most recent access is furthest in the past.

This is a basic implementation of LRU-2, which evicts entries according to the time
of their penultimate access. The main benefit of this approach is to prevent
a problem when the items being checked exceeds the number of items in the cache. A
classic LRU will evict and repopulate the cache for every call. LRU-2 reduces the
likelihood of this, but not preferring the MRU item to be retained.

LRU-K should be used in conjunction with eviction limits per query - this appears to

joocer

function colorGradient(colors, fadeFraction) {
    if (fadeFraction >= 1) {
        return colors[colors.length - 1]
    } else if (fadeFraction <= 0) {
        return colors[0]
    }

    let fade = fadeFraction * (colors.length - 1);
    let interval = Math.trunc(fade);
    fade = fade - interval

joocer

"""
Grammar:
========
Expression --> AndTerm { OR AndTerm}+
AndTerm --> Condition { AND Condition}+
Condition --> Terminal (>,<,>=,<=,==) Terminal | (Expression)
Terminal --> Number or String or Variable

Usage:
======

joocer

from matplotlib import pyplot as plt  # type:ignore
from mabel.data.formats import dictset
import numpy as np  # type:ignore


def bollinger_bands(series, length=20, sigmas=2):      
    index = 0
    window = series[0:length] 
    num_vals = len(window)

joocer

bar_chars = (' ', '▁', '▂', '▃', '▄', '▅', '▆', '▇', '█')

def _draw_histogram(bins):
    mx = max([v for k,v in bins.items()])
    bar_height = (mx / 7)
    if mx == 0:
        return ' ' * len(bins)
    
    histogram = ''
    for k,v in bins.items():

joocer

"""
B+Tree Code Adapted From:

https://gist.github.com/savarin/69acd246302567395f65ad6b97ee503d

No explicit license when accessed on 2nd March 2020.

Other code:

(C) 2021 Justin Joyce.

joocer

"""
Threaded Google Cloud Storage Blob reader.

Reads a set of blobs parallel to speed up reading. Blobs are 
read line by line, the usecase this was written for was jsonl
files, but any record-per-line format where you don't care 
about the order of the lines should not have issues.

Limited performance testing reading a set of eight blobs, 
4x 19Mb, 4x 5.4Mb in four threads ran in 20.1% of the time.

joocer

import datetime, re
from google.cloud import storage
from functools import lru_cache
try:
    import ujson as json
except ImportError:
    import json


def select_dictionary_values(dictionary, values):

joocer

def read_file(filename, chunk_size=1024*1024, delimiter='\n'):
    with open(filename, 'r', encoding="utf8") as f:
        carry_forward = ''
        chunk = 'INITIALIZED'
        while len(chunk) > 0:
            chunk = f.read(chunk_size)
            augmented_chunk = carry_forward + chunk
            lines = augmented_chunk.split(delimiter)
            carry_forward = lines.pop()
            yield from lines