slidge-whatsapp 0.2.5__cp311-cp311-manylinux_2_36_aarch64.whl → 0.2.7__cp311-cp311-manylinux_2_36_aarch64.whl

slidge_whatsapp/vendor/go.mau.fi/util/exsync/event.go

@@ -0,0 +1,88 @@
+// Copyright (c) 2024 Tulir Asokan
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package exsync
+
+import (
+	"context"
+	"sync"
+	"time"
+)
+
+// Event is a wrapper around a channel that can be used to notify multiple waiters that some event has happened.
+//
+// It's modelled after Python's asyncio.Event: https://docs.python.org/3/library/asyncio-sync.html#asyncio.Event
+type Event struct {
+	ch  chan empty
+	set bool
+	l   sync.RWMutex
+}
+
+// NewEvent creates a new event. It will initially be unset.
+func NewEvent() *Event {
+	return &Event{
+		ch: make(chan empty),
+	}
+}
+
+type EventChan = <-chan empty
+
+// GetChan returns the channel that will be closed when the event is set.
+func (e *Event) GetChan() EventChan {
+	e.l.RLock()
+	defer e.l.RUnlock()
+	return e.ch
+}
+
+// Wait waits for either the event to happen or the given context to be done.
+// If the context is done first, the error is returned, otherwise the return value is nil.
+func (e *Event) Wait(ctx context.Context) error {
+	select {
+	case <-e.GetChan():
+		return nil
+	case <-ctx.Done():
+		return ctx.Err()
+	}
+}
+
+// WaitTimeout waits for either the event to happen within the given timeout.
+// If the timeout expires first, the return value is false, otherwise it's true.
+func (e *Event) WaitTimeout(timeout time.Duration) bool {
+	select {
+	case <-e.GetChan():
+		return true
+	case <-time.After(timeout):
+		return false
+	}
+}
+
+// IsSet returns true if the event has been set.
+func (e *Event) IsSet() bool {
+	e.l.RLock()
+	defer e.l.RUnlock()
+	return e.set
+}
+
+// Set sets the event, notifying all waiters.
+func (e *Event) Set() {
+	e.l.Lock()
+	defer e.l.Unlock()
+	if !e.set {
+		close(e.ch)
+		e.set = true
+	}
+}
+
+// Clear clears the event, making it unset. Future calls to Wait will now block until Set is called again.
+// If the event is not already set, this is a no-op and existing calls to Wait will keep working.
+func (e *Event) Clear() {
+	e.l.Lock()
+	defer e.l.Unlock()
+	if e.set {
+		e.ch = make(chan empty)
+		e.set = false
+	}
+}

slidge_whatsapp/vendor/go.mau.fi/util/exsync/returnonce.go

@@ -0,0 +1,25 @@
+// Copyright (c) 2023 Tulir Asokan
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package exsync
+
+import "sync"
+
+// ReturnableOnce is a wrapper for sync.Once that can return a value
+//
+// Deprecated: Use [sync.OnceValues] instead.
+type ReturnableOnce[Value any] struct {
+	once   sync.Once
+	output Value
+	err    error
+}
+
+func (ronce *ReturnableOnce[Value]) Do(fn func() (Value, error)) (Value, error) {
+	ronce.once.Do(func() {
+		ronce.output, ronce.err = fn()
+	})
+	return ronce.output, ronce.err
+}

slidge_whatsapp/vendor/go.mau.fi/util/exsync/ringbuffer.go

@@ -0,0 +1,139 @@
+// Copyright (c) 2023 Tulir Asokan
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package exsync
+
+import (
+	"errors"
+	"sync"
+)
+
+type pair[Key comparable, Value any] struct {
+	Set   bool
+	Key   Key
+	Value Value
+}
+
+type RingBuffer[Key comparable, Value any] struct {
+	ptr  int
+	data []pair[Key, Value]
+	lock sync.RWMutex
+	size int
+}
+
+func NewRingBuffer[Key comparable, Value any](size int) *RingBuffer[Key, Value] {
+	return &RingBuffer[Key, Value]{
+		data: make([]pair[Key, Value], size),
+	}
+}
+
+var (
+	// StopIteration can be returned by the RingBuffer.Iter or MapRingBuffer callbacks to stop iteration immediately.
+	StopIteration = errors.New("stop iteration") //lint:ignore ST1012 not an error
+
+	// SkipItem can be returned by the MapRingBuffer callback to skip adding a specific item.
+	SkipItem = errors.New("skip item") //lint:ignore ST1012 not an error
+)
+
+func (rb *RingBuffer[Key, Value]) unlockedIter(callback func(key Key, val Value) error) error {
+	end := rb.ptr
+	for i := clamp(end-1, len(rb.data)); i != end; i = clamp(i-1, len(rb.data)) {
+		entry := rb.data[i]
+		if !entry.Set {
+			break
+		}
+		err := callback(entry.Key, entry.Value)
+		if err != nil {
+			if errors.Is(err, StopIteration) {
+				return nil
+			}
+			return err
+		}
+	}
+	return nil
+}
+
+func (rb *RingBuffer[Key, Value]) Iter(callback func(key Key, val Value) error) error {
+	rb.lock.RLock()
+	defer rb.lock.RUnlock()
+	return rb.unlockedIter(callback)
+}
+
+func MapRingBuffer[Key comparable, Value, Output any](rb *RingBuffer[Key, Value], callback func(key Key, val Value) (Output, error)) ([]Output, error) {
+	rb.lock.RLock()
+	defer rb.lock.RUnlock()
+	output := make([]Output, 0, rb.size)
+	err := rb.unlockedIter(func(key Key, val Value) error {
+		item, err := callback(key, val)
+		if err != nil {
+			if errors.Is(err, SkipItem) {
+				return nil
+			}
+			return err
+		}
+		output = append(output, item)
+		return nil
+	})
+	return output, err
+}
+
+func (rb *RingBuffer[Key, Value]) Size() int {
+	rb.lock.RLock()
+	defer rb.lock.RUnlock()
+	return rb.size
+}
+
+func (rb *RingBuffer[Key, Value]) Contains(val Key) bool {
+	_, ok := rb.Get(val)
+	return ok
+}
+
+func (rb *RingBuffer[Key, Value]) Get(key Key) (val Value, found bool) {
+	rb.lock.RLock()
+	end := rb.ptr
+	for i := clamp(end-1, len(rb.data)); i != end; i = clamp(i-1, len(rb.data)) {
+		if rb.data[i].Key == key {
+			val = rb.data[i].Value
+			found = true
+			break
+		}
+	}
+	rb.lock.RUnlock()
+	return
+}
+
+func (rb *RingBuffer[Key, Value]) Replace(key Key, val Value) bool {
+	rb.lock.Lock()
+	defer rb.lock.Unlock()
+	end := rb.ptr
+	for i := clamp(end-1, len(rb.data)); i != end; i = clamp(i-1, len(rb.data)) {
+		if rb.data[i].Key == key {
+			rb.data[i].Value = val
+			return true
+		}
+	}
+	return false
+}
+
+func (rb *RingBuffer[Key, Value]) Push(key Key, val Value) {
+	rb.lock.Lock()
+	rb.data[rb.ptr] = pair[Key, Value]{Key: key, Value: val, Set: true}
+	rb.ptr = (rb.ptr + 1) % len(rb.data)
+	if rb.size < len(rb.data) {
+		rb.size++
+	}
+	rb.lock.Unlock()
+}
+
+func clamp(index, len int) int {
+	if index < 0 {
+		return len + index
+	} else if index >= len {
+		return len - index
+	} else {
+		return index
+	}
+}

slidge_whatsapp/vendor/go.mau.fi/util/exsync/syncmap.go

@@ -0,0 +1,94 @@
+// Copyright (c) 2023 Tulir Asokan
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package exsync
+
+import "sync"
+
+// Map is a simple map with a built-in mutex.
+type Map[Key comparable, Value any] struct {
+	data map[Key]Value
+	lock sync.RWMutex
+}
+
+func NewMap[Key comparable, Value any]() *Map[Key, Value] {
+	return &Map[Key, Value]{
+		data: make(map[Key]Value),
+	}
+}
+
+// Set stores a value in the map.
+func (sm *Map[Key, Value]) Set(key Key, value Value) {
+	sm.Swap(key, value)
+}
+
+// Swap sets a value in the map and returns the old value.
+//
+// The boolean return parameter is true if the value already existed, false if not.
+func (sm *Map[Key, Value]) Swap(key Key, value Value) (oldValue Value, wasReplaced bool) {
+	sm.lock.Lock()
+	oldValue, wasReplaced = sm.data[key]
+	sm.data[key] = value
+	sm.lock.Unlock()
+	return
+}
+
+// Delete removes a key from the map.
+func (sm *Map[Key, Value]) Delete(key Key) {
+	sm.Pop(key)
+}
+
+// Pop removes a key from the map and returns the old value.
+//
+// The boolean return parameter is the same as with normal Go map access (true if the key exists, false if not).
+func (sm *Map[Key, Value]) Pop(key Key) (value Value, ok bool) {
+	sm.lock.Lock()
+	value, ok = sm.data[key]
+	delete(sm.data, key)
+	sm.lock.Unlock()
+	return
+}
+
+// Get gets a value in the map.
+//
+// The boolean return parameter is the same as with normal Go map access (true if the key exists, false if not).
+func (sm *Map[Key, Value]) Get(key Key) (value Value, ok bool) {
+	sm.lock.RLock()
+	value, ok = sm.data[key]
+	sm.lock.RUnlock()
+	return
+}
+
+// GetOrSet gets a value in the map if the key already exists, otherwise inserts the given value and returns it.
+//
+// The boolean return parameter is true if the key already exists, and false if the given value was inserted.
+func (sm *Map[Key, Value]) GetOrSet(key Key, value Value) (actual Value, wasGet bool) {
+	sm.lock.Lock()
+	defer sm.lock.Unlock()
+	actual, wasGet = sm.data[key]
+	if wasGet {
+		return
+	}
+	sm.data[key] = value
+	actual = value
+	return
+}
+
+// Clone returns a copy of the map.
+func (sm *Map[Key, Value]) Clone() *Map[Key, Value] {
+	return &Map[Key, Value]{data: sm.CopyData()}
+}
+
+// CopyData returns a copy of the data in the map as a normal (non-atomic) map.
+func (sm *Map[Key, Value]) CopyData() map[Key]Value {
+	sm.lock.RLock()
+	copied := make(map[Key]Value, len(sm.data))
+	for key, value := range sm.data {
+		copied[key] = value
+	}
+	sm.lock.RUnlock()
+	return copied
+}

slidge_whatsapp/vendor/go.mau.fi/util/exsync/syncset.go

@@ -0,0 +1,136 @@
+// Copyright (c) 2023 Tulir Asokan
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package exsync
+
+import (
+	"sync"
+)
+
+type empty struct{}
+
+var emptyVal = empty{}
+
+// Set is a wrapper around a map[T]struct{} with a built-in mutex.
+type Set[T comparable] struct {
+	m map[T]empty
+	l sync.RWMutex
+}
+
+// NewSet constructs a Set with an empty map.
+func NewSet[T comparable]() *Set[T] {
+	return NewSetWithMap[T](make(map[T]empty))
+}
+
+// NewSetWithSize constructs a Set with a map that has been allocated the given amount of space.
+func NewSetWithSize[T comparable](size int) *Set[T] {
+	return NewSetWithMap[T](make(map[T]empty, size))
+}
+
+// NewSetWithMap constructs a Set with the given map. Accessing the map directly after passing it here is not safe.
+func NewSetWithMap[T comparable](m map[T]empty) *Set[T] {
+	return &Set[T]{m: m}
+}
+
+// NewSetWithItems constructs a Set with items from the given slice pre-filled.
+// The slice is not modified or used after the function returns, so using it after this is safe.
+func NewSetWithItems[T comparable](items []T) *Set[T] {
+	s := NewSetWithSize[T](len(items))
+	for _, item := range items {
+		s.m[item] = emptyVal
+	}
+	return s
+}
+
+// Add adds an item to the set. The return value is true if the item was added to the set, or false otherwise.
+func (s *Set[T]) Add(item T) bool {
+	if s == nil {
+		return false
+	}
+	s.l.Lock()
+	_, exists := s.m[item]
+	if exists {
+		s.l.Unlock()
+		return false
+	}
+	s.m[item] = emptyVal
+	s.l.Unlock()
+	return true
+}
+
+// Has checks if the given item is in the set.
+func (s *Set[T]) Has(item T) bool {
+	if s == nil {
+		return false
+	}
+	s.l.RLock()
+	_, exists := s.m[item]
+	s.l.RUnlock()
+	return exists
+}
+
+// Pop removes the given item from the set. The return value is true if the item was in the set, or false otherwise.
+func (s *Set[T]) Pop(item T) bool {
+	if s == nil {
+		return false
+	}
+	s.l.Lock()
+	_, exists := s.m[item]
+	if exists {
+		delete(s.m, item)
+	}
+	s.l.Unlock()
+	return exists
+}
+
+// Remove removes the given item from the set.
+func (s *Set[T]) Remove(item T) {
+	if s == nil {
+		return
+	}
+	s.l.Lock()
+	delete(s.m, item)
+	s.l.Unlock()
+}
+
+// ReplaceAll replaces this set with the given set. If the given set is nil, the set is cleared.
+func (s *Set[T]) ReplaceAll(newSet *Set[T]) {
+	if s == nil {
+		return
+	}
+	s.l.Lock()
+	if newSet == nil {
+		s.m = make(map[T]empty)
+	} else {
+		s.m = newSet.m
+	}
+	s.l.Unlock()
+}
+
+func (s *Set[T]) Size() int {
+	if s == nil {
+		return 0
+	}
+	s.l.RLock()
+	size := len(s.m)
+	s.l.RUnlock()
+	return size
+}
+
+func (s *Set[T]) AsList() []T {
+	if s == nil {
+		return nil
+	}
+	s.l.RLock()
+	list := make([]T, len(s.m))
+	i := 0
+	for item := range s.m {
+		list[i] = item
+		i++
+	}
+	s.l.RUnlock()
+	return list
+}

slidge_whatsapp/vendor/go.mau.fi/util/exzerolog/callermarshal.go

@@ -0,0 +1,28 @@
+// Copyright (c) 2023 Tulir Asokan
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package exzerolog
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+)
+
+// CallerWithFunctionName is an implementation for zerolog.CallerMarshalFunc that includes the caller function name
+// in addition to the file and line number.
+//
+// Use as
+//
+//	zerolog.CallerMarshalFunc = exzerolog.CallerWithFunctionName
+func CallerWithFunctionName(pc uintptr, file string, line int) string {
+	files := strings.Split(file, "/")
+	file = files[len(files)-1]
+	name := runtime.FuncForPC(pc).Name()
+	fns := strings.Split(name, ".")
+	name = fns[len(fns)-1]
+	return fmt.Sprintf("%s:%d:%s()", file, line, name)
+}

slidge_whatsapp/vendor/go.mau.fi/util/exzerolog/defaults.go

@@ -0,0 +1,32 @@
+// Copyright (c) 2024 Tulir Asokan
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package exzerolog
+
+import (
+	"time"
+
+	"github.com/rs/zerolog"
+	deflog "github.com/rs/zerolog/log"
+)
+
+// SetupDefaults updates zerolog globals with sensible defaults.
+//
+// * [zerolog.TimeFieldFormat] is set to time.RFC3339Nano instead of time.RFC3339
+// * [zerolog.CallerMarshalFunc] is set to [CallerWithFunctionName]
+// * [zerolog.DefaultContextLogger] is set to the given logger with default_context_log=true and caller info enabled
+// * The global default [log.Logger] is set to the given logger with global_log=true and caller info enabled
+// * [zerolog.LevelColors] are updated to swap trace and debug level colors
+func SetupDefaults(log *zerolog.Logger) {
+	zerolog.TimeFieldFormat = time.RFC3339Nano
+	zerolog.CallerMarshalFunc = CallerWithFunctionName
+	defaultCtxLog := log.With().Bool("default_context_log", true).Caller().Logger()
+	zerolog.DefaultContextLogger = &defaultCtxLog
+	deflog.Logger = log.With().Bool("global_log", true).Caller().Logger()
+	// Swap trace and debug level colors so trace pops out the least
+	zerolog.LevelColors[zerolog.TraceLevel] = 0
+	zerolog.LevelColors[zerolog.DebugLevel] = 34 // blue
+}

slidge_whatsapp/vendor/go.mau.fi/util/exzerolog/generics.go

@@ -0,0 +1,45 @@
+// Copyright (c) 2023 Tulir Asokan
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package exzerolog
+
+import (
+	"fmt"
+
+	"github.com/rs/zerolog"
+)
+
+func ArrayOf[T any](slice []T, fn func(arr *zerolog.Array, item T)) *zerolog.Array {
+	arr := zerolog.Arr()
+	for _, item := range slice {
+		fn(arr, item)
+	}
+	return arr
+}
+
+func AddObject[T zerolog.LogObjectMarshaler](arr *zerolog.Array, obj T) {
+	arr.Object(obj)
+}
+
+func AddStringer[T fmt.Stringer](arr *zerolog.Array, str T) {
+	arr.Str(str.String())
+}
+
+func AddStr[T ~string](arr *zerolog.Array, str T) {
+	arr.Str(string(str))
+}
+
+func ArrayOfObjs[T zerolog.LogObjectMarshaler](slice []T) *zerolog.Array {
+	return ArrayOf(slice, AddObject[T])
+}
+
+func ArrayOfStringers[T fmt.Stringer](slice []T) *zerolog.Array {
+	return ArrayOf(slice, AddStringer[T])
+}
+
+func ArrayOfStrs[T ~string](slice []T) *zerolog.Array {
+	return ArrayOf(slice, AddStr[T])
+}

slidge_whatsapp/vendor/go.mau.fi/util/exzerolog/writer.go

@@ -0,0 +1,81 @@
+// Copyright (c) 2023 Tulir Asokan
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package exzerolog
+
+import (
+	"bytes"
+	"sync"
+
+	"github.com/rs/zerolog"
+)
+
+// LogWriter wraps a zerolog.Logger and provides an io.Writer with buffering so each written line is logged separately.
+type LogWriter struct {
+	log   zerolog.Logger
+	level zerolog.Level
+	field string
+	mu    sync.Mutex
+	buf   bytes.Buffer
+}
+
+func NewLogWriter(log zerolog.Logger) *LogWriter {
+	zerolog.Nop()
+	return &LogWriter{
+		log:   log,
+		level: zerolog.DebugLevel,
+		field: zerolog.MessageFieldName,
+	}
+}
+
+func (lw *LogWriter) WithLevel(level zerolog.Level) *LogWriter {
+	return &LogWriter{
+		log:   lw.log,
+		level: level,
+		field: lw.field,
+	}
+}
+
+func (lw *LogWriter) WithField(field string) *LogWriter {
+	return &LogWriter{
+		log:   lw.log,
+		level: lw.level,
+		field: field,
+	}
+}
+
+func (lw *LogWriter) writeLine(data []byte) {
+	if len(data) == 0 {
+		return
+	}
+	if data[len(data)-1] == '\n' {
+		data = data[:len(data)-1]
+	}
+	if lw.buf.Len() > 0 {
+		lw.buf.Write(data)
+		data = lw.buf.Bytes()
+		lw.buf.Reset()
+	}
+	lw.log.WithLevel(lw.level).Bytes(lw.field, data).Send()
+}
+
+func (lw *LogWriter) Write(data []byte) (n int, err error) {
+	lw.mu.Lock()
+	defer lw.mu.Unlock()
+	newline := bytes.IndexByte(data, '\n')
+	if newline == len(data)-1 {
+		lw.writeLine(data)
+	} else if newline < 0 {
+		lw.buf.Write(data)
+	} else {
+		lines := bytes.Split(data, []byte{'\n'})
+		for _, line := range lines[:len(lines)-1] {
+			lw.writeLine(line)
+		}
+		lw.buf.Write(lines[len(lines)-1])
+	}
+	return len(data), nil
+}