anymous 1.3.0 → 1.3.2

package/skills/pdf/scripts/convert_pdf_to_images.py

@@ -1,33 +0,0 @@
-import os
-import sys
-
-from pdf2image import convert_from_path
-
-
-
-
-def convert(pdf_path, output_dir, max_dim=1000):
-    images = convert_from_path(pdf_path, dpi=200)
-
-    for i, image in enumerate(images):
-        width, height = image.size
-        if width > max_dim or height > max_dim:
-            scale_factor = min(max_dim / width, max_dim / height)
-            new_width = int(width * scale_factor)
-            new_height = int(height * scale_factor)
-            image = image.resize((new_width, new_height))
-        
-        image_path = os.path.join(output_dir, f"page_{i+1}.png")
-        image.save(image_path)
-        print(f"Saved page {i+1} as {image_path} (size: {image.size})")
-
-    print(f"Converted {len(images)} pages to PNG images")
-
-
-if __name__ == "__main__":
-    if len(sys.argv) != 3:
-        print("Usage: convert_pdf_to_images.py [input pdf] [output directory]")
-        sys.exit(1)
-    pdf_path = sys.argv[1]
-    output_directory = sys.argv[2]
-    convert(pdf_path, output_directory)

package/skills/pdf/scripts/create_validation_image.py

@@ -1,37 +0,0 @@
-import json
-import sys
-
-from PIL import Image, ImageDraw
-
-
-
-
-def create_validation_image(page_number, fields_json_path, input_path, output_path):
-    with open(fields_json_path, 'r') as f:
-        data = json.load(f)
-
-        img = Image.open(input_path)
-        draw = ImageDraw.Draw(img)
-        num_boxes = 0
-        
-        for field in data["form_fields"]:
-            if field["page_number"] == page_number:
-                entry_box = field['entry_bounding_box']
-                label_box = field['label_bounding_box']
-                draw.rectangle(entry_box, outline='red', width=2)
-                draw.rectangle(label_box, outline='blue', width=2)
-                num_boxes += 2
-        
-        img.save(output_path)
-        print(f"Created validation image at {output_path} with {num_boxes} bounding boxes")
-
-
-if __name__ == "__main__":
-    if len(sys.argv) != 5:
-        print("Usage: create_validation_image.py [page number] [fields.json file] [input image path] [output image path]")
-        sys.exit(1)
-    page_number = int(sys.argv[1])
-    fields_json_path = sys.argv[2]
-    input_image_path = sys.argv[3]
-    output_image_path = sys.argv[4]
-    create_validation_image(page_number, fields_json_path, input_image_path, output_image_path)

package/skills/pdf/scripts/extract_form_field_info.py

@@ -1,122 +0,0 @@
-import json
-import sys
-
-from pypdf import PdfReader
-
-
-
-
-def get_full_annotation_field_id(annotation):
-    components = []
-    while annotation:
-        field_name = annotation.get('/T')
-        if field_name:
-            components.append(field_name)
-        annotation = annotation.get('/Parent')
-    return ".".join(reversed(components)) if components else None
-
-
-def make_field_dict(field, field_id):
-    field_dict = {"field_id": field_id}
-    ft = field.get('/FT')
-    if ft == "/Tx":
-        field_dict["type"] = "text"
-    elif ft == "/Btn":
-        field_dict["type"] = "checkbox"  
-        states = field.get("/_States_", [])
-        if len(states) == 2:
-            if "/Off" in states:
-                field_dict["checked_value"] = states[0] if states[0] != "/Off" else states[1]
-                field_dict["unchecked_value"] = "/Off"
-            else:
-                print(f"Unexpected state values for checkbox `${field_id}`. Its checked and unchecked values may not be correct; if you're trying to check it, visually verify the results.")
-                field_dict["checked_value"] = states[0]
-                field_dict["unchecked_value"] = states[1]
-    elif ft == "/Ch":
-        field_dict["type"] = "choice"
-        states = field.get("/_States_", [])
-        field_dict["choice_options"] = [{
-            "value": state[0],
-            "text": state[1],
-        } for state in states]
-    else:
-        field_dict["type"] = f"unknown ({ft})"
-    return field_dict
-
-
-def get_field_info(reader: PdfReader):
-    fields = reader.get_fields()
-
-    field_info_by_id = {}
-    possible_radio_names = set()
-
-    for field_id, field in fields.items():
-        if field.get("/Kids"):
-            if field.get("/FT") == "/Btn":
-                possible_radio_names.add(field_id)
-            continue
-        field_info_by_id[field_id] = make_field_dict(field, field_id)
-
-
-    radio_fields_by_id = {}
-
-    for page_index, page in enumerate(reader.pages):
-        annotations = page.get('/Annots', [])
-        for ann in annotations:
-            field_id = get_full_annotation_field_id(ann)
-            if field_id in field_info_by_id:
-                field_info_by_id[field_id]["page"] = page_index + 1
-                field_info_by_id[field_id]["rect"] = ann.get('/Rect')
-            elif field_id in possible_radio_names:
-                try:
-                    on_values = [v for v in ann["/AP"]["/N"] if v != "/Off"]
-                except KeyError:
-                    continue
-                if len(on_values) == 1:
-                    rect = ann.get("/Rect")
-                    if field_id not in radio_fields_by_id:
-                        radio_fields_by_id[field_id] = {
-                            "field_id": field_id,
-                            "type": "radio_group",
-                            "page": page_index + 1,
-                            "radio_options": [],
-                        }
-                    radio_fields_by_id[field_id]["radio_options"].append({
-                        "value": on_values[0],
-                        "rect": rect,
-                    })
-
-    fields_with_location = []
-    for field_info in field_info_by_id.values():
-        if "page" in field_info:
-            fields_with_location.append(field_info)
-        else:
-            print(f"Unable to determine location for field id: {field_info.get('field_id')}, ignoring")
-
-    def sort_key(f):
-        if "radio_options" in f:
-            rect = f["radio_options"][0]["rect"] or [0, 0, 0, 0]
-        else:
-            rect = f.get("rect") or [0, 0, 0, 0]
-        adjusted_position = [-rect[1], rect[0]]
-        return [f.get("page"), adjusted_position]
-    
-    sorted_fields = fields_with_location + list(radio_fields_by_id.values())
-    sorted_fields.sort(key=sort_key)
-
-    return sorted_fields
-
-
-def write_field_info(pdf_path: str, json_output_path: str):
-    reader = PdfReader(pdf_path)
-    field_info = get_field_info(reader)
-    with open(json_output_path, "w") as f:
-        json.dump(field_info, f, indent=2)
-    print(f"Wrote {len(field_info)} fields to {json_output_path}")
-
-
-if __name__ == "__main__":
-    if len(sys.argv) != 3:
-        print("Usage: extract_form_field_info.py [input pdf] [output json]")
-        sys.exit(1)
-    write_field_info(sys.argv[1], sys.argv[2])

package/skills/pdf/scripts/extract_form_structure.py

@@ -1,115 +0,0 @@
-"""
-Extract form structure from a non-fillable PDF.
-
-This script analyzes the PDF to find:
-- Text labels with their exact coordinates
-- Horizontal lines (row boundaries)
-- Checkboxes (small rectangles)
-
-Output: A JSON file with the form structure that can be used to generate
-accurate field coordinates for filling.
-
-Usage: python extract_form_structure.py <input.pdf> <output.json>
-"""
-
-import json
-import sys
-import pdfplumber
-
-
-def extract_form_structure(pdf_path):
-    structure = {
-        "pages": [],
-        "labels": [],
-        "lines": [],
-        "checkboxes": [],
-        "row_boundaries": []
-    }
-
-    with pdfplumber.open(pdf_path) as pdf:
-        for page_num, page in enumerate(pdf.pages, 1):
-            structure["pages"].append({
-                "page_number": page_num,
-                "width": float(page.width),
-                "height": float(page.height)
-            })
-
-            words = page.extract_words()
-            for word in words:
-                structure["labels"].append({
-                    "page": page_num,
-                    "text": word["text"],
-                    "x0": round(float(word["x0"]), 1),
-                    "top": round(float(word["top"]), 1),
-                    "x1": round(float(word["x1"]), 1),
-                    "bottom": round(float(word["bottom"]), 1)
-                })
-
-            for line in page.lines:
-                if abs(float(line["x1"]) - float(line["x0"])) > page.width * 0.5:
-                    structure["lines"].append({
-                        "page": page_num,
-                        "y": round(float(line["top"]), 1),
-                        "x0": round(float(line["x0"]), 1),
-                        "x1": round(float(line["x1"]), 1)
-                    })
-
-            for rect in page.rects:
-                width = float(rect["x1"]) - float(rect["x0"])
-                height = float(rect["bottom"]) - float(rect["top"])
-                if 5 <= width <= 15 and 5 <= height <= 15 and abs(width - height) < 2:
-                    structure["checkboxes"].append({
-                        "page": page_num,
-                        "x0": round(float(rect["x0"]), 1),
-                        "top": round(float(rect["top"]), 1),
-                        "x1": round(float(rect["x1"]), 1),
-                        "bottom": round(float(rect["bottom"]), 1),
-                        "center_x": round((float(rect["x0"]) + float(rect["x1"])) / 2, 1),
-                        "center_y": round((float(rect["top"]) + float(rect["bottom"])) / 2, 1)
-                    })
-
-    lines_by_page = {}
-    for line in structure["lines"]:
-        page = line["page"]
-        if page not in lines_by_page:
-            lines_by_page[page] = []
-        lines_by_page[page].append(line["y"])
-
-    for page, y_coords in lines_by_page.items():
-        y_coords = sorted(set(y_coords))
-        for i in range(len(y_coords) - 1):
-            structure["row_boundaries"].append({
-                "page": page,
-                "row_top": y_coords[i],
-                "row_bottom": y_coords[i + 1],
-                "row_height": round(y_coords[i + 1] - y_coords[i], 1)
-            })
-
-    return structure
-
-
-def main():
-    if len(sys.argv) != 3:
-        print("Usage: extract_form_structure.py <input.pdf> <output.json>")
-        sys.exit(1)
-
-    pdf_path = sys.argv[1]
-    output_path = sys.argv[2]
-
-    print(f"Extracting structure from {pdf_path}...")
-    structure = extract_form_structure(pdf_path)
-
-    with open(output_path, "w") as f:
-        json.dump(structure, f, indent=2)
-
-    print(f"Found:")
-    print(f"  - {len(structure['pages'])} pages")
-    print(f"  - {len(structure['labels'])} text labels")
-    print(f"  - {len(structure['lines'])} horizontal lines")
-    print(f"  - {len(structure['checkboxes'])} checkboxes")
-    print(f"  - {len(structure['row_boundaries'])} row boundaries")
-    print(f"Saved to {output_path}")
-
-
-if __name__ == "__main__":
-    main()

package/skills/pdf/scripts/fill_fillable_fields.py

@@ -1,98 +0,0 @@
-import json
-import sys
-
-from pypdf import PdfReader, PdfWriter
-
-from extract_form_field_info import get_field_info
-
-
-
-
-def fill_pdf_fields(input_pdf_path: str, fields_json_path: str, output_pdf_path: str):
-    with open(fields_json_path) as f:
-        fields = json.load(f)
-    fields_by_page = {}
-    for field in fields:
-        if "value" in field:
-            field_id = field["field_id"]
-            page = field["page"]
-            if page not in fields_by_page:
-                fields_by_page[page] = {}
-            fields_by_page[page][field_id] = field["value"]
-    
-    reader = PdfReader(input_pdf_path)
-
-    has_error = False
-    field_info = get_field_info(reader)
-    fields_by_ids = {f["field_id"]: f for f in field_info}
-    for field in fields:
-        existing_field = fields_by_ids.get(field["field_id"])
-        if not existing_field:
-            has_error = True
-            print(f"ERROR: `{field['field_id']}` is not a valid field ID")
-        elif field["page"] != existing_field["page"]:
-            has_error = True
-            print(f"ERROR: Incorrect page number for `{field['field_id']}` (got {field['page']}, expected {existing_field['page']})")
-        else:
-            if "value" in field:
-                err = validation_error_for_field_value(existing_field, field["value"])
-                if err:
-                    print(err)
-                    has_error = True
-    if has_error:
-        sys.exit(1)
-
-    writer = PdfWriter(clone_from=reader)
-    for page, field_values in fields_by_page.items():
-        writer.update_page_form_field_values(writer.pages[page - 1], field_values, auto_regenerate=False)
-
-    writer.set_need_appearances_writer(True)
-    
-    with open(output_pdf_path, "wb") as f:
-        writer.write(f)
-
-
-def validation_error_for_field_value(field_info, field_value):
-    field_type = field_info["type"]
-    field_id = field_info["field_id"]
-    if field_type == "checkbox":
-        checked_val = field_info["checked_value"]
-        unchecked_val = field_info["unchecked_value"]
-        if field_value != checked_val and field_value != unchecked_val:
-            return f'ERROR: Invalid value "{field_value}" for checkbox field "{field_id}". The checked value is "{checked_val}" and the unchecked value is "{unchecked_val}"'
-    elif field_type == "radio_group":
-        option_values = [opt["value"] for opt in field_info["radio_options"]]
-        if field_value not in option_values:
-            return f'ERROR: Invalid value "{field_value}" for radio group field "{field_id}". Valid values are: {option_values}' 
-    elif field_type == "choice":
-        choice_values = [opt["value"] for opt in field_info["choice_options"]]
-        if field_value not in choice_values:
-            return f'ERROR: Invalid value "{field_value}" for choice field "{field_id}". Valid values are: {choice_values}'
-    return None
-
-
-def monkeypatch_pydpf_method():
-    from pypdf.generic import DictionaryObject
-    from pypdf.constants import FieldDictionaryAttributes
-
-    original_get_inherited = DictionaryObject.get_inherited
-
-    def patched_get_inherited(self, key: str, default = None):
-        result = original_get_inherited(self, key, default)
-        if key == FieldDictionaryAttributes.Opt:
-            if isinstance(result, list) and all(isinstance(v, list) and len(v) == 2 for v in result):
-                result = [r[0] for r in result]
-        return result
-
-    DictionaryObject.get_inherited = patched_get_inherited
-
-
-if __name__ == "__main__":
-    if len(sys.argv) != 4:
-        print("Usage: fill_fillable_fields.py [input pdf] [field_values.json] [output pdf]")
-        sys.exit(1)
-    monkeypatch_pydpf_method()
-    input_pdf = sys.argv[1]
-    fields_json = sys.argv[2]
-    output_pdf = sys.argv[3]
-    fill_pdf_fields(input_pdf, fields_json, output_pdf)

package/skills/pdf/scripts/fill_pdf_form_with_annotations.py

@@ -1,107 +0,0 @@
-import json
-import sys
-
-from pypdf import PdfReader, PdfWriter
-from pypdf.annotations import FreeText
-
-
-
-
-def transform_from_image_coords(bbox, image_width, image_height, pdf_width, pdf_height):
-    x_scale = pdf_width / image_width
-    y_scale = pdf_height / image_height
-
-    left = bbox[0] * x_scale
-    right = bbox[2] * x_scale
-
-    top = pdf_height - (bbox[1] * y_scale)
-    bottom = pdf_height - (bbox[3] * y_scale)
-
-    return left, bottom, right, top
-
-
-def transform_from_pdf_coords(bbox, pdf_height):
-    left = bbox[0]
-    right = bbox[2]
-
-    pypdf_top = pdf_height - bbox[1]      
-    pypdf_bottom = pdf_height - bbox[3]   
-
-    return left, pypdf_bottom, right, pypdf_top
-
-
-def fill_pdf_form(input_pdf_path, fields_json_path, output_pdf_path):
-    
-    with open(fields_json_path, "r") as f:
-        fields_data = json.load(f)
-    
-    reader = PdfReader(input_pdf_path)
-    writer = PdfWriter()
-    
-    writer.append(reader)
-    
-    pdf_dimensions = {}
-    for i, page in enumerate(reader.pages):
-        mediabox = page.mediabox
-        pdf_dimensions[i + 1] = [mediabox.width, mediabox.height]
-    
-    annotations = []
-    for field in fields_data["form_fields"]:
-        page_num = field["page_number"]
-
-        page_info = next(p for p in fields_data["pages"] if p["page_number"] == page_num)
-        pdf_width, pdf_height = pdf_dimensions[page_num]
-
-        if "pdf_width" in page_info:
-            transformed_entry_box = transform_from_pdf_coords(
-                field["entry_bounding_box"],
-                float(pdf_height)
-            )
-        else:
-            image_width = page_info["image_width"]
-            image_height = page_info["image_height"]
-            transformed_entry_box = transform_from_image_coords(
-                field["entry_bounding_box"],
-                image_width, image_height,
-                float(pdf_width), float(pdf_height)
-            )
-        
-        if "entry_text" not in field or "text" not in field["entry_text"]:
-            continue
-        entry_text = field["entry_text"]
-        text = entry_text["text"]
-        if not text:
-            continue
-        
-        font_name = entry_text.get("font", "Arial")
-        font_size = str(entry_text.get("font_size", 14)) + "pt"
-        font_color = entry_text.get("font_color", "000000")
-
-        annotation = FreeText(
-            text=text,
-            rect=transformed_entry_box,
-            font=font_name,
-            font_size=font_size,
-            font_color=font_color,
-            border_color=None,
-            background_color=None,
-        )
-        annotations.append(annotation)
-        writer.add_annotation(page_number=page_num - 1, annotation=annotation)
-        
-    with open(output_pdf_path, "wb") as output:
-        writer.write(output)
-    
-    print(f"Successfully filled PDF form and saved to {output_pdf_path}")
-    print(f"Added {len(annotations)} text annotations")
-
-
-if __name__ == "__main__":
-    if len(sys.argv) != 4:
-        print("Usage: fill_pdf_form_with_annotations.py [input pdf] [fields.json] [output pdf]")
-        sys.exit(1)
-    input_pdf = sys.argv[1]
-    fields_json = sys.argv[2]
-    output_pdf = sys.argv[3]
-    
-    fill_pdf_form(input_pdf, fields_json, output_pdf)

package/skills/pptx/LICENSE.txt

@@ -1,30 +0,0 @@
-© 2025 Anthropic, PBC. All rights reserved.
-
-LICENSE: Use of these materials (including all code, prompts, assets, files,
-and other components of this Skill) is governed by your agreement with
-Anthropic regarding use of Anthropic's services. If no separate agreement
-exists, use is governed by Anthropic's Consumer Terms of Service or
-Commercial Terms of Service, as applicable:
-https://www.anthropic.com/legal/consumer-terms
-https://www.anthropic.com/legal/commercial-terms
-Your applicable agreement is referred to as the "Agreement." "Services" are
-as defined in the Agreement.
-
-ADDITIONAL RESTRICTIONS: Notwithstanding anything in the Agreement to the
-contrary, users may not:
-
-- Extract these materials from the Services or retain copies of these
-  materials outside the Services
-- Reproduce or copy these materials, except for temporary copies created
-  automatically during authorized use of the Services
-- Create derivative works based on these materials
-- Distribute, sublicense, or transfer these materials to any third party
-- Make, offer to sell, sell, or import any inventions embodied in these
-  materials
-- Reverse engineer, decompile, or disassemble these materials
-
-The receipt, viewing, or possession of these materials does not convey or
-imply any license or right beyond those expressly granted above.
-
-Anthropic retains all right, title, and interest in these materials,
-including all copyrights, patents, and other intellectual property rights.