### Install the library

Source: https://github.com/ppoelzl/pathofbuildingapi/blob/master/README.rst

Use pip to install the pobapi package.

```console
pip install pobapi
```

--------------------------------

### Install development dependencies

Source: https://github.com/ppoelzl/pathofbuildingapi/blob/master/README.rst

Use Poetry to install the necessary dependencies for local development.

```console
poetry install
```

--------------------------------

### Load Build from Pastebin URL

Source: https://context7.com/ppoelzl/pathofbuildingapi/llms.txt

Load a Path of Building build directly from a pastebin.com URL. Access basic character information such as class, ascendancy, level, and bandit choice. Also retrieves build notes.

```python
import pobapi

# Load build from pastebin URL
url = "https://pastebin.com/bQRjfedq"
build = pobapi.from_url(url, timeout=6.0)

# Access basic character info
print(f"Class: {build.class_name}")           # e.g., "Witch"
print(f"Ascendancy: {build.ascendancy_name}") # e.g., "Elementalist"
print(f"Level: {build.level}")                # e.g., 95
print(f"Bandit: {build.bandit}")              # e.g., "Alira" or None

# Access build notes
print(f"Notes: {build.notes}")
```

--------------------------------

### Working with Item Sets

Source: https://context7.com/ppoelzl/pathofbuildingapi/llms.txt

Access equipment slots and item sets within a build.

```python
import pobapi

build = pobapi.from_url("https://pastebin.com/bQRjfedq")

# Get the active item set
active_set = build.active_item_set

# Access specific equipment slots (returns item index or None)
# Note: Slot IDs are 0-indexed
slots = {
    'weapon1': active_set.weapon1,
    'weapon2': active_set.weapon2,
    'helmet': active_set.helmet,
    'body_armour': active_set.body_armour,
    'gloves': active_set.gloves,
    'boots': active_set.boots,
    'amulet': active_set.amulet,
    'ring1': active_set.ring1,
    'ring2': active_set.ring2,
    'belt': active_set.belt,
    'flask1': active_set.flask1,
    'flask2': active_set.flask2,
    'flask3': active_set.flask3,
    'flask4': active_set.flask4,
    'flask5': active_set.flask5,
}

# Get actual item from slot
items = build.items
for slot_name, item_index in slots.items():
    if item_index is not None:
        item = items[item_index]
        print(f"{slot_name}: {item.name}")
    else:
        print(f"{slot_name}: Empty")

# Access weapon swap slots
print(f"Weapon 1 Swap: {active_set.weapon1_swap}")
print(f"Weapon 2 Swap: {active_set.weapon2_swap}")

# Access abyssal socket slots
print(f"Helmet Abyssal Socket 1: {active_set.helmet_as1}")
print(f"Belt Abyssal Socket 1: {active_set.belt_as1}")

# Iterate through all item sets
for i, item_set in enumerate(build.item_sets):
    print(f"Item Set {i + 1}:")
    if item_set.body_armour is not None:
        print(f"  Body Armour: {items[item_set.body_armour].name}")
```

--------------------------------

### Access Build Configuration Settings

Source: https://context7.com/ppoelzl/pathofbuildingapi/llms.txt

Loads a Path of Building build from a URL and accesses various configuration settings. This includes general settings, combat conditions, charges, buffs, skill-specific configurations, enemy conditions, map mod simulations, and 'recently' conditions.

```python
import pobapi

build = pobapi.from_url("https://pastebin.com/bQRjfedq")

config = build.config

# General settings
print(f"Resistance Penalty: {config.resistance_penalty}")  # -60 after Kitava
print(f"Enemy Level: {config.enemy_level}")

# Combat conditions
print(f"Is Stationary: {config.is_stationary}")
print(f"Is Moving: {config.is_moving}")
print(f"On Full Life: {config.on_full_life}")
print(f"On Low Life: {config.on_low_life}")

# Charges
print(f"Using Power Charges: {config.use_power_charges}")
print(f"Using Frenzy Charges: {config.use_frenzy_charges}")
print(f"Using Endurance Charges: {config.use_endurance_charges}")

# Buffs
print(f"Fortify: {config.fortify}")
print(f"Onslaught: {config.onslaught}")
print(f"Tailwind: {config.tailwind}")
print(f"Focus: {config.focus}")
print(f"Adrenaline: {config.adrenaline}")

# Skill-specific config
print(f"Brand Attached: {config.brand_attached}")
print(f"Stance: {config.stance}")  # 'Blood' or 'Sand'
print(f"Infusion: {config.infusion}")

# Enemy conditions
print(f"Enemy Boss: {config.enemy_boss}")  # False, True, or 'Shaper'
print(f"Enemy Cursed: {config.enemy_cursed}")
print(f"Enemy Shocked: {config.enemy_shocked}")
print(f"Enemy Ignited: {config.enemy_ignited}")
print(f"Enemy Chilled: {config.enemy_chilled}")

# Map mod simulation
print(f"No Leech: {config.no_leech}")
print(f"No Regen: {config.no_regen}")
print(f"Enemy Hexproof: {config.enemy_hexproof}")

# "Recently" conditions
print(f"Hit Recently: {config.hit_recently}")
print(f"Killed Recently: {config.killed_recently}")
print(f"Crit Recently: {config.crit_recently}")
print(f"Been Hit Recently: {config.been_hit_recently}")
```

--------------------------------

### Analyze Complete Build Summary

Source: https://context7.com/ppoelzl/pathofbuildingapi/llms.txt

Analyzes a Path of Building build from a URL or import code and prints a comprehensive summary. This includes character overview, main skill details, defensive stats, offensive stats, active keystones, and unique items.

```python
import pobapi

def analyze_build(url_or_code):
    """Analyze a Path of Building build and print a summary."""

    # Load the build
    if url_or_code.startswith("https://"):
        build = pobapi.from_url(url_or_code)
    else:
        build = pobapi.from_import_code(url_or_code)

    # Character Overview
    print("=" * 50)
    print("CHARACTER OVERVIEW")
    print("=" * 50)
    print(f"Class: {build.class_name} / {build.ascendancy_name}")
    print(f"Level: {build.level}")
    print(f"Bandit: {build.bandit or 'Kill All'}")

    # Main Skill
    print(f"\nMain Skill: {build.active_skill.name}")
    print("Linked with:")
    for gem in build.active_skill_group.abilities:
        if gem.support:
            print(f"  + {gem.name} (Lv{gem.level})")

    # Defenses
    print("\n" + "=" * 50)
    print("DEFENSES")
    print("=" * 50)
    stats = build.stats
    print(f"Life: {stats.life}")
    if stats.energy_shield:
        print(f"Energy Shield: {stats.energy_shield}")
    print(f"Armour: {stats.armour}")
    print(f"Evasion: {stats.evasion}")
    print(f"\nResistances:")
    print(f"  Fire: {stats.fire_resistance}%")
    print(f"  Cold: {stats.cold_resistance}%")
    print(f"  Lightning: {stats.lightning_resistance}%")
    print(f"  Chaos: {stats.chaos_resistance}%")

    # Offense
    print("\n" + "=" * 50)
    print("OFFENSE")
    print("=" * 50)
    if stats.total_dps:
        print(f"Total DPS: {stats.total_dps:,.0f}")
    if stats.average_hit:
        print(f"Average Hit: {stats.average_hit:,.0f}")
    if stats.crit_chance:
        print(f"Crit Chance: {stats.crit_chance:.2f}%")
    if stats.crit_multiplier:
        print(f"Crit Multi: {stats.crit_multiplier:.0f}%")

    # Active Keystones
    print("\n" + "=" * 50)
    print("KEYSTONES")
    print("=" * 50)
    active_keystones = list(build.keystones)
    if active_keystones:
        for ks in active_keystones:
            print(f"  - {ks.replace('_', ' ').title()}")
    else:
        print("  None")

    # Unique Items
    print("\n" + "=" * 50)
    print("UNIQUE ITEMS")
    print("=" * 50)
    uniques = [item for item in build.items if item.rarity == "Unique"]
    for item in uniques:
        print(f"  - {item.name} ({item.base})")

    return build

# Usage
build = analyze_build("https://pastebin.com/bQRjfedq")
```

--------------------------------

### Handle Build Loading Errors

Source: https://context7.com/ppoelzl/pathofbuildingapi/llms.txt

Wraps build loading functions in try-except blocks to manage network exceptions and data decoding errors.

```python
import pobapi
import requests

def safe_load_build(url):
    """Safely load a build with proper error handling."""
    try:
        build = pobapi.from_url(url, timeout=10.0)
        return build
    except requests.URLRequired:
        print(f"Invalid URL: {url}")
    except requests.Timeout:
        print("Request timed out - try increasing timeout")
    except requests.ConnectionError:
        print("Network error - check your connection")
    except requests.HTTPError as e:
        print(f"HTTP error: {e}")
    except requests.TooManyRedirects:
        print("Too many redirects")
    except requests.RequestException as e:
        print(f"Request failed: {e}")
    return None

def safe_load_import_code(code):
    """Safely load a build from import code."""
    try:
        build = pobapi.from_import_code(code)
        return build
    except TypeError:
        print("Invalid import code format")
    except ValueError:
        print("Could not decode import code")
    return None

# Usage
build = safe_load_build("https://pastebin.com/bQRjfedq")
if build:
    print(f"Loaded: {build.class_name}")
```

--------------------------------

### Load Build from Import Code

Source: https://context7.com/ppoelzl/pathofbuildingapi/llms.txt

Load a Path of Building build directly from its import code string (base64 encoded). This method allows loading builds without needing a pastebin URL.

```python
import pobapi

# Load build from import code (base64 encoded string from PoB)
import_code = "eNrtWF1v2jAU_S8..."  # truncated for example
build = pobapi.from_import_code(import_code)

# Access character information
print(f"Class: {build.class_name}")
print(f"Ascendancy: {build.ascendancy_name}")
print(f"Level: {build.level}")
```

--------------------------------

### Access build data

Source: https://github.com/ppoelzl/pathofbuildingapi/blob/master/README.rst

Retrieve build information from a pastebin URL and access attributes like stats, skills, and items.

```python
>>> import pobapi
>>> url = "https://pastebin.com/bQRjfedq"
>>> build = pobapi.from_url(url)
>>> print(build.ascendancy_name)
Elementalist
>>> print(build.bandit)
None
>>> print(build.stats.life)
6911
>>> if  build.active_skill.name in ["Blade Vortex", "Vaal Blade Vortex"]:
...     if "Storm Brand" in build.skill_names:
...         print(build.config.brand_attached)
...
True
>>> for item in build.items:
...    if item.name == "Inpulsa's Broken Heart":
...        print(item)
...        break
...
Rarity: Unique
Name: Inpulsa's Broken Heart
Base: Sadist Garb
Quality: 20
Sockets: (('G', 'G', 'G', 'B', 'B', 'B'),)
LevelReq: 68
ItemLvl: 71
+64 to maximum Life
26% increased Damage if you have Shocked an Enemy Recently
33% increased Effect of Shock
Shocked Enemies you Kill Explode, dealing 5% of
their Maximum Life as Lightning Damage which cannot Shock
Unaffected by Shock
```

--------------------------------

### Working with Items

Source: https://context7.com/ppoelzl/pathofbuildingapi/llms.txt

Access properties of equipped items, including sockets, mods, and special attributes.

```python
import pobapi

build = pobapi.from_url("https://pastebin.com/bQRjfedq")

# Iterate through all items
for item in build.items:
    print(f"\n{item.name}")
    print(f"  Rarity: {item.rarity}")           # Normal, Magic, Rare, Unique
    print(f"  Base Type: {item.base}")
    print(f"  Item Level: {item.item_level}")
    print(f"  Level Requirement: {item.level_req}")

    if item.quality:
        print(f"  Quality: {item.quality}%")

    if item.sockets:
        # Sockets format: tuple of tuples, e.g., (('R', 'G', 'B'), ('B', 'B'))
        print(f"  Sockets: {item.sockets}")

    if item.shaper:
        print("  Shaper Item")
    if item.elder:
        print("  Elder Item")
    if item.crafted:
        print("  Has Crafted Mod")

    # Item mod text
    print(f"  Mods:\n{item.text}")

# Find specific item
for item in build.items:
    if item.name == "Inpulsa's Broken Heart":
        print(item)  # Uses __str__ for formatted output
        break

# Check which weapon set is active
if build.second_weapon_set:
    print("Using second weapon set")
```

--------------------------------

### Working with Passive Skill Trees

Source: https://context7.com/ppoelzl/pathofbuildingapi/llms.txt

Access skill tree URLs, allocated nodes, and jewel socket information.

```python
import pobapi

build = pobapi.from_url("https://pastebin.com/bQRjfedq")

# Get the active skill tree
tree = build.active_skill_tree
print(f"Tree URL: {tree.url}")
print(f"Allocated nodes: {len(tree.nodes)}")
print(f"Node IDs: {tree.nodes}")  # List of passive node IDs

# Get jewel socket assignments
# Format: {node_id: jewel_item_id}
for node_id, jewel_id in tree.sockets.items():
    print(f"Node {node_id} has jewel with ID {jewel_id}")

# Iterate through all saved trees
for i, tree in enumerate(build.trees):
    print(f"Tree {i + 1}: {len(tree.nodes)} nodes allocated")
    print(f"  URL: {tree.url}")
```

--------------------------------

### Clone the repository

Source: https://github.com/ppoelzl/pathofbuildingapi/blob/master/README.rst

Clone the source code from GitHub for development purposes.

```console
git clone https://github.com/ppoelzl/PathOfBuildingAPI.git
```

--------------------------------

### Work with Skills and Gems

Source: https://context7.com/ppoelzl/pathofbuildingapi/llms.txt

Access and process information about active skills, skill groups, and all equipped skill gems within a loaded Path of Building. This includes details like gem level, quality, and whether a skill is enabled or a support gem.

```python
import pobapi

build = pobapi.from_url("https://pastebin.com/bQRjfedq")

# Get the main active skill
active_skill = build.active_skill
print(f"Main Skill: {active_skill.name}")      # e.g., "Blade Vortex"
print(f"Level: {active_skill.level}")
print(f"Quality: {active_skill.quality}")
print(f"Enabled: {active_skill.enabled}")
print(f"Is Support: {active_skill.support}")

# Get the main skill group (linked gems)
skill_group = build.active_skill_group
print(f"Label: {skill_group.label}")
print(f"Enabled: {skill_group.enabled}")
print(f"Active Skill Index: {skill_group.active}")

# Iterate through all gems in the main skill group
for gem in skill_group.abilities:
    if hasattr(gem, 'quality'):  # It's a Gem
        print(f"  {gem.name} (Level {gem.level}, {gem.quality}% quality)")
    else:  # It's a GrantedAbility (from item)
        print(f"  {gem.name} (Level {gem.level}) - Granted by item")

# Get all skill groups
for i, group in enumerate(build.skill_groups):
    print(f"Skill Group {i + 1}: {group.label or 'Unnamed'}")
    for ability in group.abilities:
        support_str = " (Support)" if ability.support else ""
        print(f"  - {ability.name}{support_str}")
```

--------------------------------

### Working with Keystones

Source: https://context7.com/ppoelzl/pathofbuildingapi/llms.txt

Check which keystone passives are allocated in the build.

```python
import pobapi

build = pobapi.from_url("https://pastebin.com/bQRjfedq")

# Access keystones namespace
keystones = build.keystones

# Check individual keystones
print(f"Chaos Inoculation: {keystones.chaos_inoculation}")
print(f"Mind Over Matter: {keystones.mind_over_matter}")
print(f"Acrobatics: {keystones.acrobatics}")
print(f"Phase Acrobatics: {keystones.phase_acrobatics}")
print(f"Iron Reflexes: {keystones.iron_reflexes}")
print(f"Blood Magic: {keystones.blood_magic}")
print(f"Eldritch Battery: {keystones.eldritch_battery}")
print(f"Vaal Pact: {keystones.vaal_pact}")
print(f"Ghost Reaver: {keystones.ghost_reaver}")
print(f"Resolute Technique: {keystones.resolute_technique}")
print(f"Elemental Equilibrium: {keystones.elemental_equilibrium}")
print(f"Ancestral Bond: {keystones.ancestral_bond}")
print(f"Necromantic Aegis: {keystones.necromantic_aegis}")
print(f"Avatar of Fire: {keystones.avatar_of_fire}")
print(f"Point Blank: {keystones.point_blank}")
```

--------------------------------

### Accessing Skill Gems

Source: https://context7.com/ppoelzl/pathofbuildingapi/llms.txt

Retrieve and iterate through equipped skill gems in a build.

```python
# Get all skill gems (excludes item-granted abilities)
all_gems = build.skill_gems
print(f"Total gems equipped: {len(all_gems)}")
for gem in all_gems:
    print(f"  {gem.name}: Level {gem.level}, {gem.quality}% quality")

# Check for specific skills
skill_names = [gem.name for gem in build.skill_gems]
if "Storm Brand" in skill_names:
    print("Build uses Storm Brand!")
```

--------------------------------

### Iterate Over Active Keystones

Source: https://context7.com/ppoelzl/pathofbuildingapi/llms.txt

Iterates through a list of keystones and prints each active one. Assumes 'keystones' is a pre-defined iterable.

```python
print("\nActive Keystones:")
for keystone in keystones:
    print(f"  - {keystone}")
```

--------------------------------

### Access Character Stats

Source: https://context7.com/ppoelzl/pathofbuildingapi/llms.txt

Access all calculated character statistics, including defensive stats (life, energy shield, resistances), offensive stats (DPS, crit chance), DoT stats, and attributes. Requires a loaded build object.

```python
import pobapi

build = pobapi.from_url("https://pastebin.com/bQRjfedq")

# Defensive stats
print(f"Life: {build.stats.life}")                          # e.g., 6911
print(f"Energy Shield: {build.stats.energy_shield}")
print(f"Mana: {build.stats.mana}")
print(f"Life Regen: {build.stats.life_regen}")
print(f"Armour: {build.stats.armour}")
print(f"Evasion: {build.stats.evasion}")

# Resistances
print(f"Fire Resistance: {build.stats.fire_resistance}")
print(f"Cold Resistance: {build.stats.cold_resistance}")
print(f"Lightning Resistance: {build.stats.lightning_resistance}")
print(f"Chaos Resistance: {build.stats.chaos_resistance}")

# Offensive stats
print(f"Total DPS: {build.stats.total_dps}")
print(f"Average Hit: {build.stats.average_hit}")
print(f"Crit Chance: {build.stats.crit_chance}")
print(f"Crit Multiplier: {build.stats.crit_multiplier}")
print(f"Attack Speed: {build.stats.attack_speed}")
print(f"Cast Speed: {build.stats.cast_speed}")

# DoT stats
print(f"Bleed DPS: {build.stats.bleed_dps}")
print(f"Ignite DPS: {build.stats.ignite_dps}")
print(f"Poison DPS: {build.stats.poison_dps}")

# Attributes
print(f"Strength: {build.stats.strength}")
print(f"Dexterity: {build.stats.dexterity}")
print(f"Intelligence: {build.stats.intelligence}")

# Charges
print(f"Power Charges: {build.stats.power_charges_maximum}")
print(f"Frenzy Charges: {build.stats.frenzy_charges_maximum}")
print(f"Endurance Charges: {build.stats.endurance_charges_maximum}")
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.