dballe.Var

Var holds a measured value, which can be integer, float or string, and a dballe.Varinfo with all available information (description, unit, precision, ...) related to it.

Var objects can be created from a dballe.Varinfo object, and an optional value. Omitting the value creates an unset variable.

Examples:

v = dballe.Var(table["B12101"], 32.5)
# v.info returns detailed informations about the variable in a Varinfo object.
print("%s: %s %s %s" % (v.code, str(v), v.info.unit, v.info.desc))

dballe.Varinfo

Varinfo object holds all possible information about a variable, such as its measurement unit, description and number of significant digits.

Varinfo objects cannot be instantiated directly, and are created by querying dballe.Vartable objects.

dballe.Vartable

Collection of Varinfo objects indexed by WMO BUFR/CREX table B code.

A Vartable is instantiated by the name (without extension) of the table file installed in wreport's data directory (normally, /usr/share/wreport/):

table = dballe.Vartable("B0000000000000023000")
print(table["B12101"].desc)

for i in table:
    print(i.code, i.desc)

dballe.Level

Level or layer.

Constructor: Level(ltype1: int=None, l1: int=None, ltype2: int=None, l2: int=None)

dballe.Trange

Time range.

Constructor: Trange(pind: int=None, p1: int=None, p2: int=None)

dballe.Station

Station information.

Constructor: Station(report: str, lat: float, lon: float, ident: str=None)

dballe.DBStation

Station information with database ID.

Constructor: Station(report: str, id: int, lat: float, lon: float, ident: str=None)

dballe.Data

key-value representation of a value with its associated metadata

dballe.BinaryMessage

Binary message.

This is basically a simple wrapper around a bytes() object, providing extra information about the filename, offset and index where the message data was read. Is it used by dballe.File to return the binary messages it reads.

dballe.File

Read-only access to files with weather bulletins in BUFR or CREX format.

No write functions are supported: to write files, you can simply write dballe.BinaryMessage objects or encoded messages to normal Python files.

Constructor: File(file: Union[str, File], encoding: str=None)

file can be a file name, or a file-like object. If a file-like object supports fileno(), that file descriptor is dup()-ed and used for efficient reading. Otherwise, file.read() is called to load the data to read in memory.

If encoding is omitted, it is auto detected by looking at the first byte of the file only. Files with leading padding data will not be detected properly, and you need to explicitly specify the encoding to read them.

Example usage:

with dballe.File("test.bufr", "BUFR") as f:
    for binmsg in f:
        print("#{m.index}: {m.pathname}:{m.offset}: {m.encoding} message".format(m=binmsg))

dballe.Message

The contents of a decoded BUFR or CREX message.

DB-All.e can interpret the contents of most weather messages commonly in use, and represent them as variables identified by dballe.Level, dballe.Trange, datetime, coordinates, network, and mobile station identifier.

A message contains only one reference station (coordinates, network, mobile station identifier), only one reference datetime, and many (level, trange, varcode, value) variables.

Variables that describe the station are accessible using None for level and trange.

Constructor: Message(type: str)

type is a string identifying the message type, and it will affect how the message will be encoded by the exporter.

Available values are:

• generic
• synop
• pilot
• temp
• temp_ship;
• airep
• amdar
• acars
• ship
• buoy
• metar
• sat

Example usage:

importer = dballe.Importer("BUFR")
with importer.from_file("test.bufr") as f:
    for msg in f:
        print("{m.report},{m.coords},{m.ident},{m.datetime},{m.type}".format(m=msg))

dballe.Importer

Message importer.

This is the engine that decodes binary messages and interprets their contents using a uniform data model.

Note that one binary message is often decoded to multiple data messages, in case, for example, of compressed BUFR files.

Constructor: Importer(encoding: str, simplified: bool=True)

encoding can be "BUFR" or "CREX".

simplified control whether messages are constructed using standard levels and time ranges, or using the exact levels and time ranges contained in the input. For example, a simplified intepretation of a synop message will place the temperature at 2M above ground, regardless of the reported sensor height. A non-simplified import will place the temperature reading at the reported sensor height.

When a message is imported in simplified mode, the actual context information will be stored as data attributes.

Example usage:

importer = dballe.Importer("BUFR")
with importer.from_file("test.bufr") as f:
    for msg in f:
        print("{m.report},{m.coords},{m.ident},{m.datetime},{m.type}".format(m=msg))

importer = dballe.Importer("BUFR")
with dbale.File("test.bufr") as f:
    for binmsg in f:
        msgs = importer.from_binary(binmsg)
        for msg in msgs:
            print("#{b.index}: {m.report},{m.coords},{m.ident},{m.datetime},{m.type}".format(b=binmsg, m=msg))

dballe.ImporterFile

Message importer iterating over the contents of a a dballe.File.

This is never instantiated explicitly, but is returned by Importer.from_file().

It can be used in a context manager, and it is an iterable that yields tuples of dballe.Message objects.

dballe.Exporter

Message exporter.

This is the engine that can reconstruct a standard BUFR or CREX message from the contents of a dballe.Message.

dballe.DB

DB-All.e database access.

Many methods are the same in dballe.DB and dballe.Transaction. The versions in dballe.DB are implemented by automatically creating a temporary transaction and running the equivalent dballe.Transaction method inside it.

dballe.DB objects are not constructed explicitly, but via one of the DB.connect or DB.connect_test class methods.

Examples:

# Connect to a database and run a query
db = dballe.DB.connect_from_file("db.sqlite")
query = {latmin=44.0, latmax=45.0, lonmin=11.0, lonmax=12.0}

# The result is a dballe.Cursor (dballe.CursorData in this case), which can
# be iterated to get results as dict objects.
for row in db.query_data(query):
    print(row["lat"], row["lon"], row["var"], row.var().format("undefined"))

# Insert 2 new variables in the database
db.insert_data({
    "lat": 44.5, "lon": 11.4,
    "level": dballe.Level(1),
    "trange": dballe.Trange(254),
    "date": datetime.datetime(2013, 4, 25, 12, 0, 0),
    "B11101": 22.4,
    "B12103": 17.2,
})

dballe.Transaction

DB-All.e transaction

A Transaction is used to execute DB operations in an all-or-nothing fashion. In fact, most DB methods are implemented using a short-lived temporary transaction.

You cannot have more than one active dballe.Transaction for each dballe.DB. An attempt to start a second one will result in an exception being raised. Note that dballe.DB functions like insert_data or export_to_file create a temporary transaction to run, and so they will also fail if a transaction is currently open. The general idea is that all database work should be done inside a transaction.

Transactions run using the REPEATABLE READ isolation level of the underlying database. This usually means that modifications performed inside a transaction are not visible to other database connections until the transaction is committed. If a transaction is rolled back, all changes done with it are undone.

Transactions can also be used as context managers, like this:

with db.transaction() as t:
    for i in range(10):
        t.insert({
            "lat": 44.5 + i, "lon": 11.4 + i, "level": (1,),
            "trange": (254,), "date": datetime.datetime(2013, 4, 25, 12, 0, 0),
            "B11101": 22.4 + i, "B12103": 17.2
        })

The dballe.Transaction methods are the same as those in dballe.DB. The version in dballe.DB is implemented by automatically creating a temporary transaction and running the dballe.Transaction method inside it.

dballe.CursorStation

A Cursor is the result of database queries. It is generally iterated through the contents of the result. Each iteration returns the cursor itself, that can be used to access the result values.

A Cursor works like a read-only dict to access data from the current result. The list of available keys is documented in doc/fapi_parms.md.

For example:

with self.db.query_data({...}) as cur:
    for row in cur:
        print("Station:", cur["station"])
        print("Var:", cur["var"], cur.enqf(cur["var"]))

dballe.CursorStationData

A Cursor is the result of database queries. It is generally iterated through the contents of the result. Each iteration returns the cursor itself, that can be used to access the result values.

A Cursor works like a read-only dict to access data from the current result. The list of available keys is documented in doc/fapi_parms.md.

For example:

with self.db.query_data({...}) as cur:
    for row in cur:
        print("Station:", cur["station"])
        print("Var:", cur["var"], cur.enqf(cur["var"]))

dballe.CursorData

A Cursor is the result of database queries. It is generally iterated through the contents of the result. Each iteration returns the cursor itself, that can be used to access the result values.

A Cursor works like a read-only dict to access data from the current result. The list of available keys is documented in doc/fapi_parms.md.

For example:

with self.db.query_data({...}) as cur:
    for row in cur:
        print("Station:", cur["station"])
        print("Var:", cur["var"], cur.enqf(cur["var"]))

dballe.CursorStationDB

A Cursor is the result of database queries. It is generally iterated through the contents of the result. Each iteration returns the cursor itself, that can be used to access the result values.

A Cursor works like a read-only dict to access data from the current result. The list of available keys is documented in doc/fapi_parms.md.

For example:

with self.db.query_data({...}) as cur:
    for row in cur:
        print("Station:", cur["station"])
        print("Var:", cur["var"], cur.enqf(cur["var"]))

dballe.CursorStationDataDB

A Cursor is the result of database queries. It is generally iterated through the contents of the result. Each iteration returns the cursor itself, that can be used to access the result values.

A Cursor works like a read-only dict to access data from the current result. The list of available keys is documented in doc/fapi_parms.md.

For example:

with self.db.query_data({...}) as cur:
    for row in cur:
        print("Station:", cur["station"])
        print("Var:", cur["var"], cur.enqf(cur["var"]))

dballe.CursorDataDB

A Cursor is the result of database queries. It is generally iterated through the contents of the result. Each iteration returns the cursor itself, that can be used to access the result values.

A Cursor works like a read-only dict to access data from the current result. The list of available keys is documented in doc/fapi_parms.md.

For example:

with self.db.query_data({...}) as cur:
    for row in cur:
        print("Station:", cur["station"])
        print("Var:", cur["var"], cur.enqf(cur["var"]))

dballe.CursorSummaryDB

A Cursor is the result of database queries. It is generally iterated through the contents of the result. Each iteration returns the cursor itself, that can be used to access the result values.

A Cursor works like a read-only dict to access data from the current result. The list of available keys is documented in doc/fapi_parms.md.

For example:

with self.db.query_data({...}) as cur:
    for row in cur:
        print("Station:", cur["station"])
        print("Var:", cur["var"], cur.enqf(cur["var"]))

dballe.CursorSummarySummary

A Cursor is the result of database queries. It is generally iterated through the contents of the result. Each iteration returns the cursor itself, that can be used to access the result values.

A Cursor works like a read-only dict to access data from the current result. The list of available keys is documented in doc/fapi_parms.md.

For example:

with self.db.query_data({...}) as cur:
    for row in cur:
        print("Station:", cur["station"])
        print("Var:", cur["var"], cur.enqf(cur["var"]))

dballe.CursorSummaryDBSummary

A Cursor is the result of database queries. It is generally iterated through the contents of the result. Each iteration returns the cursor itself, that can be used to access the result values.

A Cursor works like a read-only dict to access data from the current result. The list of available keys is documented in doc/fapi_parms.md.

For example:

with self.db.query_data({...}) as cur:
    for row in cur:
        print("Station:", cur["station"])
        print("Var:", cur["var"], cur.enqf(cur["var"]))

dballe.CursorMessage

A Cursor is the result of database queries. It is generally iterated through the contents of the result. Each iteration returns the cursor itself, that can be used to access the result values.

A Cursor works like a read-only dict to access data from the current result. The list of available keys is documented in doc/fapi_parms.md.

For example:

with self.db.query_data({...}) as cur:
    for row in cur:
        print("Station:", cur["station"])
        print("Var:", cur["var"], cur.enqf(cur["var"]))

dballe.Explorer

Browser for a summary of DB-All-e database of message contents

dballe.DBExplorer

Browser for a summary of DB-All-e database of message contents

dballe.ExplorerUpdate

Manage updates to an Explorer

dballe.DBExplorerUpdate

Manage updates to an Explorer