0
# Junos PyEZ (junos-eznc)
1

2
A comprehensive Python library for remotely managing and automating Juniper Networks Junos devices through NETCONF protocol. The library enables both non-programmers and experienced developers to interact with Junos devices without requiring deep knowledge of Junos XML API or complex CLI screen scraping, providing device connectivity management, facts gathering, operational and configuration state retrieval, and common utilities for secure file operations and software updates.
3

4
## Package Information
5

6
- **Package Name**: junos-eznc
7
- **Language**: Python
8
- **Installation**: `pip install junos-eznc`
9
- **Python Version**: Requires Python >= 3.8
10

11
## Core Imports
12

13
```python
14
from jnpr.junos import Device
15
```
16

17
For console connections:
18

19
```python
20
from jnpr.junos import Console
21
```
22

23
For exception handling:
24

25
```python
26
from jnpr.junos import exception
27
```
28

29
## Basic Usage
30

31
```python
32
from jnpr.junos import Device
33

34
# Connect to a Junos device
35
dev = Device(host='192.168.1.1', user='admin', passwd='secret')
36
dev.open()
37

38
# Get device facts
39
print(f"Hostname: {dev.facts['hostname']}")
40
print(f"Model: {dev.facts['model']}")
41
print(f"Version: {dev.facts['version']}")
42

43
# Execute CLI commands
44
result = dev.cli('show version')
45
print(result)
46

47
# Execute RPC commands
48
interfaces = dev.rpc.get_interface_information()
49

50
# Close connection
51
dev.close()
52
```
53

54
## Architecture
55

56
Junos PyEZ is built around several key architectural components:
57

58
- **Device/Console Classes**: Core connection management for NETCONF and console sessions
59
- **RPC Meta-Execution**: Dynamic access to all Junos RPC operations through Python methods
60
- **Facts System**: Automatic gathering and caching of device information
61
- **Utility Framework**: Modular utilities for configuration, software management, and file operations
62
- **Factory System**: Structured data handling through YAML-defined tables and views
63
- **Exception Hierarchy**: Comprehensive error handling for all operation types
64

65
The design provides a Python-native abstraction layer over Junos device management that supports all Junos and Junos Evolved platforms, with built-in version independence and extensibility.
66

67
## Capabilities
68

69
### Device Connection Management
70

71
Core device connection functionality for NETCONF and console sessions, including authentication, session management, connectivity testing, and connection lifecycle management.
72

73
```python { .api }
74
class Device:
75
    def __init__(self, host=None, user=None, passwd=None, port=830, **kwargs): ...
76
    def open(self, **kwargs): ...
77
    def close(self): ...
78
    def probe(self, timeout=5): ...
79

80
class Console:
81
    def __init__(self, host=None, user='root', mode='telnet', **kwargs): ...
82
    def open(self, **kwargs): ...
83
    def close(self): ...
84
```
85

86
[Device Connection Management](./device-connection.md)
87

88
### Command and RPC Execution
89

90
Command execution capabilities including CLI commands, RPC operations, and XML processing for both structured and unstructured command output.
91

92
```python { .api }
93
def cli(self, command, format='text', warning=True): ...
94
def execute(self, rpc_cmd, **kwargs): ...
95
def display_xml_rpc(self, command, format='xml'): ...
96
```
97

98
[Command and RPC Execution](./command-execution.md)
99

100
### Configuration Management
101

102
Configuration management utilities for loading, committing, rolling back, and managing Junos device configurations with support for multiple formats and advanced commit options.
103

104
```python { .api }
105
class Config:
106
    def load(self, config_data, format='text', merge=False, overwrite=False, **kwargs): ...
107
    def commit(self, comment=None, confirm=None, timeout=None, **kwargs): ...
108
    def rollback(self, rb_id=0, timeout=None): ...
109
    def diff(self, rb_id=0, timeout=None): ...
110
    def lock(self): ...
111
    def unlock(self): ...
112
```
113

114
[Configuration Management](./configuration.md)
115

116
### Facts and Device Information
117

118
Device facts gathering system providing comprehensive device information including hardware details, software versions, network interfaces, and system status.
119

120
```python { .api }
121
def facts_refresh(self, **kwargs): ...
122

123
# Facts dictionary properties
124
facts: dict  # Complete device facts
125
hostname: str  # Device hostname
126
uptime: int  # Device uptime in seconds
127
```
128

129
[Facts and Device Information](./facts.md)
130

131
### Software Management
132

133
Software installation and management utilities for updating Junos software, managing software packages, and performing system operations like reboots.
134

135
```python { .api }
136
class SW:
137
    def install(self, package=None, remote_path='/var/tmp', progress=None, **kwargs): ...
138
    def reboot(self, in_min=0, at=None): ...
139
    def poweroff(self, in_min=0, at=None): ...
140
    def validate(self, remote_package, timeout=300): ...
141
```
142

143
[Software Management](./software.md)
144

145
### File System Operations
146

147
File system and transfer utilities for secure file operations, including SCP and FTP transfers, directory operations, and file management.
148

149
```python { .api }
150
class FS:
151
    # File system operations
152

153
class SCP:
154
    # Secure copy operations
155

156
class FTP:
157
    # FTP operations
158
```
159

160
[File System Operations](./filesystem.md)
161

162
### Operational Data Tables
163

164
Factory-based system for retrieving structured operational data from devices using YAML-defined tables and views for network protocols, interfaces, and system information.
165

166
```python { .api }
167
class Table:
168
    def get(self, **kwargs): ...
169
    def __iter__(self): ...
170

171
class View:
172
    # Data extraction and formatting
173
```
174

175
[Operational Data Tables](./operational-tables.md)
176

177
### Exception Handling
178

179
Comprehensive exception hierarchy for handling all types of errors including connection failures, RPC errors, configuration problems, and operational issues.
180

181
```python { .api }
182
class ConnectError(Exception): ...
183
class RpcError(Exception): ...
184
class CommitError(RpcError): ...
185
class ConfigLoadError(RpcError): ...
186
class LockError(RpcError): ...
187
```
188

189
[Exception Handling](./exceptions.md)
190

191
## Types
192

193
```python { .api }
194
# Connection parameters
195
ConnectionParams = dict  # host, user, passwd, port, timeout, etc.
196

197
# RPC response format
198
RpcResponse = dict  # Parsed RPC response data
199

200
# Facts dictionary
201
FactsDict = dict  # Device facts with standard keys
202

203
# Configuration data formats
204
ConfigData = str | dict  # Configuration in text, set, XML, or JSON format
205
```