arkham-utils 0.1.0__tar.gz

arkham_utils-0.1.0/PKG-INFO

@@ -0,0 +1,84 @@
+Metadata-Version: 2.1
+Name: arkham-utils
+Version: 0.1.0
+Summary: Arkham Horror LCG utilities
+Author: Ian Su
+Author-email: iansu1979+github@gmail.com
+Requires-Python: >=3.12,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: Pillow (>=9.5.0,<10.0.0)
+Requires-Dist: PyMuPDF (>=1.24.5,<2.0.0)
+Requires-Dist: fpdf2 (>=2.7.4,<3.0.0)
+Requires-Dist: platformdirs (>=4.3.7,<5.0.0)
+Requires-Dist: requests (>=2.29.0,<3.0.0)
+Requires-Dist: requests-cache (>=1.2.1,<2.0.0)
+Description-Content-Type: text/markdown
+
+# Arkham Horror LCG utilities
+
+A simple set of utilities to read from [ArkhamDB](https://arkhamdb.com/) and [OCTGN files](https://github.com/GeckoTH/arkham-horror) mainly used to generate printable proxies in PDF format.
+
+```sh
+pip install arkham-utils
+```
+
+## Using ArkhamDB images
+
+Note the images from ArkhamDB have an FFG watermark on them.
+
+```py
+from arkham_utils.arkhamdb import db
+from arkham_utils.pdf.builder import PDFBuilder
+
+cards = [db.search(name) for name in [
+  'Blackjack',
+  'Guts',
+  'Emergency Cache',
+  'Elder Sign',
+  'Shrivelling',
+  'Daisy Walker'
+]]
+pdf = PDFBuilder(cards)
+pdf.write('proxies.pdf')
+```
+
+## Using OCTGN images
+
+You will need to first download the image packs from <https://ahlcgoctgn.wordpress.com/image-packs/> into your application support directory (`Library/Application Support/arkham_utils` on MacOS).
+
+```py
+from arkham_utils.octgn import db
+from arkham_utils.pdf.builder import PDFBuilder
+
+cards = [db.find(name) for name in [
+  'Blackjack',
+  'Guts',
+  'Emergency Cache',
+  'Elder Sign',
+  'Shrivelling',
+  'Daisy Walker'
+]]
+pdf = PDFBuilder(cards)
+pdf.write('proxies.pdf')
+```
+
+### Proxying an entire set
+
+```py
+from arkham_utils.octgn import db
+from arkham_utils.pdf.builder import PDFBuilder, PDFBuilderConfig
+
+# write all the non-mini cards as a PDF
+barkham = db.find_set('Meowlathotep')
+PDFBuilder([c for c in barkham.cards if c.type != 'Mini']).write('barkham.pdf')
+
+# write the mini investigator cards
+mini_cfg = PDFBuilderConfig()
+mini_cfg.cards_per_row = 4
+mini_cfg.rows_per_page = 4
+mini_cfg.card_height = 2.5
+mini_cfg.card_width = 1.625
+PDFBuilder([c for c in barkham.cards if c.type == 'Mini'], mini_cfg).write('barkham_minis.pdf')
+```
+

arkham_utils-0.1.0/README.md

@@ -0,0 +1,66 @@
+# Arkham Horror LCG utilities
+
+A simple set of utilities to read from [ArkhamDB](https://arkhamdb.com/) and [OCTGN files](https://github.com/GeckoTH/arkham-horror) mainly used to generate printable proxies in PDF format.
+
+```sh
+pip install arkham-utils
+```
+
+## Using ArkhamDB images
+
+Note the images from ArkhamDB have an FFG watermark on them.
+
+```py
+from arkham_utils.arkhamdb import db
+from arkham_utils.pdf.builder import PDFBuilder
+
+cards = [db.search(name) for name in [
+  'Blackjack',
+  'Guts',
+  'Emergency Cache',
+  'Elder Sign',
+  'Shrivelling',
+  'Daisy Walker'
+]]
+pdf = PDFBuilder(cards)
+pdf.write('proxies.pdf')
+```
+
+## Using OCTGN images
+
+You will need to first download the image packs from <https://ahlcgoctgn.wordpress.com/image-packs/> into your application support directory (`Library/Application Support/arkham_utils` on MacOS).
+
+```py
+from arkham_utils.octgn import db
+from arkham_utils.pdf.builder import PDFBuilder
+
+cards = [db.find(name) for name in [
+  'Blackjack',
+  'Guts',
+  'Emergency Cache',
+  'Elder Sign',
+  'Shrivelling',
+  'Daisy Walker'
+]]
+pdf = PDFBuilder(cards)
+pdf.write('proxies.pdf')
+```
+
+### Proxying an entire set
+
+```py
+from arkham_utils.octgn import db
+from arkham_utils.pdf.builder import PDFBuilder, PDFBuilderConfig
+
+# write all the non-mini cards as a PDF
+barkham = db.find_set('Meowlathotep')
+PDFBuilder([c for c in barkham.cards if c.type != 'Mini']).write('barkham.pdf')
+
+# write the mini investigator cards
+mini_cfg = PDFBuilderConfig()
+mini_cfg.cards_per_row = 4
+mini_cfg.rows_per_page = 4
+mini_cfg.card_height = 2.5
+mini_cfg.card_width = 1.625
+PDFBuilder([c for c in barkham.cards if c.type == 'Mini'], mini_cfg).write('barkham_minis.pdf')
+```

arkham_utils-0.1.0/arkham_utils/arkhamdb/__init__.py

@@ -0,0 +1,50 @@
+import re
+from typing import Generator
+import requests
+from arkham_utils.arkhamdb.card import ArkhamDBCard
+from arkham_utils.arkhamdb.constants import API
+from arkham_utils.arkhamdb.set import ArkhamDBSet
+import requests_cache
+from platformdirs import user_cache_dir
+
+requests_cache.install_cache(
+    f'{user_cache_dir('arkham_utils')}/arkhamdb_cache', expire_after=1800)
+
+
+class ArkhamDB(object):
+    def __init__(self):
+        print('loading packs', f'{API}/packs/')
+        r = requests.get(f'{API}/packs/')
+        self.packs_data = r.json()
+        self.packs = [ArkhamDBSet(pack) for pack in self.packs_data]
+        print(f'loaded {len(self.packs)} packs')
+
+    def find_all_sets(self, regex: str) -> Generator[ArkhamDBSet, None, None]:
+        for s in self.packs:
+            m = re.search(regex, s.name)
+            if m:
+                yield s
+
+    def find_set(self, regex: str) -> ArkhamDBSet:
+        return next(self.find_all_sets(regex))
+
+    # beware that this will return Revised Core and Core together
+    def find_sets_in_cycle(self, regex: str) -> Generator[ArkhamDBSet, None, None]:
+        root = self.find_set(regex)
+        cycle = root.data['cycle_position']
+        for s in self.packs:
+            if s.data['cycle_position'] == cycle:
+                yield s
+
+    def find_all_cards(self, regex: str) -> Generator[ArkhamDBCard, None, None]:
+        for s in self.packs:
+            for c in s.cards:
+                m = re.search(regex, c.name)
+                if m:
+                    yield c
+
+    def search(self, regex: str) -> ArkhamDBCard:
+        return next(self.find_all_cards(regex))
+
+
+db = ArkhamDB()

arkham_utils-0.1.0/arkham_utils/arkhamdb/card.py

@@ -0,0 +1,61 @@
+import requests
+from arkham_utils.card import ArkhamCard
+from PIL import Image
+import io
+import requests
+from arkham_utils.arkhamdb.constants import API
+
+
+def _get_image_from_url(url) -> Image.Image:
+    r = requests.get(url)
+    return Image.open(io.BytesIO(r.content))
+
+
+class ArkhamDBCard(ArkhamCard):
+    def __init__(self, data):
+        self.data = data
+        self._images = None
+
+    def _lazy_load_images(self):
+        if self._images is not None:
+            return
+        if 'backimagesrc' in self.data:
+            self._images = _get_image_from_url(f'https://arkhamdb.com{self.data["imagesrc"]}'), _get_image_from_url(
+                f'https://arkhamdb.com{self.data["backimagesrc"]}')
+        elif 'imagesrc' in self.data:
+            self._images = _get_image_from_url(
+                f'https://arkhamdb.com{self.data["imagesrc"]}'),
+        else:
+            self._images = []
+            print(f"{self.name} has no images!")
+
+    @property
+    def code(self):
+        return self.data['code']
+
+    @property
+    def name(self):
+        return self.data['name']
+
+    @property
+    def image(self):
+        self._lazy_load_images()
+        return self._images[0]
+    
+    @property
+    def faction(self):
+        return self.data['faction_code']
+    
+    @property
+    def type(self):
+        return self.data['type_code']
+
+    @property
+    def images(self):
+        self._lazy_load_images()
+        return self._images
+
+    @staticmethod
+    def from_id(id: str):
+        r = requests.get(f"{API}/card/{id}.json")
+        return ArkhamDBCard(r.json())

arkham_utils-0.1.0/arkham_utils/arkhamdb/constants.py

@@ -0,0 +1 @@
+API = 'https://arkhamdb.com/api/public'

arkham_utils-0.1.0/arkham_utils/arkhamdb/public_deck.py

@@ -0,0 +1,38 @@
+from typing import Dict, List
+from arkham_utils.arkhamdb.card import ArkhamDBCard
+from arkham_utils.arkhamdb.constants import API
+import requests
+
+
+class ArkhamDBPublicDeck(object):
+  id: int
+  data: object
+  _cards: Dict[str, ArkhamDBCard]
+
+  def __init__(self, id: int, is_decklist: bool = False):
+    self.id = id
+    key = 'decklist' if is_decklist else 'deck'
+    r = requests.get(f"{API}/{key}/{self.id}.json")
+    print(f"{API}/{key}/{self.id}.json")
+    print(r.content)
+    self.data = r.json()
+    self._cards = None
+
+  @property
+  def cards(self):
+    if self._cards is None:
+      self._cards = {}
+      for id in self.data['slots']:
+        self._cards[id] = ArkhamDBCard.from_id(id)
+
+    all_cards = []
+    for id, count in self.data['slots'].items():
+      all_cards.extend([self._cards[id]] * count)
+
+    return all_cards
+
+  def dump(self):
+    self.cards
+    print(f"{self.data['name']}")
+    for id, count in self.data['slots'].items():
+      print(f"  {self._cards[id].name} x{count}")

arkham_utils-0.1.0/arkham_utils/arkhamdb/set.py

@@ -0,0 +1,32 @@
+from typing import Generator
+import requests
+from arkham_utils.arkhamdb.card import ArkhamDBCard
+from arkham_utils.arkhamdb.constants import API
+import re
+
+class ArkhamDBSet(object):
+    def __init__(self, data):
+        self.data = data
+        self._cards = None
+
+    def _lazy_load_cards(self, include_encounter=True):
+        if self._cards is not None:
+            return
+        r = requests.get(
+            f"{API}/cards/{self.data['code']}?encounter={1 if include_encounter else 0}")
+        cards_data = r.json()
+        self._cards = [ArkhamDBCard(data) for data in cards_data]
+
+    @property
+    def name(self):
+        return self.data['name']
+
+    @property
+    def cards(self):
+        self._lazy_load_cards()
+        return self._cards
+
+    def find_by_regex(self, regex: str | re.Pattern[str]) -> Generator[ArkhamDBCard, None, None]:
+        for c in self.cards:
+            if re.match(regex, c.name):
+                yield c

arkham_utils-0.1.0/arkham_utils/card.py

@@ -0,0 +1,18 @@
+from abc import ABC,abstractmethod
+
+class ArkhamCard(ABC):
+    def __init__(self, front, back=None):
+        self._images = (front, back) if back else front,
+
+    @property
+    def image(self):
+        return self._images[0]
+
+    @property
+    def images(self):
+        return self._images
+    
+    @property
+    @abstractmethod
+    def type(self):
+        return 'Card'

arkham_utils-0.1.0/arkham_utils/octgn/__init__.py

@@ -0,0 +1,63 @@
+import glob
+import re
+import time
+from typing import List
+import zipfile
+
+import requests
+import os
+
+from arkham_utils.octgn.set import OctgnSet
+from platformdirs import user_data_dir
+
+class OctgnSetDatabase(object):
+    sets: List[OctgnSet]
+    path: str
+
+    @property
+    def gitzip(self):
+        return f'{self.path}/o8g.zip'
+
+    def download(self):
+        if os.path.exists(self.gitzip) and os.path.getmtime(self.gitzip) > time.time() - 60 * 60 * 24:
+            return
+        os.makedirs(self.path, exist_ok=True)
+        r = requests.get('https://github.com/GeckoTH/arkham-horror/archive/refs/heads/master.zip', allow_redirects=True)
+        open(self.gitzip, 'wb').write(r.content)
+    
+    def __init__(self, path='o8g'):
+        self.path = path
+        self.sets = []
+        self.download()
+        with zipfile.ZipFile(self.gitzip) as z:
+            for f in z.filelist:
+                if f.filename.endswith('/set.xml'):
+                    with z.open(f.filename) as fd:
+                        s = OctgnSet(fd)
+                        self.sets.append(s)
+        print(f'loaded {len(self.sets)} sets, {sum([len(s.cards) for s in self.sets])} cards')
+        
+    def lookup(self, card_id):
+        for s in self.sets:
+            card = s.find(card_id)
+            if card is not None:
+                return card
+        return None
+    
+    def find_all(self, regex, xp=None):
+        for s in self.sets:
+            for found in s.find_by_regex(regex, xp):
+                yield found
+                
+    def find(self, regex, xp=None):
+        return next(self.find_all(regex, xp))
+    
+    def find_all_sets(self, regex):
+        for s in self.sets:
+            if re.search(regex, s.name):
+                yield s
+    
+    def find_set(self, regex):
+        return next(self.find_all_sets(regex))
+            
+db = OctgnSetDatabase(f'{user_data_dir('arkham_utils')}/o8g')

arkham_utils-0.1.0/arkham_utils/octgn/card.py

@@ -0,0 +1,25 @@
+from xml.etree.ElementTree import Element
+from arkham_utils.card import ArkhamCard
+from arkham_utils.octgn.image_db import image_db
+
+class OctgnCard(ArkhamCard):
+    def __init__(self, card_elem: Element, image_db=image_db):
+        self.elem = card_elem
+        self.image_db = image_db
+    @property
+    def id(self):
+        return self.elem.attrib['id']
+    @property
+    def name(self):
+        return self.elem.text
+    @property
+    def image(self):
+        return self.image_db.get_image(self.id)
+    @property
+    def images(self):
+        return self.image_db.get_images(self.id)
+    @property
+    def quantity(self):
+        return int(self.elem.attrib['qty'])
+    def __str__(self):
+        return f"[{self.id}] {self.name}"

arkham_utils-0.1.0/arkham_utils/octgn/deck.py

@@ -0,0 +1,16 @@
+import csv
+import sys
+import xml.etree.ElementTree as ET
+
+from arkham_utils.octgn.card import OctgnCard
+
+
+class OctgnDeck(object):
+    def __init__(self, o8d='starter-deck.o8d'):
+        tree = ET.parse(o8d)
+        self.cards = [OctgnCard(card) for card in tree.findall('.//card')]        
+    def csv(self, fh=sys.stdout):
+        writer = csv.writer(fh)
+        for card in self.cards:
+            writer.writerow([card.id, card.name, card.quantity])
+            

arkham_utils-0.1.0/arkham_utils/octgn/image_db.py

@@ -0,0 +1,52 @@
+import glob
+import zipfile
+import re
+from PIL import Image
+from platformdirs import user_data_dir
+import os
+
+# download files from https://ahlcgoctgn.wordpress.com/image-packs/ into o8c/
+class OctgnImageDatabase(object):
+    def __init__(self, path='o8c'):
+        if not os.path.exists(path):
+            raise RuntimeError(f'{path} does not exist! Please download the image packs from https://ahlcgoctgn.wordpress.com/image-packs/ into {path}')
+        
+        self.images = {} # uuid -> (zip_name, zip_internal_file)
+        self.images_back = {}
+        for o8c in glob.glob(f'{path}/*.o8c'):
+            with zipfile.ZipFile(o8c) as z:
+                for f in z.filelist:
+                    m = re.match(
+                        r'[^/]+/Sets/[^/]+/Cards/([^\.]+)\.(jpg|png)$', f.filename)
+                    if m is not None:
+                        uuid = m.group(1)
+                        self.images[uuid] = (o8c, f.filename)
+                    else:
+                        m = re.match(
+                            r'[^/]+/Sets/[^/]+/Cards/([^\.]+)\.[A-Za-z]\.(jpg|png)$', f.filename)
+                        if m is not None:
+                            uuid = m.group(1)
+                            self.images_back[uuid] = (o8c, f.filename)
+
+        print(f'loaded {len(self.images)} card images and {len(self.images_back)} back images')
+    
+    def get_image(self, card_id, front=True):
+        images = self.images if front else self.images_back
+        if card_id not in images:
+            raise KeyError('unknown card_id', card_id)
+        o8c, fname = images[card_id]
+        with zipfile.ZipFile(o8c) as z:
+            with z.open(fname) as f:
+                i = Image.open(f)
+                i.load()
+        return i
+    
+    def get_images(self, card_id):
+        front = self.get_image(card_id)
+        try:
+            back = self.get_image(card_id, False)
+            return front, back
+        except KeyError:
+            return front,
+
+image_db = OctgnImageDatabase(f'{user_data_dir('arkham_utils')}/o8c')

arkham_utils-0.1.0/arkham_utils/octgn/set.py

@@ -0,0 +1,56 @@
+import csv
+import re
+import sys
+from typing import List
+import xml.etree.ElementTree as ET
+
+from arkham_utils.octgn.set_card import OctgnSetCard
+
+
+# check out repo https://github.com/GeckoTH/arkham-horror/tree/master/o8g
+class OctgnSet(object):
+    cards: List[OctgnSetCard]
+    
+    def __init__(self, set_xml='o8g/Sets/Core Set/set.xml'):
+        self.xml = set_xml
+        tree = ET.parse(set_xml)
+        self.name = tree.getroot().attrib['name']
+        self.cards = [OctgnSetCard(card) for card in tree.findall('.//card')]
+        self.counts = {}
+        for card in self.cards:
+            try:
+                self.counts[card.id] = card.quantity
+            except AttributeError:
+                self.counts[card.id] = 1
+#                 logging.warning(f'{set_xml} card {card.name} ({card.id}) has no quantity')
+        self.proxies = []
+            
+    def csv(self, fh=sys.stdout):
+        writer = csv.writer(fh)
+        for card in self.cards:
+            writer.writerow([card.id, card.set_number, card.name, card.quantity, card.xp])
+    
+    def find(self, card_id):
+        return next((x for x in self.cards if x.id == card_id), None)
+    
+    def find_by_regex(self, pattern, xp=None):
+        return [x for x in self.cards if re.search(pattern, x.name) is not None and (xp is None or xp == x.xp)]
+    
+    def remove(self, card_id):
+        if card_id in self.counts:
+            self.counts[card_id] -= 1
+#             print(f'ok removing {self.find(card_id).name}, {self.counts[card_id]} left')
+            if self.counts[card_id] == 0:
+                del self.counts[card_id]
+            return True
+        if not self.find(card_id):
+            raise KeyError(f'Unknown card id: {card_id}')
+        return False
+    
+    def remove_deck(self, deck):
+        for card in deck.cards:
+            for _ in range(card.quantity):
+                ok = self.remove(card.id)
+                if not ok:
+#                     print(f'proxy: {card.name}')
+                    self.proxies.append(card)

arkham_utils-0.1.0/arkham_utils/octgn/set_card.py

@@ -0,0 +1,29 @@
+from arkham_utils.octgn.card import OctgnCard
+
+class OctgnSetCard(OctgnCard):
+    def get_property(self, key):
+        return self.elem.find(f'property[@name="{key}"]').attrib['value']
+    @property
+    def name(self):
+        return self.elem.attrib['name']
+    @property
+    def size(self):
+        try:
+            return self.elem.attrib['size']
+        except:
+            return None
+    @property
+    def set_number(self):
+        return int(self.get_property("Card Number"))
+    @property
+    def quantity(self):
+        return int(self.get_property("Quantity"))
+    @property
+    def type(self):
+        return self.get_property("Type")
+    @property
+    def xp(self):
+        try:
+            return int(self.get_property("Level"))
+        except:
+            return 'n/a'

arkham_utils-0.1.0/arkham_utils/pdf/builder.py

@@ -0,0 +1,105 @@
+from typing import Dict, List, Tuple
+
+from fpdf import FPDF
+
+from arkham_utils.card import ArkhamCard
+from PIL import Image
+
+
+MAX_PAGES = 100
+card_width = 2.4
+card_height = 3.5
+cards_per_row = 3
+rows_per_page = 3
+a4_width = 8.27
+a4_height = 11.69
+bleed_thickness = 0.05
+padding = 0.015
+
+
+class PDFBuilderConfig(object):
+    card_width: float = card_width
+    card_height: float = card_height
+    cards_per_row: int = cards_per_row
+    rows_per_page: int = rows_per_page
+    bleed_thickness: float = bleed_thickness
+    paper_width: float = a4_width
+    paper_height: float = a4_height
+    padding: float = padding
+
+
+class PDFBuilder(object):
+    def __init__(self, cards: List[ArkhamCard], config: PDFBuilderConfig = PDFBuilderConfig()):
+        self.cards = cards
+        self.config = config
+        self.layout = self.get_layout()
+
+    def get_layout(self) -> Dict[Tuple[int, int, int], Image.Image]:
+        layout = {}
+        twosided = [c for c in self.cards if len(c.images) == 2]
+        onesided = [c for c in self.cards if len(c.images) == 1]
+        for card in twosided:
+            self.layout_2side(layout, card)
+        for card in onesided:
+            self.layout_1side(layout, card)
+        return layout
+
+    def layout_2side(self, layout, card: ArkhamCard):
+        front, back = card.images
+        if front.width < front.height:
+            front = front.rotate(180)
+        for p in range(MAX_PAGES):
+            for r in range(0, self.config.rows_per_page, 2):
+                if r + 1 == self.config.rows_per_page:
+                    continue
+                for c in range(self.config.cards_per_row):
+                    if (p, r, c) not in layout:
+                        layout[(p, r, c)] = back
+                        layout[(p, r + 1, c)] = front
+                        return
+        raise RuntimeError('Exceeded last page')
+
+    def layout_1side(self, layout, card: ArkhamCard):
+        for p in range(MAX_PAGES):
+            for r in range(self.config.rows_per_page):
+                for c in range(self.config.cards_per_row):
+                    if (p, r, c) not in layout:
+                        layout[(p, r, c)] = card.image
+                        return
+        raise RuntimeError('Exceeded last page')
+
+    def write(self, filename: str):
+        padding_left = (self.config.paper_width -
+                        (self.config.cards_per_row * self.config.card_width) - ((self.config.cards_per_row - 1) * self.config.padding)) / 2
+        padding_top = (self.config.paper_height - (self.config.rows_per_page *
+                       self.config.card_height) - ((self.config.rows_per_page - 1) * self.config.padding)) / 2
+
+        pdf = FPDF(orientation='P', format='A4', unit='in')
+        pages = max([p for (p, r, c) in self.layout]) + 1
+        for p in range(pages):
+            pdf.add_page()
+            # add bleed bg
+            for row in range(self.config.rows_per_page):
+                for col in range(self.config.cards_per_row):
+                    if (p, row, col) in self.layout:
+                        pdf.rect(w=self.config.card_width + 2 * self.config.bleed_thickness,
+                                 h=self.config.card_height + 2 * self.config.bleed_thickness,
+                                 x=padding_left + col *
+                                 (self.config.card_width + self.config.padding) -
+                                 self.config.bleed_thickness,
+                                 y=padding_top + row *
+                                 (self.config.card_height + self.config.padding) -
+                                 self.config.bleed_thickness,
+                                 style='F')
+            # add actual images
+            for row in range(self.config.rows_per_page):
+                for col in range(self.config.cards_per_row):
+                    if (p, row, col) in self.layout:
+                        image = self.layout[(p, row, col)]
+                        if image.width > image.height:
+                            image = image.rotate(-90, expand=True)
+                        pdf.image(image, w=self.config.card_width, h=self.config.card_height, x=padding_left +
+                                  col * (self.config.card_width +
+                                         self.config.padding),
+                                  y=padding_top + row * (self.config.card_height + self.config.padding))
+        pdf.output(filename)

arkham_utils-0.1.0/arkham_utils/pdf/image_reader.py

@@ -0,0 +1,22 @@
+from typing import Generator
+from arkham_utils.card import ArkhamCard
+from arkham_utils.pdf.builder import PDFBuilder
+import fitz
+from PIL import Image
+
+
+class PDFImageReader(object):
+    def __init__(self, filename, zoom=4):
+        self.filename = filename
+        self.zoom = zoom
+
+    def get_images(self) -> Generator[Image.Image, None, None]:
+        with fitz.open(self.filename) as pdf:
+            mat = fitz.Matrix(self.zoom, self.zoom)
+            for i in range(len(pdf)):
+                page = pdf.load_page(i)
+                pix = page.get_pixmap(matrix=mat)
+                yield Image.frombytes("RGB", [pix.width, pix.height], pix.samples)
+
+    def build_pdf(self):
+        return PDFBuilder([ArkhamCard(im) for im in self.get_images()])

arkham_utils-0.1.0/arkham_utils/pdf/tiled_image_builder.py

@@ -0,0 +1,161 @@
+from typing import List, Tuple
+import math
+
+from fpdf import FPDF
+
+from PIL import Image
+
+a4_width = 210
+a4_height = 297
+
+
+class PDFTiledImageBuilder(object):
+    def __init__(self, image_width_mm, image_height_mm, image_files: List[str], bleed_color: Tuple[int, int, int] = (0, 0, 0), space_between: int = 0.2):
+        self.image_width = image_width_mm
+        self.image_height = image_height_mm
+        self.images = [Image.open(fname) for fname in image_files]
+        self.bleed_thickness = 0.5
+        self.minimum_page_padding = 5
+        self.bleed_color = bleed_color  # rgb
+        self.space_between = space_between
+
+    def write(self, filename: str):
+        # work out which orientation maximizes tiling
+        printable_width = a4_width - 2 * \
+            (self.bleed_thickness + self.minimum_page_padding)
+        printable_height = a4_height - 2 * \
+            (self.bleed_thickness + self.minimum_page_padding)
+        rows0 = int(printable_height //
+                    (self.image_height + self.space_between))
+        cols0 = int(printable_width // (self.image_width + self.space_between))
+        tiles_per_page0 = rows0 * cols0
+        rows1 = int(printable_height //
+                    (self.image_width + self.space_between))
+        cols1 = int(printable_width //
+                    (self.image_height + self.space_between))
+        tiles_per_page1 = rows1 * cols1
+
+        self.rotate_90deg = tiles_per_page1 > tiles_per_page0
+        if not self.rotate_90deg:
+            self.rows_per_page = rows0
+            self.cols_per_page = cols0
+            self.tiles_per_page = tiles_per_page0
+            self.tile_width = self.image_width
+            self.tile_height = self.image_height
+            self.pages = math.ceil(len(self.images) / tiles_per_page0)
+        else:
+            self.rows_per_page = rows1
+            self.cols_per_page = cols1
+            self.tiles_per_page = tiles_per_page1
+            self.tile_width = self.image_height
+            self.tile_height = self.image_width
+            self.pages = math.ceil(len(self.images) / tiles_per_page1)
+        print(
+            f"max tiles_per_page (rotated? {self.rotate_90deg}):{self.tiles_per_page} ({self.cols_per_page}x{self.rows_per_page}) pages:{self.pages}")
+
+        # work out padding
+        self.padding_left = (a4_width - self.cols_per_page * self.tile_width -
+                             (self.cols_per_page - 1) * self.space_between) / 2
+        self.padding_top = (a4_height - self.rows_per_page * self.tile_height -
+                            (self.rows_per_page - 1) * self.space_between) / 2
+        print(f"padding left:{self.padding_left} top:{self.padding_top}")
+
+        pdf = FPDF(orientation='P', format='A4', unit='mm')
+        for p in range(self.pages):
+            pdf.add_page()
+            # add bleed bg if needed
+            if self.bleed_thickness > 0:
+                for row in range(self.rows_per_page):
+                    for col in range(self.cols_per_page):
+                        idx = p * self.tiles_per_page + row * self.cols_per_page + col
+                        if idx < len(self.images):
+                            pdf.set_fill_color(*self.bleed_color)
+                            pdf.rect(w=self.tile_width + 2 * self.bleed_thickness,
+                                     h=self.tile_height + 2 * self.bleed_thickness,
+                                     x=self.padding_left + col *
+                                     (self.tile_width + self.space_between) -
+                                     self.bleed_thickness,
+                                     y=self.padding_top + row *
+                                     (self.tile_height + self.space_between) -
+                                     self.bleed_thickness,
+                                     style='F')
+            # add images
+            for row in range(self.rows_per_page):
+                for col in range(self.cols_per_page):
+                    idx = p * self.tiles_per_page + row * self.cols_per_page + col
+                    if idx < len(self.images):
+                        print('adding image', idx + 1)
+                        img = self.images[idx]
+                        if self.rotate_90deg:
+                            img = img.rotate(-90, expand=True)
+                        pdf.image(img, w=self.tile_width, h=self.tile_height, x=self.padding_left +
+                                  col * (self.tile_width + self.space_between), y=self.padding_top + row * (self.tile_height + self.space_between))
+
+    #         # add bleed bg
+    #         for row in range(3):
+    #             for col in range(3):
+    #                 if (p, row, col) in self.layout:
+    #                     image = self.layout[(p, row, col)]
+    #                     if image.width > image.height:
+    #                         image = image.rotate(-90, expand=True)
+    #                     pdf.image(image, w=card_width, h=card_height, x=padding_left +
+    #                               col * card_width, y=padding_top + row * card_height)
+        pdf.output(filename)
+
+    # def get_layout(self) -> Dict[Tuple[int, int, int], Image.Image]:
+    #     layout = {}
+    #     twosided = [c for c in self.cards if len(c.images) == 2]
+    #     onesided = [c for c in self.cards if len(c.images) == 1]
+    #     for card in twosided:
+    #         self.layout_2side(layout, card)
+    #     for card in onesided:
+    #         self.layout_1side(layout, card)
+    #     return layout
+
+    # @staticmethod
+    # def layout_2side(layout, card: ArkhamCard):
+    #     front, back = card.images
+    #     if front.width < front.height:
+    #         front = front.rotate(180)
+    #     for p in range(MAX_PAGES):
+    #         for c in range(3):
+    #             if (p, 0, c) not in layout:
+    #                 layout[(p, 0, c)] = back
+    #                 layout[(p, 1, c)] = front
+    #                 return
+    #     raise RuntimeError('Exceeded last page')
+
+    # @staticmethod
+    # def layout_1side(layout, card: ArkhamCard):
+    #     for p in range(MAX_PAGES):
+    #         for r in range(3):
+    #             for c in range(3):
+    #                 if (p, r, c) not in layout:
+    #                     layout[(p, r, c)] = card.image
+    #                     return
+    #     raise RuntimeError('Exceeded last page')
+
+    # def write(self, filename: str):
+    #     pdf = FPDF(orientation='P', format='A4', unit='in')
+    #     pages = max([p for (p, r, c) in self.layout]) + 1
+    #     for p in range(pages):
+    #         pdf.add_page()
+    #         # add bleed bg
+    #         for row in range(3):
+    #             for col in range(3):
+    #                 if (p, row, col) in self.layout:
+    #                     pdf.rect(w=card_width + 2 * bleed_thickness,
+    #                              h=card_height + 2 * bleed_thickness,
+    #                              x=padding_left + col * card_width - bleed_thickness,
+    #                              y=padding_top + row * card_height - bleed_thickness,
+    #                              style='F')
+    #         # add bleed bg
+    #         for row in range(3):
+    #             for col in range(3):
+    #                 if (p, row, col) in self.layout:
+    #                     image = self.layout[(p, row, col)]
+    #                     if image.width > image.height:
+    #                         image = image.rotate(-90, expand=True)
+    #                     pdf.image(image, w=card_width, h=card_height, x=padding_left +
+    #                               col * card_width, y=padding_top + row * card_height)
+    #     pdf.output(filename)

arkham_utils-0.1.0/pyproject.toml

@@ -0,0 +1,22 @@
+[tool.poetry]
+name = "arkham-utils"
+version = "0.1.0"
+description = "Arkham Horror LCG utilities"
+authors = ["Ian Su <iansu1979+github@gmail.com>"]
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.12"
+requests = "^2.29.0"
+Pillow = "^9.5.0"
+fpdf2 = "^2.7.4"
+PyMuPDF = "^1.24.5"
+requests-cache = "^1.2.1"
+platformdirs = "^4.3.7"
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^8.3.5"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"