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,022 |
easul.decision
|
describe
| null |
def describe(self):
desc = super().describe()
desc.update({
"next_step": self.next_step.title + "(" + self.next_step.name + ")",
})
return desc
|
(self)
|
46,023 |
easul.outcome
|
PauseOutcome
|
Outcome indicating that system should pause and only continue when pushed.
|
class PauseOutcome(Outcome):
"""
Outcome indicating that system should pause and only continue when pushed.
"""
pass
|
(*, outcome_step, next_step, reason, context=None, input_data=None) -> None
|
46,024 |
easul.outcome
|
__eq__
|
Method generated by attrs for class PauseOutcome.
|
from attrs import define, field
@define(kw_only=True)
class Outcome:
"""
Base Outcome class. Output by Decision classes and contains information on the next step (based on the decision),
the reason for the outcome/decision and context related to the result.
"""
outcome_step = field()
next_step = field()
reason = field()
context = field(default=None)
input_data = field(default=None)
def asdict(self):
return {
"outcome_step":self.outcome_step.name,
"next_step":self.next_step.name if self.next_step else None,
"reason":self.reason,
"context":self.context if self.context else {},
"input_data": self.input_data if type(self.input_data) is dict else self.input_data.asdict() if self.input_data else {}
}
def __repr__(self):
return f"<{self.__class__.__name__ } {self.asdict()}>"
|
(self, other)
|
46,027 |
easul.outcome
|
__ne__
|
Method generated by attrs for class PauseOutcome.
| null |
(self, other)
|
46,031 |
easul.step
|
PauseStep
|
Step which indicates that the process should be paused. Used to prevent runs from getting into iterative loops.
|
class PauseStep(ActionStep):
"""
Step which indicates that the process should be paused. Used to prevent runs from getting into iterative loops.
"""
next_step: Step = field()
def _determine_outcome(self, event):
event.driver.store_step(self.name, StepStatuses.PAUSE, status_info="Paused for next time transition", timestamp=event.driver.clock.timestamp)
return PauseOutcome(outcome_step=self, next_step=self.next_step, reason="next", input_data=None)
@property
def possible_links(self):
return {"next": self.next_step}
def describe(self):
desc = super().describe()
desc.update({
"next_step": self.next_step.title
})
return desc
|
(*, title, visual=None, exclude_from_chart=False, name=None, actions=NOTHING, source=None, next_step: easul.step.Step) -> None
|
46,032 |
easul.step
|
__eq__
|
Method generated by attrs for class PauseStep.
|
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,035 |
easul.step
|
__ne__
|
Method generated by attrs for class PauseStep.
| null |
(self, other)
|
46,038 |
easul.step
|
_determine_outcome
| null |
def _determine_outcome(self, event):
event.driver.store_step(self.name, StepStatuses.PAUSE, status_info="Paused for next time transition", timestamp=event.driver.clock.timestamp)
return PauseOutcome(outcome_step=self, next_step=self.next_step, reason="next", input_data=None)
|
(self, event)
|
46,043 |
easul.step
|
describe
| null |
def describe(self):
desc = super().describe()
desc.update({
"next_step": self.next_step.title
})
return desc
|
(self)
|
46,048 |
easul.visual.render
|
PlainRenderer
| null |
class PlainRenderer:
def setup_render(self):
matplotlib.use('Agg')
return [
"""
<style>label.easul { font-weight:bold; display:block; }
</style>
"""
]
def render(self, data):
pass
def create(self, visual, **kwargs):
rendered = self.setup_render()
for element in visual.elements:
html = element.create(**kwargs, visual=visual)
rendered.append(html)
final_list = list(map(str, rendered))
data = "".join(final_list)
self.render("".join(final_list))
return data
|
()
|
46,049 |
easul.visual.render
|
create
| null |
def create(self, visual, **kwargs):
rendered = self.setup_render()
for element in visual.elements:
html = element.create(**kwargs, visual=visual)
rendered.append(html)
final_list = list(map(str, rendered))
data = "".join(final_list)
self.render("".join(final_list))
return data
|
(self, visual, **kwargs)
|
46,050 |
easul.visual.render
|
render
| null |
def render(self, data):
pass
|
(self, data)
|
46,051 |
easul.visual.render
|
setup_render
| null |
def setup_render(self):
matplotlib.use('Agg')
return [
"""
<style>label.easul { font-weight:bold; display:block; }
</style>
"""
]
|
(self)
|
46,052 |
easul.plan._plan
|
Plan
|
Core class for handling Plans.
which includes re-usable/replaceable steps, sources, algorithms, schemas, visuals and states.
|
class Plan:
"""
Core class for handling Plans.
which includes re-usable/replaceable steps, sources, algorithms, schemas, visuals and states.
"""
title = field()
steps:Dict[str, Step] = field(factory=DeferredCatalog)
sources = field(factory=DeferredCatalog)
algorithms = field(factory=DeferredCatalog)
schemas = field(factory=DeferredCatalog)
visuals = field(factory=DeferredCatalog)
states = field(factory=DeferredCatalog)
config = field(factory=DeferredCatalog)
_check_steps = field(init=False)
@_check_steps.default
def default_check_steps(self):
return list(filter(lambda x: isinstance(x, CheckEndStep), self.steps.values()))
def _check_steps_for_end(self, driver):
for cs in self._check_steps:
cs.run_all(driver=driver)
def run(self, driver):
"""
Run plan for driver-based on a specific journey.
Args:
driver:
Returns:
"""
from easul.step import StepStatuses
steps = self.steps
if driver.journey.get("complete") == 1:
LOG.info(f"Journey '{driver.journey.get('reference')}' is already complete")
return
self._check_steps_for_end(driver)
current_journey_step = driver.get_current_journey_step()
if current_journey_step is None:
next_step = get_start_step(steps)
step_status = StepStatuses.INIT.name
else:
step_status = current_journey_step["status"]
next_step = steps[current_journey_step["name"]]
if step_status in [StepStatuses.WAITING.name]:
event = ActionEvent(step=next_step, driver=driver, previous_outcome=None)
outcome = run_step_logic(next_step,event)
if is_successful_outcome(outcome) is False:
return
next_step = outcome.next_step
elif step_status == StepStatuses.COMPLETE.name:
journey_step_outcome = current_journey_step["outcome"]
if journey_step_outcome:
next_step_name = current_journey_step.get("next_step")
if next_step_name is None:
LOG.warning(f"No next step in journey from previous outcome")
next_step = None
else:
next_step = steps.get(next_step_name)
else:
next_step = None
if not next_step:
self._mark_complete(driver)
return
run_step_chain(next_step, driver)
def _mark_complete(self, driver):
LOG.info(f"Journey marked complete [{driver.journey['reference']}]")
driver._client.mark_complete(reference=driver.journey["reference"])
def run_from(self, step_name:str, driver:"easul.driver.Driver"):
"""
Run plan for driver-based on a specific journey from a particular step
Args:
step_name: name of step
driver:
Returns:
"""
from_step = self.steps.get(step_name)
run_step_chain(from_step, driver)
def add_step(self, name:str, step):
step.name = name
self.steps[name] = step
self._check_steps = self.default_check_steps()
def get_or_defer_property(self, property, name):
if name not in getattr(self, property):
return DeferredItem(plan=self, property=property, name=name)
return getattr(self, property)[name]
def get_property(self, property, name=None):
if not name:
return getattr(self, property)
try:
return getattr(self, property)[name]
except KeyError:
raise SystemError(f"There is no '{name}' present in '{property}'")
def get_step(self, name:str):
return self.get_or_defer_property("steps", name)
def add_state(self, name:str, state):
self.states[name] = state
def get_state(self, name:str):
return self.get_or_defer_property("states", name)
def add_schema(self, name:str, schema):
self.schemas[name] = schema
def get_schema(self, name:str):
return self.get_or_defer_property("schemas", name)
def add_algorithm(self, name:str, algorithm):
self.algorithms[name] = algorithm
def get_algorithm(self, name:str):
return self.get_or_defer_property("algorithms", name)
def add_source(self, name:str, source):
self.sources[name] = source
def get_source(self, name:str):
return self.get_or_defer_property("sources", name)
def add_visual(self, name:str, visual):
self.visuals[name] = visual
def get_visual(self, name:str):
return self.get_or_defer_property("visuals", name)
def replace_source(self, name, source):
actual_source = self.sources.get(name)
if not actual_source:
raise SystemError(f"Actual source '{name}' does not exist in plan")
if isinstance(source, CollatedReplace):
replace_sources = actual_source.sources
for sub_source_name, sub_source in source.kwargs.items():
if not sub_source_name in replace_sources:
raise ValueError(f"Replacement source name '{sub_source_name} does not exist in the collated source")
replace_actual_source = replace_sources[sub_source_name]
print(f"replace_actual_source:{replace_actual_source}")
replace_sources[sub_source_name] = StaticSource(source_data ={source.reference:sub_source}, title= replace_actual_source.title + "_" + sub_source_name, processes= replace_actual_source.processes)
self.sources[name] = CollatedSource(sources = replace_sources,title= actual_source.title, processes = actual_source.processes)
else:
self.sources[name] = StaticSource(source_data=source, title = actual_source.title, processes = actual_source.processes)
|
(*, title, steps: Dict[str, easul.step.Step] = NOTHING, sources=NOTHING, algorithms=NOTHING, schemas=NOTHING, visuals=NOTHING, states=NOTHING, config=NOTHING) -> None
|
46,053 |
easul.plan._plan
|
__eq__
|
Method generated by attrs for class Plan.
|
from typing import Dict
from attrs import define, field
import logging
from easul.source import LOG, StaticSource, CollatedSource
from easul.step import ActionEvent, CheckEndStep, StepStatuses, Step
from easul.util import DeferredItem,DeferredCatalog,is_successful_outcome, get_start_step
LOG = logging.getLogger(__name__)
from easul.run import run_step_chain
@define(kw_only=True)
class Plan:
"""
Core class for handling Plans.
which includes re-usable/replaceable steps, sources, algorithms, schemas, visuals and states.
"""
title = field()
steps:Dict[str, Step] = field(factory=DeferredCatalog)
sources = field(factory=DeferredCatalog)
algorithms = field(factory=DeferredCatalog)
schemas = field(factory=DeferredCatalog)
visuals = field(factory=DeferredCatalog)
states = field(factory=DeferredCatalog)
config = field(factory=DeferredCatalog)
_check_steps = field(init=False)
@_check_steps.default
def default_check_steps(self):
return list(filter(lambda x: isinstance(x, CheckEndStep), self.steps.values()))
def _check_steps_for_end(self, driver):
for cs in self._check_steps:
cs.run_all(driver=driver)
def run(self, driver):
"""
Run plan for driver-based on a specific journey.
Args:
driver:
Returns:
"""
from easul.step import StepStatuses
steps = self.steps
if driver.journey.get("complete") == 1:
LOG.info(f"Journey '{driver.journey.get('reference')}' is already complete")
return
self._check_steps_for_end(driver)
current_journey_step = driver.get_current_journey_step()
if current_journey_step is None:
next_step = get_start_step(steps)
step_status = StepStatuses.INIT.name
else:
step_status = current_journey_step["status"]
next_step = steps[current_journey_step["name"]]
if step_status in [StepStatuses.WAITING.name]:
event = ActionEvent(step=next_step, driver=driver, previous_outcome=None)
outcome = run_step_logic(next_step,event)
if is_successful_outcome(outcome) is False:
return
next_step = outcome.next_step
elif step_status == StepStatuses.COMPLETE.name:
journey_step_outcome = current_journey_step["outcome"]
if journey_step_outcome:
next_step_name = current_journey_step.get("next_step")
if next_step_name is None:
LOG.warning(f"No next step in journey from previous outcome")
next_step = None
else:
next_step = steps.get(next_step_name)
else:
next_step = None
if not next_step:
self._mark_complete(driver)
return
run_step_chain(next_step, driver)
def _mark_complete(self, driver):
LOG.info(f"Journey marked complete [{driver.journey['reference']}]")
driver._client.mark_complete(reference=driver.journey["reference"])
def run_from(self, step_name:str, driver:"easul.driver.Driver"):
"""
Run plan for driver-based on a specific journey from a particular step
Args:
step_name: name of step
driver:
Returns:
"""
from_step = self.steps.get(step_name)
run_step_chain(from_step, driver)
def add_step(self, name:str, step):
step.name = name
self.steps[name] = step
self._check_steps = self.default_check_steps()
def get_or_defer_property(self, property, name):
if name not in getattr(self, property):
return DeferredItem(plan=self, property=property, name=name)
return getattr(self, property)[name]
def get_property(self, property, name=None):
if not name:
return getattr(self, property)
try:
return getattr(self, property)[name]
except KeyError:
raise SystemError(f"There is no '{name}' present in '{property}'")
def get_step(self, name:str):
return self.get_or_defer_property("steps", name)
def add_state(self, name:str, state):
self.states[name] = state
def get_state(self, name:str):
return self.get_or_defer_property("states", name)
def add_schema(self, name:str, schema):
self.schemas[name] = schema
def get_schema(self, name:str):
return self.get_or_defer_property("schemas", name)
def add_algorithm(self, name:str, algorithm):
self.algorithms[name] = algorithm
def get_algorithm(self, name:str):
return self.get_or_defer_property("algorithms", name)
def add_source(self, name:str, source):
self.sources[name] = source
def get_source(self, name:str):
return self.get_or_defer_property("sources", name)
def add_visual(self, name:str, visual):
self.visuals[name] = visual
def get_visual(self, name:str):
return self.get_or_defer_property("visuals", name)
def replace_source(self, name, source):
actual_source = self.sources.get(name)
if not actual_source:
raise SystemError(f"Actual source '{name}' does not exist in plan")
if isinstance(source, CollatedReplace):
replace_sources = actual_source.sources
for sub_source_name, sub_source in source.kwargs.items():
if not sub_source_name in replace_sources:
raise ValueError(f"Replacement source name '{sub_source_name} does not exist in the collated source")
replace_actual_source = replace_sources[sub_source_name]
print(f"replace_actual_source:{replace_actual_source}")
replace_sources[sub_source_name] = StaticSource(source_data ={source.reference:sub_source}, title= replace_actual_source.title + "_" + sub_source_name, processes= replace_actual_source.processes)
self.sources[name] = CollatedSource(sources = replace_sources,title= actual_source.title, processes = actual_source.processes)
else:
self.sources[name] = StaticSource(source_data=source, title = actual_source.title, processes = actual_source.processes)
|
(self, other)
|
46,056 |
easul.plan._plan
|
__ne__
|
Method generated by attrs for class Plan.
| null |
(self, other)
|
46,059 |
easul.plan._plan
|
_check_steps_for_end
| null |
def _check_steps_for_end(self, driver):
for cs in self._check_steps:
cs.run_all(driver=driver)
|
(self, driver)
|
46,060 |
easul.plan._plan
|
_mark_complete
| null |
def _mark_complete(self, driver):
LOG.info(f"Journey marked complete [{driver.journey['reference']}]")
driver._client.mark_complete(reference=driver.journey["reference"])
|
(self, driver)
|
46,061 |
easul.plan._plan
|
add_algorithm
| null |
def add_algorithm(self, name:str, algorithm):
self.algorithms[name] = algorithm
|
(self, name: str, algorithm)
|
46,062 |
easul.plan._plan
|
add_schema
| null |
def add_schema(self, name:str, schema):
self.schemas[name] = schema
|
(self, name: str, schema)
|
46,063 |
easul.plan._plan
|
add_source
| null |
def add_source(self, name:str, source):
self.sources[name] = source
|
(self, name: str, source)
|
46,064 |
easul.plan._plan
|
add_state
| null |
def add_state(self, name:str, state):
self.states[name] = state
|
(self, name: str, state)
|
46,065 |
easul.plan._plan
|
add_step
| null |
def add_step(self, name:str, step):
step.name = name
self.steps[name] = step
self._check_steps = self.default_check_steps()
|
(self, name: str, step)
|
46,066 |
easul.plan._plan
|
add_visual
| null |
def add_visual(self, name:str, visual):
self.visuals[name] = visual
|
(self, name: str, visual)
|
46,067 |
easul.plan._plan
|
default_check_steps
| null |
@_check_steps.default
def default_check_steps(self):
return list(filter(lambda x: isinstance(x, CheckEndStep), self.steps.values()))
|
(self)
|
46,068 |
easul.plan._plan
|
get_algorithm
| null |
def get_algorithm(self, name:str):
return self.get_or_defer_property("algorithms", name)
|
(self, name: str)
|
46,069 |
easul.plan._plan
|
get_or_defer_property
| null |
def get_or_defer_property(self, property, name):
if name not in getattr(self, property):
return DeferredItem(plan=self, property=property, name=name)
return getattr(self, property)[name]
|
(self, property, name)
|
46,070 |
easul.plan._plan
|
get_property
| null |
def get_property(self, property, name=None):
if not name:
return getattr(self, property)
try:
return getattr(self, property)[name]
except KeyError:
raise SystemError(f"There is no '{name}' present in '{property}'")
|
(self, property, name=None)
|
46,071 |
easul.plan._plan
|
get_schema
| null |
def get_schema(self, name:str):
return self.get_or_defer_property("schemas", name)
|
(self, name: str)
|
46,072 |
easul.plan._plan
|
get_source
| null |
def get_source(self, name:str):
return self.get_or_defer_property("sources", name)
|
(self, name: str)
|
46,073 |
easul.plan._plan
|
get_state
| null |
def get_state(self, name:str):
return self.get_or_defer_property("states", name)
|
(self, name: str)
|
46,074 |
easul.plan._plan
|
get_step
| null |
def get_step(self, name:str):
return self.get_or_defer_property("steps", name)
|
(self, name: str)
|
46,075 |
easul.plan._plan
|
get_visual
| null |
def get_visual(self, name:str):
return self.get_or_defer_property("visuals", name)
|
(self, name: str)
|
46,076 |
easul.plan._plan
|
replace_source
| null |
def replace_source(self, name, source):
actual_source = self.sources.get(name)
if not actual_source:
raise SystemError(f"Actual source '{name}' does not exist in plan")
if isinstance(source, CollatedReplace):
replace_sources = actual_source.sources
for sub_source_name, sub_source in source.kwargs.items():
if not sub_source_name in replace_sources:
raise ValueError(f"Replacement source name '{sub_source_name} does not exist in the collated source")
replace_actual_source = replace_sources[sub_source_name]
print(f"replace_actual_source:{replace_actual_source}")
replace_sources[sub_source_name] = StaticSource(source_data ={source.reference:sub_source}, title= replace_actual_source.title + "_" + sub_source_name, processes= replace_actual_source.processes)
self.sources[name] = CollatedSource(sources = replace_sources,title= actual_source.title, processes = actual_source.processes)
else:
self.sources[name] = StaticSource(source_data=source, title = actual_source.title, processes = actual_source.processes)
|
(self, name, source)
|
46,077 |
easul.plan._plan
|
run
|
Run plan for driver-based on a specific journey.
Args:
driver:
Returns:
|
def run(self, driver):
"""
Run plan for driver-based on a specific journey.
Args:
driver:
Returns:
"""
from easul.step import StepStatuses
steps = self.steps
if driver.journey.get("complete") == 1:
LOG.info(f"Journey '{driver.journey.get('reference')}' is already complete")
return
self._check_steps_for_end(driver)
current_journey_step = driver.get_current_journey_step()
if current_journey_step is None:
next_step = get_start_step(steps)
step_status = StepStatuses.INIT.name
else:
step_status = current_journey_step["status"]
next_step = steps[current_journey_step["name"]]
if step_status in [StepStatuses.WAITING.name]:
event = ActionEvent(step=next_step, driver=driver, previous_outcome=None)
outcome = run_step_logic(next_step,event)
if is_successful_outcome(outcome) is False:
return
next_step = outcome.next_step
elif step_status == StepStatuses.COMPLETE.name:
journey_step_outcome = current_journey_step["outcome"]
if journey_step_outcome:
next_step_name = current_journey_step.get("next_step")
if next_step_name is None:
LOG.warning(f"No next step in journey from previous outcome")
next_step = None
else:
next_step = steps.get(next_step_name)
else:
next_step = None
if not next_step:
self._mark_complete(driver)
return
run_step_chain(next_step, driver)
|
(self, driver)
|
46,078 |
easul.plan._plan
|
run_from
|
Run plan for driver-based on a specific journey from a particular step
Args:
step_name: name of step
driver:
Returns:
|
def run_from(self, step_name:str, driver:"easul.driver.Driver"):
"""
Run plan for driver-based on a specific journey from a particular step
Args:
step_name: name of step
driver:
Returns:
"""
from_step = self.steps.get(step_name)
run_step_chain(from_step, driver)
|
(self, step_name: str, driver: 'easul.driver.Driver')
|
46,079 |
easul.action
|
PreRunStateAction
|
Action which updates a state with a new value following the run.
|
class PreRunStateAction(Action):
"""
Action which updates a state with a new value following the run.
"""
state = field()
state_value = field()
def after_run(self, event):
event.driver.store_state(self.state.label, self.state_value, event.step.name)
|
(*, state, state_value) -> None
|
46,080 |
easul.action
|
__eq__
|
Method generated by attrs for class PreRunStateAction.
|
"""
"""
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,083 |
easul.action
|
__ne__
|
Method generated by attrs for class PreRunStateAction.
| null |
(self, other)
|
46,087 |
easul.action
|
after_run
| null |
def after_run(self, event):
event.driver.store_state(self.state.label, self.state_value, event.step.name)
|
(self, event)
|
46,092 |
easul.step
|
PreStep
|
Step which precedes another one.
NB. It may include extraction of source data but this is simply added to the outcome
without requiring a decision to be made.
|
class PreStep(ActionStep):
"""
Step which precedes another one.
NB. It may include extraction of source data but this is simply added to the outcome
without requiring a decision to be made.
"""
next_step: Step = field()
def _determine_outcome(self, event):
if self.source:
data = self._retrieve_data(event)
else:
data = None
return Outcome(outcome_step=self, next_step=self.next_step, reason="next", input_data=data)
@property
def possible_links(self):
return {"next": self.next_step}
def describe(self):
desc = super().describe()
desc.update({
"next_step": self.next_step.title
})
return desc
|
(*, title, visual=None, exclude_from_chart=False, name=None, actions=NOTHING, source=None, next_step: easul.step.Step) -> None
|
46,093 |
easul.step
|
__eq__
|
Method generated by attrs for class PreStep.
|
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,096 |
easul.step
|
__ne__
|
Method generated by attrs for class PreStep.
| null |
(self, other)
|
46,099 |
easul.step
|
_determine_outcome
| null |
def _determine_outcome(self, event):
if self.source:
data = self._retrieve_data(event)
else:
data = None
return Outcome(outcome_step=self, next_step=self.next_step, reason="next", input_data=data)
|
(self, event)
|
46,109 |
easul.visual.element.element
|
Prediction
|
Show prediction/result from algorithm input data
|
class Prediction(ValueElement):
"""
Show prediction/result from algorithm input data
"""
scope = ROW_SCOPE
label_side = "left"
as_value = field(default=False)
show_label = field(default=True)
def retrieve_value(self, result, **kwargs):
if not result:
raise VisualDataMissing(self, scope="result")
if self.as_value:
return result["value"]
return f"{result['label']}"
|
(*, 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', as_value=False, show_label=True) -> None
|
46,110 |
easul.visual.element.element
|
__eq__
|
Method generated by attrs for class Prediction.
|
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,113 |
easul.visual.element.element
|
__ne__
|
Method generated by attrs for class Prediction.
| null |
(self, other)
|
46,117 |
easul.visual.element.element
|
create
| null |
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)
|
(self, **kwargs)
|
46,118 |
easul.visual.element.element
|
generate_context
| null |
def generate_context(self, **kwargs):
pass
|
(self, **kwargs)
|
46,124 |
easul.visual.element.element
|
retrieve_value
| null |
def retrieve_value(self, result, **kwargs):
if not result:
raise VisualDataMissing(self, scope="result")
if self.as_value:
return result["value"]
return f"{result['label']}"
|
(self, result, **kwargs)
|
46,125 |
easul.algorithm.predictive
|
PredictiveAlgorithm
|
Base predictive algorithm based on AI or ML model. Includes support for an encoder and schema which are applied
on the input data if required.
|
class PredictiveAlgorithm(Algorithm):
"""
Base predictive algorithm based on AI or ML model. Includes support for an encoder and schema which are applied
on the input data if required.
"""
result_class = None
model:Any = field()
schema:ds.DataSchema = field()
encoder:Optional[ds.InputEncoder] = field(default=None)
unique_id = field(init=False)
@unique_id.default
def _default_unique_id(self):
return str(easul.util.new_id())
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)
def serialize_with_dataset_id(self):
return easul.util.to_serialized(self)
@property
def unique_digest(self):
digest = str(self.schema.unique_digest + "_" + self.unique_id).encode("utf-8")
return hashlib.sha256(digest).hexdigest()
@property
def help(self):
model_cls = self.model.__class__
return {
"type":model_cls.__name__
}
@abstractmethod
def _create_result(self, prediction):
pass
def __eq__(self, other):
return self.unique_digest == other.unique_digest
|
(*, title: str, model: Any, schema: easul.data.DataSchema, encoder: Optional[easul.data.InputEncoder] = None) -> None
|
46,128 |
easul.algorithm.predictive
|
__init__
|
Method generated by attrs for class PredictiveAlgorithm.
|
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
|
46,142 |
easul.algorithm.predictive
|
PredictiveTypes
|
An enumeration.
|
class PredictiveTypes(Enum):
REGRESSION = auto()
CLASSIFICATION = auto()
|
(value, names=None, *, module=None, qualname=None, type=None, start=1)
|
46,143 |
easul.algorithm.result
|
Probability
|
Probability(probability, label, value)
|
from easul.algorithm.result import Probability
|
(probability, label, value)
|
46,145 |
namedtuple_Probability
|
__new__
|
Create new instance of Probability(probability, label, value)
|
from builtins import function
|
(_cls, probability, label, value)
|
46,148 |
collections
|
_replace
|
Return a new Probability object replacing specified fields with new values
|
def namedtuple(typename, field_names, *, rename=False, defaults=None, module=None):
"""Returns a new subclass of tuple with named fields.
>>> Point = namedtuple('Point', ['x', 'y'])
>>> Point.__doc__ # docstring for the new class
'Point(x, y)'
>>> p = Point(11, y=22) # instantiate with positional args or keywords
>>> p[0] + p[1] # indexable like a plain tuple
33
>>> x, y = p # unpack like a regular tuple
>>> x, y
(11, 22)
>>> p.x + p.y # fields also accessible by name
33
>>> d = p._asdict() # convert to a dictionary
>>> d['x']
11
>>> Point(**d) # convert from a dictionary
Point(x=11, y=22)
>>> p._replace(x=100) # _replace() is like str.replace() but targets named fields
Point(x=100, y=22)
"""
# Validate the field names. At the user's option, either generate an error
# message or automatically replace the field name with a valid name.
if isinstance(field_names, str):
field_names = field_names.replace(',', ' ').split()
field_names = list(map(str, field_names))
typename = _sys.intern(str(typename))
if rename:
seen = set()
for index, name in enumerate(field_names):
if (not name.isidentifier()
or _iskeyword(name)
or name.startswith('_')
or name in seen):
field_names[index] = f'_{index}'
seen.add(name)
for name in [typename] + field_names:
if type(name) is not str:
raise TypeError('Type names and field names must be strings')
if not name.isidentifier():
raise ValueError('Type names and field names must be valid '
f'identifiers: {name!r}')
if _iskeyword(name):
raise ValueError('Type names and field names cannot be a '
f'keyword: {name!r}')
seen = set()
for name in field_names:
if name.startswith('_') and not rename:
raise ValueError('Field names cannot start with an underscore: '
f'{name!r}')
if name in seen:
raise ValueError(f'Encountered duplicate field name: {name!r}')
seen.add(name)
field_defaults = {}
if defaults is not None:
defaults = tuple(defaults)
if len(defaults) > len(field_names):
raise TypeError('Got more default values than field names')
field_defaults = dict(reversed(list(zip(reversed(field_names),
reversed(defaults)))))
# Variables used in the methods and docstrings
field_names = tuple(map(_sys.intern, field_names))
num_fields = len(field_names)
arg_list = ', '.join(field_names)
if num_fields == 1:
arg_list += ','
repr_fmt = '(' + ', '.join(f'{name}=%r' for name in field_names) + ')'
tuple_new = tuple.__new__
_dict, _tuple, _len, _map, _zip = dict, tuple, len, map, zip
# Create all the named tuple methods to be added to the class namespace
namespace = {
'_tuple_new': tuple_new,
'__builtins__': {},
'__name__': f'namedtuple_{typename}',
}
code = f'lambda _cls, {arg_list}: _tuple_new(_cls, ({arg_list}))'
__new__ = eval(code, namespace)
__new__.__name__ = '__new__'
__new__.__doc__ = f'Create new instance of {typename}({arg_list})'
if defaults is not None:
__new__.__defaults__ = defaults
@classmethod
def _make(cls, iterable):
result = tuple_new(cls, iterable)
if _len(result) != num_fields:
raise TypeError(f'Expected {num_fields} arguments, got {len(result)}')
return result
_make.__func__.__doc__ = (f'Make a new {typename} object from a sequence '
'or iterable')
def _replace(self, /, **kwds):
result = self._make(_map(kwds.pop, field_names, self))
if kwds:
raise ValueError(f'Got unexpected field names: {list(kwds)!r}')
return result
_replace.__doc__ = (f'Return a new {typename} object replacing specified '
'fields with new values')
def __repr__(self):
'Return a nicely formatted representation string'
return self.__class__.__name__ + repr_fmt % self
def _asdict(self):
'Return a new dict which maps field names to their values.'
return _dict(_zip(self._fields, self))
def __getnewargs__(self):
'Return self as a plain tuple. Used by copy and pickle.'
return _tuple(self)
# Modify function metadata to help with introspection and debugging
for method in (
__new__,
_make.__func__,
_replace,
__repr__,
_asdict,
__getnewargs__,
):
method.__qualname__ = f'{typename}.{method.__name__}'
# Build-up the class namespace dictionary
# and use type() to build the result class
class_namespace = {
'__doc__': f'{typename}({arg_list})',
'__slots__': (),
'_fields': field_names,
'_field_defaults': field_defaults,
'__new__': __new__,
'_make': _make,
'_replace': _replace,
'__repr__': __repr__,
'_asdict': _asdict,
'__getnewargs__': __getnewargs__,
'__match_args__': field_names,
}
for index, name in enumerate(field_names):
doc = _sys.intern(f'Alias for field number {index}')
class_namespace[name] = _tuplegetter(index, doc)
result = type(typename, (tuple,), class_namespace)
# For pickling to work, the __module__ variable needs to be set to the frame
# where the named tuple is created. Bypass this step in environments where
# sys._getframe is not defined (Jython for example) or sys._getframe is not
# defined for arguments greater than 0 (IronPython), or where the user has
# specified a particular module.
if module is None:
try:
module = _sys._getframe(1).f_globals.get('__name__', '__main__')
except (AttributeError, ValueError):
pass
if module is not None:
result.__module__ = module
return result
|
(self, /, **kwds)
|
46,149 |
easul.expression
|
QueryCountExpression
|
Expression which uses an operator function to test how many rows (value) in a pandas DataFrame meet a specific
query.
|
class QueryCountExpression(Expression):
"""
Expression which uses an operator function to test how many rows (value) in a pandas DataFrame meet a specific
query.
"""
query = field()
operator = field()
value = field()
label = field()
def evaluate(self, dset):
queried_data = dset.data.query(self.query)
rows = queried_data.shape[0]
if self.operator(rows, self.value):
return True
return False
|
(*, query, operator, value, label) -> None
|
46,150 |
easul.expression
|
__eq__
|
Method generated by attrs for class QueryCountExpression.
|
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)
|
46,153 |
easul.expression
|
__ne__
|
Method generated by attrs for class QueryCountExpression.
| null |
(self, other)
|
46,156 |
easul.expression
|
evaluate
| null |
def evaluate(self, dset):
queried_data = dset.data.query(self.query)
rows = queried_data.shape[0]
if self.operator(rows, self.value):
return True
return False
|
(self, dset)
|
46,157 |
easul.decision
|
RankedDecision
|
Extension of SelectCaseDecision which includes focuses on checking ranks which are turned into cases (e.g. low, medium, high) and operators.
|
class RankedDecision(SelectCaseDecision):
"""
Extension of SelectCaseDecision which includes focuses on checking ranks which are turned into cases (e.g. low, medium, high) and operators.
"""
ranks = field()
input_field = field()
cases = field(init=False)
def __attrs_post_init__(self):
from easul.expression import OperatorExpression
import operator
self.cases = [
DecisionCase(expression=OperatorExpression(input_field=self.input_field, value=value, operator=operator.eq),
true_step=rank_step) for value, rank_step in self.ranks.items()]
|
(*, default_step=None, ranks, input_field) -> None
|
46,158 |
easul.decision
|
__attrs_post_init__
| null |
def __attrs_post_init__(self):
from easul.expression import OperatorExpression
import operator
self.cases = [
DecisionCase(expression=OperatorExpression(input_field=self.input_field, value=value, operator=operator.eq),
true_step=rank_step) for value, rank_step in self.ranks.items()]
|
(self)
|
46,159 |
easul.decision
|
__eq__
|
Method generated by attrs for class RankedDecision.
|
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,162 |
easul.decision
|
__ne__
|
Method generated by attrs for class RankedDecision.
| null |
(self, other)
|
46,165 |
easul.decision
|
decide_outcome
| null |
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)
|
(self, result, context, data, step)
|
46,166 |
easul.decision
|
describe
| null |
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
|
(self)
|
46,167 |
easul.process
|
RecordApply
|
Apply specified function to record (rather than specific field) and return result in the 'target_field_name'
|
class RecordApply:
"""
Apply specified function to record (rather than specific field) and return result in the 'target_field_name'
"""
target_field_name:str = field()
fn:Callable = field()
def __call__(self, record):
record[self.target_field_name] = self.fn(record)
return record
|
(*, target_field_name: str, fn: Callable) -> None
|
46,168 |
easul.process
|
__call__
| null |
def __call__(self, record):
record[self.target_field_name] = self.fn(record)
return record
|
(self, record)
|
46,169 |
easul.process
|
__eq__
|
Method generated by attrs for class RecordApply.
|
# 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,172 |
easul.process
|
__ne__
|
Method generated by attrs for class RecordApply.
| null |
(self, other)
|
46,175 |
easul.process
|
ReformatDate
|
Converts field value string date in 'field_name' from a 'source_format' to a datetime object
and then back into a string with 'target_format'
|
class ReformatDate:
"""
Converts field value string date in 'field_name' from a 'source_format' to a datetime object
and then back into a string with 'target_format'
"""
field_name:str = field()
source_format:str = field()
target_format:str = field()
def __call__(self, record):
source_date = record.get(self.field_name)
if source_date is None:
record[self.field_name] = None
return
try:
dt = source_date if isinstance(source_date, datetime) else datetime.strptime(source_date,self.source_format)
record[self.field_name] = dt.strftime(self.target_format)
except ValueError:
record[self.field_name] = None
return record
|
(*, field_name: str, source_format: str, target_format: str) -> None
|
46,176 |
easul.process
|
__call__
| null |
def __call__(self, record):
source_date = record.get(self.field_name)
if source_date is None:
record[self.field_name] = None
return
try:
dt = source_date if isinstance(source_date, datetime) else datetime.strptime(source_date,self.source_format)
record[self.field_name] = dt.strftime(self.target_format)
except ValueError:
record[self.field_name] = None
return record
|
(self, record)
|
46,177 |
easul.process
|
__eq__
|
Method generated by attrs for class ReformatDate.
|
# 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,180 |
easul.process
|
__ne__
|
Method generated by attrs for class ReformatDate.
| null |
(self, other)
|
46,183 |
easul.expression
|
RegexExpression
|
Expression which checks whether a field value matches/does not match a regular expression pattern
|
class RegexExpression(FieldExpression):
"""
Expression which checks whether a field value matches/does not match a regular expression pattern
"""
input_field = field()
pattern = field()
negated = field(default=False)
def _test(self, item):
if not item or pd.isna(item):
return self.negated
match = re.search(self.pattern, item)
if self.negated:
return False if match else True
else:
return True if match else False
def label(self):
return f"{self.input_field} matches {self.pattern}"
|
(*, ignore_empty: bool = False, input_field: str, pattern, negated=False) -> None
|
46,184 |
easul.expression
|
__eq__
|
Method generated by attrs for class RegexExpression.
|
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)
|
46,187 |
easul.expression
|
__ne__
|
Method generated by attrs for class RegexExpression.
| null |
(self, other)
|
46,190 |
easul.expression
|
_test
| null |
def _test(self, item):
if not item or pd.isna(item):
return self.negated
match = re.search(self.pattern, item)
if self.negated:
return False if match else True
else:
return True if match else False
|
(self, item)
|
46,192 |
easul.expression
|
label
| null |
def label(self):
return f"{self.input_field} matches {self.pattern}"
|
(self)
|
46,193 |
easul.algorithm.predictive
|
RegressionAlgorithm
|
Regression-specific version of the PredictiveAlgorithm which returns a result with a continuous value.
|
class RegressionAlgorithm(PredictiveAlgorithm):
"""
Regression-specific version of the PredictiveAlgorithm which returns a result with a continuous value.
"""
result_class = RegressionResult
def single_result(self, data):
dset = ds.create_input_dataset(data, self.schema, allow_multiple=False, encoder=self.encoder)
pns = self.model.predict(dset.X)
return RegressionResult(value=pns[0], data=dset)
|
(*, title: str, model: Any, schema: easul.data.DataSchema, encoder: Optional[easul.data.InputEncoder] = None) -> None
|
46,194 |
easul.algorithm.predictive
|
__eq__
|
Method generated by attrs for class RegressionAlgorithm.
|
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, other)
|
46,197 |
easul.algorithm.predictive
|
__ne__
|
Method generated by attrs for class RegressionAlgorithm.
| null |
(self, other)
|
46,208 |
easul.algorithm.predictive
|
single_result
| null |
def single_result(self, data):
dset = ds.create_input_dataset(data, self.schema, allow_multiple=False, encoder=self.encoder)
pns = self.model.predict(dset.X)
return RegressionResult(value=pns[0], data=dset)
|
(self, data)
|
46,210 |
easul.algorithm.result
|
RegressionResult
|
Result for regression which only contains the value
|
class RegressionResult(Result):
"""
Result for regression which only contains the value
"""
pass
|
(*, value, data) -> None
|
46,211 |
easul.algorithm.result
|
__eq__
|
Method generated by attrs for class RegressionResult.
|
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,215 |
easul.algorithm.result
|
__ne__
|
Method generated by attrs for class RegressionResult.
| null |
(self, other)
|
46,219 |
easul.process
|
RemoveNonNumeric
|
Removes non-numeric values from 'field_name' and replaces them with 'replace_with'
|
class RemoveNonNumeric:
"""
Removes non-numeric values from 'field_name' and replaces them with 'replace_with'
"""
field_name = field()
replace_with=field(default=None)
def __call__(self, record):
try:
float(record.get(self.field_name))
except ValueError:
record[self.field_name] = self.replace_with
except TypeError:
record[self.field_name] = self.replace_with
|
(*, field_name, replace_with=None) -> None
|
46,220 |
easul.process
|
__call__
| null |
def __call__(self, record):
try:
float(record.get(self.field_name))
except ValueError:
record[self.field_name] = self.replace_with
except TypeError:
record[self.field_name] = self.replace_with
|
(self, record)
|
46,221 |
easul.process
|
__eq__
|
Method generated by attrs for class RemoveNonNumeric.
|
# 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,224 |
easul.process
|
__ne__
|
Method generated by attrs for class RemoveNonNumeric.
| null |
(self, other)
|
46,227 |
easul.process
|
RenameField
|
Rename from_field to to_field.
|
class RenameField:
"""
Rename from_field to to_field.
"""
from_field:str = field()
to_field:str = field()
def __call__(self, record):
if self.from_field not in record:
return record
record[self.to_field] = record[self.from_field]
del(record[self.from_field])
return record
|
(*, from_field: str, to_field: str) -> None
|
46,228 |
easul.process
|
__call__
| null |
def __call__(self, record):
if self.from_field not in record:
return record
record[self.to_field] = record[self.from_field]
del(record[self.from_field])
return record
|
(self, record)
|
46,229 |
easul.process
|
__eq__
|
Method generated by attrs for class RenameField.
|
# 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,232 |
easul.process
|
__ne__
|
Method generated by attrs for class RenameField.
| null |
(self, other)
|
46,235 |
easul.algorithm.result
|
Result
|
Base result class which at a simple level just returns a value.
|
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()
|
(*, value, data) -> None
|
46,239 |
easul.algorithm.result
|
__init__
|
Method generated by attrs for class Result.
|
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) -> NoneType
|
46,243 |
easul.outcome
|
ResultOutcome
|
Outcome also containing a value and an algorithm result.
|
class ResultOutcome(Outcome):
"""
Outcome also containing a value and an algorithm result.
"""
value = field()
result = field()
def asdict(self):
data = super().asdict()
data.update({
"result":self.result.asdict(),
})
return data
|
(*, outcome_step, next_step, reason, context=None, input_data=None, value, result) -> None
|
46,244 |
easul.outcome
|
__eq__
|
Method generated by attrs for class ResultOutcome.
|
from attrs import define, field
@define(kw_only=True)
class Outcome:
"""
Base Outcome class. Output by Decision classes and contains information on the next step (based on the decision),
the reason for the outcome/decision and context related to the result.
"""
outcome_step = field()
next_step = field()
reason = field()
context = field(default=None)
input_data = field(default=None)
def asdict(self):
return {
"outcome_step":self.outcome_step.name,
"next_step":self.next_step.name if self.next_step else None,
"reason":self.reason,
"context":self.context if self.context else {},
"input_data": self.input_data if type(self.input_data) is dict else self.input_data.asdict() if self.input_data else {}
}
def __repr__(self):
return f"<{self.__class__.__name__ } {self.asdict()}>"
|
(self, other)
|
46,247 |
easul.outcome
|
__ne__
|
Method generated by attrs for class ResultOutcome.
| null |
(self, other)
|
46,250 |
easul.outcome
|
asdict
| null |
def asdict(self):
data = super().asdict()
data.update({
"result":self.result.asdict(),
})
return data
|
(self)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.