automatic import of python-implicits

1 files changed, 258 insertions, 0 deletions

diff --git a/python-implicits.spec b/python-implicits.spec
new file mode 100644
index 0000000..b7263a5
--- /dev/null
+++ b/python-implicits.spec
@@ -0,0 +1,258 @@
+%global _empty_manifest_terminate_build 0
+Name:		python-implicits
+Version:	1.0.2
+Release:	1
+Summary:	Implicit parameters in Python
+License:	MIT
+URL:		https://github.com/JadenGeller/Implicits
+Source0:	https://mirrors.nju.edu.cn/pypi/web/packages/7b/76/0ea282a955c2893a49fc77e44f737f868855386089c3f1e3bed54752d448/implicits-1.0.2.tar.gz
+BuildArch:	noarch
+
+
+%description
+# Implicits
+Global state can be hard to reason about, but piping dependencies from function to function is a pain. With implicits, you _explicitly_ which function parameters are _implicit_ dependencies. When you call the function, no need to explicilty provide these parameters; instead, the parameters will be implicitly passed! All that's required is that there exists local variables in scope that match the names of the parameters you're calling.
+```python3
+@implicits("current_user")
+def create_task(title, *, current_user):
+    print(f"{current_user} created a task titled '{title}'")
+
+current_user = "Jaden"
+create_task("Hooray, a task!") # Jaden created a task titled 'Hooray, a task!'
+create_task("Buy some trackpants") # Jaden created a task titled 'Buy some trackpants'
+```
+
+## Usage
+1) Install via `pip install implicits`.
+2) Import with `from implicits import implicits`.
+3) Decorate using `@implicits("names", "of", "implicit", "parameters")`.
+
+## Example
+```python3
+import logging
+import boto3
+
+from implicits import implicits
+
+class Giraffe:
+    @implicits("logger")
+    def __init__(self, name, *, logger):
+        self.name = name
+        logger.info(f"Creating a Giraffe named {name}")
+
+    @property
+    @implicits("logger")
+    def full_name(self, *, logger):
+        logger.info(f"Getting {self.name}'s full name")
+        return f"{self.name} the Giraffe"
+
+    @property
+    @implicits("food")
+    def is_hungry(self, *, food):
+        return "leaves" in food
+
+@implicits("logger")
+def main(*, logger):
+    jeff = Giraffe("Jeff") # Creating a Giraffe named Jeff
+    name = jeff.full_name  # Getting Jeff's full name
+    food = ["rocks", "dirt"]
+    logger.info(jeff.is_hungry) # False
+    food.append("leaves")
+    logger.info(jeff.is_hungry) # True
+
+logger = logging.getLogger()
+logger.setLevel(logging.INFO)
+logger.addHandler(logging.StreamHandler())
+
+main()
+```
+
+## References
+
+I didn't invent this idea! Quite a few other languages support implicit parameters. The most mainstream of these languages is Scala. [Check out how implicits work in Scala!](https://docs.scala-lang.org/tour/implicit-parameters.html)
+
+
+
+
+%package -n python3-implicits
+Summary:	Implicit parameters in Python
+Provides:	python-implicits
+BuildRequires:	python3-devel
+BuildRequires:	python3-setuptools
+BuildRequires:	python3-pip
+%description -n python3-implicits
+# Implicits
+Global state can be hard to reason about, but piping dependencies from function to function is a pain. With implicits, you _explicitly_ which function parameters are _implicit_ dependencies. When you call the function, no need to explicilty provide these parameters; instead, the parameters will be implicitly passed! All that's required is that there exists local variables in scope that match the names of the parameters you're calling.
+```python3
+@implicits("current_user")
+def create_task(title, *, current_user):
+    print(f"{current_user} created a task titled '{title}'")
+
+current_user = "Jaden"
+create_task("Hooray, a task!") # Jaden created a task titled 'Hooray, a task!'
+create_task("Buy some trackpants") # Jaden created a task titled 'Buy some trackpants'
+```
+
+## Usage
+1) Install via `pip install implicits`.
+2) Import with `from implicits import implicits`.
+3) Decorate using `@implicits("names", "of", "implicit", "parameters")`.
+
+## Example
+```python3
+import logging
+import boto3
+
+from implicits import implicits
+
+class Giraffe:
+    @implicits("logger")
+    def __init__(self, name, *, logger):
+        self.name = name
+        logger.info(f"Creating a Giraffe named {name}")
+
+    @property
+    @implicits("logger")
+    def full_name(self, *, logger):
+        logger.info(f"Getting {self.name}'s full name")
+        return f"{self.name} the Giraffe"
+
+    @property
+    @implicits("food")
+    def is_hungry(self, *, food):
+        return "leaves" in food
+
+@implicits("logger")
+def main(*, logger):
+    jeff = Giraffe("Jeff") # Creating a Giraffe named Jeff
+    name = jeff.full_name  # Getting Jeff's full name
+    food = ["rocks", "dirt"]
+    logger.info(jeff.is_hungry) # False
+    food.append("leaves")
+    logger.info(jeff.is_hungry) # True
+
+logger = logging.getLogger()
+logger.setLevel(logging.INFO)
+logger.addHandler(logging.StreamHandler())
+
+main()
+```
+
+## References
+
+I didn't invent this idea! Quite a few other languages support implicit parameters. The most mainstream of these languages is Scala. [Check out how implicits work in Scala!](https://docs.scala-lang.org/tour/implicit-parameters.html)
+
+
+
+
+%package help
+Summary:	Development documents and examples for implicits
+Provides:	python3-implicits-doc
+%description help
+# Implicits
+Global state can be hard to reason about, but piping dependencies from function to function is a pain. With implicits, you _explicitly_ which function parameters are _implicit_ dependencies. When you call the function, no need to explicilty provide these parameters; instead, the parameters will be implicitly passed! All that's required is that there exists local variables in scope that match the names of the parameters you're calling.
+```python3
+@implicits("current_user")
+def create_task(title, *, current_user):
+    print(f"{current_user} created a task titled '{title}'")
+
+current_user = "Jaden"
+create_task("Hooray, a task!") # Jaden created a task titled 'Hooray, a task!'
+create_task("Buy some trackpants") # Jaden created a task titled 'Buy some trackpants'
+```
+
+## Usage
+1) Install via `pip install implicits`.
+2) Import with `from implicits import implicits`.
+3) Decorate using `@implicits("names", "of", "implicit", "parameters")`.
+
+## Example
+```python3
+import logging
+import boto3
+
+from implicits import implicits
+
+class Giraffe:
+    @implicits("logger")
+    def __init__(self, name, *, logger):
+        self.name = name
+        logger.info(f"Creating a Giraffe named {name}")
+
+    @property
+    @implicits("logger")
+    def full_name(self, *, logger):
+        logger.info(f"Getting {self.name}'s full name")
+        return f"{self.name} the Giraffe"
+
+    @property
+    @implicits("food")
+    def is_hungry(self, *, food):
+        return "leaves" in food
+
+@implicits("logger")
+def main(*, logger):
+    jeff = Giraffe("Jeff") # Creating a Giraffe named Jeff
+    name = jeff.full_name  # Getting Jeff's full name
+    food = ["rocks", "dirt"]
+    logger.info(jeff.is_hungry) # False
+    food.append("leaves")
+    logger.info(jeff.is_hungry) # True
+
+logger = logging.getLogger()
+logger.setLevel(logging.INFO)
+logger.addHandler(logging.StreamHandler())
+
+main()
+```
+
+## References
+
+I didn't invent this idea! Quite a few other languages support implicit parameters. The most mainstream of these languages is Scala. [Check out how implicits work in Scala!](https://docs.scala-lang.org/tour/implicit-parameters.html)
+
+
+
+
+%prep
+%autosetup -n implicits-1.0.2
+
+%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-implicits -f filelist.lst
+%dir %{python3_sitelib}/*
+
+%files help -f doclist.lst
+%{_docdir}/*
+
+%changelog
+* Wed Apr 12 2023 Python_Bot <Python_Bot@openeuler.org> - 1.0.2-1
+- Package Spec generated