index
int64 0
731k
| package
stringlengths 2
98
⌀ | name
stringlengths 1
76
| docstring
stringlengths 0
281k
⌀ | code
stringlengths 4
1.07M
⌀ | signature
stringlengths 2
42.8k
⌀ |
|---|---|---|---|---|---|
46,251 |
easul.action
|
ResultStoreAction
|
Action which stores a result in the broker once an outcome has been obtained.
Result data is stored with an outcome prefix (e.g. outcome:[step-name])
|
class ResultStoreAction(Action):
"""
Action which stores a result in the broker once an outcome has been obtained.
Result data is stored with an outcome prefix (e.g. outcome:[step-name])
"""
data_source:str = "easul"
decision_steps = field(factory=list)
send_message = field(default=False)
def after_run(self, event):
if self.decision_steps and event.outcome.next_step.name not in self.decision_steps:
return
data = event.outcome.input_data.asdict() if hasattr(event.outcome, "input_data") else {}
data["result"] = event.outcome.result.asdict() if hasattr(event.outcome, "result") else None
if not event.outcome.context:
context = None
else:
context = event.outcome.context if type(event.outcome.context) is dict else event.outcome.context.asdict()
data["context"] = context
event.driver.store_data_in_broker(reference=event.driver.journey["reference"], data_type="outcome:" + event.outcome.outcome_step.name, data = data, external=True, send_message=self.send_message)
|
(*, decision_steps=NOTHING, send_message=False) -> None
|
46,252 |
easul.action
|
__eq__
|
Method generated by attrs for class ResultStoreAction.
|
"""
"""
import logging
from easul.algorithm.result import DefaultResult
from easul.outcome import ResultOutcome
LOG = logging.getLogger(__name__)
from attrs import define, field
class StopFlow(Exception):
pass
|
(self, other)
|
46,255 |
easul.action
|
__ne__
|
Method generated by attrs for class ResultStoreAction.
| null |
(self, other)
|
46,259 |
easul.action
|
after_run
| null |
def after_run(self, event):
if self.decision_steps and event.outcome.next_step.name not in self.decision_steps:
return
data = event.outcome.input_data.asdict() if hasattr(event.outcome, "input_data") else {}
data["result"] = event.outcome.result.asdict() if hasattr(event.outcome, "result") else None
if not event.outcome.context:
context = None
else:
context = event.outcome.context if type(event.outcome.context) is dict else event.outcome.context.asdict()
data["context"] = context
event.driver.store_data_in_broker(reference=event.driver.journey["reference"], data_type="outcome:" + event.outcome.outcome_step.name, data = data, external=True, send_message=self.send_message)
|
(self, event)
|
46,264 |
easul.algorithm.logic
|
ScoreAlgorithm
|
Score-based algorithm built from one or more factors. Also supports ranges and has a data schema.
|
class ScoreAlgorithm(Algorithm):
"""
Score-based algorithm built from one or more factors. Also supports ranges and has a data schema.
"""
schema: ds.DataSchema = field()
factors:List[Factor] = field()
ranges:List[Any] = field(factory=list)
start_score:int = field(default=0)
def single_result(self, data):
dset = ds.create_input_dataset(data, self.schema, allow_multiple=False)
matched = []
for factor in self.factors:
match = factor.calc_match(dset)
if match:
matched.append(match)
value = self._calculate_value(matched)
return ScoreResult(value=value, matched_factors=matched, label=self._find_label(value), ranges=self.ranges, data=dset)
def _find_label(self, value):
if not self.ranges:
return None
for rank, range in self.ranges.items():
try:
iter(range)
if range[0] is None and value<=range[1]:
return rank
if range[1] is None and value>=range[0]:
return rank
if (range[0] is not None and value>=range[0]) and (range[1] is not None and value<=range[1]):
return rank
except TypeError:
if range == value:
return rank
return None
def _calculate_value(self, matched):
value = self.start_score
for match in matched:
value = value + match.penalty
return value
|
(*, title: str, encoder=None, schema: easul.data.DataSchema, factors: List[easul.algorithm.factor.Factor], ranges: List[Any] = NOTHING, start_score: int = 0) -> None
|
46,265 |
easul.algorithm.logic
|
__eq__
|
Method generated by attrs for class ScoreAlgorithm.
|
from typing import List, Any
from .algorithm import Algorithm
import easul.data as ds
from .factor import Factor, FactorMatch
from .result import ScoreResult, CaseResult, Result
import logging
from attrs import define, field
from easul.expression import Case, Expression
LOG = logging.getLogger(__name__)
class Binary:
pass
|
(self, other)
|
46,268 |
easul.algorithm.logic
|
__ne__
|
Method generated by attrs for class ScoreAlgorithm.
| null |
(self, other)
|
46,272 |
easul.algorithm.logic
|
_calculate_value
| null |
def _calculate_value(self, matched):
value = self.start_score
for match in matched:
value = value + match.penalty
return value
|
(self, matched)
|
46,273 |
easul.algorithm.logic
|
_find_label
| null |
def _find_label(self, value):
if not self.ranges:
return None
for rank, range in self.ranges.items():
try:
iter(range)
if range[0] is None and value<=range[1]:
return rank
if range[1] is None and value>=range[0]:
return rank
if (range[0] is not None and value>=range[0]) and (range[1] is not None and value<=range[1]):
return rank
except TypeError:
if range == value:
return rank
return None
|
(self, value)
|
46,278 |
easul.algorithm.logic
|
single_result
| null |
def single_result(self, data):
dset = ds.create_input_dataset(data, self.schema, allow_multiple=False)
matched = []
for factor in self.factors:
match = factor.calc_match(dset)
if match:
matched.append(match)
value = self._calculate_value(matched)
return ScoreResult(value=value, matched_factors=matched, label=self._find_label(value), ranges=self.ranges, data=dset)
|
(self, data)
|
46,280 |
easul.algorithm.result
|
ScoreResult
|
Score-based result which also contains a list of matched factors, a label for the match and a set of score ranges.
|
class ScoreResult(Result):
"""
Score-based result which also contains a list of matched factors, a label for the match and a set of score ranges.
"""
label = field()
matched_factors = field(factory=list)
ranges = field(factory=dict)
def __repr__(self):
return f"<ScoreResult matched_factors={self.matched_factors}, value={self.value}, label={self.label}, ranges={self.ranges}>"
def __str__(self):
return self.__repr__()
def asdict(self):
return {
"matched_factors":[f.asdict() for f in self.matched_factors],
"value": self.value,
"label": self.label,
"ranges": self.ranges,
"data": self.data.asdict()
}
|
(*, value, data, label, matched_factors=NOTHING, ranges=NOTHING) -> None
|
46,281 |
easul.algorithm.result
|
__eq__
|
Method generated by attrs for class ScoreResult.
|
from collections import namedtuple
from typing import Optional
from attrs import define, field
import logging
LOG = logging.getLogger(__name__)
Probability = namedtuple("Probability",["probability","label","value"])
@define(kw_only=True, eq=False)
class Result:
"""
Base result class which at a simple level just returns a value.
"""
value = field()
data = field()
def asdict(self):
"""
Dictionary representation of the result used to store the object in databases etc.
Returns:
"""
return {
"value": self.value,
"data": self.data.asdict()
}
def __getitem__(self, item):
if not hasattr(self, item):
return None
return getattr(self, item)
def __eq__(self, other):
return self.asdict() == other.asdict()
|
(self, other)
|
46,285 |
easul.algorithm.result
|
__ne__
|
Method generated by attrs for class ScoreResult.
| null |
(self, other)
|
46,286 |
easul.algorithm.result
|
__repr__
| null |
def __repr__(self):
return f"<ScoreResult matched_factors={self.matched_factors}, value={self.value}, label={self.label}, ranges={self.ranges}>"
|
(self)
|
46,288 |
easul.algorithm.result
|
__str__
| null |
def __str__(self):
return self.__repr__()
|
(self)
|
46,289 |
easul.algorithm.result
|
asdict
| null |
def asdict(self):
return {
"matched_factors":[f.asdict() for f in self.matched_factors],
"value": self.value,
"label": self.label,
"ranges": self.ranges,
"data": self.data.asdict()
}
|
(self)
|
46,290 |
easul.algorithm.logic
|
SelectCaseAlgorithm
|
Algorithm based on cases, each of which are tested based on input data.
The CaseResult returned contains the true_value from the specific case
|
class SelectCaseAlgorithm(Algorithm):
"""
Algorithm based on cases, each of which are tested based on input data.
The CaseResult returned contains the true_value from the specific case
"""
cases:List[Case] = field()
default_value = field(default=False)
def single_result(self, data):
dset = ds.create_input_dataset(data, self.schema, allow_multiple=False)
for case in self.cases:
if case.test(dset) is True:
return CaseResult(value=case.true_value, matched_case=case, data=dset)
return CaseResult(value = self.default_value, matched_case=None, data=dset)
|
(*, title: str, schema: Any, encoder=None, cases: List[easul.expression.Case], default_value=False) -> None
|
46,291 |
easul.algorithm.logic
|
__eq__
|
Method generated by attrs for class SelectCaseAlgorithm.
|
from typing import List, Any
from .algorithm import Algorithm
import easul.data as ds
from .factor import Factor, FactorMatch
from .result import ScoreResult, CaseResult, Result
import logging
from attrs import define, field
from easul.expression import Case, Expression
LOG = logging.getLogger(__name__)
class Binary:
pass
|
(self, other)
|
46,294 |
easul.algorithm.logic
|
__ne__
|
Method generated by attrs for class SelectCaseAlgorithm.
| null |
(self, other)
|
46,302 |
easul.algorithm.logic
|
single_result
| null |
def single_result(self, data):
dset = ds.create_input_dataset(data, self.schema, allow_multiple=False)
for case in self.cases:
if case.test(dset) is True:
return CaseResult(value=case.true_value, matched_case=case, data=dset)
return CaseResult(value = self.default_value, matched_case=None, data=dset)
|
(self, data)
|
46,304 |
easul.decision
|
SelectCaseDecision
|
Decision which returns an outcome and next step based on a set of cases (StepCase objects).
|
class SelectCaseDecision(Decision):
"""
Decision which returns an outcome and next step based on a set of cases (StepCase objects).
"""
cases = field()
default_step = field(default=None)
def describe(self):
desc = super().describe()
desc.update({
"cases": [c.title for c in self.cases]
})
if self.default_step:
desc["default_step"] = self.default_step.title + "(" + self.default_step.name + ")"
return desc
def decide_outcome(self, result, context, data, step):
for case in self.cases:
if case.expression.evaluate(result):
return ResultOutcome(outcome_step=step, next_step=case.true_step, reason=case.expression.label,
input_data=data, context=context, result=result, value=None)
return ResultOutcome(outcome_step=step, next_step=self.default_step, reason="default",
input_data=data, context=context, result=result, value=None)
@property
def possible_links(self):
links = {case.title if case.title else case.expression.label: case.true_step for case in self.cases}
if self.default_step:
links["default"]=self.default_step
return links
|
(*, cases, default_step=None) -> None
|
46,305 |
easul.decision
|
__eq__
|
Method generated by attrs for class SelectCaseDecision.
|
from abc import abstractmethod
from attrs import define, field
from easul.algorithm import Result
from easul.outcome import Outcome, ResultOutcome
from easul.expression import DecisionCase
@define(kw_only=True)
class Decision:
"""
Decides the outcome based on the provided result and the type of decision. The outcome includes the next step,
the result and other contextual information.
"""
@abstractmethod
def decide_outcome(self, result, context, data, step):
pass
@property
def possible_links(self):
return {}
def describe(self):
return {
"type":self.__class__.__name__
}
|
(self, other)
|
46,308 |
easul.decision
|
__ne__
|
Method generated by attrs for class SelectCaseDecision.
| null |
(self, other)
|
46,313 |
easul.data
|
SingleDataInput
|
Data input containing a single row of inputs (e.g. dictionary or DataFrame) which follow the schema.
This is used to handle single element predictions/interpretations from user supplied values.
|
class SingleDataInput(DataInput):
"""
Data input containing a single row of inputs (e.g. dictionary or DataFrame) which follow the schema.
This is used to handle single element predictions/interpretations from user supplied values.
"""
def convert_data(self, data):
if not self._convert:
return data
data = self._convert_data(data, self.schema.x)
return data
def validate(self, data):
self._validate_data(data, self.schema.x)
@property
def Y(self):
raise ValueError("Y values are not available in SingleInputDataSet")
@property
def Y_scalar(self):
raise ValueError("Y scalar values are not available in SingleInputDataSet")
@property
def X_data(self):
return self.data
@property
def Y_data(self):
raise ValueError("Y data is not available in SingleInputDataSet")
def __getitem__(self, item):
return self._data[item][0]
def get(self, item, default=None):
try:
return self[item]
except ValueError:
return default
def asdict(self):
return self.data.to_dict("records")[0]
def clean(self, data):
new_data = {}
for column, value in data.items():
if column not in self.schema:
continue
new_data[column] = value
return new_data
|
(data, schema: easul.data.DataSchema, convert: bool = True, validate: bool = True, encoded_with=None, encoder=None)
|
46,314 |
easul.data
|
__getitem__
| null |
def __getitem__(self, item):
return self._data[item][0]
|
(self, item)
|
46,322 |
easul.data
|
asdict
| null |
def asdict(self):
return self.data.to_dict("records")[0]
|
(self)
|
46,323 |
easul.data
|
clean
| null |
def clean(self, data):
new_data = {}
for column, value in data.items():
if column not in self.schema:
continue
new_data[column] = value
return new_data
|
(self, data)
|
46,324 |
easul.data
|
convert_data
| null |
def convert_data(self, data):
if not self._convert:
return data
data = self._convert_data(data, self.schema.x)
return data
|
(self, data)
|
46,325 |
easul.data
|
get
| null |
def get(self, item, default=None):
try:
return self[item]
except ValueError:
return default
|
(self, item, default=None)
|
46,328 |
easul.data
|
validate
| null |
def validate(self, data):
self._validate_data(data, self.schema.x)
|
(self, data)
|
46,329 |
easul.process
|
SortList
|
Sort input record (which must be a list) based on the 'field_name'.
If reverse is set, sorting is in reverse.
|
class SortList:
"""
Sort input record (which must be a list) based on the 'field_name'.
If reverse is set, sorting is in reverse.
"""
field_name = field()
reverse = field(default=False)
def __call__(self, record):
if not isinstance(record, list):
raise AttributeError("'record' must be list")
return sorted(record, key=lambda x: x[self.field_name], reverse=self.reverse)
|
(*, field_name, reverse=False) -> None
|
46,330 |
easul.process
|
__call__
| null |
def __call__(self, record):
if not isinstance(record, list):
raise AttributeError("'record' must be list")
return sorted(record, key=lambda x: x[self.field_name], reverse=self.reverse)
|
(self, record)
|
46,331 |
easul.process
|
__eq__
|
Method generated by attrs for class SortList.
|
# processes are callables which receive a data structure and return a processed version of the data structure
# most of the processes defined here are classes but functions can work as well
from datetime import datetime, date, time
import logging
from typing import Callable, List, Dict, Optional
LOG = logging.getLogger(__name__)
from attrs import define, field
@define(kw_only=True)
class ExcludeFields:
"""
Exclude specified fields from the output data
"""
exclude_fields = field()
def __call__(self, record):
for exclude_field in self.exclude_fields:
if exclude_field in record.keys():
del record[exclude_field]
return record
|
(self, other)
|
46,334 |
easul.process
|
__ne__
|
Method generated by attrs for class SortList.
| null |
(self, other)
|
46,337 |
easul.source
|
Source
|
Base Source class. Sources provide access to raw data and processing which enables the creation of validated
InputData - which can be fed into algorithms.
|
class Source:
"""
Base Source class. Sources provide access to raw data and processing which enables the creation of validated
InputData - which can be fed into algorithms.
"""
title: str = field()
processes = field(factory=list)
def retrieve(self, driver, step):
"""
Retrieve data in the form of a Python data structure.
Args:
driver:
step:
Returns:
"""
data = self._retrieve_final_data(driver, step)
if not data:
raise StepDataNotAvailable(driver.journey, step.name, retry=False, source_title=self.title)
return data
def _retrieve_final_data(self, driver, step):
raw_data = self._retrieve_raw_data(driver, step)
return self._process_raw_data(raw_data)
@abstractmethod
def _retrieve_raw_data(self, driver, step):
pass
@property
def source_titles(self):
return [self.title]
def describe(self):
return {
"title":self.title,
"type":self.__class__.__name__,
}
def _process_raw_data(self, raw_data):
if raw_data is None:
raw_data = {}
for process in self.processes:
raw_data = process(raw_data)
return raw_data
|
(*, title: str, processes=NOTHING) -> None
|
46,338 |
easul.source
|
__eq__
|
Method generated by attrs for class Source.
|
import pandas as pd
from typing import List, Any, Dict
from easul.error import StepDataNotAvailable
import logging
from abc import abstractmethod
from attrs import define, field
from functools import partial
from easul.util import get_current_result
LOG = logging.getLogger(__name__)
@define(kw_only=True)
class Source:
"""
Base Source class. Sources provide access to raw data and processing which enables the creation of validated
InputData - which can be fed into algorithms.
"""
title: str = field()
processes = field(factory=list)
def retrieve(self, driver, step):
"""
Retrieve data in the form of a Python data structure.
Args:
driver:
step:
Returns:
"""
data = self._retrieve_final_data(driver, step)
if not data:
raise StepDataNotAvailable(driver.journey, step.name, retry=False, source_title=self.title)
return data
def _retrieve_final_data(self, driver, step):
raw_data = self._retrieve_raw_data(driver, step)
return self._process_raw_data(raw_data)
@abstractmethod
def _retrieve_raw_data(self, driver, step):
pass
@property
def source_titles(self):
return [self.title]
def describe(self):
return {
"title":self.title,
"type":self.__class__.__name__,
}
def _process_raw_data(self, raw_data):
if raw_data is None:
raw_data = {}
for process in self.processes:
raw_data = process(raw_data)
return raw_data
|
(self, other)
|
46,341 |
easul.source
|
__ne__
|
Method generated by attrs for class Source.
| null |
(self, other)
|
46,349 |
easul.step
|
StartStep
|
Start step in journey. The run logic searches for this to determine where the run should start.
|
class StartStep(PreStep):
"""
Start step in journey. The run logic searches for this to determine where the run should start.
"""
pass
|
(*, title, visual=None, exclude_from_chart=False, name=None, actions=NOTHING, source=None, next_step: easul.step.Step) -> None
|
46,350 |
easul.step
|
__eq__
|
Method generated by attrs for class StartStep.
|
from attrs import define, field
import logging
from easul.decision import BinaryDecision
LOG = logging.getLogger(__name__)
from easul.error import StepDataNotAvailable, ConversionError, InvalidStepData, VisualDataMissing, ValidationError
from enum import Enum, auto
from easul.outcome import Outcome, EndOutcome, PauseOutcome, InvalidDataOutcome, MissingDataOutcome
from abc import abstractmethod
NO_VISUAL_IN_STEP_MESSAGE = "Sorry no visual for this step"
@define(kw_only=True)
class Step:
"""
Base Step class. Steps are the driving force of plans, they bring the different components together.
The key things are 'visual' components which provide graphical views associated with steps and 'actions' which
define action classes that occur during the lifecycle of a step run.
"""
title = field()
visual = field(default=None)
exclude_from_chart = field(default=False)
name = field(default=None)
actions = field(factory=list)
def layout_kwargs(self, driver, steps, **kwargs):
return {"steps":steps, "driver":driver, "step":self, **kwargs}
def render_visual(self, driver: "easul.driver.Driver", steps, result=None, context=None, renderer=None, **kwargs):
"""
Render visual to HTML utilising the data in the broker (if not supplied) and the supplied renderer
Args:
driver:
steps:
result:
context:
renderer:
**kwargs:
Returns:
"""
if not self.visual:
return NO_VISUAL_IN_STEP_MESSAGE
if not result and not context:
b_data = driver.get_broker_data("outcome:" + self.name)
if b_data:
result = b_data.get("result")
context = b_data.get("context")
try:
return self.visual.render(driver=driver, steps=steps, step=self, result=result, context=context, renderer=renderer)
except VisualDataMissing as ex:
return str(ex)
@property
def possible_links(self):
return {}
@property
def data_sources(self):
return []
def _trigger_actions(self, trigger_type, event):
for action in self.actions:
getattr(action, trigger_type)(event)
def _generate_visual_context(self, data):
return self.visual.generate_context(data) if self.visual else None
def __repr__(self):
return self.name
def describe(self):
"""
Describe step as Python data structures (lists and dicts)
Returns:
"""
return {
"name": self.name,
"title": self.title,
"actions": [a.describe() for a in self.actions],
"visual":self.visual.describe() if self.visual else "N/A"
}
|
(self, other)
|
46,353 |
easul.step
|
__ne__
|
Method generated by attrs for class StartStep.
| null |
(self, other)
|
46,366 |
easul.state
|
State
|
State class which contains a 'label' and defines a 'default' and 'possible_states'
|
class State:
"""
State class which contains a 'label' and defines a 'default' and 'possible_states'
"""
label: str = field()
default: str = field()
possible_states:Optional[List] = field(factory=list)
def describe(self):
return {
"label": self.label,
"type": self.__class__.__name__,
}
|
(*, label: str, default: str, possible_states: Optional[List] = NOTHING) -> None
|
46,367 |
easul.state
|
__eq__
|
Method generated by attrs for class State.
|
from attrs import field, define
from typing import List, Optional
@define(kw_only=True)
class State:
"""
State class which contains a 'label' and defines a 'default' and 'possible_states'
"""
label: str = field()
default: str = field()
possible_states:Optional[List] = field(factory=list)
def describe(self):
return {
"label": self.label,
"type": self.__class__.__name__,
}
|
(self, other)
|
46,370 |
easul.state
|
__ne__
|
Method generated by attrs for class State.
| null |
(self, other)
|
46,373 |
easul.state
|
describe
| null |
def describe(self):
return {
"label": self.label,
"type": self.__class__.__name__,
}
|
(self)
|
46,374 |
easul.source
|
StateSource
|
Source which uses the client to get a specific current 'state' and puts it in the 'output_field'.
|
class StateSource(Source):
"""
Source which uses the client to get a specific current 'state' and puts it in the 'output_field'.
"""
state = field()
output_field = field()
def _retrieve_final_data(self, driver, step):
state = driver._client.get_current_state(state_label=self.state.label, journey_id=driver.journey_id, timestamp=driver.clock.timestamp)
if not state:
return None
data = { self.output_field : state["status"]}
return data
|
(*, title: str, processes=NOTHING, state, output_field) -> None
|
46,375 |
easul.source
|
__eq__
|
Method generated by attrs for class StateSource.
|
import pandas as pd
from typing import List, Any, Dict
from easul.error import StepDataNotAvailable
import logging
from abc import abstractmethod
from attrs import define, field
from functools import partial
from easul.util import get_current_result
LOG = logging.getLogger(__name__)
@define(kw_only=True)
class Source:
"""
Base Source class. Sources provide access to raw data and processing which enables the creation of validated
InputData - which can be fed into algorithms.
"""
title: str = field()
processes = field(factory=list)
def retrieve(self, driver, step):
"""
Retrieve data in the form of a Python data structure.
Args:
driver:
step:
Returns:
"""
data = self._retrieve_final_data(driver, step)
if not data:
raise StepDataNotAvailable(driver.journey, step.name, retry=False, source_title=self.title)
return data
def _retrieve_final_data(self, driver, step):
raw_data = self._retrieve_raw_data(driver, step)
return self._process_raw_data(raw_data)
@abstractmethod
def _retrieve_raw_data(self, driver, step):
pass
@property
def source_titles(self):
return [self.title]
def describe(self):
return {
"title":self.title,
"type":self.__class__.__name__,
}
def _process_raw_data(self, raw_data):
if raw_data is None:
raw_data = {}
for process in self.processes:
raw_data = process(raw_data)
return raw_data
|
(self, other)
|
46,378 |
easul.source
|
__ne__
|
Method generated by attrs for class StateSource.
| null |
(self, other)
|
46,382 |
easul.source
|
_retrieve_final_data
| null |
def _retrieve_final_data(self, driver, step):
state = driver._client.get_current_state(state_label=self.state.label, journey_id=driver.journey_id, timestamp=driver.clock.timestamp)
if not state:
return None
data = { self.output_field : state["status"]}
return data
|
(self, driver, step)
|
46,386 |
easul.source
|
StaticSource
|
Source which gets data from a 'source_data' property which contains specific journey data.
The data is supplied as a dictionary:
source_data = {
"JOURNEY_REF_1": {"x1":1, "x2":2, "x3":3},
"JOURNEY_REF_2": {"x1":2, "x2":4, "x3":6}
}
e.g.
|
class StaticSource(Source):
"""
Source which gets data from a 'source_data' property which contains specific journey data.
The data is supplied as a dictionary:
source_data = {
"JOURNEY_REF_1": {"x1":1, "x2":2, "x3":3},
"JOURNEY_REF_2": {"x1":2, "x2":4, "x3":6}
}
e.g.
"""
source_data = field(factory=dict)
def _retrieve_raw_data(self, driver, step):
if driver.journey["reference"] not in self.source_data:
raise StepDataNotAvailable(journey=driver.journey, step_name = step.name)
return self.source_data.get(driver.journey["reference"])
|
(*, title: str, processes=NOTHING, source_data=NOTHING) -> None
|
46,387 |
easul.source
|
__eq__
|
Method generated by attrs for class StaticSource.
|
import pandas as pd
from typing import List, Any, Dict
from easul.error import StepDataNotAvailable
import logging
from abc import abstractmethod
from attrs import define, field
from functools import partial
from easul.util import get_current_result
LOG = logging.getLogger(__name__)
@define(kw_only=True)
class Source:
"""
Base Source class. Sources provide access to raw data and processing which enables the creation of validated
InputData - which can be fed into algorithms.
"""
title: str = field()
processes = field(factory=list)
def retrieve(self, driver, step):
"""
Retrieve data in the form of a Python data structure.
Args:
driver:
step:
Returns:
"""
data = self._retrieve_final_data(driver, step)
if not data:
raise StepDataNotAvailable(driver.journey, step.name, retry=False, source_title=self.title)
return data
def _retrieve_final_data(self, driver, step):
raw_data = self._retrieve_raw_data(driver, step)
return self._process_raw_data(raw_data)
@abstractmethod
def _retrieve_raw_data(self, driver, step):
pass
@property
def source_titles(self):
return [self.title]
def describe(self):
return {
"title":self.title,
"type":self.__class__.__name__,
}
def _process_raw_data(self, raw_data):
if raw_data is None:
raw_data = {}
for process in self.processes:
raw_data = process(raw_data)
return raw_data
|
(self, other)
|
46,390 |
easul.source
|
__ne__
|
Method generated by attrs for class StaticSource.
| null |
(self, other)
|
46,395 |
easul.source
|
_retrieve_raw_data
| null |
def _retrieve_raw_data(self, driver, step):
if driver.journey["reference"] not in self.source_data:
raise StepDataNotAvailable(journey=driver.journey, step_name = step.name)
return self.source_data.get(driver.journey["reference"])
|
(self, driver, step)
|
46,398 |
easul.step
|
Step
|
Base Step class. Steps are the driving force of plans, they bring the different components together.
The key things are 'visual' components which provide graphical views associated with steps and 'actions' which
define action classes that occur during the lifecycle of a step run.
|
class Step:
"""
Base Step class. Steps are the driving force of plans, they bring the different components together.
The key things are 'visual' components which provide graphical views associated with steps and 'actions' which
define action classes that occur during the lifecycle of a step run.
"""
title = field()
visual = field(default=None)
exclude_from_chart = field(default=False)
name = field(default=None)
actions = field(factory=list)
def layout_kwargs(self, driver, steps, **kwargs):
return {"steps":steps, "driver":driver, "step":self, **kwargs}
def render_visual(self, driver: "easul.driver.Driver", steps, result=None, context=None, renderer=None, **kwargs):
"""
Render visual to HTML utilising the data in the broker (if not supplied) and the supplied renderer
Args:
driver:
steps:
result:
context:
renderer:
**kwargs:
Returns:
"""
if not self.visual:
return NO_VISUAL_IN_STEP_MESSAGE
if not result and not context:
b_data = driver.get_broker_data("outcome:" + self.name)
if b_data:
result = b_data.get("result")
context = b_data.get("context")
try:
return self.visual.render(driver=driver, steps=steps, step=self, result=result, context=context, renderer=renderer)
except VisualDataMissing as ex:
return str(ex)
@property
def possible_links(self):
return {}
@property
def data_sources(self):
return []
def _trigger_actions(self, trigger_type, event):
for action in self.actions:
getattr(action, trigger_type)(event)
def _generate_visual_context(self, data):
return self.visual.generate_context(data) if self.visual else None
def __repr__(self):
return self.name
def describe(self):
"""
Describe step as Python data structures (lists and dicts)
Returns:
"""
return {
"name": self.name,
"title": self.title,
"actions": [a.describe() for a in self.actions],
"visual":self.visual.describe() if self.visual else "N/A"
}
|
(*, title, visual=None, exclude_from_chart=False, name=None, actions=NOTHING) -> None
|
46,399 |
easul.step
|
__eq__
|
Method generated by attrs for class Step.
|
from attrs import define, field
import logging
from easul.decision import BinaryDecision
LOG = logging.getLogger(__name__)
from easul.error import StepDataNotAvailable, ConversionError, InvalidStepData, VisualDataMissing, ValidationError
from enum import Enum, auto
from easul.outcome import Outcome, EndOutcome, PauseOutcome, InvalidDataOutcome, MissingDataOutcome
from abc import abstractmethod
NO_VISUAL_IN_STEP_MESSAGE = "Sorry no visual for this step"
@define(kw_only=True)
class Step:
"""
Base Step class. Steps are the driving force of plans, they bring the different components together.
The key things are 'visual' components which provide graphical views associated with steps and 'actions' which
define action classes that occur during the lifecycle of a step run.
"""
title = field()
visual = field(default=None)
exclude_from_chart = field(default=False)
name = field(default=None)
actions = field(factory=list)
def layout_kwargs(self, driver, steps, **kwargs):
return {"steps":steps, "driver":driver, "step":self, **kwargs}
def render_visual(self, driver: "easul.driver.Driver", steps, result=None, context=None, renderer=None, **kwargs):
"""
Render visual to HTML utilising the data in the broker (if not supplied) and the supplied renderer
Args:
driver:
steps:
result:
context:
renderer:
**kwargs:
Returns:
"""
if not self.visual:
return NO_VISUAL_IN_STEP_MESSAGE
if not result and not context:
b_data = driver.get_broker_data("outcome:" + self.name)
if b_data:
result = b_data.get("result")
context = b_data.get("context")
try:
return self.visual.render(driver=driver, steps=steps, step=self, result=result, context=context, renderer=renderer)
except VisualDataMissing as ex:
return str(ex)
@property
def possible_links(self):
return {}
@property
def data_sources(self):
return []
def _trigger_actions(self, trigger_type, event):
for action in self.actions:
getattr(action, trigger_type)(event)
def _generate_visual_context(self, data):
return self.visual.generate_context(data) if self.visual else None
def __repr__(self):
return self.name
def describe(self):
"""
Describe step as Python data structures (lists and dicts)
Returns:
"""
return {
"name": self.name,
"title": self.title,
"actions": [a.describe() for a in self.actions],
"visual":self.visual.describe() if self.visual else "N/A"
}
|
(self, other)
|
46,402 |
easul.step
|
__ne__
|
Method generated by attrs for class Step.
| null |
(self, other)
|
46,407 |
easul.step
|
describe
|
Describe step as Python data structures (lists and dicts)
Returns:
|
def describe(self):
"""
Describe step as Python data structures (lists and dicts)
Returns:
"""
return {
"name": self.name,
"title": self.title,
"actions": [a.describe() for a in self.actions],
"visual":self.visual.describe() if self.visual else "N/A"
}
|
(self)
|
46,408 |
easul.step
|
layout_kwargs
| null |
def layout_kwargs(self, driver, steps, **kwargs):
return {"steps":steps, "driver":driver, "step":self, **kwargs}
|
(self, driver, steps, **kwargs)
|
46,410 |
easul.error
|
StepDataError
|
Base class for errors related to unavailable or invalid step data.
|
class StepDataError(Exception):
"""
Base class for errors related to unavailable or invalid step data.
"""
@property
def _message(self):
return ""
def __init__(self, journey, step_name, exception=None, message=None, **kwargs):
self.step_name = step_name
self.journey = journey
self.kwargs = kwargs
if not message:
message = self._message
if exception:
message+=f" [exception:{exception}]"
super().__init__(message)
|
(journey, step_name, exception=None, message=None, **kwargs)
|
46,412 |
easul.error
|
StepDataNotAvailable
|
Error thrown when data is not available in a step. Should result in step status changing to 'WAITING'
|
class StepDataNotAvailable(StepDataError):
"""
Error thrown when data is not available in a step. Should result in step status changing to 'WAITING'
"""
@property
def _message(self):
return f"Data not available in step {self.step_name}"
|
(journey, step_name, exception=None, message=None, **kwargs)
|
46,414 |
easul.decision
|
StepResultDecision
|
Decision which returns the outcome and next step based on the value of the algorithm result.
|
class StepResultDecision(Decision):
"""
Decision which returns the outcome and next step based on the value of the algorithm result.
"""
step_field = field()
def describe(self):
desc = super().describe()
desc.update({
"step_field": self.step_field
})
return desc
def decide_outcome(self, result, context, data, step):
return Outcome(
outcome_step=step,
next_step=result[self.step_field],
reason=""
)
|
(*, step_field) -> None
|
46,415 |
easul.decision
|
__eq__
|
Method generated by attrs for class StepResultDecision.
|
from abc import abstractmethod
from attrs import define, field
from easul.algorithm import Result
from easul.outcome import Outcome, ResultOutcome
from easul.expression import DecisionCase
@define(kw_only=True)
class Decision:
"""
Decides the outcome based on the provided result and the type of decision. The outcome includes the next step,
the result and other contextual information.
"""
@abstractmethod
def decide_outcome(self, result, context, data, step):
pass
@property
def possible_links(self):
return {}
def describe(self):
return {
"type":self.__class__.__name__
}
|
(self, other)
|
46,418 |
easul.decision
|
__ne__
|
Method generated by attrs for class StepResultDecision.
| null |
(self, other)
|
46,421 |
easul.decision
|
decide_outcome
| null |
def decide_outcome(self, result, context, data, step):
return Outcome(
outcome_step=step,
next_step=result[self.step_field],
reason=""
)
|
(self, result, context, data, step)
|
46,422 |
easul.decision
|
describe
| null |
def describe(self):
desc = super().describe()
desc.update({
"step_field": self.step_field
})
return desc
|
(self)
|
46,423 |
easul.source
|
StepResultSource
|
Source which returns the result from a previous step.
|
class StepResultSource(Source):
"""
Source which returns the result from a previous step.
"""
output_field = field()
result_step_name = field()
def retrieve(self, driver, step):
step = driver._client.get_step(step_name=self.result_step_name, journey_id=driver.journey_id)
data = {self.output_field: step["value"]}
return data
|
(*, title: str, processes=NOTHING, output_field, result_step_name) -> None
|
46,424 |
easul.source
|
__eq__
|
Method generated by attrs for class StepResultSource.
|
import pandas as pd
from typing import List, Any, Dict
from easul.error import StepDataNotAvailable
import logging
from abc import abstractmethod
from attrs import define, field
from functools import partial
from easul.util import get_current_result
LOG = logging.getLogger(__name__)
@define(kw_only=True)
class Source:
"""
Base Source class. Sources provide access to raw data and processing which enables the creation of validated
InputData - which can be fed into algorithms.
"""
title: str = field()
processes = field(factory=list)
def retrieve(self, driver, step):
"""
Retrieve data in the form of a Python data structure.
Args:
driver:
step:
Returns:
"""
data = self._retrieve_final_data(driver, step)
if not data:
raise StepDataNotAvailable(driver.journey, step.name, retry=False, source_title=self.title)
return data
def _retrieve_final_data(self, driver, step):
raw_data = self._retrieve_raw_data(driver, step)
return self._process_raw_data(raw_data)
@abstractmethod
def _retrieve_raw_data(self, driver, step):
pass
@property
def source_titles(self):
return [self.title]
def describe(self):
return {
"title":self.title,
"type":self.__class__.__name__,
}
def _process_raw_data(self, raw_data):
if raw_data is None:
raw_data = {}
for process in self.processes:
raw_data = process(raw_data)
return raw_data
|
(self, other)
|
46,427 |
easul.source
|
__ne__
|
Method generated by attrs for class StepResultSource.
| null |
(self, other)
|
46,434 |
easul.source
|
retrieve
| null |
def retrieve(self, driver, step):
step = driver._client.get_step(step_name=self.result_step_name, journey_id=driver.journey_id)
data = {self.output_field: step["value"]}
return data
|
(self, driver, step)
|
46,435 |
easul.step
|
StepStatuses
|
Enum containing statuses which match those used within the client.
|
class StepStatuses(Enum):
"""
Enum containing statuses which match those used within the client.
"""
INIT = auto()
WAITING = auto()
COMPLETE = auto()
PENDING = auto()
ERROR = auto()
PAUSE = auto()
|
(value, names=None, *, module=None, qualname=None, type=None, start=1)
|
46,436 |
easul.action
|
StopFlow
| null |
class StopFlow(Exception):
pass
| null |
46,437 |
easul.algorithm.algorithm
|
StoredAlgorithm
|
Stored algorithm which updates from a file through load_algorithm or a source definition.
Acts as a decorator for the underlying algorithm.
|
class StoredAlgorithm(Algorithm):
"""
Stored algorithm which updates from a file through load_algorithm or a source definition.
Acts as a decorator for the underlying algorithm.
"""
filename:str = field()
definition: str = field()
_algorithm = field(init=False)
schema = field(init=False)
encoder = field(init=False)
def __attrs_post_init__(self):
filename = self.filename
if os.path.exists(filename):
self.update_from_file(filename)
else:
LOG.warning(f"Algorithm file '{filename}' does not exist")
self.update_from_definition()
def update_from_definition(self):
from easul.util import create_package_class
if callable(self.definition):
algorithm_def = self.definition
else:
algorithm_def = create_package_class(self.definition)
algorithm = algorithm_def() if callable(algorithm_def) else algorithm_def
self._algorithm = algorithm
self.schema = algorithm.schema
def update_from_file(self, filename):
algorithm = util.load_data(filename)
self._algorithm = algorithm
self.schema = algorithm.schema
def __getattr__(self, item):
return getattr(self._algorithm, item)
def single_result(self, data):
return self._algorithm.single_result(data)
@property
def unique_digest(self):
return self._algorithm.unique_digest
def save_to_file(self, filename=None):
from easul.util import save_data
if not filename:
filename = self.filename
save_data(filename, self._algorithm)
def describe(self):
return {
"title":self._algorithm.title,
"type":self._algorithm.__class__.__name__ + " (StoredAlgorithm)",
"filename":self.filename
}
|
(*, title: str, filename: str, definition: str) -> None
|
46,438 |
easul.algorithm.algorithm
|
__attrs_post_init__
| null |
def __attrs_post_init__(self):
filename = self.filename
if os.path.exists(filename):
self.update_from_file(filename)
else:
LOG.warning(f"Algorithm file '{filename}' does not exist")
self.update_from_definition()
|
(self)
|
46,439 |
easul.algorithm.algorithm
|
__eq__
|
Method generated by attrs for class StoredAlgorithm.
|
import os
from typing import Any
from easul import util
from easul.algorithm.result import Result
from abc import abstractmethod
import dill
import hashlib
from attrs import define, field
from easul.data import create_input_dataset, DataInput
import logging
logging.basicConfig(level=logging.INFO)
LOG = logging.getLogger(__name__)
@define(kw_only=True)
class Algorithm:
"""
Base class for algorithms
"""
title:str = field()
schema:Any = field()
encoder = field(default=None)
def __post_init__(self):
self.id = str(util.new_id())
def to_serialized(self):
return util.to_serialized(self)
@abstractmethod
def serialize_with_dataset_id(self):
pass
@property
def unique_digest(self)->str:
"""
Generate unique digest for algorithm
Returns: hex digest
"""
algo_dump = dill.dumps(self)
return hashlib.sha256(algo_dump).hexdigest()
@abstractmethod
def single_result(self, data:Any)->Result:
"""
Execute algorithm based on input data
Args:
data: input data
Returns: an algorithm result object
"""
pass
def create_input_dataset(self, data:Any)->DataInput:
return create_input_dataset(data=data, schema=self.schema, encoder=self.encoder)
def save(self, filename:str):
"""
Save algorithm
Args:
filename:
"""
from easul.util import save_data
save_data(filename, self)
def describe(self):
"""
Describes the algorithm
Returns: dictionary containing key elements
"""
return {
"title":self.title,
"type":self.__class__.__name__
}
|
(self, other)
|
46,440 |
easul.algorithm.algorithm
|
__getattr__
| null |
def __getattr__(self, item):
return getattr(self._algorithm, item)
|
(self, item)
|
46,443 |
easul.algorithm.algorithm
|
__ne__
|
Method generated by attrs for class StoredAlgorithm.
| null |
(self, other)
|
46,448 |
easul.algorithm.algorithm
|
describe
| null |
def describe(self):
return {
"title":self._algorithm.title,
"type":self._algorithm.__class__.__name__ + " (StoredAlgorithm)",
"filename":self.filename
}
|
(self)
|
46,450 |
easul.algorithm.algorithm
|
save_to_file
| null |
def save_to_file(self, filename=None):
from easul.util import save_data
if not filename:
filename = self.filename
save_data(filename, self._algorithm)
|
(self, filename=None)
|
46,452 |
easul.algorithm.algorithm
|
single_result
| null |
def single_result(self, data):
return self._algorithm.single_result(data)
|
(self, data)
|
46,454 |
easul.algorithm.algorithm
|
update_from_definition
| null |
def update_from_definition(self):
from easul.util import create_package_class
if callable(self.definition):
algorithm_def = self.definition
else:
algorithm_def = create_package_class(self.definition)
algorithm = algorithm_def() if callable(algorithm_def) else algorithm_def
self._algorithm = algorithm
self.schema = algorithm.schema
|
(self)
|
46,455 |
easul.algorithm.algorithm
|
update_from_file
| null |
def update_from_file(self, filename):
algorithm = util.load_data(filename)
self._algorithm = algorithm
self.schema = algorithm.schema
|
(self, filename)
|
46,456 |
easul.source
|
TimebasedDbSource
|
Time-based DB source which introduces a timestamp_field which it uses with a Clock to retrieve data.
|
class TimebasedDbSource(DbSource):
"""
Time-based DB source which introduces a timestamp_field which it uses with a Clock to retrieve data.
"""
timestamp_field:str = field(default=None)
default_values = field(default=None)
sort_field = field(default=None)
reverse_sort = field(default=False)
def _get_parameters(self, driver):
return {self.reference_field: driver.journey["reference"]}
def _retrieve_final_data(self, driver, step):
data = super()._retrieve_final_data(driver, step)
res = get_current_result(data, driver.clock.timestamp, self.timestamp_field, self.sort_field, self.reverse_sort)
return res
|
(*, title: str, processes=NOTHING, db: str, table_name: str = None, sql: str = None, reference_field: str, multiple_rows=False, cache=NOTHING, data_fn=NOTHING, timestamp_field: str = None, default_values=None, sort_field=None, reverse_sort=False) -> None
|
46,458 |
easul.source
|
__eq__
|
Method generated by attrs for class TimebasedDbSource.
|
import pandas as pd
from typing import List, Any, Dict
from easul.error import StepDataNotAvailable
import logging
from abc import abstractmethod
from attrs import define, field
from functools import partial
from easul.util import get_current_result
LOG = logging.getLogger(__name__)
@define(kw_only=True)
class Source:
"""
Base Source class. Sources provide access to raw data and processing which enables the creation of validated
InputData - which can be fed into algorithms.
"""
title: str = field()
processes = field(factory=list)
def retrieve(self, driver, step):
"""
Retrieve data in the form of a Python data structure.
Args:
driver:
step:
Returns:
"""
data = self._retrieve_final_data(driver, step)
if not data:
raise StepDataNotAvailable(driver.journey, step.name, retry=False, source_title=self.title)
return data
def _retrieve_final_data(self, driver, step):
raw_data = self._retrieve_raw_data(driver, step)
return self._process_raw_data(raw_data)
@abstractmethod
def _retrieve_raw_data(self, driver, step):
pass
@property
def source_titles(self):
return [self.title]
def describe(self):
return {
"title":self.title,
"type":self.__class__.__name__,
}
def _process_raw_data(self, raw_data):
if raw_data is None:
raw_data = {}
for process in self.processes:
raw_data = process(raw_data)
return raw_data
|
(self, other)
|
46,461 |
easul.source
|
__ne__
|
Method generated by attrs for class TimebasedDbSource.
| null |
(self, other)
|
46,465 |
easul.source
|
_get_parameters
| null |
def _get_parameters(self, driver):
return {self.reference_field: driver.journey["reference"]}
|
(self, driver)
|
46,467 |
easul.source
|
_retrieve_final_data
| null |
def _retrieve_final_data(self, driver, step):
data = super()._retrieve_final_data(driver, step)
res = get_current_result(data, driver.clock.timestamp, self.timestamp_field, self.sort_field, self.reverse_sort)
return res
|
(self, driver, step)
|
46,471 |
easul.visual.element.element
|
TrafficLightSwatch
| null |
class TrafficLightSwatch:
RED = Color("#cc3232")
AMBER = Color("#e7b416")
GREEN = Color("#2dc937")
def __init__(self, start, end, step_size):
self.start = start
self.end = end
self.step_size = step_size
self.range_size = int(self.end - self.start)
self.steps_avail = self.range_size/self.step_size
self.patches = self._create_color_patches()
def _create_color_patches(self):
number = self.range_size / self.step_size
ga_number = int(number/2)
ar_number = int(number/2) + 1
ga = list(self.GREEN.range_to(self.AMBER, ga_number))
ar = list(self.AMBER.range_to(self.RED, ar_number))
return ga + ar[1:]
def get_step_idx_to_show(self, value):
value = float(value)
if value == self.end:
return 0
if value == self.start:
return self.steps_avail - 1
std_value = value + (-self.start)
return int(math.ceil(self.steps_avail - (std_value / self.step_size))) - 1
def get_html_spans(self, value):
step_to_show = self.get_step_idx_to_show(value)
return [
f"<span style='background:{c};width:4px;border:{'solid 1px black' if step_to_show == idx else ''}'> </span>"
for idx, c in enumerate(self.patches)]
def get_bg_color_for_value(self, value)->Color:
idx = self.get_step_idx_to_show(value)
return self.patches[idx]
def get_fg_color_for_value(self, value):
bg = self.get_bg_color_for_value(value)
return suggest_text_color_from_fill(bg.get_web())
|
(start, end, step_size)
|
46,472 |
easul.visual.element.element
|
__init__
| null |
def __init__(self, start, end, step_size):
self.start = start
self.end = end
self.step_size = step_size
self.range_size = int(self.end - self.start)
self.steps_avail = self.range_size/self.step_size
self.patches = self._create_color_patches()
|
(self, start, end, step_size)
|
46,473 |
easul.visual.element.element
|
_create_color_patches
| null |
def _create_color_patches(self):
number = self.range_size / self.step_size
ga_number = int(number/2)
ar_number = int(number/2) + 1
ga = list(self.GREEN.range_to(self.AMBER, ga_number))
ar = list(self.AMBER.range_to(self.RED, ar_number))
return ga + ar[1:]
|
(self)
|
46,474 |
easul.visual.element.element
|
get_bg_color_for_value
| null |
def get_bg_color_for_value(self, value)->Color:
idx = self.get_step_idx_to_show(value)
return self.patches[idx]
|
(self, value) -> colour.Color
|
46,475 |
easul.visual.element.element
|
get_fg_color_for_value
| null |
def get_fg_color_for_value(self, value):
bg = self.get_bg_color_for_value(value)
return suggest_text_color_from_fill(bg.get_web())
|
(self, value)
|
46,476 |
easul.visual.element.element
|
get_html_spans
| null |
def get_html_spans(self, value):
step_to_show = self.get_step_idx_to_show(value)
return [
f"<span style='background:{c};width:4px;border:{'solid 1px black' if step_to_show == idx else ''}'> </span>"
for idx, c in enumerate(self.patches)]
|
(self, value)
|
46,477 |
easul.visual.element.element
|
get_step_idx_to_show
| null |
def get_step_idx_to_show(self, value):
value = float(value)
if value == self.end:
return 0
if value == self.start:
return self.steps_avail - 1
std_value = value + (-self.start)
return int(math.ceil(self.steps_avail - (std_value / self.step_size))) - 1
|
(self, value)
|
46,484 |
collections
|
UserDict
| null |
class UserDict(_collections_abc.MutableMapping):
# Start by filling-out the abstract methods
def __init__(self, dict=None, /, **kwargs):
self.data = {}
if dict is not None:
self.update(dict)
if kwargs:
self.update(kwargs)
def __len__(self):
return len(self.data)
def __getitem__(self, key):
if key in self.data:
return self.data[key]
if hasattr(self.__class__, "__missing__"):
return self.__class__.__missing__(self, key)
raise KeyError(key)
def __setitem__(self, key, item):
self.data[key] = item
def __delitem__(self, key):
del self.data[key]
def __iter__(self):
return iter(self.data)
# Modify __contains__ to work correctly when __missing__ is present
def __contains__(self, key):
return key in self.data
# Now, add the methods in dicts but not in MutableMapping
def __repr__(self):
return repr(self.data)
def __or__(self, other):
if isinstance(other, UserDict):
return self.__class__(self.data | other.data)
if isinstance(other, dict):
return self.__class__(self.data | other)
return NotImplemented
def __ror__(self, other):
if isinstance(other, UserDict):
return self.__class__(other.data | self.data)
if isinstance(other, dict):
return self.__class__(other | self.data)
return NotImplemented
def __ior__(self, other):
if isinstance(other, UserDict):
self.data |= other.data
else:
self.data |= other
return self
def __copy__(self):
inst = self.__class__.__new__(self.__class__)
inst.__dict__.update(self.__dict__)
# Create a copy and avoid triggering descriptors
inst.__dict__["data"] = self.__dict__["data"].copy()
return inst
def copy(self):
if self.__class__ is UserDict:
return UserDict(self.data.copy())
import copy
data = self.data
try:
self.data = {}
c = copy.copy(self)
finally:
self.data = data
c.update(self)
return c
@classmethod
def fromkeys(cls, iterable, value=None):
d = cls()
for key in iterable:
d[key] = value
return d
|
(dict=None, /, **kwargs)
|
46,508 |
easul.util
|
Utf8EncodedImage
| null |
class Utf8EncodedImage(BytesIO):
def decode(self):
return base64.b64encode(self.getvalue()).decode('utf-8')
|
(initial_bytes=b'')
|
46,509 |
easul.util
|
decode
| null |
def decode(self):
return base64.b64encode(self.getvalue()).decode('utf-8')
|
(self)
|
46,510 |
easul.error
|
ValidationError
|
Data validation of data by cerberus has failed.
|
class ValidationError(InvalidData):
"""
Data validation of data by cerberus has failed.
"""
pass
| null |
46,581 |
easul.visual.element.element
|
ValueElement
| null |
class ValueElement(Element):
suffix:str = field(default="")
prefix:str = field(default="")
format:str = field(default=None)
round_dp:int = field(default=2)
expression:str = field(default=None)
hide_rag_bars:bool = field(default=False)
use_background:bool = field(default=False)
html_width = field(default=None)
start_range = field(default=None)
end_range = field(default=None)
step_size = field(default=None)
label_side = field(default="right")
def retrieve_value(self, result=None, **kwargs):
return result["value"]
def create(self, **kwargs):
value = self.retrieve_value(**kwargs)
if not self.hide_rag_bars and self.start_range is not None:
swatch = TrafficLightSwatch(self.start_range, self.end_range, self.step_size)
bg_colour = swatch.get_bg_color_for_value(value)
fg_colour = swatch.get_fg_color_for_value(value)
patches = ["<span class='rag-bars d-inline-block'>"] + swatch.get_html_spans(value) + ["</span>"]
else:
bg_colour = "transparent"
fg_colour = "black"
patches = []
if self.expression:
ld = self.expression
cmp = compile(ld, '', 'eval')
value = eval(cmp, {}, {"value": value})
if self.round_dp is not None:
num_format = "." + str(self.round_dp) + "f"
else:
num_format = self.format
if num_format:
try:
value = format(value, num_format)
except ValueError:
pass
doc = div(class_name="py-2")
if self.title and self.label_side == "left":
lab = label()
lab.add_raw_string(self.title)
doc.add(lab)
final_value = f"{self.prefix}{value}{self.suffix}"
value_width = self.html_width or len(final_value)
doc.add(span(h5(final_value),style=f"border:none;width:{value_width}em;background:{bg_colour};color:{fg_colour}", class_name="d-inline-block"))
doc.add_raw_string(" " + "".join(patches))
if self.help:
doc.add(p(i(self.help), class_='small'))
if self.title and self.label_side == "right":
lab = label()
lab.add_raw_string(self.title)
doc.add(lab)
return str(doc)
def generate_context(self, **kwargs):
pass
|
(*, name='untitled', help='', title='Untitled', fill_container=False, style=None, html_class='', html_tag='h5', suffix: str = '', prefix: str = '', format: str = None, round_dp: int = 2, expression: str = None, hide_rag_bars: bool = False, use_background: bool = False, html_width=None, start_range=None, end_range=None, step_size=None, label_side='right') -> None
|
46,582 |
easul.visual.element.element
|
__eq__
|
Method generated by attrs for class ValueElement.
|
from abc import abstractmethod
from typing import Dict
from attr import define, field
from dominate.tags import *
from stringcase import snakecase
from easul.error import VisualDataMissing
from easul.util import Utf8EncodedImage
from easul.visual.render import from_html_template
from easul.visual.draw.style import suggest_text_color_from_fill
LIST_TYPES = ["options","list","category"]
MODEL_SCOPE = "model"
ROW_SCOPE = "row"
EITHER_SCOPE = "either"
import logging
LOG = logging.getLogger(__name__)
class Html:
def __init__(self):
self._elements = []
def start_element(self, tag, attrs=None):
if attrs:
attrs = [k + "=\"" + (v if v else "") +"\"" for k,v in attrs.items()]
else:
attrs = []
attr_list = " ".join(attrs)
self._elements.append(f"<{tag} {attr_list}>")
def end_element(self, tag):
self._elements.append(f"</{tag}>")
def add_text_element(self, tag, text, attrs=None):
self.start_element(tag, attrs)
self._elements.append(text)
self.end_element(tag)
def __repr__(self):
return "".join(self._elements)
def append(self, element):
self._elements.append(element)
def add_element(self, tag, attrs):
attrs = [k + "=\"" + v + "\"" for k, v in attrs.items()]
attr_list = " ".join(attrs)
self._elements.append(f"<{tag} {attr_list} />")
|
(self, other)
|
46,585 |
easul.visual.element.element
|
__ne__
|
Method generated by attrs for class ValueElement.
| null |
(self, other)
|
46,596 |
easul.visual.element.element
|
retrieve_value
| null |
def retrieve_value(self, result=None, **kwargs):
return result["value"]
|
(self, result=None, **kwargs)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.