Refactor

garfpy/__init__.py

@@ -0,0 +1,12 @@
+# garfpy/__init__.py
+from .log import logger
+from .kroger import(
+    kroger_token, find_store, search_product
+)
+from .garfai import(
+    picture_time,
+    process_image_requests,
+    generate_chat
+)
+from .iputils import is_private
+from .aod import aod_message

garfpy/aod.py

@@ -0,0 +1,94 @@
+import os
+import json
+import discord
+from garfpy import logger
+from datetime import datetime
+from operator import itemgetter
+from collections import defaultdict
+
+
+# Meows Json Handling
+meows_file = "meow_counts.json"
+stats_file = "user_stats.json"
+
+def json_load(file_path, default):
+    if os.path.isfile(file_path):
+        with open(file_path, "r") as f:
+            return json.load(f)
+    else:
+        return default
+
+meow_counts = defaultdict(int, json_load(meows_file, {}))
+user_stats = json_load(stats_file, {})
+
+async def aod_message(garfbot, message):
+        if "meow" in message.content.lower():
+            logger.info(f"Meow detected! {message.author.name} said: {message.content}")
+
+            meow_counts[str(message.author.id)] += 1
+
+            with open(meows_file, "w") as f:
+                json.dump(dict(meow_counts), f)
+
+            if message.content.lower() == "meowcount":
+                response = f"My records show that <@{message.author.id}> has meowed {meow_counts[str(message.author.id)]} time(s). Have a nice day."
+                await message.channel.send(response)
+
+            if message.content.lower() == "top meowers":
+                top_meowers = sorted(meow_counts.items(), key=itemgetter(1), reverse=True)[:10]
+                embed = discord.Embed(title="Top Meowers :cat:", color=0x000000)
+                for i, (user_id, meow_count) in enumerate(top_meowers):
+                    user = await garfbot.fetch_user(int(user_id))
+                    embed.add_field(name=f"{i+1}. {user.name}", value=f"{meow_count} meows", inline=False)
+                await message.channel.send(embed=embed)
+
+        if message.content.lower() == "checking in":
+            user_id = str(message.author.id)
+            if user_id in user_stats and user_stats[user_id]["check_in_time"] is not None:
+                await message.channel.send(f"{message.author.mention} You are already checked in. Please check out first.")
+                return
+
+            check_in_time = datetime.now().timestamp()
+            if user_id not in user_stats:
+                user_stats[user_id] = {"check_ins": 0, "total_time": 0, "check_in_time": None}
+            user_stats[user_id]["check_in_time"] = check_in_time
+            await message.channel.send(f"{message.author.mention} You have been checked in. Please mute your microphone.")
+
+        elif message.content.lower() == "checking out":
+            user_id = str(message.author.id)
+            if user_id not in user_stats or user_stats[user_id]["check_in_time"] is None:
+                await message.channel.send(f"{message.author.mention} You have not checked in yet. Please check in first.")
+                return
+
+            check_out_time = datetime.now().timestamp()
+            check_in_time = user_stats[user_id]["check_in_time"]
+            time_delta = check_out_time - check_in_time
+            user_stats[user_id]["check_ins"] += 1
+            user_stats[user_id]["total_time"] += time_delta
+            user_stats[user_id]["check_in_time"] = None
+
+            with open("user_stats.json", "w") as f:
+                json.dump(user_stats, f)
+            await message.channel.send(f"{message.author.mention} You have been checked out. Your session was {time_delta:.2f} seconds.")
+
+        elif message.content.lower() == "stats":
+            stats_embed = discord.Embed(title="User stats  :trophy:", color=0x000000)
+            sorted_user_stats = sorted(user_stats.items(), key=lambda x: x[1]["total_time"], reverse=True)
+            table_rows = [["Name", "Check-ins", "Total Time"]]
+            for user_id, stats in sorted_user_stats:
+                if stats["check_in_time"] is None:
+                    total_time_seconds = stats["total_time"]
+                    hours, total_time_seconds = divmod(total_time_seconds, 3600)
+                    minutes, total_time_seconds = divmod(total_time_seconds, 60)
+                    seconds, fractions = divmod(total_time_seconds, 1)
+                    fractions_str = f"{fractions:.3f}"[2:]
+                    username = garfbot.get_user(int(user_id)).name
+                    table_rows.append([username, str(stats["check_ins"]), f"{int(hours)}h {int(minutes)}m {int(seconds)}s {fractions_str}ms"])
+                else:
+                    username = garfbot.get_user(int(user_id)).name
+                    table_rows.append([username, "Currently checked in", "-"])
+            table_columns = list(zip(*table_rows[1:]))
+            table_fields = table_rows[0]
+            for field, values in zip(table_fields, table_columns):
+                stats_embed.add_field(name=field, value="\n".join(values), inline=True)
+            await message.channel.send(embed=stats_embed)

garfpy/garfai.py

@@ -0,0 +1,90 @@
+import io
+import openai
+import config
+import aiohttp
+import asyncio
+import discord
+from openai import AsyncOpenAI
+from garfpy import logger
+
+openaikey = config.OPENAI_TOKEN
+
+txtmodel = config.TXT_MODEL
+imgmodel = config.IMG_MODEL
+
+# GarfPics
+image_request_queue = asyncio.Queue()
+
+async def picture_time(message, prompt):
+    await image_request_queue.put({'message': message, 'prompt': prompt})
+
+async def generate_image(prompt):
+    try:
+        client = AsyncOpenAI(api_key = openaikey)
+        response = await client.images.generate(
+            model=imgmodel,
+            prompt=prompt,
+            n=1,
+            size="1024x1024"
+        )
+        image_url = response.data[0].url
+        return image_url
+    except openai.BadRequestError as e:
+        return f"`GarfBot Error: ({e.status_code}) - Your request was rejected as a result of our safety system.`"
+    except openai.InternalServerError as e:
+        logger.error(e)
+        return f"`GarfBot Error: ({e.status_code}) - Monday`"
+    except Exception as e:
+        logger.error(e)
+        return f"`GarfBot Error: Lasagna`"
+
+async def process_image_requests():
+    async with aiohttp.ClientSession() as session:
+        while True:
+            request = await image_request_queue.get()
+            message = request['message']
+            prompt = request['prompt']
+            image_url = await generate_image(prompt)
+            if "GarfBot Error" not in image_url:
+                logger.info("Downloading & sending image...")
+                async with session.get(image_url) as resp:
+                    if resp.status == 200:
+                        image_data = await resp.read()
+                        ram_image = io.BytesIO(image_data)
+                        ram_image.seek(0)
+                        timestamp = message.created_at.strftime('%Y%m%d%H%M%S')
+                        filename = f"{timestamp}_generated_image.png"
+                        sendfile = discord.File(fp=ram_image, filename=filename)
+                        try:
+                            await message.channel.send(file=sendfile)
+                        except Exception as e:
+                            logger.error(e)
+                    else:
+                        await message.channel.send("`GarfBot Error: Odie`")
+            else:
+                await message.channel.send(image_url)
+            image_request_queue.task_done()
+            await asyncio.sleep(2)
+
+# GarfChats
+async def generate_chat(question):
+    try:
+        client = AsyncOpenAI(api_key = openaikey)
+        response = await client.chat.completions.create(
+            model=txtmodel,
+            messages=[
+            	{"role": "system", "content": "Pretend you are sarcastic Garfield."},
+            	{"role": "user", "content": f"{question}"}
+            ],
+            max_tokens=400
+        )
+        answer = response.choices[0].message.content
+        return answer.replace("an AI language model", "a cartoon animal")
+    except openai.BadRequestError as e:
+        return f"`GarfBot Error: {e}`"
+    except openai.APIError as e:
+        logger.info(e, flush=True)
+        return f"`GarfBot Error: Monday`"
+    except Exception as e:
+        logger.info(e, flush=True)
+        return f"`GarfBot Error: Lasagna`"

garfpy/iputils.py

@@ -0,0 +1,19 @@
+import ipaddress
+
+def is_private(target):
+    try:
+        ip_obj = ipaddress.ip_address(target)
+        if ip_obj.is_private:
+            return True
+    except ValueError:
+        if "crate.lan" in target.lower():
+            return True
+        if "crate.zip" in target.lower():
+            return True
+        if "memtec.org" in target.lower():
+            return True
+        if "crateit.net" in target.lower():
+            return True
+        if "garfbot.art" in target.lower():
+            return True
+    return False

garfpy/kroger.py

@@ -0,0 +1,48 @@
+import config
+import requests
+from base64 import b64encode
+from garfpy import logger
+
+
+client_id = config.CLIENT_ID
+client_secret = config.CLIENT_SECRET
+
+auth = b64encode(f"{client_id}:{client_secret}".encode()).decode()
+
+def kroger_token():
+    headers = {
+        'Content-Type': 'application/x-www-form-urlencoded',
+        'Authorization': f'Basic {auth}'
+    }
+
+    response = requests.post('https://api.kroger.com/v1/connect/oauth2/token', headers=headers, data={
+        'grant_type': 'client_credentials',
+        'scope': 'product.compact'
+    })
+
+    response.raise_for_status()
+    return response.json()['access_token']
+
+def find_store(zipcode, kroken):
+    headers = {
+        'Authorization': f'Bearer {kroken}',
+    }
+    params = {
+        'filter.zipCode.near': zipcode,
+        'filter.limit': 1,
+    }
+    response = requests.get('https://api.kroger.com/v1/locations', headers=headers, params=params)
+    return response.json()
+
+def search_product(product, loc_id, kroken):
+    logger.info(f"Searching for {product}...")
+    headers = {
+        'Authorization': f'Bearer {kroken}',
+    }
+    params = {
+        'filter.term': product,
+        'filter.locationId': loc_id,
+        'filter.limit': 10
+    }
+    response = requests.get('https://api.kroger.com/v1/products', headers=headers, params=params)
+    return response.json()

garfpy/log.py

@@ -0,0 +1,25 @@
+import logging
+from logging.handlers import TimedRotatingFileHandler
+
+logger = logging.getLogger('garflog')
+logger.setLevel(logging.INFO)
+formatter=logging.Formatter(
+    '%(asctime)s [%(levelname)s] %(message)s',
+    datefmt='%Y-%m-%d %H:%M:%S'
+    )
+file_handler = TimedRotatingFileHandler(
+    'garfbot.log',
+    when='midnight',
+    interval=1,
+    backupCount=7,
+    delay=True # Counter-intuitively, this will flush output immediately
+    )
+file_handler.setFormatter(formatter)
+console_handler = logging.StreamHandler()
+console_handler.setFormatter(formatter)
+logger.addHandler(file_handler)
+logger.addHandler(console_handler)
+
+if not logger.hasHandlers():
+    logger.addHandler(file_handler)
+    logger.addHandler(console_handler)