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

slidge_whatsapp/vendor/go.mau.fi/util/jsontime/integer.go

@@ -0,0 +1,170 @@
+// 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 jsontime
+
+import (
+	"database/sql"
+	"database/sql/driver"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"time"
+)
+
+var ErrNotInteger = errors.New("value is not an integer")
+
+func parseTime(data []byte, unixConv func(int64) time.Time, into *time.Time) error {
+	var val int64
+	err := json.Unmarshal(data, &val)
+	if err != nil {
+		return err
+	}
+	if val == 0 {
+		*into = time.Time{}
+	} else {
+		*into = unixConv(val)
+	}
+	return nil
+}
+
+func anyIntegerTo64(src any) (int64, error) {
+	switch v := src.(type) {
+	case int:
+		return int64(v), nil
+	case int8:
+		return int64(v), nil
+	case int16:
+		return int64(v), nil
+	case int32:
+		return int64(v), nil
+	case int64:
+		return v, nil
+	default:
+		return 0, fmt.Errorf("%w: %T", ErrNotInteger, src)
+	}
+}
+
+func anyIntegerToTime(src any, unixConv func(int64) time.Time, into *time.Time) error {
+	i64, err := anyIntegerTo64(src)
+	if err != nil {
+		return err
+	}
+	*into = unixConv(i64)
+	return nil
+}
+
+var _ sql.Scanner = &UnixMilli{}
+var _ driver.Valuer = UnixMilli{}
+
+type UnixMilli struct {
+	time.Time
+}
+
+func (um UnixMilli) MarshalJSON() ([]byte, error) {
+	if um.IsZero() {
+		return []byte{'0'}, nil
+	}
+	return json.Marshal(um.UnixMilli())
+}
+
+func (um *UnixMilli) UnmarshalJSON(data []byte) error {
+	return parseTime(data, time.UnixMilli, &um.Time)
+}
+
+func (um UnixMilli) Value() (driver.Value, error) {
+	return um.UnixMilli(), nil
+}
+
+func (um *UnixMilli) Scan(src any) error {
+	return anyIntegerToTime(src, time.UnixMilli, &um.Time)
+}
+
+var _ sql.Scanner = &UnixMicro{}
+var _ driver.Valuer = UnixMicro{}
+
+type UnixMicro struct {
+	time.Time
+}
+
+func (um UnixMicro) MarshalJSON() ([]byte, error) {
+	if um.IsZero() {
+		return []byte{'0'}, nil
+	}
+	return json.Marshal(um.UnixMicro())
+}
+
+func (um *UnixMicro) UnmarshalJSON(data []byte) error {
+	return parseTime(data, time.UnixMicro, &um.Time)
+}
+
+func (um UnixMicro) Value() (driver.Value, error) {
+	return um.UnixMicro(), nil
+}
+
+func (um *UnixMicro) Scan(src any) error {
+	return anyIntegerToTime(src, time.UnixMicro, &um.Time)
+}
+
+var _ sql.Scanner = &UnixNano{}
+var _ driver.Valuer = UnixNano{}
+
+type UnixNano struct {
+	time.Time
+}
+
+func (un UnixNano) MarshalJSON() ([]byte, error) {
+	if un.IsZero() {
+		return []byte{'0'}, nil
+	}
+	return json.Marshal(un.UnixNano())
+}
+
+func (un *UnixNano) UnmarshalJSON(data []byte) error {
+	return parseTime(data, func(i int64) time.Time {
+		return time.Unix(0, i)
+	}, &un.Time)
+}
+
+func (un UnixNano) Value() (driver.Value, error) {
+	return un.UnixNano(), nil
+}
+
+func (un *UnixNano) Scan(src any) error {
+	return anyIntegerToTime(src, func(i int64) time.Time {
+		return time.Unix(0, i)
+	}, &un.Time)
+}
+
+type Unix struct {
+	time.Time
+}
+
+func (u Unix) MarshalJSON() ([]byte, error) {
+	if u.IsZero() {
+		return []byte{'0'}, nil
+	}
+	return json.Marshal(u.Unix())
+}
+
+var _ sql.Scanner = &Unix{}
+var _ driver.Valuer = Unix{}
+
+func (u *Unix) UnmarshalJSON(data []byte) error {
+	return parseTime(data, func(i int64) time.Time {
+		return time.Unix(i, 0)
+	}, &u.Time)
+}
+
+func (u Unix) Value() (driver.Value, error) {
+	return u.Unix(), nil
+}
+
+func (u *Unix) Scan(src any) error {
+	return anyIntegerToTime(src, func(i int64) time.Time {
+		return time.Unix(i, 0)
+	}, &u.Time)
+}

slidge_whatsapp/vendor/go.mau.fi/util/jsontime/string.go

@@ -0,0 +1,95 @@
+// 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 jsontime
+
+import (
+	"encoding/json"
+	"strconv"
+	"time"
+)
+
+func parseTimeString(data []byte, unixConv func(int64) time.Time, into *time.Time) error {
+	var strVal string
+	err := json.Unmarshal(data, &strVal)
+	if err != nil {
+		return err
+	}
+	val, err := strconv.ParseInt(strVal, 10, 64)
+	if err != nil {
+		return err
+	}
+	if val == 0 {
+		*into = time.Time{}
+	} else {
+		*into = unixConv(val)
+	}
+	return nil
+}
+
+type UnixMilliString struct {
+	time.Time
+}
+
+func (um UnixMilliString) MarshalJSON() ([]byte, error) {
+	if um.IsZero() {
+		return []byte{'"', '0', '"'}, nil
+	}
+	return json.Marshal(strconv.FormatInt(um.UnixMilli(), 10))
+}
+
+func (um *UnixMilliString) UnmarshalJSON(data []byte) error {
+	return parseTimeString(data, time.UnixMilli, &um.Time)
+}
+
+type UnixMicroString struct {
+	time.Time
+}
+
+func (um UnixMicroString) MarshalJSON() ([]byte, error) {
+	if um.IsZero() {
+		return []byte{'"', '0', '"'}, nil
+	}
+	return json.Marshal(strconv.FormatInt(um.UnixMicro(), 10))
+}
+
+func (um *UnixMicroString) UnmarshalJSON(data []byte) error {
+	return parseTimeString(data, time.UnixMicro, &um.Time)
+}
+
+type UnixNanoString struct {
+	time.Time
+}
+
+func (um UnixNanoString) MarshalJSON() ([]byte, error) {
+	if um.IsZero() {
+		return []byte{'"', '0', '"'}, nil
+	}
+	return json.Marshal(strconv.FormatInt(um.UnixNano(), 10))
+}
+
+func (um *UnixNanoString) UnmarshalJSON(data []byte) error {
+	return parseTimeString(data, func(i int64) time.Time {
+		return time.Unix(0, i)
+	}, &um.Time)
+}
+
+type UnixString struct {
+	time.Time
+}
+
+func (u UnixString) MarshalJSON() ([]byte, error) {
+	if u.IsZero() {
+		return []byte{'"', '0', '"'}, nil
+	}
+	return json.Marshal(strconv.FormatInt(u.Unix(), 10))
+}
+
+func (u *UnixString) UnmarshalJSON(data []byte) error {
+	return parseTimeString(data, func(i int64) time.Time {
+		return time.Unix(i, 0)
+	}, &u.Time)
+}

slidge_whatsapp/vendor/go.mau.fi/util/ptr/ptr.go

@@ -0,0 +1,43 @@
+// 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 ptr
+
+// Clone creates a shallow copy of the given pointer.
+func Clone[T any](val *T) *T {
+	if val == nil {
+		return nil
+	}
+	valCopy := *val
+	return &valCopy
+}
+
+// Ptr returns a pointer to the given value.
+func Ptr[T any](val T) *T {
+	return &val
+}
+
+// NonZero returns a pointer to the given comparable value, unless the value is the type's zero value.
+func NonZero[T comparable](val T) *T {
+	var zero T
+	return NonDefault(val, zero)
+}
+
+// NonDefault returns a pointer to the first parameter, unless it is equal to the second parameter.
+func NonDefault[T comparable](val, def T) *T {
+	if val == def {
+		return nil
+	}
+	return &val
+}
+
+// Val returns the value of the given pointer, or the zero value of the type if the pointer is nil.
+func Val[T any](ptr *T) (val T) {
+	if ptr != nil {
+		val = *ptr
+	}
+	return
+}

slidge_whatsapp/vendor/go.mau.fi/util/random/bytes.go

@@ -0,0 +1,21 @@
+// 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 random
+
+import (
+	"crypto/rand"
+)
+
+// Bytes generates the given amount of random bytes using crypto/rand, and panics if it fails.
+func Bytes(n int) []byte {
+	data := make([]byte, n)
+	_, err := rand.Read(data)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}

slidge_whatsapp/vendor/go.mau.fi/util/random/string.go

@@ -0,0 +1,87 @@
+// 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 random
+
+import (
+	"encoding/binary"
+	"hash/crc32"
+	"strings"
+	"unsafe"
+)
+
+const letters = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+
+// StringBytes generates a random string of the given length and returns it as a byte array.
+func StringBytes(n int) []byte {
+	if n <= 0 {
+		return []byte{}
+	}
+	input := Bytes(n * 2)
+	for i := 0; i < n; i++ {
+		// Risk of modulo bias is only 2 in 65535, values between 0 and 65533 are uniformly distributed
+		input[i] = letters[binary.BigEndian.Uint16(input[i*2:])%uint16(len(letters))]
+	}
+	input = input[:n]
+	return input
+}
+
+// String generates a random string of the given length.
+func String(n int) string {
+	if n <= 0 {
+		return ""
+	}
+	str := StringBytes(n)
+	return *(*string)(unsafe.Pointer(&str))
+}
+
+func base62Encode(val uint32, minWidth int) []byte {
+	out := make([]byte, 0, minWidth)
+	for val > 0 {
+		out = append(out, letters[val%uint32(len(letters))])
+		val /= 62
+	}
+	if len(out) < minWidth {
+		paddedOut := make([]byte, minWidth)
+		copy(paddedOut[minWidth-len(out):], out)
+		for i := 0; i < minWidth-len(out); i++ {
+			paddedOut[i] = '0'
+		}
+		out = paddedOut
+	}
+	return out
+}
+
+// Token generates a GitHub-style token with the given prefix, a random part, and a checksum at the end.
+// The format is `prefix_random_checksum`. The checksum is always 6 characters.
+func Token(namespace string, randomLength int) string {
+	token := make([]byte, len(namespace)+1+randomLength+1+6)
+	copy(token, namespace)
+	token[len(namespace)] = '_'
+	copy(token[len(namespace)+1:], StringBytes(randomLength))
+	token[len(namespace)+randomLength+1] = '_'
+	checksum := base62Encode(crc32.ChecksumIEEE(token[:len(token)-7]), 6)
+	copy(token[len(token)-6:], checksum)
+	return *(*string)(unsafe.Pointer(&token))
+}
+
+// GetTokenPrefix parses the given token generated with Token, validates the checksum and returns the prefix namespace.
+func GetTokenPrefix(token string) string {
+	parts := strings.Split(token, "_")
+	if len(parts) != 3 {
+		return ""
+	}
+	checksum := base62Encode(crc32.ChecksumIEEE([]byte(parts[0]+"_"+parts[1])), 6)
+	if string(checksum) != parts[2] {
+		return ""
+	}
+	return parts[0]
+}
+
+// IsToken checks if the given token is a valid token generated with Token with the given namespace..
+func IsToken(namespace, token string) bool {
+	return GetTokenPrefix(token) == namespace
+}

slidge_whatsapp/vendor/go.mau.fi/util/retryafter/retryafter.go

@@ -0,0 +1,53 @@
+// Copyright (c) 2021 Dillon Dixon
+// 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 retryafter contains a utility function for parsing the Retry-After HTTP header.
+package retryafter
+
+import (
+	"net/http"
+	"strconv"
+	"time"
+)
+
+var now = time.Now
+
+// Parse parses the backoff time specified in the Retry-After header if present.
+// See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After.
+//
+// The second parameter is the fallback duration to use if the header is not present or invalid.
+//
+// Example:
+//
+//	time.Sleep(retryafter.Parse(resp.Header.Get("Retry-After"), 5*time.Second))
+func Parse(retryAfter string, fallback time.Duration) time.Duration {
+	if retryAfter == "" {
+		return fallback
+	} else if t, err := time.Parse(http.TimeFormat, retryAfter); err == nil {
+		return t.Sub(now())
+	} else if seconds, err := strconv.Atoi(retryAfter); err == nil {
+		return time.Duration(seconds) * time.Second
+	}
+
+	return fallback
+}
+
+// Should returns true if the given status code indicates that the request should be retried.
+//
+//	if retryafter.Should(resp.StatusCode, true) {
+//		time.Sleep(retryafter.Parse(resp.Header.Get("Retry-After"), 5*time.Second))
+//	}
+func Should(statusCode int, retryOnRateLimit bool) bool {
+	switch statusCode {
+	case http.StatusBadGateway, http.StatusServiceUnavailable, http.StatusGatewayTimeout:
+		return true
+	case http.StatusTooManyRequests:
+		return retryOnRateLimit
+	default:
+		return false
+	}
+}

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/.editorconfig

@@ -0,0 +1,13 @@
+root = true
+
+[*]
+indent_style = tab
+indent_size = 4
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.{yaml,yml}]
+indent_style = space
+indent_size = 2

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/.gitattributes

@@ -0,0 +1,3 @@
+*.pb.go linguist-generated=true
+*.pb.raw binary linguist-generated=true
+internals.go linguist-generated=true

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/.pre-commit-config.yaml

@@ -0,0 +1,31 @@
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v5.0.0
+    hooks:
+      - id: trailing-whitespace
+        exclude_types: [markdown]
+        exclude: LICENSE
+      - id: end-of-file-fixer
+        exclude: LICENSE
+      - id: check-yaml
+      - id: check-added-large-files
+
+  - repo: https://github.com/tekwizely/pre-commit-golang
+    rev: v1.0.0-rc.1
+    hooks:
+      - id: go-imports-repo
+        args:
+          - "-local"
+          - "go.mau.fi/whatsmeow"
+          - "-w"
+      - id: go-vet-repo-mod
+      # TODO enable this
+      #- id: go-staticcheck-repo-mod
+      - id: go-mod-tidy
+
+  - repo: https://github.com/beeper/pre-commit-go
+    rev: v0.3.1
+    hooks:
+      # TODO enable this
+      #- id: zerolog-ban-msgf
+      - id: zerolog-use-stringer