elicdavis / associationengine Goto Github PK

We want to use tox to consolidate and standardizing testing frameworks. Helps test code against multiple versions of python quickly.

Must determine expected formatting for appropriate interfaces.

Need to implement wrappers for Matrix methods:

• get_value_matrix
• get_relationships_by_value_range

This needs to be done to avoid the end user needing to acquire an instance of AssociationMatrix and operate on it directly. Instead, the end user should only ever interact directly with an instance of Manager.

The snapper module must generate variable objects as needed from sensor objects supplied, rather than expect to be provided with the variables from outside the module.

Changes to the architecture have been made and we need to update the diagrams to reflect the new architecture.

We need to figure out what python server we want to use for our demos

This Serves Two Purposes

1. This spread sheet should be used for integration testing
2. What will be run as an example for the demo

Realistically, sensors don't follow perfect functions like Sine and Cosine.
Instead, we should have a sensors read a spreadsheet column to get it's values. This is a sufficient way to simulate "real-life" data.

The meat of the Snapper's functionality.

This will include the method for synchronizing values into a coherent snapshot in the event that they are out of line. This issue will be long-standing and will encompass multiple smaller issues for a while as we research the viability of different approaches.

Must actually implement proper aggregation to replace the simple echo placeholder

Need to create additional tests to cover more of the snapper module code base

Right now it's only returning see here. This needs to be implemented for Spearframe and determine values midway through calculations

Create a MockRelationship class that inherits from the Relationship class that makes testing the parts of the system easier and more reliable.

Implement a basic aggregation method to fill in for the final method in Issue #10 until we complete research.

This fill in method should just simply return the most recent value from each sensor for publishing to its corresponding variable and be written in a way that will allow for easy transition to the true algorithm by just simply reading from the built in data buffer.

Variable should be able to subscribe to Snapper and publish to the relationship subscribers

We currently believe that a dictionary using frozen sets containing variable uuids as keys would be the easiest and most efficient way to do this, but any new ideas are welcome as long as they can be implemented quickly.

Should return a relationship from the underlying matrix given a pair of sensors

• Determine effective data format (possibly a nested array?)
• Develop method to add relationship object
• Develop method to remove relationship object

Gary would like a way to be able to get the current value between two variables given only emitted values between two time intervals.

http://pandas.pydata.org/pandas-docs/stable/10min.html#

Need to restructure the module to have a clean interface via a manager class that creates and manages instances of Snapper, AssociationMatrix, and the Variables, Relationships, etc necessary for function internal to the system.

The 'on_data' function is spread across multiple different classes for subscribing which should be put in it's own interface.

Need to pass start and stop times for each snapshot upon forwarding.

Snapper should be able to subscribe to a Raw Sensor, and publish data to it's subscribers.

• Determine output format for interfacing with Variable
• Determine expected input value from Raw Sensor
• Implement algorithm to convert from input to output
• Implement actual publish-subscribe connections to Raw Sensor and Variable objects

Need to make certain methods and variables private, possibly adding new methods as well.

Should output as (timestamp, data) instead of just data