%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 - 1.0.2-1 - Package Spec generated