Why bacpypes3 Defines class AnyAtomic(Any)

The Scenario

You are reading bacpypes3 source — or your IDE jumped to a definition — and you land on a line that reads class AnyAtomic(Any):. The name looks like a contradiction. "Atomic" in BACnet means a single primitive value, while Any sounds like an open, anything-goes container. Why would the atomic type inherit from the open one?

This usually surfaces in one of two ways. Either you are tracing how a Schedule object is built and want to know what type to hand bacpypes3, or you read a property back, expected a plain Python number or string, and got an AnyAtomic instance instead. Both lead to the same question: what is this class, and how do I work with it without fighting the encoder?

What AnyAtomic Represents

BACnet's abstract syntax (ASHRAE Standard 135) includes an open datatype written as ABSTRACT-SYNTAX.&Type. It is the BACnet equivalent of "a value whose datatype is not fixed by the schema — it is whatever the application tag on the wire says it is." A property declared with this datatype can carry a Real on Monday and an Enumerated on Tuesday, and the receiver decides what it is from the tag.

Standard 135 defines thirteen atomic (primitive, application-tagged) datatypes:

• Null
• Boolean
• Unsigned Integer
• Signed Integer
• Real (32-bit float)
• Double (64-bit float)
• Octet String
• Character String
• Bit String
• Enumerated
• Date
• Time
• Object Identifier

AnyAtomic is bacpypes3's model of an open value that is restricted to exactly one of those atomic types — no constructed types (no Sequence, no Array, no nested CHOICE). That restriction matters: several places in the standard allow "any primitive value" but explicitly forbid a constructed one, and AnyAtomic is how bacpypes3 enforces that boundary.

Why It Inherits From Any

The inheritance is the answer to the "contradiction." In bacpypes3, Any is the general open-type container. It holds the raw, application-tagged content and defers decoding until you cast it to a concrete type — that is what makes it able to carry "any" value. AnyAtomic subclasses Any to reuse that open encode/decode machinery, then narrows it: it accepts and validates a single atomic element and rejects constructed data.

This is the same pattern you see elsewhere in the library, where a type reuses a more general base and adds a constraint rather than reimplementing encoding from scratch. It mirrors the reasoning behind why bacpypes3 defines Real as a subclass of both Atomic and float — inheritance carries the protocol behavior, and the subclass pins down the specifics. Reading AnyAtomic(Any) the right way: "an open value (Any) that happens to be a single primitive."

Where You Actually Encounter It

The most common place is the Schedule object. In ASHRAE 135, a BACnetTimeValue is a SEQUENCE of a Time and a value, where that value is the open ABSTRACT-SYNTAX.&Type restricted to a primitive. A Schedule's Weekly_Schedule is an array of seven BACnetDailySchedule entries, each a list of those TimeValue pairs. So when you build or read a weekly schedule in bacpypes3, every setpoint value passes through AnyAtomic.

The Schedule object's Present_Value and Schedule_Default are also open primitive types for the same reason — a schedule might drive an analog setpoint, a binary state, or a multistate command, and the object cannot know which at design time. If you have hit type errors building a Weekly_Schedule, the related entry on bacpypes3 AnyAtomic and the get_value accessor walks through extracting the native value from what ReadProperty returns.

How to Find the Definition in Your Installed Release

Module paths and accessor names have moved between bacpypes3 releases, so rather than trust a path from a blog post, confirm where AnyAtomic lives in the exact version you have installed. Locate the package directory and grep for the class:

# Find where bacpypes3 is installed
python -c "import bacpypes3, os; print(os.path.dirname(bacpypes3.__file__))"

# Grep that directory for the class definition
grep -rn "class AnyAtomic" /path/printed/above

You will typically find the line reads class AnyAtomic(Any):, defined alongside Any and the other constructed/open types rather than next to the simple primitives. You can confirm the inheritance chain at runtime without reading the file:

import inspect
from bacpypes3.constructeddata import AnyAtomic  # confirm this import against your release

print(inspect.getsourcefile(AnyAtomic))
print(AnyAtomic.__mro__)

Treat the import line as something to verify, not copy blindly — if it raises ImportError, the grep above tells you the correct module for your version. The __mro__ output is the authoritative answer to "what does it inherit from" for the code actually running on your machine.

Common Pitfalls

• Expecting a native value back. A property typed as AnyAtomic does not return a bare Python float or str. It returns the wrapper, and you cast or unwrap it to the concrete atomic type. Comparing the wrapper directly to a number will silently behave differently than you expect.
• Trying to put a constructed value in it. AnyAtomic rejects Sequence, Array, and CHOICE content by design. If you need an open value that can hold a constructed type, that is plain Any, not AnyAtomic — check what the property's datatype actually requires in the standard.
• Assuming the module path from an old example. Code written for the original bacpypes (BACpypes, the pre-3 line) does not import cleanly into bacpypes3, and even within bacpypes3 the layout has shifted. Always confirm the import against your installed release with the grep above.
• Confusing AnyAtomic with Atomic. Atomic is the base mixin shared by the individual primitive classes (Real, Unsigned, CharacterString, and so on). AnyAtomic is the open container that can hold one of them. They are related but not interchangeable.

When to Escalate

If you have confirmed the inheritance and the atomic constraint but encoding still fails on a real device, the issue is usually the specific atomic type you are supplying, not AnyAtomic itself — a device may accept a Real where you sent an Unsigned, or reject a Null relinquish where you expected one. Capture the exchange and compare the application tag on the wire against what the device's PICS says the property accepts.

When the class definition or accessor genuinely differs from what any guide describes, the source of truth is the bacpypes3 project itself. Open an issue or check the discussions on the bacpypes3 GitHub repository rather than guessing, since the maintainer documents behavior changes there. For building custom BACnet applications on top of these types, see the bacpypes3 custom applications tutorial.

Source Attribution

The technical guidance in this entry is informed by the following sources:

• ASHRAE Standard 135 — BACnet—A Data Communication Protocol for Building Automation and Control Networks. The normative reference for the atomic datatypes, the ABSTRACT-SYNTAX.&Type open datatype, and the BACnetTimeValue / BACnetDailySchedule / Schedule object definitions.
• bacpypes3 — GitHub (JoelBender/BACpypes3) — the library source and documentation; the authoritative reference for the class definition and module layout in any given release.
• bacpypes3 on PyPI — release listing for confirming which version is installed before relying on a specific import path.

Additional testing and field validation by SiteConduit.