jaycosaur

const fetchHOC = (WrappedComponent, fetchPath, optionalHeader) => {
    return class extends Component {
      constructor(props){
        super(props)
        this.state = {
          data: null,
          isError: false,
          isFetching: true
        }
      }

jaycosaur

class APIFetch extends Component {
    constructor(props){
      super(props)
      this.state = {
        data: null,
        isError: false,
        isFetching: true
      }
    }
  

jaycosaur

import { google } from 'googleapis';
import { auth } from 'google-auth-library'

export default class getModel {
    modelName: string;
    projectName: string;

    constructor(attrs) {
        this.modelName = attrs.modelName
        this.projectName = attrs.projectName

jaycosaur

// extension of classical overwriting ring buffer that holds an incremental counter that can be indexed

// this should not be used for read heavy write infrequent streams (as a map would be a much mor effective implementation)
// this could be used for write heavy read infrequent streams

export class OverwritingRingBuffer<T> {
  private buffer: T[];
  private bufferLength: number;
  private pointer: number;
  private counter: number;

jaycosaur

from shared import camera_producer, cpu_bound, display


def main():
    frames = camera_producer()
    cpu_bound_op = cpu_bound()
    for frame in frames:
        cpu_bound_op(frame)
        display(frame)

jaycosaur

import cv2
import time
import numpy as np

from threading import Thread
from queue import Queue

log_const = 30

jaycosaur

import cv2
import time
import numpy as np
import multiprocessing as mp


log_const = 30


class FPS:

jaycosaur

import cv2
import time
import numpy as np
import multiprocessing as mp


log_const = 30

shared_frame = mp.RawArray('B', 2764800)
camera_dims = (720, 1280, 3)

jaycosaur

from queue import Queue
from threading import Thread
from typing import Any, List, Iterator


class PipeClose:
    pass


class PipeExtra:

jaycosaur

from queue import Queue
from threading import Thread
from typing import cast
import asyncio
import janus

# note that this will never cleanup the thread. You will need to implement your own shutdown logic / methods.

def sync_to_async_queue(queue: Queue, loop: asyncio.AbstractEventLoop) -> asyncio.Queue:
    conversion_queue: janus.Queue = janus.Queue(loop=loop)