automatic import of python-autodora

1 files changed, 498 insertions, 0 deletions

diff --git a/python-autodora.spec b/python-autodora.spec
new file mode 100644
index 0000000..240f84c
--- /dev/null
+++ b/python-autodora.spec
@@ -0,0 +1,498 @@
+%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 [![Build Status](https://travis-ci.org/samuelkolb/autodora.svg?branch=master)](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 [![Build Status](https://travis-ci.org/samuelkolb/autodora.svg?branch=master)](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 [![Build Status](https://travis-ci.org/samuelkolb/autodora.svg?branch=master)](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