PyP6Xer

https://hassanemam.github.io/PyP6Xer
Admin
PyP6Xer is an open-source Python library for parsing, manipulating, and exporting Primavera P6 XER...
Tokens:77,532
Snippets:361
Trust Score:8.3
Update:1 month ago
Show doc for...
Tokens:
Raw
### Install PyP6Xer

Source: https://hassanemam.github.io/PyP6Xer/_sources/index.md.txt

Use pip to install the library in your Python environment.

```bash
pip install PyP6XER
```

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

### Install PyP6Xer from Source

Source: https://hassanemam.github.io/PyP6Xer/_sources/getting_started.md.txt

Alternative installation method for developers requiring the latest source code.

```bash
git clone https://github.com/HassanEmam/PyP6Xer.git
cd PyP6Xer
pip install -e .
```

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

### Verify PyP6Xer installation

Source: https://hassanemam.github.io/PyP6Xer/troubleshooting.html

Test the library by reading a sample XER file.

```python
import xerparser
from xerparser.reader import Reader

# Test with a sample XER file
try:
    xer = Reader("sample.xer")
    print("PyP6Xer installed successfully!")
    print(f"Projects found: {len(xer.projects)}")
except Exception as e:
    print(f"Installation issue: {e}")
```

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

### Install development dependencies

Source: https://hassanemam.github.io/PyP6Xer/_sources/contributing.md.txt

Commands to install the package in editable mode and required testing/documentation tools.

```bash
pip install -e .
pip install pytest pytest-cov sphinx sphinx-rtd-theme
```

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

### Google-style docstring example

Source: https://hassanemam.github.io/PyP6Xer/_sources/contributing.md.txt

Template for documenting functions using Google-style docstrings.

```python
def function_name(param1: str, param2: int) -> bool:
    """Brief description of the function.
    
    Longer description if needed.
    
    Args:
        param1: Description of param1
        param2: Description of param2
        
    Returns:
        Description of return value
        
    Raises:
        ValueError: Description of when this is raised
    """
```

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

### Test structure example

Source: https://hassanemam.github.io/PyP6Xer/_sources/contributing.md.txt

Example of a unit test structure for verifying reader functionality.

```python
def test_reader_loads_basic_xer_file():
    """Test that Reader can load a basic XER file."""
    reader = Reader("test_data/sample.xer")
    assert reader.projects.count > 0
    assert len(reader.activities) > 0
```

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

### Validate XER file format

Source: https://hassanemam.github.io/PyP6Xer/troubleshooting.html

Example error message and a function to verify file headers before loading.

```text
AttributeError: 'NoneType' object has no attribute 'strip'
```

```python
def validate_xer_file(filename):
    """Validate XER file format."""
    try:
        with open(filename, 'r', encoding='utf-8', errors='ignore') as f:
            first_line = f.readline()
            if not first_line.startswith('ERMHDR'):
                print("Warning: File doesn't appear to be a valid XER file")
                return False
        return True
    except Exception as e:
        print(f"File validation error: {e}")
        return False

# Use validation before loading
if validate_xer_file("project.xer"):
    xer = Reader("project.xer")
else:
    print("Invalid XER file")
```

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

### Load and Parse XER Files

Source: https://hassanemam.github.io/PyP6Xer/_sources/getting_started.md.txt

Demonstrates initializing the Reader and iterating through project metadata.

```python
from xerparser.reader import Reader

# Load the XER file
xer_file = Reader("sample.xer")

# Display basic information
print(f"Found {xer_file.projects.count} project(s)")

# Iterate through projects
for project in xer_file.projects:
    print(f"\nProject: {project.proj_short_name}")
    print(f"Project Name: {project.proj_name}")
    print(f"Start Date: {project.plan_start_date}")
    print(f"Finish Date: {project.plan_end_date}")
    print(f"Number of Activities: {len(project.activities)}")
```

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

### Run the test suite

Source: https://hassanemam.github.io/PyP6Xer/_sources/contributing.md.txt

Command to execute the project's test suite.

```bash
pytest
```

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

### Initialize Project Attributes

Source: https://hassanemam.github.io/PyP6Xer/_modules/xerparser/model/classes/project.html

These snippets demonstrate the initialization of various project attributes from a parameters dictionary, including date parsing and ID conversion.

```python
self.sum_refresh_date = params.get('sum_refresh_date').strip() if params.get('sum_refresh_date') else None
```

```python
self.trsrcsum_loaded = params.get('trsrcsum_loaded').strip() if params.get('trsrcsum_loaded') else None
```

```python
self.fintmpl_id = int(params.get('fintmpl_id').strip()) if params.get('fintmpl_id') else None
```

```python
self.sumtask_loaded = params.get('sumtask_loaded').strip() if params.get('sumtask_loaded') else None
```

```python
self.data = data
```

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

### Handle UnicodeDecodeError

Source: https://hassanemam.github.io/PyP6Xer/troubleshooting.html

Example error message and logic to attempt reading files with multiple encodings.

```text
UnicodeDecodeError: 'utf-8' codec can't decode byte 0x92 in position 1234
```

```python
# PyP6Xer handles this automatically, but if issues persist:
import codecs

# Try different encodings
encodings_to_try = ['utf-8', 'latin-1', 'cp1252', 'iso-8859-1']

for encoding in encodings_to_try:
    try:
        with codecs.open("project.xer", 'r', encoding=encoding) as f:
            content = f.read()
        print(f"File readable with {encoding} encoding")
        break
    except UnicodeDecodeError:
        continue
```

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

### Handle FileNotFoundError

Source: https://hassanemam.github.io/PyP6Xer/troubleshooting.html

Example error message and defensive coding patterns for file path validation.

```text
FileNotFoundError: [Errno 2] No such file or directory: 'project.xer'
```

```python
import os

# Check if file exists
if os.path.exists("project.xer"):
    xer = Reader("project.xer")
else:
    print("File not found. Check the file path.")

# Use absolute path
xer = Reader(r"C:\path\to\your\project.xer")
```

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

### Import and Load XER File

Source: https://hassanemam.github.io/PyP6Xer/_sources/quick_reference.md.txt

Initialize the Reader class with the path to your XER file.

```python
from xerparser.reader import Reader

# Load XER file
xer = Reader("project.xer")
```

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

### Publish release to PyPI

Source: https://hassanemam.github.io/PyP6Xer/_sources/contributing.md.txt

Use these commands to build the distribution and upload it to PyPI.

```bash
python setup.py sdist bdist_wheel
twine upload dist/*
```

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

### Get string representation of SchedOption

Source: https://hassanemam.github.io/PyP6Xer/_modules/xerparser/model/classes/schedoption.html

Returns the project ID associated with the scheduling option instance.

```python
def __repr__(self):
    return self.proj_id
```

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

### Safely access object properties

Source: https://hassanemam.github.io/PyP6Xer/troubleshooting.html

Example error message and a helper function to safely retrieve attributes.

```text
AttributeError: 'Task' object has no attribute 'some_property'
```

```python
# Always check if properties exist before accessing
def safe_get_property(obj, property_name, default=None):
    """Safely get object property."""
    return getattr(obj, property_name, default)

# Example usage
for activity in xer.activities:
    duration = safe_get_property(activity, 'target_drtn_hr_cnt', 0)
    start_date = safe_get_property(activity, 'target_start_date')
    
    if start_date:
        print(f"Activity: {activity.task_name}, Start: {start_date}")
```

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

### Create a virtual environment

Source: https://hassanemam.github.io/PyP6Xer/_sources/contributing.md.txt

Commands to create and activate a Python virtual environment.

```bash
python -m venv .venv
source .venv/bin/activate  # On Windows: .venv\Scripts\activate
```

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

### Handle None values in calculations

Source: https://hassanemam.github.io/PyP6Xer/troubleshooting.html

Example error message and techniques for handling missing data during arithmetic operations.

```text
TypeError: unsupported operand type(s) for +: 'NoneType' and 'float'
```

```python
# Handle None values in calculations
def safe_sum(values):
    """Sum values, treating None as 0."""
    return sum(v for v in values if v is not None)

# Example: Calculate total cost
total_cost = safe_sum([
    assignment.target_cost for assignment in xer.activityresources
])

# Or use default values
for assignment in xer.activityresources:
    cost = assignment.target_cost or 0  # Use 0 if None
    hours = assignment.target_qty or 0
```

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

### Write XER files

Source: https://hassanemam.github.io/PyP6Xer/_sources/examples.md.txt

Demonstrates loading an existing XER file and saving modifications to a new file.

```python
from xerparser.reader import Reader

# Load and modify data
xer = Reader("input.xer")

# Make modifications to the data...
# (See modification examples below)

# Write to a new file
xer.write("output.xer")
print("XER file written successfully")
```

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

### Initialize Project Parameters

Source: https://hassanemam.github.io/PyP6Xer/_modules/xerparser/model/classes/project.html

Extracts and cleans project attributes from a parameters dictionary, including handling date parsing for specific fields.

```python
self.scd_end_date = params.get('scd_end_date').strip() if params.get('scd_end_date') and params.get('scd_end_date').strip() else None


# Fix for add_date datetime parsing issue - check if not empty before parsing
try:
    self.add_date = datetime.strptime(params.get('add_date').strip(), '%Y-%m-%d %H:%M') if params.get('add_date') and params.get('add_date').strip() else None
except (ValueError, AttributeError):
    self.add_date = None
```

```python
self.last_tasksum_date = params.get('last_tasksum_date').strip() if params.get('last_tasksum_date') and params.get('last_tasksum_date').strip() else None
```

```python
self.fcst_start_date = params.get('fcst_start_date').strip() if params.get('fcst_start_date') and params.get('fcst_start_date').strip() else None
```

```python
self.def_duration_type = params.get('def_duration_type').strip() if params.get('def_duration_type') else None
```

```python
self.task_code_prefix = params.get('task_code_prefix').strip() if params.get('task_code_prefix') else None
```

```python
self.guid = params.get('guid').strip() if params.get('guid') else None
```

```python
self.def_qty_type = params.get('def_qty_type').strip() if params.get('def_qty_type') else None
```

```python
self.add_by_name = params.get('add_by_name').strip() if params.get('add_by_name') else None
```

```python
self.web_local_root_path = params.get('web_local_root_path').strip() if params.get('web_local_root_path') else None
```

```python
self.proj_url = params.get('proj_url').strip() if params.get('proj_url') else None
```

```python
self.def_rate_type = params.get('def_rate_type').strip() if params.get('def_rate_type') else None
```

```python
self.add_act_remain_flag = params.get('add_act_remain_flag').strip() if params.get('add_act_remain_flag') else None
```

```python
self.act_this_per_link_flag = params.get('act_this_per_link_flag').strip() if params.get('act_this_per_link_flag') else None
```

```python
self.def_task_type = params.get('def_task_type').strip() if params.get('def_task_type') else None
```

```python
self.act_pct_link_flag = params.get('act_pct_link_flag').strip() if params.get('act_pct_link_flag') else None
```

```python
self.critical_path_type = params.get('critical_path_type').strip() if params.get('critical_path_type') else None
```

```python
self.task_code_prefix_flag = params.get('task_code_prefix_flag').strip() if params.get('task_code_prefix_flag') else None
```

```python
self.def_rollup_dates_flag = params.get('def_rollup_dates_flag').strip() if params.get('def_rollup_dates_flag') else None
```

```python
self.use_project_baseline_flag = params.get('use_project_baseline_flag').strip() if params.get('use_project_baseline_flag') else None
```

```python
self.rem_target_link_flag = params.get('rem_target_link_flag').strip() if params.get('rem_target_link_flag') else None
```

```python
self.reset_planned_flag = params.get('reset_planned_flag').strip() if params.get('reset_planned_flag') else None
```

```python
self.allow_neg_act_flag = params.get('allow_neg_act_flag').strip() if params.get('allow_neg_act_flag') else None
```

```python
self.sum_assign_level = params.get('sum_assign_level').strip() if params.get('sum_assign_level') else None
```

```python
self.last_fin_dates_id = params.get('last_fin_dates_id').strip() if params.get('last_fin_dates_id') else None
```

```python
self.last_baseline_update_date = params.get('last_fin_dates_id').strip() if params.get('last_fin_dates_id') else None
```

```python
self.cr_external_key = params.get('cr_external_key').strip() if params.get('cr_external_key') else None
```

```python
self.apply_actuals_date = params.get('apply_actuals_date').strip() if params.get('apply_actuals_date') else None
```

```python
self.location_id = params.get('location_id') if params.get('location_id') else None
```

```python
self.loaded_scope_level = params.get('loaded_scope_level').strip() if params.get('loaded_scope_level') else None
```

```python
self.export_flag = params.get('export_flag').strip() if params.get('export_flag') else None
```

```python
self.new_fin_dates_id = params.get('new_fin_dates_id').strip() if params.get('new_fin_dates_id') else None
```

```python
self.baselines_to_export = params.get('baselines_to_export').strip() if params.get('baselines_to_export') else None
```

```python
self.baseline_names_to_export = params.get('baseline_names_to_export').strip() if params.get('baseline_names_to_export') else None
```

```python
self.next_data_date = params.get('next_data_date').strip() if params.get('next_data_date') else None
```

```python
self.close_period_flag = params.get('close_period_flag').strip() if params.get('close_period_flag') else None
```

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

### Filtering by Date Range

Source: https://hassanemam.github.io/PyP6Xer/_sources/quick_reference.md.txt

Filter activities based on a specific start date range using the datetime module.

```python
# Filter activities by date range
from datetime import datetime

start_date = datetime(2024, 1, 1)
end_date = datetime(2024, 12, 31)

filtered_activities = [
    act for p in xer.projects for act in p.activities
    if act.early_start_date and start_date <= act.early_start_date <= end_date
]
```

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

### Task date properties

Source: https://hassanemam.github.io/PyP6Xer/_modules/xerparser/model/classes/task.html

Properties to retrieve the effective start and end dates based on actual or target values.

```python
@property
    def start_date(self):
        if self.act_start_date:
            return self.act_start_date
        else:
            return self.target_start_date
```

```python
@property
    def end_date(self):
        if self.act_end_date:
            return self.act_end_date
        else:
            return self.target_end_date
```

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

### Clone the repository

Source: https://hassanemam.github.io/PyP6Xer/_sources/contributing.md.txt

Commands to clone the repository and navigate into the project directory.

```bash
git clone https://github.com/HassanEmam/PyP6Xer.git
cd PyP6Xer
```

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

### Manage memory for large files

Source: https://hassanemam.github.io/PyP6Xer/troubleshooting.html

Example error message and a wrapper function to manage garbage collection when loading large files.

```text
MemoryError: Unable to allocate array
```

```python
import gc

# For very large XER files, monitor memory usage
def load_large_xer(filename):
    """Load large XER files with memory management."""
    
    print("Loading large XER file...")
    
    # Force garbage collection before loading
gc.collect()
    
    try:
        xer = Reader(filename)
        print(f"Loaded successfully: {len(xer.activities)} activities")
        return xer
    except MemoryError:
        print("File too large for available memory")
        print("Consider:")
        print("- Splitting the XER file")
        print("- Using a machine with more RAM")
        print("- Processing subsets of data")
        return None

xer = load_large_xer("large_project.xer")
```

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

### Initialize Project Class

Source: https://hassanemam.github.io/PyP6Xer/_modules/xerparser/model/classes/project.html

The Project class constructor extracts and cleans various project attributes from the provided params dictionary.

```python
# PyP6XER
# Copyright (C) 2020, 2021 Hassan Emam <hassan@constology.com>
#
# This file is part of PyP6XER.
#
# PyP6XER library is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License v2.1 as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# PyP6XER is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with PyP6XER.  If not, see <https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html>.

from datetime import datetime
from xerparser.model.classes.wbs import WBS
from xerparser.model.tasks import Tasks
from xerparser.model.wbss import WBSs



[docs]
class Project:

    def __init__(self, params, data):

[docs]
        self.proj_id = int(params.get('proj_id').strip()) if params.get('proj_id') else None

[docs]
        self.fy_start_month_num = params.get('fy_start_month_num').strip() if params.get('fy_start_month_num') else None

[docs]
        self.rsrc_self_add_flag = params.get('rsrc_self_add_flag').strip() if params.get('rsrc_self_add_flag') else None

[docs]
        self.allow_complete_flag = params.get('allow_complete_flag').strip() if params.get('allow_complete_flag') else None

[docs]
        self.rsrc_multi_assign_flag = params.get('rsrc_multi_assign_flag').strip() if params.get('rsrc_multi_assign_flag') else None

[docs]
        self.checkout_flag = params.get('checkout_flag').strip() if params.get('checkout_flag') else None

[docs]
        self.project_flag = params.get('project_flag').strip() if params.get('project_flag') else None

[docs]
        self.step_complete_flag = params.get('step_complete_flag').strip() if params.get('step_complete_flag') else None

[docs]
        self.cost_qty_recalc_flag = params.get('cost_qty_recalc_flag').strip() if params.get('cost_qty_recalc_flag') else None

[docs]
        self.batch_sum_flag = params.get('batch_sum_flag').strip() if params.get('batch_sum_flag') else None

[docs]
        self.name_sep_char = params.get('name_sep_char').strip() if params.get('name_sep_char') else None

[docs]
        self.def_complete_pct_type = params.get('def_complete_pct_type').strip() if params.get('def_complete_pct_type') else None

[docs]
        self.proj_short_name = params.get('proj_short_name').strip() if params.get('proj_short_name') else None

[docs]
        self.acct_id = params.get('acct_id').strip() if params.get('acct_id') else None

[docs]
        self.orig_proj_id = params.get('orig_proj_id').strip() if params.get('orig_proj_id') else None

[docs]
        self.source_proj_id = params.get('source_proj_id').strip() if params.get('source_proj_id') else None

[docs]
        self.base_type_id = params.get('base_type_id').strip() if params.get('base_type_id') else None

[docs]
        self.clndr_id = params.get('clndr_id').strip() if params.get('clndr_id') else None

[docs]
        self.sum_base_proj_id = params.get('sum_base_proj_id').strip() if params.get('sum_base_proj_id') else None

[docs]
        self.task_code_base = params.get('task_code_base').strip() if params.get('task_code_base') else None

[docs]
        self.task_code_step = params.get('task_code_step').strip() if params.get('task_code_step') else None

[docs]
        self.priority_num = params.get('priority_num').strip() if params.get('priority_num') else None

[docs]
        self.wbs_max_sum_level = params.get('wbs_max_sum_level').strip() if params.get('wbs_max_sum_level') else None

[docs]
        self.strgy_priority_num = params.get('strgy_priority_num').strip() if params.get('strgy_priority_num') else None

[docs]
        self.last_checksum = params.get('last_checksum').strip() if params.get('last_checksum') else None

[docs]
        self.critical_drtn_hr_cnt = params.get('critical_drtn_hr_cnt').strip() if params.get('critical_drtn_hr_cnt') else None

[docs]
        self.def_cost_per_qty = params.get('def_cost_per_qty').strip() if params.get('def_cost_per_qty') else None

[docs]
        self.last_recalc_date = params.get('last_recalc_date').strip() if params.get('last_recalc_date') and params.get('last_recalc_date').strip() else None

[docs]
        self.plan_start_date = params.get('plan_start_date').strip() if params.get('plan_start_date') and params.get('plan_start_date').strip() else None

[docs]
        self.plan_end_date = params.get('plan_end_date').strip() if params.get('plan_end_date') and params.get('plan_end_date').strip() else None
```

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

### DCMA14.__init__

Source: https://hassanemam.github.io/PyP6Xer/_modules/xerparser/dcma14/analysis.html

Initializes the DCMA14 analysis object with a programme and optional thresholds for duration, lag, and total float.

```APIDOC
## Constructor: DCMA14(programme, duration_limit=1, lag_limit=0, tf_limit=0)

### Description
Initializes the analysis engine with the project programme and specific thresholds for quality metrics.

### Parameters
- **programme** (object) - Required - The project programme/schedule to analyze.
- **duration_limit** (int) - Optional - Threshold for activity duration analysis (default: 1).
- **lag_limit** (int) - Optional - Threshold for relationship lag analysis (default: 0).
- **tf_limit** (int) - Optional - Threshold for total float analysis (default: 0).
```

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

### Perform Network Analysis in Python

Source: https://hassanemam.github.io/PyP6Xer/_sources/examples.md.txt

Analyzes project network structure by counting relationship types and identifying start and end activities.

```python
def network_analysis(xer_file):
    """Analyze the project network structure."""
    
    activities = xer_file.activities.get_list()
    relationships = xer_file.relations.get_list()
    
    # Count relationship types
    relationship_types = {}
    for rel in relationships:
        rel_type = rel.pred_type
        relationship_types[rel_type] = relationship_types.get(rel_type, 0) + 1
    
    # Find activities with no predecessors (start activities)
    activity_ids = {a.task_id for a in activities}
    successor_ids = {r.task_id for r in relationships}
    start_activities = activity_ids - successor_ids
    
    # Find activities with no successors (end activities)
    predecessor_ids = {r.pred_task_id for r in relationships}
    end_activities = activity_ids - predecessor_ids
    
    print(f"NETWORK ANALYSIS")
    print(f"{'='*30}")
    print(f"Total Activities: {len(activities)}")
    print(f"Total Relationships: {len(relationships)}")
    print(f"Start Activities: {len(start_activities)}")
    print(f"End Activities: {len(end_activities)}")
    
    print(f"\nRelationship Types:")
    for rel_type, count in relationship_types.items():
        print(f"  {rel_type}: {count}")

# Usage
network_analysis(xer)
```

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

### Project Directory Structure

Source: https://hassanemam.github.io/PyP6Xer/contributing.html

Visual representation of the PyP6Xer repository layout, highlighting the core package, data models, and test suite locations.

```text
PyP6Xer/
├── xerparser/              # Main package
│   ├── __init__.py        # Package imports
│   ├── reader.py          # Main XER file reader
│   ├── write.py           # XER file writer
│   ├── model/             # Data model classes
│   │   ├── classes/       # Individual entity classes
│   │   │   ├── project.py # Project class
│   │   │   ├── task.py    # Task/Activity class
│   │   │   ├── resource.py# Resource class
│   │   │   └── ...        # Other classes
│   │   ├── projects.py    # Projects collection
│   │   ├── tasks.py       # Tasks collection
│   │   └── ...            # Other collections
│   └── dcma14/            # DCMA 14-point analysis
├── tests/                 # Test suite
├── docs/                  # Documentation
├── sample.xer            # Sample XER file
├── setup.py              # Package setup
└── README.md             # Project README
```

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

### Filter Project Activities

Source: https://hassanemam.github.io/PyP6Xer/_sources/examples.md.txt

Filters a list of activities using keyword arguments for status, start date, duration, and WBS name.

```python
def filter_activities(activities, **filters):
    """Filter activities based on various criteria."""
    
    filtered = activities
    
    # Filter by status
    if 'status' in filters:
        filtered = [a for a in filtered if a.status_code == filters['status']]
    
    # Filter by date range
    if 'start_after' in filters:
        start_date = filters['start_after']
        filtered = [a for a in filtered 
                   if a.act_start_date and a.act_start_date >= start_date]
    
    # Filter by duration
    if 'min_duration' in filters:
        min_dur = filters['min_duration']
        filtered = [a for a in filtered 
                   if a.target_drtn_hr_cnt and a.target_drtn_hr_cnt >= min_dur]
    
    # Filter by WBS
    if 'wbs_name' in filters:
        wbs_name = filters['wbs_name']
        filtered = [a for a in filtered 
                   if wbs_name.lower() in (a.wbs_name or "").lower()]
    
    return filtered

# Usage examples
project = xer.projects[0]
activities = project.activities

# Get all active activities
active = filter_activities(activities, status="TK_Active")

# Get long-duration activities (> 40 hours)
long_activities = filter_activities(activities, min_duration=40)

# Get activities in specific WBS
design_activities = filter_activities(activities, wbs_name="Design")
```

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

### Initialize reader

Source: https://hassanemam.github.io/PyP6Xer/_modules/xerparser/reader.html

Initialize the reader with a filename.

```python
    def __init__(self, filename):


[docs]
        self.file = filename
```

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

### Initialize Reader

Source: https://hassanemam.github.io/PyP6Xer/_modules/xerparser/reader.html

Instantiate the Reader class with a file path to begin parsing an XER file.

```python
from xerparser.reader import Reader
file = Reader('file.xer')
```

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

### Define the Account class

Source: https://hassanemam.github.io/PyP6Xer/_modules/xerparser/model/classes/account.html

Initializes an Account object by parsing specific keys from a provided dictionary.

```python
# PyP6XER
# Copyright (C) 2020, 2021 Hassan Emam <hassan@constology.com>
#
# This file is part of PyP6XER.
#
# PyP6XER library is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License v2.1 as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# PyP6XER is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with PyP6XER.  If not, see <https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html>




[docs]
class Account:
    # obj_list = []

    def __init__(self, params):


[docs]
        self.acct_id = int(params.get('acct_id').strip()) if params.get('acct_id') else None




[docs]
        self.parent_acct_id = int(params.get('parent_acct_id').strip()) if params.get('parent_acct_id') else None




[docs]
        self.acct_seq_num = int(params.get('acct_seq_num').strip()) if params.get('acct_seq_num') else None




[docs]
        self.acct_name = params.get('acct_name').strip() if params.get('acct_name') else None




[docs]
        self.acct_short_name = params.get('acct_short_name').strip() if params.get('acct_short_name') else None




[docs]
        self.acct_descr = params.get('acct_descr').strip() if params.get('acct_descr') else None


        # Account.obj_list.append(self)



[docs]
    def get_tsv(self):
        tsv = ["%R", self.acct_id, self.parent_acct_id, self.acct_seq_num, self.acct_name, self.acct_short_name,
               self.acct_descr]
        return tsv

    @classmethod


[docs]
    def find_by_id(cls, id):
        obj = list(filter(lambda x: x.acct_id == id, cls.obj_list))[0]
        return obj



[docs]
    def __repr__(self):
        return self.acct_name
```

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

### Analyze Resource Over-allocation in XER Files

Source: https://hassanemam.github.io/PyP6Xer/advanced_examples.html

Calculates daily resource usage by distributing target quantities over activity durations and identifies days exceeding 8 hours of work. Requires a Reader instance from the project library.

```python
def resource_leveling_analysis(xer_file):
    """Analyze resource conflicts and over-allocation."""
    
    xer = Reader(xer_file)
    
    print("RESOURCE LEVELING ANALYSIS")
    print("=" * 50)
    
    from collections import defaultdict
    from datetime import timedelta
    
    # Group assignments by resource and date
    resource_schedule = defaultdict(lambda: defaultdict(float))
    
    for assignment in xer.activityresources:
        if not assignment.target_qty or not assignment.target_start_date:
            continue
            
        # Find the activity to get duration
        activity = None
        for task in xer.activities:
            if task.task_id == assignment.task_id:
                activity = task
                break
        
        if not activity or not activity.target_start_date or not activity.target_end_date:
            continue
        
        # Simple daily allocation (assumes even distribution)
        duration_days = (activity.target_end_date - activity.target_start_date).days
        if duration_days <= 0:
            duration_days = 1
            
        daily_hours = assignment.target_qty / duration_days
        
        # Add to each day in the duration
        current_date = activity.target_start_date.date()
        end_date = activity.target_end_date.date()
        
        while current_date <= end_date:
            resource_schedule[assignment.rsrc_id][current_date] += daily_hours
            current_date += timedelta(days=1)
    
    # Find over-allocations
    overallocated_resources = {}
    for rsrc_id, schedule in resource_schedule.items():
        # Find resource details
        resource = None
        for r in xer.resources:
            if r.rsrc_id == rsrc_id:
                resource = r
                break
        
        if not resource:
            continue
        
        # Assume 8 hours per day max (could use calendar)
        max_daily_hours = 8
        
        overallocation_days = []
        for date, hours in schedule.items():
            if hours > max_daily_hours:
                overallocation_days.append((date, hours))
        
        if overallocation_days:
            overallocated_resources[resource] = overallocation_days
    
    # Report over-allocations
    print(f"Over-allocated Resources: {len(overallocated_resources)}")
    
    for resource, overallocations in overallocated_resources.items():
        print(f"\nResource: {resource.rsrc_name}")
        print(f"Over-allocation Days: {len(overallocations)}")
        
        # Show worst days
        worst_days = sorted(overallocations, key=lambda x: x[1], reverse=True)[:5]
        for date, hours in worst_days:
            print(f"  {date}: {hours:.1f} hours (excess: {hours-8:.1f})")

# Usage
resource_leveling_analysis("project.xer")
```

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

### Generate a Comprehensive Project Report

Source: https://hassanemam.github.io/PyP6Xer/advanced_examples.html

Parses an XER file to extract project metadata, activity statuses, critical path tasks, and resource summaries into a text file.

```python
def generate_project_report(xer_file, output_file="project_report.txt"):
    """Generate a comprehensive project report."""
    
    xer = Reader(xer_file)
    
    with open(output_file, 'w') as f:
        def write_line(text=""):
            f.write(text + "\n")
            print(text)
        
        write_line("PROJECT ANALYSIS REPORT")
        write_line("=" * 50)
        write_line(f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
        write_line()
        
        for project in xer.projects:
            write_line(f"PROJECT: {project.proj_short_name}")
            write_line(f"Full Name: {project.proj_name}")
            write_line(f"Start Date: {project.plan_start_date}")
            write_line(f"End Date: {project.plan_end_date}")
            write_line()
            
            activities = project.activities
            
            # Activity summary
            write_line("ACTIVITY SUMMARY")
            write_line("-" * 30)
            
            status_counts = {}
            for activity in activities:
                status = activity.status_code
                status_counts[status] = status_counts.get(status, 0) + 1
            
            write_line(f"Total Activities: {len(activities)}")
            for status, count in status_counts.items():
                status_name = {
                    "TK_NotStart": "Not Started",
                    "TK_Active": "In Progress",
                    "TK_Complete": "Complete"
                }.get(status, status)
                pct = (count / len(activities)) * 100
                write_line(f"  {status_name}: {count} ({pct:.1f}%)")
            
            write_line()
            
            # Critical path
            write_line("CRITICAL PATH")
            write_line("-" * 30)
            
            critical = [a for a in activities 
                       if a.total_float_hr_cnt is not None and a.total_float_hr_cnt <= 0]
            
            write_line(f"Critical Activities: {len(critical)}")
            for activity in critical[:10]:  # Top 10
                write_line(f"  {activity.task_code}: {activity.task_name}")
            
            write_line()
            
            # Resource summary
            write_line("RESOURCE SUMMARY")
            write_line("-" * 30)
            
            resource_types = {}
            for resource in xer.resources:
                rtype = resource.rsrc_type
                resource_types[rtype] = resource_types.get(rtype, 0) + 1
            
            for rtype, count in resource_types.items():
                type_name = {
                    "RT_Labor": "Labor",
                    "RT_Mat": "Material", 
                    "RT_Equip": "Equipment"
                }.get(rtype, rtype)
                write_line(f"  {type_name}: {count}")
            
            write_line()
    
    print(f"\nReport saved to: {output_file}")

# Usage
generate_project_report("project.xer")
```

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

### Create a feature branch

Source: https://hassanemam.github.io/PyP6Xer/_sources/contributing.md.txt

Command to create and switch to a new feature branch.

```bash
git checkout -b feature/your-feature-name
```

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

### Initialize act_work_qty attribute

Source: https://hassanemam.github.io/PyP6Xer/_modules/xerparser/model/classes/task.html

Parses the actual work quantity using locale settings.

```python
self.act_work_qty = locale.atof(params.get('act_work_qty')) if params.get('act_work_qty') else None
```

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

### Analyze Resource Costs in Python

Source: https://hassanemam.github.io/PyP6Xer/advanced_examples.html

Calculates and prints a cost breakdown by resource, including totals and variance, from an XER file. Requires the Reader class to be initialized with the target file.

```python
def resource_cost_analysis(xer_file):
    """Comprehensive resource cost breakdown."""
    
    xer = Reader(xer_file)
    
    print("RESOURCE COST ANALYSIS")
    print("=" * 50)
    
    from collections import defaultdict
    
    cost_breakdown = defaultdict(lambda: {
        'planned_cost': 0,
        'actual_cost': 0,
        'remaining_cost': 0,
        'assignments': 0
    })
    
    total_costs = {
        'planned': 0,
        'actual': 0,
        'remaining': 0
    }
    
    # Analyze each assignment
    for assignment in xer.activityresources:
        rsrc_id = assignment.rsrc_id
        
        # Get costs
        planned = assignment.target_cost or 0
        actual = (assignment.act_reg_cost or 0) + (assignment.act_ot_cost or 0)
        remaining = assignment.remain_cost or 0
        
        cost_breakdown[rsrc_id]['planned_cost'] += planned
        cost_breakdown[rsrc_id]['actual_cost'] += actual
        cost_breakdown[rsrc_id]['remaining_cost'] += remaining
        cost_breakdown[rsrc_id]['assignments'] += 1
        
        total_costs['planned'] += planned
        total_costs['actual'] += actual
        total_costs['remaining'] += remaining
    
    # Create resource lookup
    resource_lookup = {r.rsrc_id: r for r in xer.resources}
    
    # Sort by planned cost
    sorted_resources = sorted(
        cost_breakdown.items(),
        key=lambda x: x[1]['planned_cost'],
        reverse=True
    )
    
    print(f"Total Project Costs:")
    print(f"  Planned: ${total_costs['planned']:,.2f}")
    print(f"  Actual: ${total_costs['actual']:,.2f}")
    print(f"  Remaining: ${total_costs['remaining']:,.2f}")
    print(f"  Total (Actual + Remaining): ${total_costs['actual'] + total_costs['remaining']:,.2f}")
    
    if total_costs['planned'] > 0:
        variance = (total_costs['actual'] + total_costs['remaining']) - total_costs['planned']
        variance_pct = (variance / total_costs['planned']) * 100
        print(f"  Variance: ${variance:,.2f} ({variance_pct:+.1f}%)")
    
    print(f"\nTop 10 Resources by Planned Cost:")
    print("-" * 80)
    print(f"{'Resource':<30} {'Planned':>12} {'Actual':>12} {'Remaining':>12} {'Variance':>12}")
    print("-" * 80)
    
    for rsrc_id, costs in sorted_resources[:10]:
        resource = resource_lookup.get(rsrc_id)
        name = resource.rsrc_name if resource else f"Resource {rsrc_id}"
        
        planned = costs['planned_cost']
        actual = costs['actual_cost']
        remaining = costs['remaining_cost']
        variance = (actual + remaining) - planned
        
        print(f"{name:<30} ${planned:>11,.0f} ${actual:>11,.0f} ${remaining:>11,.0f} ${variance:>+11,.0f}")

# Usage
resource_cost_analysis("project.xer")
```

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

### Initialize target_work_qty attribute

Source: https://hassanemam.github.io/PyP6Xer/_modules/xerparser/model/classes/task.html

Parses the target work quantity using locale settings.

```python
self.target_work_qty = locale.atof(params.get('target_work_qty')) if params.get('target_work_qty') else None
```

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

### DCMA14 Class Constructor

Source: https://hassanemam.github.io/PyP6Xer/_sources/api/xerparser/dcma14/index.rst.txt

Initializes the DCMA14 analyzer with a project programme and specific thresholds for duration, lag, and total float.

```APIDOC
## Class: DCMA14(programme, duration_limit=1, lag_limit=0, tf_limit=0)

### Description
Initializes the DCMA 14-point assessment tool for a given project schedule.

### Parameters
- **programme** (object) - Required - The project programme/schedule to analyze.
- **duration_limit** (int) - Optional - Threshold for activity duration analysis (default: 1).
- **lag_limit** (int) - Optional - Threshold for relationship lag analysis (default: 0).
- **tf_limit** (int) - Optional - Threshold for total float analysis (default: 0).
```

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

### Reader(file)

Source: https://hassanemam.github.io/PyP6Xer/_modules/xerparser/reader.html

Initializes the Reader object by parsing the specified XER file.

```APIDOC
## Reader(file)

### Description
Initializes the main parser for XER files. It reads the provided file path and parses records into classes based on their types.

### Parameters
- **file** (string) - Required - The path to the XER file to be parsed.

### Example
```python
from xerparser.reader import Reader
file = Reader('file.xer')
```
```

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

### Export Project to JSON

Source: https://hassanemam.github.io/PyP6Xer/_sources/examples.md.txt

Converts project and activity data into a dictionary structure and saves it as a JSON file. Includes a helper function to serialize datetime objects to ISO format.

```python
import json
from datetime import datetime

def activity_to_dict(activity):
    """Convert activity to dictionary for JSON export."""
    
    def serialize_date(obj):
        if isinstance(obj, datetime):
            return obj.isoformat()
        return obj
    
    return {
        'task_id': activity.task_id,
        'task_code': activity.task_code,
        'task_name': activity.task_name,
        'status_code': activity.status_code,
        'duration_hours': activity.target_drtn_hr_cnt,
        'start_date': serialize_date(activity.act_start_date),
        'end_date': serialize_date(activity.act_end_date),
        'percent_complete': activity.phys_complete_pct,
        'total_float': activity.total_float_hr_cnt,
        'wbs_id': activity.wbs_id
    }

def export_project_to_json(project, filename):
    """Export project data to JSON."""
    
    project_data = {
        'project_info': {
            'id': project.proj_id,
            'short_name': project.proj_short_name,
            'name': project.proj_name,
            'status': project.status_code
        },
        'activities': [activity_to_dict(a) for a in project.activities]
    }
    
    with open(filename, 'w', encoding='utf-8') as jsonfile:
        json.dump(project_data, jsonfile, indent=2, ensure_ascii=False)
    
    print(f"Exported project to {filename}")

# Usage
project = xer.projects[0]
export_project_to_json(project, "project_data.json")
```

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

### Initialize Data class

Source: https://hassanemam.github.io/PyP6Xer/_modules/xerparser/model/classes/data.html

The Data class initializes with several attributes set to None, representing various project data components.

```python
[docs]
class Data:

    def __init__(self) -> None:


[docs]
        self.projects = None


[docs]
        self.wbss = None


[docs]
        self.tasks = None


[docs]
        self.resources = None


[docs]
        self.taskresource = None


[docs]
        self.taskactvcodes = None


[docs]
        self.predecessors = None
```

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

### DCMA14(programme, duration_limit=1, lag_limit=0, tf_limit=0)

Source: https://hassanemam.github.io/PyP6Xer/_sources/api/xerparser/dcma14/analysis/index.rst.txt

Initializes the DCMA 14-point analysis for a project schedule.

```APIDOC
## Constructor: DCMA14(programme, duration_limit=1, lag_limit=0, tf_limit=0)

### Description
Initializes the DCMA 14-point analysis engine for a given project schedule.

### Parameters
- **programme** (object) - Required - The project programme/schedule to analyze.
- **duration_limit** (int) - Optional - Threshold for activity duration analysis (default: 1).
- **lag_limit** (int) - Optional - Threshold for relationship lag analysis (default: 0).
- **tf_limit** (int) - Optional - Threshold for total float analysis (default: 0).
```

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

### Optimize Large Project Processing

Source: https://hassanemam.github.io/PyP6Xer/troubleshooting.html

Create lookup dictionaries for activities and resources to improve access speed when working with large projects.

```python
import time

def optimize_large_project_processing(xer):
    """Optimize processing for large projects."""
    
    start_time = time.time()
    
    # Create lookup dictionaries for faster access
    activity_lookup = {a.task_id: a for a in xer.activities}
    resource_lookup = {r.rsrc_id: r for r in xer.resources}
    
    print(f"Created lookups in {time.time() - start_time:.2f} seconds")
    
    # Use lookups instead of iterating
    def find_activity(task_id):
        return activity_lookup.get(task_id)
    
    def find_resource(rsrc_id):
        return resource_lookup.get(rsrc_id)
    
    return activity_lookup, resource_lookup

# Usage
activity_lookup, resource_lookup = optimize_large_project_processing(xer)
```

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

### Error Handling

Source: https://hassanemam.github.io/PyP6Xer/_sources/quick_reference.md.txt

Wrap the Reader initialization in a try-except block to handle file loading errors.

```python
from xerparser.reader import Reader

try:
    xer = Reader("project.xer")
    print(f"Successfully loaded {len(xer.projects)} projects")
except Exception as e:
    print(f"Error loading XER file: {e}")
```
Tokens:
Raw