Added some /art/ shite

art/img2irc.py

@@ -0,0 +1,119 @@
+#!/usr/bin/env python
+# Scroll IRC Art Bot - Developed by acidvegas in Python (https://git.acid.vegas/scroll)
+
+'''
+Props:
+	- forked idea from malcom's img2irc (https://github.com/waveplate/img2irc)
+	- big props to wrk (wr34k) for forking this one
+
+pull request: https://github.com/ircart/scroll/pull/3
+
+'''
+
+import io
+
+try:
+	from PIL import Image
+except ImportError:
+	raise SystemExit('missing required \'pillow\' library (https://pypi.org/project/pillow/)')
+
+async def convert(data, img_width=80):
+	image = Image.open(io.BytesIO(data))
+	del data
+	(width, height) = image.size
+	img_height = img_width / width * height
+	del height, width
+	image.thumbnail((img_width, img_height), Image.Resampling.LANCZOS)
+	del img_height, img_width
+	ansi_image = AnsiImage(image)
+	del image
+	CHAR = '\u2580'
+	buf = ''
+	for (y, row) in enumerate(ansi_image.halfblocks):
+		last_fg = -1
+		last_bg = -1
+		for (x, pixel_pair) in enumerate(row):
+			fg = pixel_pair.top.irc
+			bg = pixel_pair.bottom.irc
+			if x != 0:
+				if fg == last_fg and bg == last_bg:
+					buf += CHAR
+				elif bg == last_bg:
+					buf += f'\x03{fg}{CHAR}'
+				else:
+					buf += f'\x03{fg},{bg}{CHAR}'
+			else:
+				buf += f'\x03{fg},{bg}{CHAR}'
+			last_fg = fg
+			last_bg = bg
+		if y != len(ansi_image.halfblocks) - 1:
+			buf += '\n'
+		else:
+			buf += '\x0f'
+	return buf.splitlines()
+
+def hex_to_rgb(color):
+	r = color >> 16
+	g = (color >> 8) % 256
+	b = color % 256
+	return (r,g,b)
+
+def rgb_to_hex(rgb):
+	(r,g,b) = rgb
+	return (r << 16) + (g << 8) + b
+
+def color_distance_squared(c1, c2):
+	dr = c1[0] - c2[0]
+	dg = c1[1] - c2[1]
+	db = c1[2] - c2[2]
+	return dr * dr + dg * dg + db * db
+
+class AnsiPixel:
+	def __init__(self, pixel_u32):
+		self.RGB99 = [
+			0xffffff, 0x000000, 0x00007f, 0x009300, 0xff0000, 0x7f0000, 0x9c009c, 0xfc7f00,
+			0xffff00, 0x00fc00, 0x009393, 0x00ffff, 0x0000fc, 0xff00ff, 0x7f7f7f, 0xd2d2d2,
+			0x470000, 0x472100, 0x474700, 0x324700, 0x004700, 0x00472c, 0x004747, 0x002747,
+			0x000047, 0x2e0047, 0x470047, 0x47002a, 0x740000, 0x743a00, 0x747400, 0x517400,
+			0x007400, 0x007449, 0x007474, 0x004074, 0x000074, 0x4b0074, 0x740074, 0x740045,
+			0xb50000, 0xb56300, 0xb5b500, 0x7db500, 0x00b500, 0x00b571, 0x00b5b5, 0x0063b5,
+			0x0000b5, 0x7500b5, 0xb500b5, 0xb5006b, 0xff0000, 0xff8c00, 0xffff00, 0xb2ff00,
+			0x00ff00, 0x00ffa0, 0x00ffff, 0x008cff, 0x0000ff, 0xa500ff, 0xff00ff, 0xff0098,
+			0xff5959, 0xffb459, 0xffff71, 0xcfff60, 0x6fff6f, 0x65ffc9, 0x6dffff, 0x59b4ff,
+			0x5959ff, 0xc459ff, 0xff66ff, 0xff59bc, 0xff9c9c, 0xffd39c, 0xffff9c, 0xe2ff9c,
+			0x9cff9c, 0x9cffdb, 0x9cffff, 0x9cd3ff, 0x9c9cff, 0xdc9cff, 0xff9cff, 0xff94d3,
+			0x000000, 0x131313, 0x282828, 0x363636, 0x4d4d4d, 0x656565, 0x818181, 0x9f9f9f,
+			0xbcbcbc, 0xe2e2e2, 0xffffff
+		]
+		self.irc  = self.nearest_hex_color(pixel_u32, self.RGB99)
+
+	def nearest_hex_color(self, pixel_u32, hex_colors):
+		rgb_colors = [hex_to_rgb(color) for color in hex_colors]
+		rgb_colors.sort(key=lambda rgb: color_distance_squared(hex_to_rgb(pixel_u32), rgb))
+		hex_color = rgb_to_hex(rgb_colors[0])
+		return hex_colors.index(hex_color)
+
+class AnsiPixelPair:
+	def __init__(self, top, bottom):
+		self.top = top
+		self.bottom = bottom
+
+class AnsiImage:
+	def __init__(self, image):
+		self.bitmap = [[rgb_to_hex(image.getpixel((x, y))) for x in range(image.size[0])] for y in range(image.size[1])]
+		if len(self.bitmap) % 2 != 0:
+			self.bitmap.append([0 for x in range(image.size[0])])
+		ansi_bitmap = [[AnsiPixel(y) for y in x] for x in self.bitmap]
+		ansi_canvas = list()
+		for two_rows in range(0, len(ansi_bitmap), 2):
+			top_row = ansi_bitmap[two_rows]
+			bottom_row = ansi_bitmap[two_rows+1]
+			ansi_row = list()
+			for i in range(len(self.bitmap[0])):
+				top_pixel = top_row[i]
+				bottom_pixel = bottom_row[i]
+				pixel_pair = AnsiPixelPair(top_pixel, bottom_pixel)
+				ansi_row.append(pixel_pair)
+			ansi_canvas.append(ansi_row)
+		self.image = image
+		self.halfblocks = ansi_canvas

art/img2irc_perplexa.py

@@ -0,0 +1,200 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+img2irc
+Copyright (C) 2012 perplexa
+"""
+
+__author__ = "perplexa"
+__version__ = "0.3"
+
+import sys
+if sys.version_info[:2] < (2, 6):
+    raise RuntimeError("Python v2.6 or later required")
+
+# requires python image library
+import Image
+import getopt
+import StringIO
+import sys
+import time
+import urllib2
+
+# define our palettes
+palette = {
+  "mirc": {
+     0: [255,255,255],
+     1: [0,0,0],
+     2: [0,0,127],
+     3: [0,147,0],
+     4: [255,0,0],
+     5: [127,0,0],
+     6: [156,0,156],
+     7: [252,127,0],
+     8: [255,255,0],
+     9: [0,252,0],
+    10: [0,147,147],
+    11: [0,255,255],
+    12: [0,0,252],
+    13: [255,0,255],
+    14: [127,127,127],
+    15: [210,210,210]
+  },
+  "perplexa": {
+     0: [255,255,255],
+     1: [0,0,0],
+     2: [58,80,120],
+     3: [174,206,146],
+     4: [207,97,113],
+     5: [158,24,40],
+     6: [150,60,89],
+     7: [150,138,56],
+     8: [255,247,150],
+     9: [197,247,121],
+    10: [65,129,121],
+    11: [113,190,190],
+    12: [65,134,190],
+    13: [207,158,190],
+    14: [102,102,102],
+    15: [190,190,190]
+  }
+}
+
+# define default parameter values
+use_palette = "perplexa"
+line_delay = None
+max_width = None
+
+#convert RGB to CIE-L*a*b* color space (takes floats between 0.0-1.0)
+def rgb_to_cielab(r, g, b):
+  return xyz_to_cielab(*rgb_to_xyz(r, g, b))
+  
+def rgb_to_xyz(r, g, b):
+  r = _r1(r)
+  g = _r1(g)
+  b = _r1(b)
+
+  # observer. = 2°, illuminant = D65
+  x = r * 0.4124 + g * 0.3576 + b * 0.1805
+  y = r * 0.2126 + g * 0.7152 + b * 0.0722
+  z = r * 0.0193 + g * 0.1192 + b * 0.9505
+
+  return x, y, z
+
+def _r1(y):
+  y = ((y + 0.055) / 1.055) ** 2.4 if y > 0.04045 else y / 12.92
+  return y * 100
+
+def _r2(y):
+  return y ** (1.0 / 3.0) if y > 0.008856 else (7.787 * y) + (16.0 / 116.0)
+
+def xyz_to_cielab(x, y, z):
+  x = x / 95.047
+  y = y / 100.0
+  z = z / 108.883
+
+  x = _r2(x)
+  y = _r2(y)
+  z = _r2(z)
+
+  L = (116 * y) - 16
+  a = 500 * (x - y)
+  b = 200 * (y - z)
+
+  return L, a, b
+
+def euclidian_distance(v1, v2):
+  return sum((a - b) ** 2 for a, b in zip(v1, v2)) ** 0.5
+
+def nearest_color(lab):
+  distance = None
+  color = None
+  for col in palette[use_palette]:
+    clab = rgb_to_cielab(*[x / 255.0 for x in palette[use_palette][col]])
+    cdist = euclidian_distance(clab, lab)
+    if distance == None or cdist < distance:
+      distance = cdist
+      color = col
+  return color
+
+def usage():
+  return """Usage: %s [OPTIONS] IMAGE
+Convert IMAGE to IRC text.
+
+Options:
+  -d, --delay      define delay per line (seconds, float)
+  -p, --palette    use specific palette (%s)
+  -w, --width      limit image width to X pixels
+""" % (sys.argv[0], ", ".join(palette.keys()))
+
+# ## ### ##### ######## ##### ### ## #
+# ## ### ##### ######## ##### ### ## #
+
+if __name__ == "__main__":
+  try:
+    opts, args = getopt.getopt(sys.argv[1:], "p:d:w:", ["palette=", "delay=", "width="])
+  except getopt.GetoptError, err:
+    sys.stderr.write(str(err) + "\n")
+    sys.exit(2)
+
+  for opt, arg in opts:
+    if opt in ("-p", "--palette"):
+      if arg not in palette:
+        sys.stderr.write("Invalid palette: %s\nUse one of the following: %s\n" % (arg, ", ".join(palette.keys())))
+        sys.exit(2)
+      use_palette = arg
+    
+    if opt in ("-d", "--delay"):
+      line_delay = float(arg)
+
+    if opt in ("-w", "--width"):
+      max_width = int(arg)
+
+  if not len(args):
+    sys.stderr.write(usage())
+    sys.exit(2)
+  fn = args[0]
+
+  try:
+    if fn[0:4] == "http":
+      sock = urllib2.urlopen(fn)
+      data = sock.read()
+      sock.close()
+      fil = StringIO.StringIO(data)
+    else:
+      fil = fn
+    img = Image.open(fil)
+  except:
+    sys.stderr.write("Could not open file: %s\n" % fn)
+    sys.exit(2)
+
+  img = img.convert(mode="RGBA")
+
+  bg = Image.new("RGBA", img.size, (255, 255, 255))
+  bg.paste(img, img)
+
+  width, height = bg.size
+  if max_width:
+    height = int(height * (max_width / float(width)))
+    width = max_width
+    bg = bg.resize((width, height))
+
+  pxl = bg.load()
+  prv = None
+
+  for y in range(height):
+    for x in range(width):
+      r, g, b, a = pxl[x, y]
+      col = nearest_color(rgb_to_cielab(r / 255.0, g / 255.0, b / 255.0))
+      if prv == None or prv != col:
+        sys.stdout.write("\x03%s,%sXX" % (col, col))
+        prv = col
+      else:
+        sys.stdout.write("XX")
+    sys.stdout.write("\n")
+    prv = None
+
+    if line_delay:
+      sys.stdout.flush()
+      time.sleep(line_delay)

bots/surge.py

@@ -33,12 +33,12 @@ import time
 
 class config:
 	class connection:
-		server    = 'irc.server.com'
+		server    = 'irc.libera.chat'
 		port      = 6667
 		ipv6      = False
 		ssl       = False
 		password  = None
-		channel   = '#chats'
+		channel   = '#weechat-live'
 		key       = None
 
 	class attacks: