0
# High-Level Interface
1

2
Object-oriented interface providing Pythonic access to GRIB/BUFR data with automatic memory management, numpy integration, and iterator patterns for efficient data processing.
3

4
## Capabilities
5

6
### Message Classes
7

8
Object-oriented message interface with dictionary-like access.
9

10
```python { .api }
11
class Message:
12
    """
13
    High-level message interface with automatic memory management.
14
    """
15
    
16
    def __getitem__(self, key):
17
        """Get message key value."""
18
    
19
    def __setitem__(self, key, value):
20
        """Set message key value."""
21
    
22
    def keys(self):
23
        """Get all available keys."""
24
    
25
    @property
26
    def data(self):
27
        """Get data values as numpy array."""
28
    
29
    @property
30
    def shape(self):
31
        """Get data shape."""
32

33
class GRIBMessage(Message):
34
    """GRIB-specific message interface."""
35

36
class BUFRMessage(Message):
37
    """BUFR-specific message interface."""
38
```
39

40
### Reader Classes
41

42
Iterator classes for reading messages from files and streams.
43

44
```python { .api }
45
class FileReader:
46
    """
47
    Iterator for reading messages from files.
48
    
49
    Parameters:
50
    - filename (str): Path to GRIB/BUFR file
51
    - product_kind (int, optional): Message type filter
52
    """
53
    
54
    def __init__(self, filename, product_kind=None):
55
        pass
56
    
57
    def __iter__(self):
58
        """Return iterator."""
59
    
60
    def __next__(self):
61
        """Get next message."""
62

63
class StreamReader:
64
    """
65
    Iterator for reading messages from streams.
66
    
67
    Parameters:
68
    - stream: File-like object
69
    - product_kind (int, optional): Message type filter
70
    """
71
    
72
    def __init__(self, stream, product_kind=None):
73
        pass
74

75
class MemoryReader:
76
    """
77
    Iterator for reading messages from memory buffers.
78
    
79
    Parameters:
80
    - data (bytes): Binary message data
81
    """
82
    
83
    def __init__(self, data):
84
        pass
85
```
86

87
## Usage Examples
88

89
### Using FileReader for Simple Data Access
90

91
```python
92
from eccodes.highlevel import FileReader
93
import numpy as np
94

95
# Read all messages from file
96
for msg in FileReader('forecast.grib'):
97
    # Access metadata like dictionary
98
    param = msg['paramId']
99
    level = msg['level']
100
    date = msg['dataDate']
101
    
102
    # Get data as numpy array
103
    data = msg.data
104
    
105
    print(f"Parameter {param}, Level {level}")
106
    print(f"Data shape: {data.shape}")
107
    print(f"Data range: {data.min():.2f} to {data.max():.2f}")
108
    
109
    # Automatic memory management - no need to call codes_release
110
```
111

112
### Working with Message Objects
113

114
```python
115
from eccodes.highlevel import FileReader
116

117
with FileReader('analysis.grib') as reader:
118
    for msg in reader:
119
        # Dictionary-like access
120
        if msg['paramId'] == 130:  # Temperature
121
            # Modify message
122
            msg['level'] = 925  # Change level
123
            
124
            # Access grid information
125
            grid_shape = msg.shape
126
            ni, nj = msg['Ni'], msg['Nj']
127
            
128
            print(f"Grid: {ni}x{nj}, Shape: {grid_shape}")
129
            
130
            # Get available keys
131
            available_keys = list(msg.keys())
132
            print(f"Available keys: {len(available_keys)}")
133
```