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
⌀ |
|---|---|---|---|---|---|
45,109 |
easul.algorithm.logic
|
Binary
| null |
class Binary:
pass
|
()
|
45,110 |
easul.decision
|
BinaryDecision
|
Binary decision which returns a true/false outcome based on the algorithm result being the defined positive value.
|
class BinaryDecision(Decision):
"""
Binary decision which returns a true/false outcome based on the algorithm result being the defined positive value.
"""
true_step = field()
false_step = field()
input_field = field(default="value")
positive_value = field(default=1)
positive_label = field(default="positive")
negative_label = field(default="negative")
def describe(self):
desc = super().describe()
desc.update({
"true_step":self.true_step.title + "(" + self.true_step.name + ")",
"false_step":self.false_step.title + "(" + self.false_step.name + ")",
"input_field":self.input_field,
"positive_value":self.positive_value,
"positive_label":self.positive_label,
"negative_label":self.negative_label
})
return desc
def decide_outcome(self, result, context, data, step):
positive_outcome = 1 if get_result_value(result, self.input_field) == self.positive_value else 0
return ResultOutcome(
outcome_step=step,
next_step=self.true_step if positive_outcome == 1 else self.false_step,
value=positive_outcome,
result=result,
context=context,
input_data=data,
reason="positive" if positive_outcome == 1 else "negative"
)
@property
def possible_links(self):
return {self.positive_label:self.true_step, self.negative_label:self.false_step}
|
(*, true_step, false_step, input_field='value', positive_value=1, positive_label='positive', negative_label='negative') -> None
|
45,111 |
easul.decision
|
__eq__
|
Method generated by attrs for class BinaryDecision.
|
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)
|
45,114 |
easul.decision
|
__ne__
|
Method generated by attrs for class BinaryDecision.
| null |
(self, other)
|
45,117 |
easul.decision
|
decide_outcome
| null |
def decide_outcome(self, result, context, data, step):
positive_outcome = 1 if get_result_value(result, self.input_field) == self.positive_value else 0
return ResultOutcome(
outcome_step=step,
next_step=self.true_step if positive_outcome == 1 else self.false_step,
value=positive_outcome,
result=result,
context=context,
input_data=data,
reason="positive" if positive_outcome == 1 else "negative"
)
|
(self, result, context, data, step)
|
45,118 |
easul.decision
|
describe
| null |
def describe(self):
desc = super().describe()
desc.update({
"true_step":self.true_step.title + "(" + self.true_step.name + ")",
"false_step":self.false_step.title + "(" + self.false_step.name + ")",
"input_field":self.input_field,
"positive_value":self.positive_value,
"positive_label":self.positive_label,
"negative_label":self.negative_label
})
return desc
|
(self)
|
45,119 |
easul.source
|
BrokerSource
|
Source which retrieves data from the broker for the defined 'data_type'.
|
class BrokerSource(Source):
"""
Source which retrieves data from the broker for the defined 'data_type'.
"""
data_source:str = field()
data_type:str = field()
def _retrieve_raw_data(self, driver, step):
data = driver.get_broker_data(self.data_type)
if not data:
raise StepDataNotAvailable(driver.journey, step.name, retry=False)
return data
|
(*, title: str, processes=NOTHING, data_source: str, data_type: str) -> None
|
45,120 |
easul.source
|
__eq__
|
Method generated by attrs for class BrokerSource.
|
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)
|
45,123 |
easul.source
|
__ne__
|
Method generated by attrs for class BrokerSource.
| null |
(self, other)
|
45,126 |
easul.source
|
_process_raw_data
| null |
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, raw_data)
|
45,127 |
easul.source
|
_retrieve_final_data
| null |
def _retrieve_final_data(self, driver, step):
raw_data = self._retrieve_raw_data(driver, step)
return self._process_raw_data(raw_data)
|
(self, driver, step)
|
45,128 |
easul.source
|
_retrieve_raw_data
| null |
def _retrieve_raw_data(self, driver, step):
data = driver.get_broker_data(self.data_type)
if not data:
raise StepDataNotAvailable(driver.journey, step.name, retry=False)
return data
|
(self, driver, step)
|
45,129 |
easul.source
|
describe
| null |
def describe(self):
return {
"title":self.title,
"type":self.__class__.__name__,
}
|
(self)
|
45,130 |
easul.source
|
retrieve
|
Retrieve data in the form of a Python data structure.
Args:
driver:
step:
Returns:
|
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
|
(self, driver, step)
|
45,131 |
easul.expression
|
Case
|
Simple Case class which includes an expression, the value returned if True and a title for documentation/help.
|
class Case:
"""
Simple Case class which includes an expression, the value returned if True and a title for documentation/help.
"""
expression = field()
true_value = field(default=True)
title = field(default=None)
def asdict(self):
return {
"expression":str(self.expression),
"true_value":str(self.true_value)
}
def test(self, dset):
return self.expression.evaluate(dset)
|
(*, expression, true_value=True, title=None) -> None
|
45,132 |
easul.expression
|
__eq__
|
Method generated by attrs for class Case.
|
import operator
import re
from abc import abstractmethod
from typing import Callable
from attrs import define, field
import numpy as np
import pandas as pd
from easul.error import MissingValue
import logging
LOG = logging.getLogger(__name__)
@define(kw_only=True)
class Expression:
"""
Base Expression class. Derived classes evaluate input data and return a True/False
"""
label = ""
empty_values = [None, np.nan]
@abstractmethod
def evaluate(self, data):
pass
@classmethod
def is_empty(cls, item):
if item in cls.empty_values:
return True
try:
if np.isnan(item):
return True
except TypeError:
pass
return False
|
(self, other)
|
45,135 |
easul.expression
|
__ne__
|
Method generated by attrs for class Case.
| null |
(self, other)
|
45,138 |
easul.expression
|
asdict
| null |
def asdict(self):
return {
"expression":str(self.expression),
"true_value":str(self.true_value)
}
|
(self)
|
45,139 |
easul.expression
|
test
| null |
def test(self, dset):
return self.expression.evaluate(dset)
|
(self, dset)
|
45,140 |
easul.algorithm.result
|
CaseResult
|
Result for case which also includes the case it was matched on (matched_case)
|
class CaseResult(Result):
"""
Result for case which also includes the case it was matched on (matched_case)
"""
matched_case = field()
def __getitem__(self, item):
if not hasattr(self, item):
return None
return getattr(self, item)
|
(*, value, data, matched_case) -> None
|
45,141 |
easul.algorithm.result
|
__eq__
|
Method generated by attrs for class CaseResult.
|
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)
|
45,142 |
easul.algorithm.result
|
__getitem__
| null |
def __getitem__(self, item):
if not hasattr(self, item):
return None
return getattr(self, item)
|
(self, item)
|
45,145 |
easul.algorithm.result
|
__ne__
|
Method generated by attrs for class CaseResult.
| null |
(self, other)
|
45,148 |
easul.algorithm.result
|
asdict
|
Dictionary representation of the result used to store the object in databases etc.
Returns:
|
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()
}
|
(self)
|
45,149 |
easul.step
|
CheckEndStep
|
Embedded step which is executed whenever a specific journey is resumed. For example, it can check if a patient
has already been discharged.
|
class CheckEndStep(AlgorithmStep):
"""
Embedded step which is executed whenever a specific journey is resumed. For example, it can check if a patient
has already been discharged.
"""
true_step = field()
decision = field(init=False)
@decision.default
def _default_decision(self):
return BinaryDecision(true_step=self.true_step, false_step=None)
def run_all(self, driver, previous_outcome=None):
event = ActionEvent(step=self, driver=driver, previous_outcome=previous_outcome)
self._trigger_actions("before_run", event)
try:
outcome = self._determine_outcome(event)
event.outcome = outcome
self._trigger_actions("after_run", event)
if outcome.next_step is not None:
event.driver.store_step(self.name, StepStatuses.COMPLETE, outcome=outcome,
timestamp=event.driver.clock.timestamp)
return outcome
except StepDataNotAvailable as ex:
return MissingDataOutcome(outcome_step=self, reason=str(ex))
except InvalidStepData as ex:
return InvalidDataOutcome(outcome_step=self, reason=str(ex))
def describe(self):
desc = super().describe()
desc.update({
"true_step": self.true_step.title,
"decision":self.decision.describe()
})
return desc
|
(*, title, visual=None, exclude_from_chart=False, name=None, actions=NOTHING, source, algorithm, true_step) -> None
|
45,150 |
easul.step
|
__eq__
|
Method generated by attrs for class CheckEndStep.
|
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)
|
45,153 |
easul.step
|
__ne__
|
Method generated by attrs for class CheckEndStep.
| null |
(self, other)
|
45,156 |
easul.step
|
_default_decision
| null |
@decision.default
def _default_decision(self):
return BinaryDecision(true_step=self.true_step, false_step=None)
|
(self)
|
45,163 |
easul.step
|
describe
| null |
def describe(self):
desc = super().describe()
desc.update({
"true_step": self.true_step.title,
"decision":self.decision.describe()
})
return desc
|
(self)
|
45,166 |
easul.step
|
run_all
| null |
def run_all(self, driver, previous_outcome=None):
event = ActionEvent(step=self, driver=driver, previous_outcome=previous_outcome)
self._trigger_actions("before_run", event)
try:
outcome = self._determine_outcome(event)
event.outcome = outcome
self._trigger_actions("after_run", event)
if outcome.next_step is not None:
event.driver.store_step(self.name, StepStatuses.COMPLETE, outcome=outcome,
timestamp=event.driver.clock.timestamp)
return outcome
except StepDataNotAvailable as ex:
return MissingDataOutcome(outcome_step=self, reason=str(ex))
except InvalidStepData as ex:
return InvalidDataOutcome(outcome_step=self, reason=str(ex))
|
(self, driver, previous_outcome=None)
|
45,168 |
easul.algorithm.predictive
|
ClassifierAlgorithm
|
Classifier-specific version of the PredictiveAlgorithm which returns a result containing a value, label
and a list of probabilities for each potential class.
|
class ClassifierAlgorithm(PredictiveAlgorithm):
"""
Classifier-specific version of the PredictiveAlgorithm which returns a result containing a value, label
and a list of probabilities for each potential class.
"""
def single_result(self, data, round_dp=2):
dset = ds.create_input_dataset(data, self.schema, allow_multiple=False, encoder=self.encoder)
pns = self.model.predict(dset.X)
prob_rows = self.model.predict_proba(dset.X)
field_name = self.schema.y_names[0]
option_list = get_field_options_from_schema(field_name, self.schema)
if round_dp:
prob_rows = np.round_(prob_rows, round_dp)
probs = [Probability(*args) for args in zip(prob_rows[0], option_list.values(), option_list.keys())]
return ClassifierResult(value=pns[0], label=option_list.get(pns[0]), probabilities=probs, data=dset)
|
(*, title: str, model: Any, schema: easul.data.DataSchema, encoder: Optional[easul.data.InputEncoder] = None) -> None
|
45,169 |
easul.algorithm.predictive
|
__eq__
| null |
def __eq__(self, other):
return self.unique_digest == other.unique_digest
|
(self, other)
|
45,171 |
easul.algorithm.predictive
|
__init__
|
Method generated by attrs for class ClassifierAlgorithm.
|
from abc import abstractmethod
from typing import Any, Optional
import numpy as np
import easul.data as ds
import easul.util
from easul.algorithm.result import ClassifierResult, RegressionResult, Probability
from .algorithm import Algorithm
import hashlib
from enum import auto, Enum
from easul.data import get_field_options_from_schema
import logging
from attrs import define, field
LOG = logging.getLogger(__name__)
class PredictiveTypes(Enum):
REGRESSION = auto()
CLASSIFICATION = auto()
|
(self, *, title: str, model: Any, schema: easul.data.DataSchema, encoder: Optional[easul.data.InputEncoder] = None) -> NoneType
|
45,176 |
easul.algorithm.predictive
|
_create_result
| null |
@abstractmethod
def _create_result(self, prediction):
pass
|
(self, prediction)
|
45,177 |
easul.algorithm.predictive
|
_default_unique_id
| null |
@unique_id.default
def _default_unique_id(self):
return str(easul.util.new_id())
|
(self)
|
45,180 |
easul.algorithm.predictive
|
fit
| null |
def fit(self, dataset):
dataset = ds.create_input_dataset(data=dataset, schema=self.schema, encoder=self.encoder, allow_multiple=True)
self.model.fit(dataset.X, dataset.Y)
|
(self, dataset)
|
45,182 |
easul.algorithm.predictive
|
serialize_with_dataset_id
| null |
def serialize_with_dataset_id(self):
return easul.util.to_serialized(self)
|
(self)
|
45,183 |
easul.algorithm.predictive
|
single_result
| null |
def single_result(self, data, round_dp=2):
dset = ds.create_input_dataset(data, self.schema, allow_multiple=False, encoder=self.encoder)
pns = self.model.predict(dset.X)
prob_rows = self.model.predict_proba(dset.X)
field_name = self.schema.y_names[0]
option_list = get_field_options_from_schema(field_name, self.schema)
if round_dp:
prob_rows = np.round_(prob_rows, round_dp)
probs = [Probability(*args) for args in zip(prob_rows[0], option_list.values(), option_list.keys())]
return ClassifierResult(value=pns[0], label=option_list.get(pns[0]), probabilities=probs, data=dset)
|
(self, data, round_dp=2)
|
45,185 |
easul.algorithm.result
|
ClassifierResult
|
Result for classifier which also includes probabilities and the label
|
class ClassifierResult(Result):
"""
Result for classifier which also includes probabilities and the label
"""
label = field()
probabilities = field()
def asdict(self):
return {
"value": self.value,
"label": self.label,
"probabilities":[p._asdict() for p in self.probabilities],
"data":self.data.asdict()
}
def __eq__(self, other):
return self.asdict() == other.asdict()
|
(*, value, data, label, probabilities) -> None
|
45,186 |
easul.algorithm.result
|
__eq__
| null |
def __eq__(self, other):
return self.asdict() == other.asdict()
|
(self, other)
|
45,189 |
easul.algorithm.result
|
__init__
|
Method generated by attrs for class ClassifierResult.
|
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, *, value, data, label, probabilities) -> NoneType
|
45,192 |
easul.algorithm.result
|
asdict
| null |
def asdict(self):
return {
"value": self.value,
"label": self.label,
"probabilities":[p._asdict() for p in self.probabilities],
"data":self.data.asdict()
}
|
(self)
|
45,193 |
easul.plan._plan
|
CollatedReplace
| null |
class CollatedReplace:
def __init__(self, reference, **kwargs):
self.reference = reference
self.kwargs = kwargs
|
(reference, **kwargs)
|
45,194 |
easul.plan._plan
|
__init__
| null |
def __init__(self, reference, **kwargs):
self.reference = reference
self.kwargs = kwargs
|
(self, reference, **kwargs)
|
45,195 |
easul.source
|
CollatedSource
|
Source which collates multiple sources into a single data output. If one source does not have data available the
whole thing will throw a StepDataNotAvailable. This source is useful for combining data from disparate sources
e.g. states, databases and messaging
|
class CollatedSource(Source):
"""
Source which collates multiple sources into a single data output. If one source does not have data available the
whole thing will throw a StepDataNotAvailable. This source is useful for combining data from disparate sources
e.g. states, databases and messaging
"""
sources: Dict[str,Source] = field(factory=list)
def _retrieve_raw_data(self, driver, step):
final_data = {}
for source_name, source in self.sources.items():
try:
data = source.retrieve(driver, step)
except StepDataNotAvailable as ex:
LOG.warning(f"[{driver.journey.get('reference')}:{step.name}] Data from sub-source '{source.title}' not found")
raise ex
if type(data) is not dict:
data = {"data":data}
final_data.update(data)
return final_data
|
(*, title: str, processes=NOTHING, sources: Dict[str, easul.source.Source] = NOTHING) -> None
|
45,196 |
easul.source
|
__eq__
|
Method generated by attrs for class CollatedSource.
|
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)
|
45,199 |
easul.source
|
__ne__
|
Method generated by attrs for class CollatedSource.
| null |
(self, other)
|
45,204 |
easul.source
|
_retrieve_raw_data
| null |
def _retrieve_raw_data(self, driver, step):
final_data = {}
for source_name, source in self.sources.items():
try:
data = source.retrieve(driver, step)
except StepDataNotAvailable as ex:
LOG.warning(f"[{driver.journey.get('reference')}:{step.name}] Data from sub-source '{source.title}' not found")
raise ex
if type(data) is not dict:
data = {"data":data}
final_data.update(data)
return final_data
|
(self, driver, step)
|
45,207 |
colour
|
Color
|
Abstraction of a color object
Color object keeps information of a color. It can input/output to different
format (HSL, RGB, HEX, WEB) and their partial representation.
>>> from colour import Color, HSL
>>> b = Color()
>>> b.hsl = HSL.BLUE
Access values
-------------
>>> b.hue # doctest: +ELLIPSIS
0.66...
>>> b.saturation
1.0
>>> b.luminance
0.5
>>> b.red
0.0
>>> b.blue
1.0
>>> b.green
0.0
>>> b.rgb
(0.0, 0.0, 1.0)
>>> b.hsl # doctest: +ELLIPSIS
(0.66..., 1.0, 0.5)
>>> b.hex
'#00f'
Change values
-------------
Let's change Hue toward red tint:
>>> b.hue = 0.0
>>> b.hex
'#f00'
>>> b.hue = 2.0/3
>>> b.hex
'#00f'
In the other way round:
>>> b.hex = '#f00'
>>> b.hsl
(0.0, 1.0, 0.5)
Long hex can be accessed directly:
>>> b.hex_l = '#123456'
>>> b.hex_l
'#123456'
>>> b.hex
'#123456'
>>> b.hex_l = '#ff0000'
>>> b.hex_l
'#ff0000'
>>> b.hex
'#f00'
Convenience
-----------
>>> c = Color('blue')
>>> c
<Color blue>
>>> c.hue = 0
>>> c
<Color red>
>>> c.saturation = 0.0
>>> c.hsl # doctest: +ELLIPSIS
(..., 0.0, 0.5)
>>> c.rgb
(0.5, 0.5, 0.5)
>>> c.hex
'#7f7f7f'
>>> c
<Color #7f7f7f>
>>> c.luminance = 0.0
>>> c
<Color black>
>>> c.hex
'#000'
>>> c.green = 1.0
>>> c.blue = 1.0
>>> c.hex
'#0ff'
>>> c
<Color cyan>
>>> c = Color('blue', luminance=0.75)
>>> c
<Color #7f7fff>
>>> c = Color('red', red=0.5)
>>> c
<Color #7f0000>
>>> print(c)
#7f0000
You can try to query unexisting attributes:
>>> c.lightness # doctest: +ELLIPSIS
Traceback (most recent call last):
...
AttributeError: 'lightness' not found
TODO: could add HSV, CMYK, YUV conversion.
# >>> b.hsv
# >>> b.value
# >>> b.cyan
# >>> b.magenta
# >>> b.yellow
# >>> b.key
# >>> b.cmyk
Recursive init
--------------
To support blind conversion of web strings (or already converted object),
the Color object supports instantiation with another Color object.
>>> Color(Color(Color('red')))
<Color red>
Equality support
----------------
Default equality is RGB hex comparison:
>>> Color('red') == Color('blue')
False
>>> Color('red') == Color('red')
True
>>> Color('red') != Color('blue')
True
>>> Color('red') != Color('red')
False
But this can be changed:
>>> saturation_equality = lambda c1, c2: c1.luminance == c2.luminance
>>> Color('red', equality=saturation_equality) == Color('blue')
True
Subclassing support
-------------------
You should be able to subclass ``Color`` object without any issues::
>>> class Tint(Color):
... pass
And keep the internal API working::
>>> Tint("red").hsl
(0.0, 1.0, 0.5)
|
class Color(object):
"""Abstraction of a color object
Color object keeps information of a color. It can input/output to different
format (HSL, RGB, HEX, WEB) and their partial representation.
>>> from colour import Color, HSL
>>> b = Color()
>>> b.hsl = HSL.BLUE
Access values
-------------
>>> b.hue # doctest: +ELLIPSIS
0.66...
>>> b.saturation
1.0
>>> b.luminance
0.5
>>> b.red
0.0
>>> b.blue
1.0
>>> b.green
0.0
>>> b.rgb
(0.0, 0.0, 1.0)
>>> b.hsl # doctest: +ELLIPSIS
(0.66..., 1.0, 0.5)
>>> b.hex
'#00f'
Change values
-------------
Let's change Hue toward red tint:
>>> b.hue = 0.0
>>> b.hex
'#f00'
>>> b.hue = 2.0/3
>>> b.hex
'#00f'
In the other way round:
>>> b.hex = '#f00'
>>> b.hsl
(0.0, 1.0, 0.5)
Long hex can be accessed directly:
>>> b.hex_l = '#123456'
>>> b.hex_l
'#123456'
>>> b.hex
'#123456'
>>> b.hex_l = '#ff0000'
>>> b.hex_l
'#ff0000'
>>> b.hex
'#f00'
Convenience
-----------
>>> c = Color('blue')
>>> c
<Color blue>
>>> c.hue = 0
>>> c
<Color red>
>>> c.saturation = 0.0
>>> c.hsl # doctest: +ELLIPSIS
(..., 0.0, 0.5)
>>> c.rgb
(0.5, 0.5, 0.5)
>>> c.hex
'#7f7f7f'
>>> c
<Color #7f7f7f>
>>> c.luminance = 0.0
>>> c
<Color black>
>>> c.hex
'#000'
>>> c.green = 1.0
>>> c.blue = 1.0
>>> c.hex
'#0ff'
>>> c
<Color cyan>
>>> c = Color('blue', luminance=0.75)
>>> c
<Color #7f7fff>
>>> c = Color('red', red=0.5)
>>> c
<Color #7f0000>
>>> print(c)
#7f0000
You can try to query unexisting attributes:
>>> c.lightness # doctest: +ELLIPSIS
Traceback (most recent call last):
...
AttributeError: 'lightness' not found
TODO: could add HSV, CMYK, YUV conversion.
# >>> b.hsv
# >>> b.value
# >>> b.cyan
# >>> b.magenta
# >>> b.yellow
# >>> b.key
# >>> b.cmyk
Recursive init
--------------
To support blind conversion of web strings (or already converted object),
the Color object supports instantiation with another Color object.
>>> Color(Color(Color('red')))
<Color red>
Equality support
----------------
Default equality is RGB hex comparison:
>>> Color('red') == Color('blue')
False
>>> Color('red') == Color('red')
True
>>> Color('red') != Color('blue')
True
>>> Color('red') != Color('red')
False
But this can be changed:
>>> saturation_equality = lambda c1, c2: c1.luminance == c2.luminance
>>> Color('red', equality=saturation_equality) == Color('blue')
True
Subclassing support
-------------------
You should be able to subclass ``Color`` object without any issues::
>>> class Tint(Color):
... pass
And keep the internal API working::
>>> Tint("red").hsl
(0.0, 1.0, 0.5)
"""
_hsl = None ## internal representation
def __init__(self, color=None,
pick_for=None, picker=RGB_color_picker, pick_key=hash_or_str,
**kwargs):
if pick_key is None:
pick_key = lambda x: x
if pick_for is not None:
color = picker(pick_key(pick_for))
if isinstance(color, Color):
self.web = color.web
else:
self.web = color if color else 'black'
self.equality = RGB_equivalence
for k, v in kwargs.items():
setattr(self, k, v)
def __getattr__(self, label):
if label.startswith("get_"):
raise AttributeError("'%s' not found" % label)
try:
return getattr(self, 'get_' + label)()
except AttributeError:
raise AttributeError("'%s' not found" % label)
def __setattr__(self, label, value):
if label not in ["_hsl", "equality"]:
fc = getattr(self, 'set_' + label)
fc(value)
else:
self.__dict__[label] = value
##
## Get
##
def get_hsl(self):
return tuple(self._hsl)
def get_hex(self):
return rgb2hex(self.rgb)
def get_hex_l(self):
return rgb2hex(self.rgb, force_long=True)
def get_rgb(self):
return hsl2rgb(self.hsl)
def get_hue(self):
return self.hsl[0]
def get_saturation(self):
return self.hsl[1]
def get_luminance(self):
return self.hsl[2]
def get_red(self):
return self.rgb[0]
def get_green(self):
return self.rgb[1]
def get_blue(self):
return self.rgb[2]
def get_web(self):
return hex2web(self.hex)
##
## Set
##
def set_hsl(self, value):
self._hsl = list(value)
def set_rgb(self, value):
self.hsl = rgb2hsl(value)
def set_hue(self, value):
self._hsl[0] = value
def set_saturation(self, value):
self._hsl[1] = value
def set_luminance(self, value):
self._hsl[2] = value
def set_red(self, value):
_, g, b = self.rgb
self.rgb = (value, g, b)
def set_green(self, value):
r, _, b = self.rgb
self.rgb = (r, value, b)
def set_blue(self, value):
r, g, _ = self.rgb
self.rgb = (r, g, value)
def set_hex(self, value):
self.rgb = hex2rgb(value)
set_hex_l = set_hex
def set_web(self, value):
self.hex = web2hex(value)
## range of color generation
def range_to(self, value, steps):
for hsl in color_scale(self._hsl, Color(value).hsl, steps - 1):
yield Color(hsl=hsl)
##
## Convenience
##
def __str__(self):
return "%s" % self.web
def __repr__(self):
return "<Color %s>" % self.web
def __eq__(self, other):
if isinstance(other, Color):
return self.equality(self, other)
return NotImplemented
if sys.version_info[0] == 2:
## Note: intended to be a backport of python 3 behavior
def __ne__(self, other):
equal = self.__eq__(other)
return equal if equal is NotImplemented else not equal
|
(color=None, pick_for=None, picker=<function RGB_color_picker at 0x7f4a17963010>, pick_key=<function hash_or_str at 0x7f4a179630a0>, **kwargs)
|
45,208 |
colour
|
__eq__
| null |
def __eq__(self, other):
if isinstance(other, Color):
return self.equality(self, other)
return NotImplemented
|
(self, other)
|
45,209 |
colour
|
__getattr__
| null |
def __getattr__(self, label):
if label.startswith("get_"):
raise AttributeError("'%s' not found" % label)
try:
return getattr(self, 'get_' + label)()
except AttributeError:
raise AttributeError("'%s' not found" % label)
|
(self, label)
|
45,210 |
colour
|
__init__
| null |
def __init__(self, color=None,
pick_for=None, picker=RGB_color_picker, pick_key=hash_or_str,
**kwargs):
if pick_key is None:
pick_key = lambda x: x
if pick_for is not None:
color = picker(pick_key(pick_for))
if isinstance(color, Color):
self.web = color.web
else:
self.web = color if color else 'black'
self.equality = RGB_equivalence
for k, v in kwargs.items():
setattr(self, k, v)
|
(self, color=None, pick_for=None, picker=<function RGB_color_picker at 0x7f4a17963010>, pick_key=<function hash_or_str at 0x7f4a179630a0>, **kwargs)
|
45,211 |
colour
|
__repr__
| null |
def __repr__(self):
return "<Color %s>" % self.web
|
(self)
|
45,212 |
colour
|
__setattr__
| null |
def __setattr__(self, label, value):
if label not in ["_hsl", "equality"]:
fc = getattr(self, 'set_' + label)
fc(value)
else:
self.__dict__[label] = value
|
(self, label, value)
|
45,213 |
colour
|
__str__
| null |
def __str__(self):
return "%s" % self.web
|
(self)
|
45,214 |
colour
|
get_blue
| null |
def get_blue(self):
return self.rgb[2]
|
(self)
|
45,215 |
colour
|
get_green
| null |
def get_green(self):
return self.rgb[1]
|
(self)
|
45,216 |
colour
|
get_hex
| null |
def get_hex(self):
return rgb2hex(self.rgb)
|
(self)
|
45,217 |
colour
|
get_hex_l
| null |
def get_hex_l(self):
return rgb2hex(self.rgb, force_long=True)
|
(self)
|
45,218 |
colour
|
get_hsl
| null |
def get_hsl(self):
return tuple(self._hsl)
|
(self)
|
45,219 |
colour
|
get_hue
| null |
def get_hue(self):
return self.hsl[0]
|
(self)
|
45,220 |
colour
|
get_luminance
| null |
def get_luminance(self):
return self.hsl[2]
|
(self)
|
45,221 |
colour
|
get_red
| null |
def get_red(self):
return self.rgb[0]
|
(self)
|
45,222 |
colour
|
get_rgb
| null |
def get_rgb(self):
return hsl2rgb(self.hsl)
|
(self)
|
45,223 |
colour
|
get_saturation
| null |
def get_saturation(self):
return self.hsl[1]
|
(self)
|
45,224 |
colour
|
get_web
| null |
def get_web(self):
return hex2web(self.hex)
|
(self)
|
45,225 |
colour
|
range_to
| null |
def range_to(self, value, steps):
for hsl in color_scale(self._hsl, Color(value).hsl, steps - 1):
yield Color(hsl=hsl)
|
(self, value, steps)
|
45,226 |
colour
|
set_blue
| null |
def set_blue(self, value):
r, g, _ = self.rgb
self.rgb = (r, g, value)
|
(self, value)
|
45,227 |
colour
|
set_green
| null |
def set_green(self, value):
r, _, b = self.rgb
self.rgb = (r, value, b)
|
(self, value)
|
45,228 |
colour
|
set_hex
| null |
def set_hex(self, value):
self.rgb = hex2rgb(value)
|
(self, value)
|
45,230 |
colour
|
set_hsl
| null |
def set_hsl(self, value):
self._hsl = list(value)
|
(self, value)
|
45,231 |
colour
|
set_hue
| null |
def set_hue(self, value):
self._hsl[0] = value
|
(self, value)
|
45,232 |
colour
|
set_luminance
| null |
def set_luminance(self, value):
self._hsl[2] = value
|
(self, value)
|
45,233 |
colour
|
set_red
| null |
def set_red(self, value):
_, g, b = self.rgb
self.rgb = (value, g, b)
|
(self, value)
|
45,234 |
colour
|
set_rgb
| null |
def set_rgb(self, value):
self.hsl = rgb2hsl(value)
|
(self, value)
|
45,235 |
colour
|
set_saturation
| null |
def set_saturation(self, value):
self._hsl[1] = value
|
(self, value)
|
45,236 |
colour
|
set_web
| null |
def set_web(self, value):
self.hex = web2hex(value)
|
(self, value)
|
45,237 |
easul.process
|
CombineDateTime
|
Combine 'date_field' and 'time_field' to create a datetime. If any of the values are None it will use the provided
default date/time. If
|
class CombineDateTime:
"""
Combine 'date_field' and 'time_field' to create a datetime. If any of the values are None it will use the provided
default date/time. If
"""
date_field:str = field()
time_field:str = field()
default_datetime:Optional[datetime] = field(default=None)
output_field:str = field()
def __call__(self, record):
date_value = record.get(self.date_field)
if date_value is None:
return self.default_datetime
time_value = record.get(self.time_field)
if time_value is None:
return self.default_datetime
record[self.output_field] = datetime.combine(date_value, time_value)
return record
|
(*, date_field: str, time_field: str, default_datetime: Optional[datetime.datetime] = None, output_field: str) -> None
|
45,238 |
easul.process
|
__call__
| null |
def __call__(self, record):
date_value = record.get(self.date_field)
if date_value is None:
return self.default_datetime
time_value = record.get(self.time_field)
if time_value is None:
return self.default_datetime
record[self.output_field] = datetime.combine(date_value, time_value)
return record
|
(self, record)
|
45,239 |
easul.process
|
__eq__
|
Method generated by attrs for class CombineDateTime.
|
# 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)
|
45,242 |
easul.process
|
__ne__
|
Method generated by attrs for class CombineDateTime.
| null |
(self, other)
|
45,245 |
easul.decision
|
CompareInputAndResultDecision
|
Decision which returns one next step (true_step) if the value from input is the same as the result of the algorithm and
another next step (false_step) is not.
|
class CompareInputAndResultDecision(Decision):
"""
Decision which returns one next step (true_step) if the value from input is the same as the result of the algorithm and
another next step (false_step) is not.
"""
input_field = field()
true_step = field()
false_step = field()
input_mapping = field(default=None)
result_mapping = field(default=None)
def decide_outcome(self, result, context, data, step):
input_value = data.get(self.input_field)
if self.input_mapping:
input_value = self.input_mapping.get(input_value)
result_value = result.value
if self.result_mapping:
result_value = self.result_mapping.get(result_value)
if input_value == result_value:
return ResultOutcome(outcome_step=step, next_step=self.true_step, reason=f"decision '{result_value}' and input match",
input_data=data, context=context, result=result, value=1)
return ResultOutcome(outcome_step=step, next_step=self.false_step, reason=f"decision '{result_value})' does not match input '{input_value})'",
input_data=data, context=context, result=result, value=0)
|
(*, input_field, true_step, false_step, input_mapping=None, result_mapping=None) -> None
|
45,246 |
easul.decision
|
__eq__
|
Method generated by attrs for class CompareInputAndResultDecision.
|
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)
|
45,249 |
easul.decision
|
__ne__
|
Method generated by attrs for class CompareInputAndResultDecision.
| null |
(self, other)
|
45,252 |
easul.decision
|
decide_outcome
| null |
def decide_outcome(self, result, context, data, step):
input_value = data.get(self.input_field)
if self.input_mapping:
input_value = self.input_mapping.get(input_value)
result_value = result.value
if self.result_mapping:
result_value = self.result_mapping.get(result_value)
if input_value == result_value:
return ResultOutcome(outcome_step=step, next_step=self.true_step, reason=f"decision '{result_value}' and input match",
input_data=data, context=context, result=result, value=1)
return ResultOutcome(outcome_step=step, next_step=self.false_step, reason=f"decision '{result_value})' does not match input '{input_value})'",
input_data=data, context=context, result=result, value=0)
|
(self, result, context, data, step)
|
45,254 |
easul.action
|
CompleteJourneyAction
|
Action which completes a journey following the run.
|
class CompleteJourneyAction(Action):
"""
Action which completes a journey following the run.
"""
def after_run(self, event):
event.driver._client.complete_journey(reference=event.driver.journey["reference"])
event.driver.journey["complete"]=1
|
() -> None
|
45,255 |
easul.action
|
__eq__
|
Method generated by attrs for class CompleteJourneyAction.
|
"""
"""
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)
|
45,258 |
easul.action
|
__ne__
|
Method generated by attrs for class CompleteJourneyAction.
| null |
(self, other)
|
45,262 |
easul.action
|
after_run
| null |
def after_run(self, event):
event.driver._client.complete_journey(reference=event.driver.journey["reference"])
event.driver.journey["complete"]=1
|
(self, event)
|
45,267 |
easul.source
|
ConstantSource
|
Simple source which returns constant data. It does not differentiate between specific journeys
(to do this you can use a StaticSource).
|
class ConstantSource(Source):
"""
Simple source which returns constant data. It does not differentiate between specific journeys
(to do this you can use a StaticSource).
"""
data:Any = field()
def retrieve(self, driver, step):
return self.data
|
(*, title: str, processes=NOTHING, data: Any) -> None
|
45,268 |
easul.source
|
__eq__
|
Method generated by attrs for class ConstantSource.
|
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)
|
45,271 |
easul.source
|
__ne__
|
Method generated by attrs for class ConstantSource.
| null |
(self, other)
|
45,276 |
easul.source
|
_retrieve_raw_data
| null |
@abstractmethod
def _retrieve_raw_data(self, driver, step):
pass
|
(self, driver, step)
|
45,278 |
easul.source
|
retrieve
| null |
def retrieve(self, driver, step):
return self.data
|
(self, driver, step)
|
45,279 |
easul.visual.element.element
|
Container
| null |
class Container(Element):
elements = field(factory=list)
def create(self, **kwargs):
"""
Create element container for output
:param form:
:return:
"""
output = []
start = self.render_content_start()
if start:
output.append(start)
body = self.render_content_body(**kwargs)
if body:
output.append(body)
end = self.render_content_end()
if end:
output.append(end)
return "".join(output)
def render_content_body(self, **kwargs):
"""
For each child element renders content using the classes'
before_add_child() the child's create function and
the classes' after_add_child()
:param html:
:param form:
:return:
"""
child_elements = self.elements
if child_elements is None:
return ""
content_list = []
for child_element in child_elements:
before = self.before_add_child(child_element)
if before:
content_list.append(before)
content = child_element.create(**kwargs)
if content:
content_list.append(content)
after = self.after_add_child(child_element)
if after:
content_list.append(after)
return "".join(content_list)
def before_add_child(self, child_element):
"""
Rendered before each child element.
:param child_element:
:return:
"""
pass
def after_add_child(self, child_element):
"""
Rendered after each child element.
:param child_element:
:return:
"""
pass
def generate_metadata(self, algorithm, dataset, **kwargs):
metadata = {}
for child_element in self.elements:
child_metadata = child_element.generate_metadata(algorithm=algorithm, dataset=dataset, **kwargs)
if child_metadata:
metadata.update(child_metadata)
return metadata
def generate_context(self, algorithm, input_data, visual, **kwargs):
ctx = {}
for element in self.elements:
element_ctx = element.generate_context(algorithm=algorithm, input_data=input_data, visual=visual, **kwargs)
if not element_ctx:
continue
ctx.update(element_ctx)
return ctx
|
(*, name='untitled', help='', title='Untitled', fill_container=False, style=None, html_class='', html_tag='h5', elements=NOTHING) -> None
|
45,280 |
easul.visual.element.element
|
__eq__
|
Method generated by attrs for class Container.
|
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)
|
45,283 |
easul.visual.element.element
|
__ne__
|
Method generated by attrs for class Container.
| null |
(self, other)
|
45,286 |
easul.visual.element.element
|
_get_context
| null |
def _get_context(self, **kwargs):
pass
|
(self, **kwargs)
|
45,287 |
easul.visual.element.element
|
after_add_child
|
Rendered after each child element.
:param child_element:
:return:
|
def after_add_child(self, child_element):
"""
Rendered after each child element.
:param child_element:
:return:
"""
pass
|
(self, child_element)
|
45,288 |
easul.visual.element.element
|
before_add_child
|
Rendered before each child element.
:param child_element:
:return:
|
def before_add_child(self, child_element):
"""
Rendered before each child element.
:param child_element:
:return:
"""
pass
|
(self, child_element)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.