%global _empty_manifest_terminate_build 0
Name: python-autodora
Version: 0.4.1
Release: 1
Summary: Automate experiments and explore your data.
License: MIT
URL: http://github.com/samuelkolb/autodora
Source0: https://mirrors.nju.edu.cn/pypi/web/packages/80/a4/5561c40dc3b4796bde4962cfd35ed0526de0ddc798b6d84ba63a1bf98431/autodora-0.4.1.tar.gz
BuildArch: noarch
Requires: python3-matplotlib
Requires: python3-peewee
Requires: python3-pebble
Requires: python3-numpy
Requires: python3-temporary
Requires: python3-telegram-bot
%description
# autodora [](https://travis-ci.org/samuelkolb/autodora)
autodora is a framework to help you:
1. setup experiments
2. running them for multiple parameters
3. storing the results
4. exploring the results
The aim of this package is to make these steps as easy and integrated as possible.
## Installation
pip install autodora
Experiments can be tracked using observers. Specialized observers may require optional packages to function that are
not included by default (because you might not need them).
### Telegram observer
pip install autodora[telegram]
In order to use the observer you have to set the environment variables `TELEGRAM_BOT_TOKEN` and `TELEGRAM_CHAT_ID`.
**Example usage**
export TELEGRAM_BOT_TOKEN="<your-bot-token>"
export TELEGRAM_CHAT_ID="<your-chat-id>"
pytest
## Using autodora
Consider the problem of computing the product of two numbers given in a string like this: `"0.1 x 0.3"`.
The heavy-lifting of this computation is performed by a function `multiply`:
def multiply(x, y):
return x * y
### Setting up
We start off by describing the experiment in a file called `product_experiment.py`:
class ProductExperiment(Experiment):
input = Parameter(str, "0.0x0.0", "The input values to be multiplied (e.g. 0.2x10)")
product = Result(float, description="Computed product")
@derived(cache=True)
def derived_x(self):
return float(self.get(self.input).split("x")[0])
@derived(cache=True)
def derived_y(self):
return float(self.get(self.input).split("x")[1])
def run_internal(self):
x, y = self.get("x"), self.get("y")
result = multiply(x, y)
self["product"] = result
ProductExperiment.enable_cli()
#### Describing parameters
...
input = Parameter(str, "0.0x0.0", "The input values to be multiplied (e.g. 0.2x10)")
...
The first step is to describe the parameters of the experiment, the name is taken from the variable you assign them to,
other than that have to specify the type and optionally a default value and description of the parameter.
While this is a powerful and easy way to set up parameters, you can also add them in the constructor:
class ProductExperiment(Experiment):
def __init__(self, group, storage=None, identifier=None):
super().__init__(group, storage=None, identifier=None)
self.parameters.add_parameter("complicated.name", datetime, None, "Description")
#### Describing results
...
product = Result(float, description="Computed product")
...
Similar to the parameters, we specify expected results. The Result class is identical to the Parameter class in all but
name, it only serves to indicate that you are trying to assign a result.
#### Computing derived features
...
@derived(cache=True)
def derived_x(self):
return float(self.get(self.input).split("x")[0])
@derived(cache=True)
def derived_y(self):
return float(self.get(self.input).split("x")[1])
...
Derived features are computed from other values (or complex computation chains) and can be marked for caching to avoid
computing them over and over again: when the experiment is saved to storage, those features will be saved with the
experiment.
You can build derived features using the derived decorator, which internally builds a `Derived object` and saves it in
the `experiment.derived_callbacks (Dict[str, Derived])` dictionary. Again, you can do this in the constructor, too.
If the decorated function is called `derived_<name>`, it will be shortened to just `<name>`.
Derived features can be accessed by calling `experiment["name"]` or `experiment[""derived.name"]` to disambiguate
if there are other parameters or results with the same name.
#### Running the experiment
...
def run_internal(self):
x, y = self.get("x"), self.get("y")
result = multiply(x, y)
self["product"] = result
...
When `experiment.run()` is called, it internally calls the `run_internal` method, which is responsible for running the
actual experiment. In this case, it fetches the (derived) parameters, computes the result and stores it.
#### Enabling the command line interface
...
ProductExperiment.enable_cli()
The `enable_cli` class method, not surprisingly, enables the current file to be run from command line.
This enables several key features:
- Making the experiment executable by command line (for internal and external use)
- Allowing you to manage (plot, list, ...) experiments of this type from command line
### Specifying trajectories
TODO
%package -n python3-autodora
Summary: Automate experiments and explore your data.
Provides: python-autodora
BuildRequires: python3-devel
BuildRequires: python3-setuptools
BuildRequires: python3-pip
%description -n python3-autodora
# autodora [](https://travis-ci.org/samuelkolb/autodora)
autodora is a framework to help you:
1. setup experiments
2. running them for multiple parameters
3. storing the results
4. exploring the results
The aim of this package is to make these steps as easy and integrated as possible.
## Installation
pip install autodora
Experiments can be tracked using observers. Specialized observers may require optional packages to function that are
not included by default (because you might not need them).
### Telegram observer
pip install autodora[telegram]
In order to use the observer you have to set the environment variables `TELEGRAM_BOT_TOKEN` and `TELEGRAM_CHAT_ID`.
**Example usage**
export TELEGRAM_BOT_TOKEN="<your-bot-token>"
export TELEGRAM_CHAT_ID="<your-chat-id>"
pytest
## Using autodora
Consider the problem of computing the product of two numbers given in a string like this: `"0.1 x 0.3"`.
The heavy-lifting of this computation is performed by a function `multiply`:
def multiply(x, y):
return x * y
### Setting up
We start off by describing the experiment in a file called `product_experiment.py`:
class ProductExperiment(Experiment):
input = Parameter(str, "0.0x0.0", "The input values to be multiplied (e.g. 0.2x10)")
product = Result(float, description="Computed product")
@derived(cache=True)
def derived_x(self):
return float(self.get(self.input).split("x")[0])
@derived(cache=True)
def derived_y(self):
return float(self.get(self.input).split("x")[1])
def run_internal(self):
x, y = self.get("x"), self.get("y")
result = multiply(x, y)
self["product"] = result
ProductExperiment.enable_cli()
#### Describing parameters
...
input = Parameter(str, "0.0x0.0", "The input values to be multiplied (e.g. 0.2x10)")
...
The first step is to describe the parameters of the experiment, the name is taken from the variable you assign them to,
other than that have to specify the type and optionally a default value and description of the parameter.
While this is a powerful and easy way to set up parameters, you can also add them in the constructor:
class ProductExperiment(Experiment):
def __init__(self, group, storage=None, identifier=None):
super().__init__(group, storage=None, identifier=None)
self.parameters.add_parameter("complicated.name", datetime, None, "Description")
#### Describing results
...
product = Result(float, description="Computed product")
...
Similar to the parameters, we specify expected results. The Result class is identical to the Parameter class in all but
name, it only serves to indicate that you are trying to assign a result.
#### Computing derived features
...
@derived(cache=True)
def derived_x(self):
return float(self.get(self.input).split("x")[0])
@derived(cache=True)
def derived_y(self):
return float(self.get(self.input).split("x")[1])
...
Derived features are computed from other values (or complex computation chains) and can be marked for caching to avoid
computing them over and over again: when the experiment is saved to storage, those features will be saved with the
experiment.
You can build derived features using the derived decorator, which internally builds a `Derived object` and saves it in
the `experiment.derived_callbacks (Dict[str, Derived])` dictionary. Again, you can do this in the constructor, too.
If the decorated function is called `derived_<name>`, it will be shortened to just `<name>`.
Derived features can be accessed by calling `experiment["name"]` or `experiment[""derived.name"]` to disambiguate
if there are other parameters or results with the same name.
#### Running the experiment
...
def run_internal(self):
x, y = self.get("x"), self.get("y")
result = multiply(x, y)
self["product"] = result
...
When `experiment.run()` is called, it internally calls the `run_internal` method, which is responsible for running the
actual experiment. In this case, it fetches the (derived) parameters, computes the result and stores it.
#### Enabling the command line interface
...
ProductExperiment.enable_cli()
The `enable_cli` class method, not surprisingly, enables the current file to be run from command line.
This enables several key features:
- Making the experiment executable by command line (for internal and external use)
- Allowing you to manage (plot, list, ...) experiments of this type from command line
### Specifying trajectories
TODO
%package help
Summary: Development documents and examples for autodora
Provides: python3-autodora-doc
%description help
# autodora [](https://travis-ci.org/samuelkolb/autodora)
autodora is a framework to help you:
1. setup experiments
2. running them for multiple parameters
3. storing the results
4. exploring the results
The aim of this package is to make these steps as easy and integrated as possible.
## Installation
pip install autodora
Experiments can be tracked using observers. Specialized observers may require optional packages to function that are
not included by default (because you might not need them).
### Telegram observer
pip install autodora[telegram]
In order to use the observer you have to set the environment variables `TELEGRAM_BOT_TOKEN` and `TELEGRAM_CHAT_ID`.
**Example usage**
export TELEGRAM_BOT_TOKEN="<your-bot-token>"
export TELEGRAM_CHAT_ID="<your-chat-id>"
pytest
## Using autodora
Consider the problem of computing the product of two numbers given in a string like this: `"0.1 x 0.3"`.
The heavy-lifting of this computation is performed by a function `multiply`:
def multiply(x, y):
return x * y
### Setting up
We start off by describing the experiment in a file called `product_experiment.py`:
class ProductExperiment(Experiment):
input = Parameter(str, "0.0x0.0", "The input values to be multiplied (e.g. 0.2x10)")
product = Result(float, description="Computed product")
@derived(cache=True)
def derived_x(self):
return float(self.get(self.input).split("x")[0])
@derived(cache=True)
def derived_y(self):
return float(self.get(self.input).split("x")[1])
def run_internal(self):
x, y = self.get("x"), self.get("y")
result = multiply(x, y)
self["product"] = result
ProductExperiment.enable_cli()
#### Describing parameters
...
input = Parameter(str, "0.0x0.0", "The input values to be multiplied (e.g. 0.2x10)")
...
The first step is to describe the parameters of the experiment, the name is taken from the variable you assign them to,
other than that have to specify the type and optionally a default value and description of the parameter.
While this is a powerful and easy way to set up parameters, you can also add them in the constructor:
class ProductExperiment(Experiment):
def __init__(self, group, storage=None, identifier=None):
super().__init__(group, storage=None, identifier=None)
self.parameters.add_parameter("complicated.name", datetime, None, "Description")
#### Describing results
...
product = Result(float, description="Computed product")
...
Similar to the parameters, we specify expected results. The Result class is identical to the Parameter class in all but
name, it only serves to indicate that you are trying to assign a result.
#### Computing derived features
...
@derived(cache=True)
def derived_x(self):
return float(self.get(self.input).split("x")[0])
@derived(cache=True)
def derived_y(self):
return float(self.get(self.input).split("x")[1])
...
Derived features are computed from other values (or complex computation chains) and can be marked for caching to avoid
computing them over and over again: when the experiment is saved to storage, those features will be saved with the
experiment.
You can build derived features using the derived decorator, which internally builds a `Derived object` and saves it in
the `experiment.derived_callbacks (Dict[str, Derived])` dictionary. Again, you can do this in the constructor, too.
If the decorated function is called `derived_<name>`, it will be shortened to just `<name>`.
Derived features can be accessed by calling `experiment["name"]` or `experiment[""derived.name"]` to disambiguate
if there are other parameters or results with the same name.
#### Running the experiment
...
def run_internal(self):
x, y = self.get("x"), self.get("y")
result = multiply(x, y)
self["product"] = result
...
When `experiment.run()` is called, it internally calls the `run_internal` method, which is responsible for running the
actual experiment. In this case, it fetches the (derived) parameters, computes the result and stores it.
#### Enabling the command line interface
...
ProductExperiment.enable_cli()
The `enable_cli` class method, not surprisingly, enables the current file to be run from command line.
This enables several key features:
- Making the experiment executable by command line (for internal and external use)
- Allowing you to manage (plot, list, ...) experiments of this type from command line
### Specifying trajectories
TODO
%prep
%autosetup -n autodora-0.4.1
%build
%py3_build
%install
%py3_install
install -d -m755 %{buildroot}/%{_pkgdocdir}
if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi
if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi
if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi
if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi
pushd %{buildroot}
if [ -d usr/lib ]; then
find usr/lib -type f -printf "/%h/%f\n" >> filelist.lst
fi
if [ -d usr/lib64 ]; then
find usr/lib64 -type f -printf "/%h/%f\n" >> filelist.lst
fi
if [ -d usr/bin ]; then
find usr/bin -type f -printf "/%h/%f\n" >> filelist.lst
fi
if [ -d usr/sbin ]; then
find usr/sbin -type f -printf "/%h/%f\n" >> filelist.lst
fi
touch doclist.lst
if [ -d usr/share/man ]; then
find usr/share/man -type f -printf "/%h/%f.gz\n" >> doclist.lst
fi
popd
mv %{buildroot}/filelist.lst .
mv %{buildroot}/doclist.lst .
%files -n python3-autodora -f filelist.lst
%dir %{python3_sitelib}/*
%files help -f doclist.lst
%{_docdir}/*
%changelog
* Wed May 17 2023 Python_Bot <Python_Bot@openeuler.org> - 0.4.1-1
- Package Spec generated