automatic import of python-i2openeuler20.03

3 files changed, 173 insertions, 0 deletions

diff --git a/.gitignore b/.gitignore
index e69de29..20fcd25 100644
--- a/.gitignore
+++ b/.gitignore
@@ -0,0 +1 @@
+/i2-0.0.183.tar.gz
diff --git a/python-i2.spec b/python-i2.spec
new file mode 100644
index 0000000..fc402f5
--- /dev/null
+++ b/python-i2.spec
@@ -0,0 +1,171 @@
+%global _empty_manifest_terminate_build 0
+Name:		python-i2
+Version:	0.0.183
+Release:	1
+Summary:	Creating manipulating and applying mint (Meta-INTerface)
+License:	Apache Software License
+URL:		https://github.com/i2mint/i2
+Source0:	https://mirrors.nju.edu.cn/pypi/web/packages/06/b7/8af2a381a305eee0c5d5f8b8b77d4cfaead9f0d3475dd223c5c7603fd147/i2-0.0.183.tar.gz
+BuildArch:	noarch
+
+
+%description
+# i2
+
+Core tools for minting code.
+
+[Documentation here.](https://i2mint.github.io/i2/)
+
+## What's mint?
+
+Mint stands for "Meta-INTerface".
+
+Minting is core technique of i2i: It can be seen as the encapsulation of a construct’s interface into a (data) 
+structure that contains everything one needs to know about the construct to perform a specific action 
+with or on the construct.
+
+A little note on the use of “encapsulation”. The term is widely used in computer science, 
+and is typically tied to object oriented programming. Wikipedia provides two definitions:
+* A language mechanism for restricting direct access to some of the object's components.
+* A language construct that facilitates the bundling of data with the methods (or other functions) 
+operating on that data.
+
+Though both these definitions apply to minting, 
+the original sense of the word “encapsulate” is even more relevant (from google definitions): 
+* express the essential features of (something) succinctly
+* enclose (something) in or as if in a capsule
+
+Indeed, minting is the process of enclosing a construct into a “mint” (for “Meta INTerface”) 
+that will express the features of the construct that are essential to the task at hand. 
+The mint provides a declarative layer of the construct that allows one to write code that operates with this layer, 
+which is designed to be (as) consistent (as possible) from one system/language to another.
+
+For example, whether a (non-anonymous) function was written in C, Python, or JavaScript, 
+it will at least have a name, and it’s arguments will (most often) have names, and may have types. 
+Similarly with “data objects”: The data of both JavaScript and Python objects can be represented by a tree whose 
+leaves are base types, which can in turn be represented by a C struct.
+
+%package -n python3-i2
+Summary:	Creating manipulating and applying mint (Meta-INTerface)
+Provides:	python-i2
+BuildRequires:	python3-devel
+BuildRequires:	python3-setuptools
+BuildRequires:	python3-pip
+%description -n python3-i2
+# i2
+
+Core tools for minting code.
+
+[Documentation here.](https://i2mint.github.io/i2/)
+
+## What's mint?
+
+Mint stands for "Meta-INTerface".
+
+Minting is core technique of i2i: It can be seen as the encapsulation of a construct’s interface into a (data) 
+structure that contains everything one needs to know about the construct to perform a specific action 
+with or on the construct.
+
+A little note on the use of “encapsulation”. The term is widely used in computer science, 
+and is typically tied to object oriented programming. Wikipedia provides two definitions:
+* A language mechanism for restricting direct access to some of the object's components.
+* A language construct that facilitates the bundling of data with the methods (or other functions) 
+operating on that data.
+
+Though both these definitions apply to minting, 
+the original sense of the word “encapsulate” is even more relevant (from google definitions): 
+* express the essential features of (something) succinctly
+* enclose (something) in or as if in a capsule
+
+Indeed, minting is the process of enclosing a construct into a “mint” (for “Meta INTerface”) 
+that will express the features of the construct that are essential to the task at hand. 
+The mint provides a declarative layer of the construct that allows one to write code that operates with this layer, 
+which is designed to be (as) consistent (as possible) from one system/language to another.
+
+For example, whether a (non-anonymous) function was written in C, Python, or JavaScript, 
+it will at least have a name, and it’s arguments will (most often) have names, and may have types. 
+Similarly with “data objects”: The data of both JavaScript and Python objects can be represented by a tree whose 
+leaves are base types, which can in turn be represented by a C struct.
+
+%package help
+Summary:	Development documents and examples for i2
+Provides:	python3-i2-doc
+%description help
+# i2
+
+Core tools for minting code.
+
+[Documentation here.](https://i2mint.github.io/i2/)
+
+## What's mint?
+
+Mint stands for "Meta-INTerface".
+
+Minting is core technique of i2i: It can be seen as the encapsulation of a construct’s interface into a (data) 
+structure that contains everything one needs to know about the construct to perform a specific action 
+with or on the construct.
+
+A little note on the use of “encapsulation”. The term is widely used in computer science, 
+and is typically tied to object oriented programming. Wikipedia provides two definitions:
+* A language mechanism for restricting direct access to some of the object's components.
+* A language construct that facilitates the bundling of data with the methods (or other functions) 
+operating on that data.
+
+Though both these definitions apply to minting, 
+the original sense of the word “encapsulate” is even more relevant (from google definitions): 
+* express the essential features of (something) succinctly
+* enclose (something) in or as if in a capsule
+
+Indeed, minting is the process of enclosing a construct into a “mint” (for “Meta INTerface”) 
+that will express the features of the construct that are essential to the task at hand. 
+The mint provides a declarative layer of the construct that allows one to write code that operates with this layer, 
+which is designed to be (as) consistent (as possible) from one system/language to another.
+
+For example, whether a (non-anonymous) function was written in C, Python, or JavaScript, 
+it will at least have a name, and it’s arguments will (most often) have names, and may have types. 
+Similarly with “data objects”: The data of both JavaScript and Python objects can be represented by a tree whose 
+leaves are base types, which can in turn be represented by a C struct.
+
+%prep
+%autosetup -n i2-0.0.183
+
+%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-i2 -f filelist.lst
+%dir %{python3_sitelib}/*
+
+%files help -f doclist.lst
+%{_docdir}/*
+
+%changelog
+* Fri May 05 2023 Python_Bot <Python_Bot@openeuler.org> - 0.0.183-1
+- Package Spec generated
diff --git a/sources b/sources
new file mode 100644
index 0000000..d72ad4e
--- /dev/null
+++ b/sources
@@ -0,0 +1 @@
+def9ba7967d9dfcee370fd798a4204b9  i2-0.0.183.tar.gz