multirandom 0.0.1__py3-none-any.whl

realrandom/hash_rand/__init__.py

@@ -0,0 +1,2 @@
+import original_random
+import sha_rand as sha_random

realrandom/hash_rand/original_random.py

@@ -0,0 +1 @@
+from random import *

realrandom/hash_rand/sha_rand.py

@@ -0,0 +1,86 @@
+_sha1 = None
+_sha224 = None
+_sha256 = None
+_sha384 = None
+_sha512 = None
+
+def _get_sha1():
+    global _sha1
+    if _sha1 is None:
+        try:
+            from _sha1 import sha1 as _sha1
+        except ImportError:
+            from hashlib import sha1 as _sha1
+    return _sha1
+
+def _get_sha224():
+    global _sha224
+    if _sha224 is None:
+        try:
+            from _sha2 import sha224 as _sha224
+        except ImportError:
+            from hashlib import sha224 as _sha224
+    return _sha224
+
+def _get_sha256():
+    global _sha256
+    if _sha256 is None:
+        try:
+            from _sha2 import sha256 as _sha256
+        except ImportError:
+            from hashlib import sha256 as _sha256
+    return _sha256
+
+def _get_sha384():
+    global _sha384
+    if _sha384 is None:
+        try:
+            from _sha2 import sha384 as _sha384
+        except ImportError:
+            from hashlib import sha384 as _sha384
+    return _sha384
+
+def _get_sha512():
+    global _sha512
+    if _sha512 is None:
+        try:
+            # hashlib is pretty heavy to load, try lean internal module first
+            from _sha2 import sha512 as _sha512
+        except ImportError:
+            # fallback to official implementation
+            from hashlib import sha512 as _sha512
+    return _sha512
+class _SHARandom:
+    def __init__(self, seed=None):
+        self.seed = seed
+        self.counter = 0
+
+    def _get_hash(self):
+        raise NotImplementedError
+
+    def getrandbytes(self, n):
+        res = b""
+        hf = self._get_hash()
+        seed_bytes = str(self.seed).encode()
+        while len(res) < n:
+            h = hf()
+            h.update(seed_bytes + self.counter.to_bytes(8, 'big'))
+            res += h.digest()
+            self.counter += 1
+        return res[:n]
+
+class SHA1Random(_SHARandom):
+    def _get_hash(self):
+        return _get_sha1()
+
+class SHA256Random(_SHARandom):
+    def _get_hash(self):
+        return _get_sha256()
+
+class SHA384Random(_SHARandom):
+    def _get_hash(self):
+        return _get_sha384()
+
+class SHA512Random(_SHARandom):
+    def _get_hash(self):
+        return _get_sha512()

realrandom/true_rand/__init__.py

@@ -0,0 +1,3 @@
+import rand_via_clicks
+import rand_using_online_api
+# import weather_rand

realrandom/true_rand/rand_using_online_api.py

@@ -0,0 +1,74 @@
+import aiohttp
+import asyncio
+
+async def fetch_random_org_integers(num: int = 1, min_val: int = 1, max_val: int = 100):
+	"""Fetches true random integers from random.org using their plain text API."""
+	url = "https://www.random.org/integers/"
+	params = {
+		"num": num,
+		"min": min_val,
+		"max": max_val,
+		"col": 1,
+		"base": 10,
+		"format": "plain",
+		"rnd": "new"
+	}
+	async with aiohttp.ClientSession() as session:
+		async with session.get(url, params=params) as response:
+			if response.status == 200:
+				text = await response.text()
+				return [int(x) for x in text.splitlines() if x.strip()]
+			return []
+
+async def fetch_qrng_anu_integers(num: int = 1):
+	"""Fetches quantum random numbers from the Australian National University QRNG API."""
+	url = "https://qrng.anu.edu.au/API/jsonI.php"
+	params = {"length": num, "type": "uint8"}
+	async with aiohttp.ClientSession() as session:
+		async with session.get(url, params=params) as response:
+			if response.status == 200:
+				data = await response.json()
+				return data.get("data", [])
+			return []
+
+async def fetch_roll_api_result():
+	"""Fetches a random dice roll from TheLastGimbus Roll-API (Physical Dice)."""
+	# Base URL found in research
+	base_url = "https://roll.lastgimbus.com/api"
+	
+	async with aiohttp.ClientSession() as session:
+		try:
+			# Attempt to get a simple result first
+			# Research mentioned 'getRandomNumber' logic which suggests a GET might trigger it
+			# or we need to check a status. 
+			# Trying the most likely 'roll' endpoint or root.
+			async with session.get(f"{base_url}/roll") as response:
+				if response.status == 200:
+					data = await response.json()
+					# Expecting 'result' or 'number'
+					return data.get("result", data.get("number", None))
+				
+				# If 202 (Accepted/Queued), we might need to wait.
+				# Capturing status for debugging
+				if response.status != 404:
+					 print(f"Roll-API Status: {response.status}")
+				
+			# Fallback check on root if /roll fails
+			async with session.get(base_url) as response:
+				 if response.status == 200:
+					 text = await response.text()
+					 # If it's just a number string
+					 if text.isdigit():
+						 return int(text)
+					 # If json
+					 try:
+						 data = await response.json()
+						 return data.get("val", data.get("result"))
+					 except:
+						 pass
+			
+			return None
+			
+		except Exception as e:
+			print(f"Roll-API Exception: {e}")
+			return None

realrandom/true_rand/rand_via_clicks.py

@@ -0,0 +1,93 @@
+import pyautogui
+import time
+import ctypes
+import random
+
+# Windows constants for mouse buttons
+VK_LBUTTON = 0x01
+VK_RBUTTON = 0x02
+VK_MBUTTON = 0x04
+
+def is_left_click_pressed():
+	"""Checks if the left mouse button is currently down using Windows API."""
+	return ctypes.windll.user32.GetAsyncKeyState(VK_LBUTTON) & 0x8000
+
+def is_right_click_pressed():
+	"""Checks if the right mouse button is currently down using Windows API."""
+	return ctypes.windll.user32.GetAsyncKeyState(VK_RBUTTON) & 0x8000
+
+def is_middle_click_pressed():
+	"""Checks if the middle mouse button is currently down using Windows API."""
+	return ctypes.windll.user32.GetAsyncKeyState(VK_MBUTTON) & 0x8000
+
+def get_click_data(button_check_func=is_left_click_pressed):
+	"""Waits for a specific click and returns (timestamp, cursor_position)."""
+	# Wait for the button to be pressed
+	while not button_check_func():
+		time.sleep(0.005) # Tiny sleep to prevent high CPU usage
+	
+	t = time.perf_counter()
+	pos = pyautogui.position()
+	
+	# Wait for the button to be released to avoid duplicate captures
+	while button_check_func():
+		time.sleep(0.005)
+		
+	return t, pos
+
+class RealRandomUsingBetweenLeftClicks(random.Random):
+	def seed(self, a=None, version=2):
+		if a is None:
+			t1, p1 = get_click_data(is_left_click_pressed)
+			t2, p2 = get_click_data(is_left_click_pressed)
+			# Use the time interval and positions to create a seed without hashing
+			a = int((t2 - t1) * 10**9) + p1.x + p1.y + p2.x + p2.y
+		super().seed(a, version=version)
+
+class RealRandomUsingBetweenRightClicks(random.Random):
+	def seed(self, a=None, version=2):
+		if a is None:
+			t1, p1 = get_click_data(is_right_click_pressed)
+			t2, p2 = get_click_data(is_right_click_pressed)
+			a = int((t2 - t1) * 10**9) + p1.x + p1.y + p2.x + p2.y
+		super().seed(a, version=version)
+
+class RealRandomUsingBetweenMiddleClicks(random.Random):
+	def seed(self, a=None, version=2):
+		if a is None:
+			t1, p1 = get_click_data(is_middle_click_pressed)
+			t2, p2 = get_click_data(is_middle_click_pressed)
+			a = int((t2 - t1) * 10**9) + p1.x + p1.y + p2.x + p2.y
+		super().seed(a, version=version)
+
+class RealRandomUsingBetweenMixedClicks(random.Random):
+	def seed(self, a=None, version=2):
+		if a is None:
+			# Mixed logic: Left -> Right -> Middle
+			t1, p1 = get_click_data(is_left_click_pressed)
+			t2, p2 = get_click_data(is_right_click_pressed)
+			t3, p3 = get_click_data(is_middle_click_pressed)
+			a = int((t3 - t1) * 10**9) + p1.x + p1.y + p2.x + p2.y + p3.x + p3.y
+		super().seed(a, version=version)
+
+def main():
+	print("--- Click-based Randomness Test ---")
+	print("Each generator requires specific mouse clicks to seed.")
+	
+	print("\n1. Seeding Left-Click Random (requires 2 left clicks)...")
+	rl = RealRandomUsingBetweenLeftClicks()
+	print(f"Result: {rl.random()}")
+
+	print("\n2. Seeding Right-Click Random (requires 2 right clicks)...")
+	rr = RealRandomUsingBetweenRightClicks()
+	print(f"Result: {rr.random()}")
+
+	print("\n3. Seeding Mixed-Click Random (requires Left -> Right -> Middle)...")
+	rm = RealRandomUsingBetweenMixedClicks()
+	print(f"Result: {rm.random()}")
+
+if __name__ == "__main__":
+	try:
+		main()
+	except KeyboardInterrupt:
+		print("\nStopped by user.")

realrandom/true_rand/weather_rand.py

@@ -0,0 +1,2 @@
+# rand via openweather api and openmeteo api
+print("coming soon")

realrandom/virt_rand/__init__.py

@@ -0,0 +1,2 @@
+import rand_using_virt_lcg as LCG
+import xor_shift

realrandom/virt_rand/flash_rand_and_reverse.py

@@ -0,0 +1 @@
+print("coming soon :/")

realrandom/virt_rand/rand_using_virt_lcg.py

@@ -0,0 +1,93 @@
+import random
+import warnings
+
+# Safety Warnings
+warnings.warn("WARNING: LCGs are NOT cryptographically secure. They use linear algebra and can be reversed.")
+warnings.warn("This is only safe for OFFLINE GAMES with NO LEADERBOARDS.")
+warnings.warn("See: https://youtu.be/XDsYPXRCXAs?si=oDaFsqZyNJWVXwEi")
+
+class LCGs: 
+	"""
+	Linear Congruential Generator (LCG) Implementation.
+	
+	Summary:
+	This class implements a Linear Congruential Generator, a simple algorithm that yields a
+	sequence of pseudo-randomized numbers calculated with a linear equation.
+	
+	WARNING:
+	LCGs are NOT safe for cryptography or high-stakes randomness (like gambling or leaderboards).
+	Because they are based on simple math (modular arithmetic), their state can be recovered 
+	(reversed) if a few outputs are known, e.g., using Modular Multiplicative Inverse (MMI).
+	
+	Required args:
+		rules: str - The forward formula, e.g., "(s * a + c) % d"
+	
+	Optional args:
+		reverse_rules: str or None - The formula to reverse the state, proving insecurity.
+									 e.g., "((s - c) * pow(a, -1, d)) % d"
+		s: int - Seed/State
+		a: int - Multiplier
+		c: int - Increment
+		d: int - Modulus
+	"""
+	def __init__(
+		self,
+		rules: str,
+		reverse_rules: str or None = None,
+		s: int = random.randint(1, 9999),
+		a: int = 10,
+		b: int = 3, # kept for backward compatibility if needed
+		c: int = 5,
+		d: int = 25565
+	):
+		if rules is None:
+			raise ValueError("rules must be provided (e.g., '(s * a + c) % d')")
+			
+		self.rules = rules
+		self.reverse_rules = reverse_rules
+		self.s = s
+		self.a = a
+		self.b = b
+		self.c = c
+		self.d = d
+
+	def roll(self):
+		"""Advance the generator state forward."""
+		# Standard eval with restricted scope
+		self.s = eval(self.rules, {"__builtins__": None}, {
+			's': self.s, 'a': self.a, 'b': self.b, 
+			'c': self.c, 'd': self.d
+		})
+		return self.s
+
+	def reverse_roll(self):
+		"""
+		Reverse the generator state backward.
+		
+		This method demonstrates the insecurity of LCGs. If you know the parameters (a, c, d)
+		and the current state (s), you can calculate the PREVIOUS state using:
+		s_prev = (s - c) * a^(-1) mod d
+		"""
+		if self.reverse_rules is None:
+			raise ValueError("reverse_rules is not defined! Cannot reverse state.")
+			
+		# Using pow(a, -1, d) for modular multiplicative inverse in python 3.8+
+		self.s = eval(self.reverse_rules, {"__builtins__": None, "pow": pow}, {
+			's': self.s, 'a': self.a, 'b': self.b, 
+			'c': self.c, 'd': self.d
+		})
+		return self.s
+
+	def random(self, s: int or None = None):
+		"""Predict next bit/value based on roll (0 or 1)."""
+		if s is not None:
+			self.s = s
+		old_s = self.s
+		self.roll()
+		return 1 if old_s <= self.s else 0
+	
+	def randint(self):
+		"""Returns the current raw state integer."""
+		self.roll()
+		return self.s
+	

realrandom/virt_rand/xor_shift.py

@@ -0,0 +1,235 @@
+import random
+import warnings
+
+# Safety Warnings
+warnings.warn("WARNING: XorShift/Xoshiro generators are SAFER than LCGs but still INSECURE for cryptography. They are pseudo-random and not true randomness.")
+warnings.warn("It uses a linear feedback shift register (LFSR) to generate pseudo-random numbers.")
+warnings.warn("See: https://youtu.be/XDsYPXRCXAs?si=oDaFsqZyNJWVXwEi")
+
+def reverse_xor_lshift(x, s, bits=32):
+    """Reverses x ^= x << s."""
+    res = x
+    mask = (1 << bits) - 1
+    for _ in range(bits // s):
+        res = x ^ ((res << s) & mask)
+    return res & mask
+
+def reverse_xor_rshift(x, s, bits=32):
+    """Reverses x ^= x >> s."""
+    res = x
+    mask = (1 << bits) - 1
+    for _ in range(bits // s):
+        res = x ^ (res >> s)
+    return res & mask
+
+class Xorshift32:
+    """
+    Marsaglia's original 32-bit Xorshift.
+    Passes some tests but too linear for modern standards.
+    """
+    def __init__(self, seed: int = None, a: int = 13, b: int = 17, c: int = 5):
+        if seed is None:
+            seed = random.randint(1, 0xFFFFFFFF)
+        self.state = seed & 0xFFFFFFFF
+        if self.state == 0: self.state = 1
+        self.a = a
+        self.b = b
+        self.c = c
+
+    def roll(self):
+        x = self.state
+        x ^= (x << self.a) & 0xFFFFFFFF
+        x ^= (x >> self.b) & 0xFFFFFFFF
+        x ^= (x << self.c) & 0xFFFFFFFF
+        self.state = x
+        return self.state
+
+    def reverse_roll(self):
+        """Demonstrates the reversibility of pure Xorshift."""
+        x = self.state
+        # Reverse x ^= x << c
+        x = reverse_xor_lshift(x, self.c, 32)
+        # Reverse x ^= x >> b
+        x = reverse_xor_rshift(x, self.b, 32)
+        # Reverse x ^= x << a
+        x = reverse_xor_lshift(x, self.a, 32)
+        self.state = x
+        return self.state
+
+    def random(self):
+        # Normalize to [0, 1)
+        return self.roll() / 0x100000000
+
+class Xorshift128:
+    """
+    Marsaglia's original 128-bit Xorshift.
+    Uses a 4-word state.
+    """
+    def __init__(self, seeds: list = None, a: int = 11, b: int = 8, c: int = 19):
+        if seeds is None or len(seeds) < 4:
+            seeds = [random.randint(1, 0xFFFFFFFF) for _ in range(4)]
+        self.state = [s & 0xFFFFFFFF for s in seeds]
+        if all(s == 0 for s in self.state): self.state[0] = 1
+        self.a = a
+        self.b = b
+        self.c = c
+
+    def roll(self):
+        t = self.state[3]
+        s = self.state[0]
+        self.state[3] = self.state[2]
+        self.state[2] = self.state[1]
+        self.state[1] = s
+        
+        t ^= (t << self.a) & 0xFFFFFFFF
+        t ^= (t >> self.b) & 0xFFFFFFFF
+        self.state[0] = (t ^ s ^ (s >> self.c)) & 0xFFFFFFFF
+        return self.state[0]
+
+    def reverse_roll(self):
+        """Demonstrates reversibility of 128-bit version."""
+        s_prev = self.state[1]
+        res_xor_s = (self.state[0] ^ s_prev ^ (s_prev >> self.c)) & 0xFFFFFFFF
+        t_original = reverse_xor_rshift(reverse_xor_lshift(res_xor_s, self.a, 32), self.b, 32)
+        
+        # Shift back
+        self.state[0] = self.state[1]
+        self.state[1] = self.state[2]
+        self.state[2] = self.state[3]
+        self.state[3] = t_original
+        return self.state[0]
+
+class Xorwow:
+    """Xorwow adds a Weyl sequence to fix linearity issues."""
+    def __init__(self, seeds: list = None):
+        if seeds is None or len(seeds) < 5:
+            seeds = [random.randint(1, 0xFFFFFFFF) for _ in range(5)]
+        self.state = [s & 0xFFFFFFFF for s in seeds]
+        self.counter = 0
+
+    def roll(self):
+        t = self.state[4]
+        s = self.state[0]
+        self.state[4] = self.state[3]
+        self.state[3] = self.state[2]
+        self.state[2] = self.state[1]
+        self.state[1] = s
+        
+        t ^= (t >> 2) & 0xFFFFFFFF
+        t ^= (t << 1) & 0xFFFFFFFF
+        t ^= (s ^ (s << 4)) & 0xFFFFFFFF
+        self.state[0] = t
+        self.counter = (self.counter + 362437) & 0xFFFFFFFF
+        return (t + self.counter) & 0xFFFFFFFF
+
+class XorshiftStar:
+    """Xorshift* multiplies outputs by a constant."""
+    def __init__(self, seed: int = None, a: int = 12, b: int = 25, c: int = 27):
+        self.state = seed or random.randint(1, 0xFFFFFFFFFFFFFFFF)
+        self.a = a
+        self.b = b
+        self.c = c
+
+    def roll(self):
+        x = self.state
+        x ^= (x >> self.a) & 0xFFFFFFFFFFFFFFFF
+        x ^= (x << self.b) & 0xFFFFFFFFFFFFFFFF
+        x ^= (x >> self.c) & 0xFFFFFFFFFFFFFFFF
+        self.state = x
+        return (x * 0x2545F4914F6CDD1D) & 0xFFFFFFFFFFFFFFFF
+
+class XorshiftPlus:
+    """Xorshift128+ used in V8 and Safari."""
+    def __init__(self, s0: int = None, s1: int = None, a: int = 23, b: int = 17, c: int = 26):
+        self.s0 = s0 or random.randint(1, 0xFFFFFFFFFFFFFFFF)
+        self.s1 = s1 or random.randint(1, 0xFFFFFFFFFFFFFFFF)
+        self.a = a
+        self.b = b
+        self.c = c
+
+    def roll(self):
+        x = self.s0
+        y = self.s1
+        self.s0 = y
+        x ^= (x << self.a) & 0xFFFFFFFFFFFFFFFF
+        self.s1 = (x ^ y ^ (x >> self.b) ^ (y >> self.c)) & 0xFFFFFFFFFFFFFFFF
+        return (self.s1 + y) & 0xFFFFFFFFFFFFFFFF
+
+def rotl(x, k, bits=64):
+    mask = (1 << bits) - 1
+    return ((x << k) & mask) | (x >> (bits - k))
+
+class Xoshiro256StarStar:
+    """Modern robust 64-bit generator."""
+    def __init__(self, seeds: list = None):
+        if seeds is None or len(seeds) < 4:
+            seeds = [random.randint(1, 0xFFFFFFFFFFFFFFFF) for _ in range(4)]
+        self.s = [s & 0xFFFFFFFFFFFFFFFF for s in seeds]
+
+    def roll(self):
+        res = (rotl((self.s[1] * 5) & 0xFFFFFFFFFFFFFFFF, 7) * 9) & 0xFFFFFFFFFFFFFFFF
+        t = (self.s[1] << 17) & 0xFFFFFFFFFFFFFFFF
+        
+        self.s[2] ^= self.s[0]
+        self.s[3] ^= self.s[1]
+        self.s[1] ^= self.s[2]
+        self.s[0] ^= self.s[3]
+        self.s[2] ^= t
+        self.s[3] = rotl(self.s[3], 45)
+        
+        return res
+
+class Xoshiro128Plus:
+    """32-bit optimized modern generator."""
+    def __init__(self, seeds: list = None):
+        if seeds is None or len(seeds) < 4:
+            seeds = [random.randint(1, 0xFFFFFFFF) for _ in range(4)]
+        self.s = [s & 0xFFFFFFFF for s in seeds]
+
+    def roll(self):
+        res = (self.s[0] + self.s[3]) & 0xFFFFFFFF
+        t = (self.s[1] << 9) & 0xFFFFFFFF
+        
+        self.s[2] ^= self.s[0]
+        self.s[3] ^= self.s[1]
+        self.s[1] ^= self.s[2]
+        self.s[0] ^= self.s[3]
+        self.s[2] ^= t
+        self.s[3] = rotl(self.s[3], 11, bits=32)
+        
+        return res
+
+class Xoroshiro128PlusPlus:
+    """
+    Xoroshiro128++ generator.
+    Used in modern Minecraft (Java 1.18+) for world generation and other random tasks.
+    """
+    def __init__(self, seeds: list = None):
+        if seeds is None or len(seeds) < 2:
+            seeds = [random.randint(1, 0xFFFFFFFFFFFFFFFF) for _ in range(2)]
+        self.s = [s & 0xFFFFFFFFFFFFFFFF for s in seeds]
+        if all(s == 0 for s in self.s):
+            self.s[0] = 1
+
+    def roll(self):
+        s0 = self.s[0]
+        s1 = self.s[1]
+        res = (rotl((s0 + s1) & 0xFFFFFFFFFFFFFFFF, 17) + s0) & 0xFFFFFFFFFFFFFFFF
+        
+        s1 ^= s0
+        self.s[0] = (rotl(s0, 49) ^ s1 ^ ((s1 << 21) & 0xFFFFFFFFFFFFFFFF)) & 0xFFFFFFFFFFFFFFFF
+        self.s[1] = rotl(s1, 28)
+        
+        return res
+
+
+if __name__ == "__main__":
+    print("Testing Xorshift32 Reverse...")
+    gen = Xorshift32(42)
+    original = gen.state
+    gen.roll()
+    print(f"Post Roll: {gen.state}")
+    gen.reverse_roll()
+    print(f"Post Reverse: {gen.state}")
+    assert gen.state == original
+    print("Success!")