Federated Jellyfin sounds like stremio+torrentio, so why not just use that instead?
deleted by creator
deleted by creator
I wouldn’t use it then since I don’t feel as comfortable sharing my bank account as I do sharing a cryptocurrency address.
I believe any other payment method has someone in the middle taking a cut. What would you propose?
Some software that enables users to browse all kinds of content and encourages them to donate to creators using cryptocurrency. This program would automatically distribute payments to verified creators who have provided a cryptocurrency address. This ensures that creators receive their rightful compensation for their work.
At present, I only donate to individual creators who receive funding through platforms like OpenCollective, Patreon, or similar services. I don’t even donate to Lemmy because there are multiple developers, but only one person in charge of receiving and distributing donations and I don’t want to waste time and effort making sure the funds are distributed between everyone involved. I’d instead prefer open-source software that simplifies the process and ensures that everyone receives their fair share.
deleted by creator
deleted by creator
This is the only thing that pops into my head but it’s not all FOSS so it’s probably not what you are looking for.
Oh right I forgot, then I only have to check that the instance federates with the others I want.
Temporary files management for a ~/tmp
folder, with archiving and cleanup after x and y days.
If you have a link I would really appreciate it.
I think AI tools are changing too quickly for a yearly survey.
React, Go, GraphQL, and PostgreSQL
deleted by creator
import asyncio
from asyncio import Queue
async def read_input(queue: Queue):
while True:
user_input = await loop.run_in_executor(None, input, "Enter something: ")
await queue.put(user_input)
async def process_input(queue: Queue):
while True:
user_input = await queue.get()
if user_input == "quit":
break
print(f"Processing input: {user_input}")
await asyncio.sleep(1) # Simulate processing time
async def main():
queue = Queue()
task1 = asyncio.create_task(read_input(queue))
task2 = asyncio.create_task(process_input(queue))
await asyncio.gather(task1, task2)
if __name__ == "__main__":
loop = asyncio.get_event_loop()
try:
loop.run_until_complete(main())
except KeyboardInterrupt:
pass
finally:
loop.close()
The read_input
function acts as a producer, continuously reading input from the command line and putting it into a Queue
.
The process_input
function acts as a consumer, taking items from the Queue
and processing them. It prints out each input and simulates processing time with asyncio.sleep()
.
The main
function creates both tasks, runs them concurrently with asyncio.gather()
, and handles cleanup of the event loop.
This allows the producer and consumer to run asynchronously, communicating through the queue. The input
call runs in a threadpool executor to avoid blocking the async loop.
Harley Quinn changes to sexy clothes
It isn’t, the open source ones that I now are Llama, Mistral and Grok