fancellu

package main

import (
	"fmt"
	"time"
)

func greet(st string, done chan bool) {
	fmt.Println(st)
	done <- true

fancellu

package main

import (
	"fmt"
	"strconv"
)

// Maps over collection of T and applies function f to each item
// Returns a new slice with the transformed items
func mapf[T any, U any](items []T, f func(T) U) []U {

fancellu

import cats.effect.{IO, IOApp}
import fs2.{Stream, text}
import fs2.io.file.{Files, Path}
import fs2.io.{stdout, stderr}

import scala.util.Try

object WindowedAverage extends IOApp.Simple:

  private object Fahrenheit:

fancellu

import scala.annotation.targetName
import scala.util.boundary
import scala.util.boundary.{Label, break}

// Works in Scala 3.4.1

def firstIndex[T](xs: List[T], p: T): Int = {
  boundary:
    for (x, i) <- xs.zipWithIndex do if (x == p) break(i)
    -1

fancellu

def add_dicts_list(dict_list):
  """
  This function adds a list of dictionaries element-wise.

  Args:
      dict_list: A list of dictionaries with k->int elements.

  Returns:
      A new dictionary with the sum of the corresponding elements from all dictionaries in dict_list.
  """

fancellu

https://huggingface.co/spaces/Fancellu/streamlit-demo

fancellu

from PIL import Image
from transformers import BeitImageProcessor, BeitForImageClassification
import os

# Define the directory containing images
image_dir = "e:/media"

# Load the model and processor
processor = BeitImageProcessor.from_pretrained('microsoft/beit-base-patch16-224-pt22k-ft22k')
model = BeitForImageClassification.from_pretrained('microsoft/beit-base-patch16-224-pt22k-ft22k')

fancellu

use futures::TryStreamExt;
use sqlx::postgres::{PgPoolOptions, PgRow};
use sqlx::{Error, PgPool, Row};
use uuid::Uuid;

#[derive(sqlx::FromRow, Debug)]
struct People {
    id: i32,
    name: String,
}

fancellu

use tokio::sync::broadcast;
use tokio::sync::mpsc;
use tokio::sync::oneshot;

#[tokio::main]
async fn main() {
    let (tx, rx) = oneshot::channel();

    tokio::spawn(async move {
        tokio::time::sleep(std::time::Duration::from_secs(1)).await;

fancellu

use std::sync::Arc;
use tokio::sync::RwLock;
use tokio::time::sleep;
use tokio::time::Duration;

// Demonstrates RwLock with a shared resourced

async fn use_read_lock(id: i32, lock: Arc<RwLock<String>>) {
    let lock = lock.read().await;
    println!("reader: {}  lock string: {}", id, lock);