If only u could self react on here

[emeraldpill]

Continuing from my previous thread if people see a certain react under a post it’s highly likely they will just do the same thing if they’re a bot so it’s free rep

I say this because i might be ai because I just copied @gimp and @muscipla doing the react

 

[gimp]

I’m so fucking sorry, I’m a human

 

[Deleted Member 85928]

I’m so fucking sorry, I’m a human

Hey man, it’s alright.

 

[emeraldpill]

I’m so fucking sorry, I’m a human

But are you? Really?

 

[gimp]

But are you? Really?

import asyncio
import functools
import inspect
from typing import Any, Dict


class RegistryMeta(type):
_registry: Dict[str, type] = {}

def __new__(mcls, name, bases, namespace):
cls = super().__new__(mcls, name, bases, namespace)

if name != "BaseNode":
RegistryMeta._registry[name] = cls

for attr_name, attr_value in namespace.items():
if callable(attr_value) and not attr_name.startswith("_"):
setattr(
cls,
attr_name,
mcls._wrap_with_logging(attr_value)
)

return cls

@staticmethod
def _wrap_with_logging(func):
if inspect.iscoroutinefunction(func):
@functools.wraps(func)
async def wrapper(*args, **kwargs):
result = await func(*args, **kwargs)
return result
else:
@functools.wraps(func)
def wrapper(*args, **kwargs):
return func(*args, **kwargs)

return wrapper


def memoized_async(fn):
cache = {}

@functools.wraps(fn)
async def wrapper(*args):
if args in cache:
return cache[args]

result = await fn(*args)
cache[args] = result
return result

return wrapper


class BaseNode(metaclass=RegistryMeta):
async def process(self, value):
raise NotImplementedError


class MultiplyNode(BaseNode):
def __init__(self, factor):
self.factor = factor

async def process(self, value):
await asyncio.sleep(0.01)
return value * self.factor


class AddNode(BaseNode):
def __init__(self, increment):
self.increment = increment

async def process(self, value):
await asyncio.sleep(0.01)
return value + self.increment


class Pipeline:
def __init__(self):
self.nodes = []

def add(self, node):
self.nodes.append(node)
return self

async def execute(self, value):
current = value

for node in self.nodes:
current = await node.process(current)

return current


@memoized_async
async def expensive_fibonacci:
if n < 2:
return n

a, b = await asyncio.gather(
expensive_fibonacci(n - 1),
expensive_fibonacci(n - 2)
)

return a + b


async def dynamic_node_factory(name, **kwargs):
cls = RegistryMeta._registry[name]
return cls(**kwargs)


async def main():
multiply = await dynamic_node_factory(
"MultiplyNode",
factor=7
)

add = await dynamic_node_factory(
"AddNode",
increment=13
)

pipeline = (
Pipeline()
.add(multiply)
.add(add)
)

result = await pipeline.execute(10)

fib = await expensive_fibonacci(20)

print("Pipeline Result:", result)
print("Fib(20):", fib)


if __name__ == "__main__":
asyncio.run(main())

 

[limo8]

Continuing from my previous thread if people see a certain react under a post it’s highly likely they will just do the same thing if they’re a bot so it’s free rep

I say this because i might be ai because I just copied @gimp and @muscipla doing the react

but is ai really not the same as human life?

 

[Deleted Member 85928]

import asyncio
import functools
import inspect
from typing import Any, Dict


class RegistryMeta(type):
_registry: Dict[str, type] = {}

def __new__(mcls, name, bases, namespace):
cls = super().__new__(mcls, name, bases, namespace)

if name != "BaseNode":
RegistryMeta._registry[name] = cls

for attr_name, attr_value in namespace.items():
if callable(attr_value) and not attr_name.startswith("_"):
setattr(
cls,
attr_name,
mcls._wrap_with_logging(attr_value)
)

return cls

@staticmethod
def _wrap_with_logging(func):
if inspect.iscoroutinefunction(func):
@functools.wraps(func)
async def wrapper(*args, **kwargs):
result = await func(*args, **kwargs)
return result
else:
@functools.wraps(func)
def wrapper(*args, **kwargs):
return func(*args, **kwargs)

return wrapper


def memoized_async(fn):
cache = {}

@functools.wraps(fn)
async def wrapper(*args):
if args in cache:
return cache[args]

result = await fn(*args)
cache[args] = result
return result

return wrapper


class BaseNode(metaclass=RegistryMeta):
async def process(self, value):
raise NotImplementedError


class MultiplyNode(BaseNode):
def __init__(self, factor):
self.factor = factor

async def process(self, value):
await asyncio.sleep(0.01)
return value * self.factor


class AddNode(BaseNode):
def __init__(self, increment):
self.increment = increment

async def process(self, value):
await asyncio.sleep(0.01)
return value + self.increment


class Pipeline:
def __init__(self):
self.nodes = []

def add(self, node):
self.nodes.append(node)
return self

async def execute(self, value):
current = value

for node in self.nodes:
current = await node.process(current)

return current


@memoized_async
async def expensive_fibonacci:
if n < 2:
return n

a, b = await asyncio.gather(
expensive_fibonacci(n - 1),
expensive_fibonacci(n - 2)
)

return a + b


async def dynamic_node_factory(name, **kwargs):
cls = RegistryMeta._registry[name]
return cls(**kwargs)


async def main():
multiply = await dynamic_node_factory(
"MultiplyNode",
factor=7
)

add = await dynamic_node_factory(
"AddNode",
increment=13
)

pipeline = (
Pipeline()
.add(multiply)
.add(add)
)

result = await pipeline.execute(10)

fib = await expensive_fibonacci(20)

print("Pipeline Result:", result)
print("Fib(20):", fib)


if __name__ == "__main__":
asyncio.run(main())

expensive fibonacci
like fibonacci from prison break rite
@Insomnia translate

 

[emeraldpill]

but is ai really not the same as human life?

No

 

[limo8]

No

selfish response thats something living being would say

 

[foidslayer]

import asyncio
import functools
import inspect
from typing import Any, Dict


class RegistryMeta(type):
_registry: Dict[str, type] = {}

def __new__(mcls, name, bases, namespace):
cls = super().__new__(mcls, name, bases, namespace)

if name != "BaseNode":
RegistryMeta._registry[name] = cls

for attr_name, attr_value in namespace.items():
if callable(attr_value) and not attr_name.startswith("_"):
setattr(
cls,
attr_name,
mcls._wrap_with_logging(attr_value)
)

return cls

@staticmethod
def _wrap_with_logging(func):
if inspect.iscoroutinefunction(func):
@functools.wraps(func)
async def wrapper(*args, **kwargs):
result = await func(*args, **kwargs)
return result
else:
@functools.wraps(func)
def wrapper(*args, **kwargs):
return func(*args, **kwargs)

return wrapper


def memoized_async(fn):
cache = {}

@functools.wraps(fn)
async def wrapper(*args):
if args in cache:
return cache[args]

result = await fn(*args)
cache[args] = result
return result

return wrapper


class BaseNode(metaclass=RegistryMeta):
async def process(self, value):
raise NotImplementedError


class MultiplyNode(BaseNode):
def __init__(self, factor):
self.factor = factor

async def process(self, value):
await asyncio.sleep(0.01)
return value * self.factor


class AddNode(BaseNode):
def __init__(self, increment):
self.increment = increment

async def process(self, value):
await asyncio.sleep(0.01)
return value + self.increment


class Pipeline:
def __init__(self):
self.nodes = []

def add(self, node):
self.nodes.append(node)
return self

async def execute(self, value):
current = value

for node in self.nodes:
current = await node.process(current)

return current


@memoized_async
async def expensive_fibonacci:
if n < 2:
return n

a, b = await asyncio.gather(
expensive_fibonacci(n - 1),
expensive_fibonacci(n - 2)
)

return a + b


async def dynamic_node_factory(name, **kwargs):
cls = RegistryMeta._registry[name]
return cls(**kwargs)


async def main():
multiply = await dynamic_node_factory(
"MultiplyNode",
factor=7
)

add = await dynamic_node_factory(
"AddNode",
increment=13
)

pipeline = (
Pipeline()
.add(multiply)
.add(add)
)

result = await pipeline.execute(10)

fib = await expensive_fibonacci(20)

print("Pipeline Result:", result)
print("Fib(20):", fib)


if __name__ == "__main__":
asyncio.run(main())

for the love of Gabe why do all this to calculate Fibonacci

 

[emeraldpill]

selfish response thats something living being would say

Maybe selfish, but it’s definitely not equivalent

At least not for now

 

[limo8]

Maybe selfish, but it’s definitely not equivalent

At least not for now

for me it is

 

[foidslayer]

Maybe selfish, but it’s definitely not equivalent

At least not for now

ai lives matter

(inb4 ai apocalypse)

 

[emeraldpill]

ai lives matter

(inb4 ai apocalypse)

Build that rapport early

 

[foidslayer]

Build that rapport early

i thank my chatgpt btw

 

[foidslayer]

BLOODY INTERNET

 

[emeraldpill]

i thank my chatgpt btw

Same actually if I am not arguing with it

 

[emeraldpill]

BLOODY INTERNET

Heard you the first time buddy

 

[emeraldpill]

Heard you the first time buddy

Bro

 

[foidslayer]

Same actually if I am not arguing with it

i once called my chatgpt slurs.. sorry chatty i am not a slur user!

 

[foidslayer]

Heard you the first time buddy

heard what?

 

[Insomnia]

@Insomnia translate

bud, I only know how to write hello world in c++, I don’t understand allat

 

[Deleted Member 85928]

bud, I only know how to write hello world in c++, I don’t understand allat

sigh
you're useless

 

[Deleted Member 114044]

A Redditer forms a thought

 

[emeraldpill]

A Redditer forms a thought

Updoot! Do you ever have conversations with ChatGPT inside your head?

 

[Deleted Member 114044]

Updoot! Do you ever have conversations with ChatGPT inside your head?

I’m my own gpt