automatic import of python-autofaker

3 files changed, 1301 insertions, 0 deletions

diff --git a/.gitignore b/.gitignore
index e69de29..fecbdab 100644
--- a/.gitignore
+++ b/.gitignore
@@ -0,0 +1 @@
+/autofaker-1.0.14.tar.gz
diff --git a/python-autofaker.spec b/python-autofaker.spec
new file mode 100644
index 0000000..e76f5a3
--- /dev/null
+++ b/python-autofaker.spec
@@ -0,0 +1,1299 @@
+%global _empty_manifest_terminate_build 0
+Name:		python-autofaker
+Version:	1.0.14
+Release:	1
+Summary:	Python library designed to minimize the setup/arrange phase of your unit tests
+License:	MIT License
+URL:		https://github.com/christianhelle/autofaker
+Source0:	https://mirrors.nju.edu.cn/pypi/web/packages/bd/6a/5f88e28b4668c5516c238281f78f1f682d26297c1ff4db9b1d13e1069ad8/autofaker-1.0.14.tar.gz
+BuildArch:	noarch
+
+Requires:	python3-pandas
+Requires:	python3-faker
+Requires:	python3-typing-inspect
+
+%description
+AutoFaker is a Python library designed to minimize the setup/arrange phase of your unit tests by removing the need to manually 
+write code to create anonymous variables as part of a test cases setup/arrange phase. 
+
+This library is heavily inspired by [AutoFixture](https://github.com/AutoFixture/AutoFixture) and was initially created 
+for simplifying how to write unit tests for ETL (Extract-Transform-Load) code running from a python library on an 
+Apache Spark cluster in Big Data solutions.
+
+When writing unit tests you normally start with creating objects that represent the initial state of the test.
+This phase is called the **arrange** or setup phase of the test.
+In most cases, the system you want to test will force you to specify much more information than you really care about, 
+so you frequently end up creating objects with no influence on the test itself just simply to satisfy the compiler/interpreter
+
+[AutoFaker](https://pypi.org/project/autofaker/) is available from PyPI and should be installed using `pip`
+
+```
+pip install autofaker
+```
+
+AutoFaker can help by creating such anonymous variables for you. Here's a simple example:
+
+```python
+import unittest
+from autofaker import Autodata
+
+class Calculator:
+  def add(self, number1: int, number2: int):
+    return number1 + number2
+
+class CalculatorTests(unittest.TestCase):
+    def test_can_add_two_numbers(self):      
+        # arrange
+        numbers = Autodata.create_many(int, 2)
+        sut = Autodata.create(Calculator)        
+        # act
+        result = sut.add(numbers[0], numbers[1])        
+        # assert
+        self.assertEqual(numbers[0] + numbers[1], result)
+```
+
+Since the point of this library is to simplify the **arrange** step of writing unit tests, we can use the
+`@autodata` and `@fakedata` are available to explicitly state 
+whether to use anonymous variables or fake data and construct our system under test.
+To use this you can either define the types or the arguments as function arguments to the decorator, or specify 
+argument annotations
+
+```python
+import unittest
+from autofaker import autodata
+
+class Calculator:
+  def add(self, number1: int, number2: int):
+    return number1 + number2
+
+class CalculatorTests(unittest.TestCase):
+    @autodata(Calculator, int, int)
+    def test_can_add_two_numbers_using_test_arguments(self, sut, number1, number2):
+        result = sut.add(number1, number2)
+        self.assertEqual(number1 + number2, result)
+
+    @autodata()
+    def test_can_add_two_numbers_using_annotated_arguments(self, 
+                                                           sut: Calculator, 
+                                                           number1: int, 
+                                                           number2: int):
+        result = sut.add(number1, number2)
+        self.assertEqual(number1 + number2, result)
+```
+
+There are times when completely anonymous variables don't make much sense, especially in data centric scenarios. 
+For these use cases this library uses [Faker](https://github.com/joke2k/faker) for generating fake data. This option 
+is enabled by setting `use_fake_data` to `True` when calling the `Autodata.create()` function
+
+```python
+from dataclasses import dataclass
+from autofaker import Autodata
+
+@dataclass
+class DataClass:
+    id: int
+    first_name: str
+    last_name: str
+    address: str
+    job: str
+
+data = Autodata.create(DataClass, use_fake_data=True)
+
+print(f'id:     {data.id}')
+print(f'name:   {data.name}')
+print(f'job:    {data.job}\n')
+```
+
+The following code above might output something like:
+
+```
+id:     8952
+name:   Justin Wise
+job:    Chief Operating Officer
+```
+
+## Supported data types
+
+Currently autofaker supports creating anonymous variables for the following data types:
+
+Built-in types:
+- int
+- float
+- str
+- complex
+- range
+- bytes
+- bytearray
+
+Datetime types:
+- datetime
+- date
+
+Classes:
+- Simple classes
+- @dataclass
+- Nested classes (and recursion)
+- Classes containing lists of other types
+- Enum classes
+
+Dataframes:
+- Pandas dataframe
+
+
+## Example usages
+
+Create anonymous built-in types like `int`, `float`, `str` and datetime types like `datetime` and `date`
+
+```python
+print(f'anonymous string:    {Autodata.create(str)}')
+print(f'anonymous int:       {Autodata.create(int)}')
+print(f'anonymous float:     {Autodata.create(float)}')
+print(f'anonymous complex:   {Autodata.create(complex)}')
+print(f'anonymous range:     {Autodata.create(range)}')
+print(f'anonymous bytes:     {Autodata.create(bytes)}')
+print(f'anonymous bytearray: {Autodata.create(bytearray)}')
+print(f'anonymous datetime:  {Autodata.create(datetime)}')
+print(f'anonymous date:      {Autodata.create(datetime.date)}')
+```
+
+The code above might output the following
+
+```
+anonymous string:    f91954f1-96df-463f-a427-665c99213395
+anonymous int:       2066712686
+anonymous float:     725758222.8712853
+anonymous datetime:  2017-06-19 02:40:41.000084
+anonymous date:      2019-11-10 00:00:00
+```
+
+Creates an anonymous class
+
+```python
+
+class SimpleClass:
+    id = -1
+    text = 'test'
+
+cls = Autodata.create(SimpleClass)
+print(f'id = {cls.id}')
+print(f'text = {cls.text}')
+```
+
+The code above might output the following
+
+```
+id = 2020177162
+text = ac54a65d-b4a3-4eda-a840-eb948ad10d5f
+```
+
+Create a collection of an anonymous class
+
+```python
+class SimpleClass:
+    id = -1
+    text = 'test'
+
+classes = Autodata.create_many(SimpleClass)
+for cls in classes:
+  print(f'id = {cls.id}')
+  print(f'text = {cls.text}')
+  print()
+```
+
+The code above might output the following
+
+```
+id = 242996515
+text = 5bb60504-ccca-4104-9b7f-b978e52a6518
+
+id = 836984239
+text = 079df61e-a87e-4f26-8196-3f44157aabd6
+
+id = 570703150
+text = a3b86f08-c73a-4730-bde7-4bdff5360ef4
+```
+
+Creates an anonymous dataclass
+
+```python
+from dataclasses import dataclass
+
+@dataclass
+class DataClass:
+    id: int
+    text: str
+
+cls = Autodata.create(DataClass)
+print(f'id = {cls.id}')
+print(f'text = {cls.text}')
+```
+
+The code above might output the following
+
+```
+id = 314075507
+text = 4a3b3cae-f4cf-4502-a7f3-61115a1e0d2a
+```
+
+Creates an anonymous dataclass using fake data
+
+```python
+@dataclass
+class DataClass:
+    id: int
+
+    name: str
+    address: str
+    job: str
+
+    country: str
+    currency_name: str
+    currency_code: str
+
+    email: str
+    safe_email: str
+    company_email: str
+
+    hostname: str
+    ipv4: str
+    ipv6: str
+
+    text: str
+
+
+data = Autodata.create(DataClass, use_fake_data=True)
+
+print(f'id:               {data.id}')
+print(f'name:             {data.name}')
+print(f'job:              {data.job}\n')
+print(f'address:\n{data.address}\n')
+
+print(f'country:          {data.country}')
+print(f'currency name:    {data.currency_name}')
+print(f'currency code:    {data.currency_code}\n')
+
+print(f'email:            {data.email}')
+print(f'safe email:       {data.safe_email}')
+print(f'work email:       {data.company_email}\n')
+
+print(f'hostname:         {data.hostname}')
+print(f'IPv4:             {data.ipv4}')
+print(f'IPv6:             {data.ipv6}\n')
+
+print(f'text:\n{data.text}')
+```
+
+The code above might output the following
+
+```
+id:               8952
+name:             Justin Wise
+job:              Chief Operating Officer
+
+address:
+65939 Hernandez Parks
+Rochaport, NC 41760
+
+country:          Equatorial Guinea
+currency name:    Burmese kyat
+currency code:    ERN
+
+email:            smithjohn@example.com
+safe email:       kent11@example.com
+work email:       marissagreen@brown-cole.com
+
+hostname:         db-90.hendricks-west.org
+IPv4:             66.139.143.242
+IPv6:             895d:82f7:7c13:e7cb:f35d:c93:aeb2:8eeb
+
+text:
+Movie author culture represent. Enjoy myself over physical green lead but home.
+Share wind factor far minute produce significant. Sense might fact leader.
+```
+
+Create an anonymous class with nested types
+
+```python
+
+class NestedClass:
+    id = -1
+    text = 'test'
+    inner = SimpleClass()
+
+cls = Autodata.create(NestedClass)
+print(f'id = {cls.id}')
+print(f'text = {cls.text}')
+print(f'inner.id = {cls.inner.id}')
+print(f'inner.text = {cls.inner.text}')
+```
+
+The code above might output the following
+
+```
+id = 1565737216
+text = e66ecd5c-c17a-4426-b755-36dfd2082672
+inner.id = 390282329
+inner.text = eef94b5c-aa95-427a-a9e6-d99e2cc1ffb2
+```
+
+Create a collection of an anonymous class with nested types
+
+```python
+class NestedClass:
+    id = -1
+    text = 'test'
+    inner = SimpleClass()
+
+classes = Autodata.create_many(NestedClass)
+for cls in classes:
+  print(f'id = {cls.id}')
+  print(f'text = {cls.text}')
+  print(f'inner.id = {cls.inner.id}')
+  print(f'inner.text = {cls.inner.text}')
+  print()
+```
+
+The code above might output the following
+
+```
+id = 1116454042
+text = ceeecf0c-7375-4f3a-8d4b-6d7a4f2b20fd
+inner.id = 1067027444
+inner.text = 079573ce-1ef4-408d-8984-1dbc7b0d0b80
+
+id = 730390288
+text = ff3ca474-a69d-4ff6-95b4-fbdb1bea7cdb
+inner.id = 1632771208
+inner.text = 9423e824-dc8f-4145-ba47-7301351a91f8
+
+id = 187364960
+text = b31ca191-5031-43a2-870a-7bc7c99e4110
+inner.id = 1705149100
+inner.text = e703a117-ba4f-4201-a31b-10ab8e54a673
+```
+
+Create a Pandas DataFrame using anonymous data generated from a specified type
+
+```python
+class DataClass:
+    id = -1
+    type = '' 
+    value = 0
+
+pdf = Autodata.create_pandas_dataframe(DataClass)
+print(pdf)
+```
+
+The code above might output the following
+
+```
+          id                                  type       value
+0  778090854  13537c5a-62e7-488b-836e-a4b17f2f3ae9  1049015695
+1  602015506  c043ca8d-e280-466a-8bba-ec1e0539fe28  1016359353
+2  387753717  986b3b1c-abf4-4bc1-95cf-0e979390e4f3   766159839
+```
+
+Create a Pandas DataFrame using fake data generated from a specified type
+
+```python
+class DataClass:
+    id = -1
+    type = '' 
+    value = 0
+
+pdf = Autodata.create_pandas_dataframe(DataClass, use_fake_data=True)
+print(pdf)
+```
+
+The code above might output the following
+
+```
+  first_name    id last_name          phone_number
+0   Lawrence  7670   Jimenez  001-172-307-0561x471
+1      Bryan  9084    Walker         (697)893-6767
+2       Paul  9824    Thomas    960.555.3577x65487
+```
+
+#
+
+For tips and tricks on software development, check out [my blog](https://christianhelle.com)
+
+If you find this useful and feel a bit generous then feel free to [buy me a coffee ☕](https://www.buymeacoffee.com/christianhelle)
+
+
+
+
+%package -n python3-autofaker
+Summary:	Python library designed to minimize the setup/arrange phase of your unit tests
+Provides:	python-autofaker
+BuildRequires:	python3-devel
+BuildRequires:	python3-setuptools
+BuildRequires:	python3-pip
+%description -n python3-autofaker
+AutoFaker is a Python library designed to minimize the setup/arrange phase of your unit tests by removing the need to manually 
+write code to create anonymous variables as part of a test cases setup/arrange phase. 
+
+This library is heavily inspired by [AutoFixture](https://github.com/AutoFixture/AutoFixture) and was initially created 
+for simplifying how to write unit tests for ETL (Extract-Transform-Load) code running from a python library on an 
+Apache Spark cluster in Big Data solutions.
+
+When writing unit tests you normally start with creating objects that represent the initial state of the test.
+This phase is called the **arrange** or setup phase of the test.
+In most cases, the system you want to test will force you to specify much more information than you really care about, 
+so you frequently end up creating objects with no influence on the test itself just simply to satisfy the compiler/interpreter
+
+[AutoFaker](https://pypi.org/project/autofaker/) is available from PyPI and should be installed using `pip`
+
+```
+pip install autofaker
+```
+
+AutoFaker can help by creating such anonymous variables for you. Here's a simple example:
+
+```python
+import unittest
+from autofaker import Autodata
+
+class Calculator:
+  def add(self, number1: int, number2: int):
+    return number1 + number2
+
+class CalculatorTests(unittest.TestCase):
+    def test_can_add_two_numbers(self):      
+        # arrange
+        numbers = Autodata.create_many(int, 2)
+        sut = Autodata.create(Calculator)        
+        # act
+        result = sut.add(numbers[0], numbers[1])        
+        # assert
+        self.assertEqual(numbers[0] + numbers[1], result)
+```
+
+Since the point of this library is to simplify the **arrange** step of writing unit tests, we can use the
+`@autodata` and `@fakedata` are available to explicitly state 
+whether to use anonymous variables or fake data and construct our system under test.
+To use this you can either define the types or the arguments as function arguments to the decorator, or specify 
+argument annotations
+
+```python
+import unittest
+from autofaker import autodata
+
+class Calculator:
+  def add(self, number1: int, number2: int):
+    return number1 + number2
+
+class CalculatorTests(unittest.TestCase):
+    @autodata(Calculator, int, int)
+    def test_can_add_two_numbers_using_test_arguments(self, sut, number1, number2):
+        result = sut.add(number1, number2)
+        self.assertEqual(number1 + number2, result)
+
+    @autodata()
+    def test_can_add_two_numbers_using_annotated_arguments(self, 
+                                                           sut: Calculator, 
+                                                           number1: int, 
+                                                           number2: int):
+        result = sut.add(number1, number2)
+        self.assertEqual(number1 + number2, result)
+```
+
+There are times when completely anonymous variables don't make much sense, especially in data centric scenarios. 
+For these use cases this library uses [Faker](https://github.com/joke2k/faker) for generating fake data. This option 
+is enabled by setting `use_fake_data` to `True` when calling the `Autodata.create()` function
+
+```python
+from dataclasses import dataclass
+from autofaker import Autodata
+
+@dataclass
+class DataClass:
+    id: int
+    first_name: str
+    last_name: str
+    address: str
+    job: str
+
+data = Autodata.create(DataClass, use_fake_data=True)
+
+print(f'id:     {data.id}')
+print(f'name:   {data.name}')
+print(f'job:    {data.job}\n')
+```
+
+The following code above might output something like:
+
+```
+id:     8952
+name:   Justin Wise
+job:    Chief Operating Officer
+```
+
+## Supported data types
+
+Currently autofaker supports creating anonymous variables for the following data types:
+
+Built-in types:
+- int
+- float
+- str
+- complex
+- range
+- bytes
+- bytearray
+
+Datetime types:
+- datetime
+- date
+
+Classes:
+- Simple classes
+- @dataclass
+- Nested classes (and recursion)
+- Classes containing lists of other types
+- Enum classes
+
+Dataframes:
+- Pandas dataframe
+
+
+## Example usages
+
+Create anonymous built-in types like `int`, `float`, `str` and datetime types like `datetime` and `date`
+
+```python
+print(f'anonymous string:    {Autodata.create(str)}')
+print(f'anonymous int:       {Autodata.create(int)}')
+print(f'anonymous float:     {Autodata.create(float)}')
+print(f'anonymous complex:   {Autodata.create(complex)}')
+print(f'anonymous range:     {Autodata.create(range)}')
+print(f'anonymous bytes:     {Autodata.create(bytes)}')
+print(f'anonymous bytearray: {Autodata.create(bytearray)}')
+print(f'anonymous datetime:  {Autodata.create(datetime)}')
+print(f'anonymous date:      {Autodata.create(datetime.date)}')
+```
+
+The code above might output the following
+
+```
+anonymous string:    f91954f1-96df-463f-a427-665c99213395
+anonymous int:       2066712686
+anonymous float:     725758222.8712853
+anonymous datetime:  2017-06-19 02:40:41.000084
+anonymous date:      2019-11-10 00:00:00
+```
+
+Creates an anonymous class
+
+```python
+
+class SimpleClass:
+    id = -1
+    text = 'test'
+
+cls = Autodata.create(SimpleClass)
+print(f'id = {cls.id}')
+print(f'text = {cls.text}')
+```
+
+The code above might output the following
+
+```
+id = 2020177162
+text = ac54a65d-b4a3-4eda-a840-eb948ad10d5f
+```
+
+Create a collection of an anonymous class
+
+```python
+class SimpleClass:
+    id = -1
+    text = 'test'
+
+classes = Autodata.create_many(SimpleClass)
+for cls in classes:
+  print(f'id = {cls.id}')
+  print(f'text = {cls.text}')
+  print()
+```
+
+The code above might output the following
+
+```
+id = 242996515
+text = 5bb60504-ccca-4104-9b7f-b978e52a6518
+
+id = 836984239
+text = 079df61e-a87e-4f26-8196-3f44157aabd6
+
+id = 570703150
+text = a3b86f08-c73a-4730-bde7-4bdff5360ef4
+```
+
+Creates an anonymous dataclass
+
+```python
+from dataclasses import dataclass
+
+@dataclass
+class DataClass:
+    id: int
+    text: str
+
+cls = Autodata.create(DataClass)
+print(f'id = {cls.id}')
+print(f'text = {cls.text}')
+```
+
+The code above might output the following
+
+```
+id = 314075507
+text = 4a3b3cae-f4cf-4502-a7f3-61115a1e0d2a
+```
+
+Creates an anonymous dataclass using fake data
+
+```python
+@dataclass
+class DataClass:
+    id: int
+
+    name: str
+    address: str
+    job: str
+
+    country: str
+    currency_name: str
+    currency_code: str
+
+    email: str
+    safe_email: str
+    company_email: str
+
+    hostname: str
+    ipv4: str
+    ipv6: str
+
+    text: str
+
+
+data = Autodata.create(DataClass, use_fake_data=True)
+
+print(f'id:               {data.id}')
+print(f'name:             {data.name}')
+print(f'job:              {data.job}\n')
+print(f'address:\n{data.address}\n')
+
+print(f'country:          {data.country}')
+print(f'currency name:    {data.currency_name}')
+print(f'currency code:    {data.currency_code}\n')
+
+print(f'email:            {data.email}')
+print(f'safe email:       {data.safe_email}')
+print(f'work email:       {data.company_email}\n')
+
+print(f'hostname:         {data.hostname}')
+print(f'IPv4:             {data.ipv4}')
+print(f'IPv6:             {data.ipv6}\n')
+
+print(f'text:\n{data.text}')
+```
+
+The code above might output the following
+
+```
+id:               8952
+name:             Justin Wise
+job:              Chief Operating Officer
+
+address:
+65939 Hernandez Parks
+Rochaport, NC 41760
+
+country:          Equatorial Guinea
+currency name:    Burmese kyat
+currency code:    ERN
+
+email:            smithjohn@example.com
+safe email:       kent11@example.com
+work email:       marissagreen@brown-cole.com
+
+hostname:         db-90.hendricks-west.org
+IPv4:             66.139.143.242
+IPv6:             895d:82f7:7c13:e7cb:f35d:c93:aeb2:8eeb
+
+text:
+Movie author culture represent. Enjoy myself over physical green lead but home.
+Share wind factor far minute produce significant. Sense might fact leader.
+```
+
+Create an anonymous class with nested types
+
+```python
+
+class NestedClass:
+    id = -1
+    text = 'test'
+    inner = SimpleClass()
+
+cls = Autodata.create(NestedClass)
+print(f'id = {cls.id}')
+print(f'text = {cls.text}')
+print(f'inner.id = {cls.inner.id}')
+print(f'inner.text = {cls.inner.text}')
+```
+
+The code above might output the following
+
+```
+id = 1565737216
+text = e66ecd5c-c17a-4426-b755-36dfd2082672
+inner.id = 390282329
+inner.text = eef94b5c-aa95-427a-a9e6-d99e2cc1ffb2
+```
+
+Create a collection of an anonymous class with nested types
+
+```python
+class NestedClass:
+    id = -1
+    text = 'test'
+    inner = SimpleClass()
+
+classes = Autodata.create_many(NestedClass)
+for cls in classes:
+  print(f'id = {cls.id}')
+  print(f'text = {cls.text}')
+  print(f'inner.id = {cls.inner.id}')
+  print(f'inner.text = {cls.inner.text}')
+  print()
+```
+
+The code above might output the following
+
+```
+id = 1116454042
+text = ceeecf0c-7375-4f3a-8d4b-6d7a4f2b20fd
+inner.id = 1067027444
+inner.text = 079573ce-1ef4-408d-8984-1dbc7b0d0b80
+
+id = 730390288
+text = ff3ca474-a69d-4ff6-95b4-fbdb1bea7cdb
+inner.id = 1632771208
+inner.text = 9423e824-dc8f-4145-ba47-7301351a91f8
+
+id = 187364960
+text = b31ca191-5031-43a2-870a-7bc7c99e4110
+inner.id = 1705149100
+inner.text = e703a117-ba4f-4201-a31b-10ab8e54a673
+```
+
+Create a Pandas DataFrame using anonymous data generated from a specified type
+
+```python
+class DataClass:
+    id = -1
+    type = '' 
+    value = 0
+
+pdf = Autodata.create_pandas_dataframe(DataClass)
+print(pdf)
+```
+
+The code above might output the following
+
+```
+          id                                  type       value
+0  778090854  13537c5a-62e7-488b-836e-a4b17f2f3ae9  1049015695
+1  602015506  c043ca8d-e280-466a-8bba-ec1e0539fe28  1016359353
+2  387753717  986b3b1c-abf4-4bc1-95cf-0e979390e4f3   766159839
+```
+
+Create a Pandas DataFrame using fake data generated from a specified type
+
+```python
+class DataClass:
+    id = -1
+    type = '' 
+    value = 0
+
+pdf = Autodata.create_pandas_dataframe(DataClass, use_fake_data=True)
+print(pdf)
+```
+
+The code above might output the following
+
+```
+  first_name    id last_name          phone_number
+0   Lawrence  7670   Jimenez  001-172-307-0561x471
+1      Bryan  9084    Walker         (697)893-6767
+2       Paul  9824    Thomas    960.555.3577x65487
+```
+
+#
+
+For tips and tricks on software development, check out [my blog](https://christianhelle.com)
+
+If you find this useful and feel a bit generous then feel free to [buy me a coffee ☕](https://www.buymeacoffee.com/christianhelle)
+
+
+
+
+%package help
+Summary:	Development documents and examples for autofaker
+Provides:	python3-autofaker-doc
+%description help
+AutoFaker is a Python library designed to minimize the setup/arrange phase of your unit tests by removing the need to manually 
+write code to create anonymous variables as part of a test cases setup/arrange phase. 
+
+This library is heavily inspired by [AutoFixture](https://github.com/AutoFixture/AutoFixture) and was initially created 
+for simplifying how to write unit tests for ETL (Extract-Transform-Load) code running from a python library on an 
+Apache Spark cluster in Big Data solutions.
+
+When writing unit tests you normally start with creating objects that represent the initial state of the test.
+This phase is called the **arrange** or setup phase of the test.
+In most cases, the system you want to test will force you to specify much more information than you really care about, 
+so you frequently end up creating objects with no influence on the test itself just simply to satisfy the compiler/interpreter
+
+[AutoFaker](https://pypi.org/project/autofaker/) is available from PyPI and should be installed using `pip`
+
+```
+pip install autofaker
+```
+
+AutoFaker can help by creating such anonymous variables for you. Here's a simple example:
+
+```python
+import unittest
+from autofaker import Autodata
+
+class Calculator:
+  def add(self, number1: int, number2: int):
+    return number1 + number2
+
+class CalculatorTests(unittest.TestCase):
+    def test_can_add_two_numbers(self):      
+        # arrange
+        numbers = Autodata.create_many(int, 2)
+        sut = Autodata.create(Calculator)        
+        # act
+        result = sut.add(numbers[0], numbers[1])        
+        # assert
+        self.assertEqual(numbers[0] + numbers[1], result)
+```
+
+Since the point of this library is to simplify the **arrange** step of writing unit tests, we can use the
+`@autodata` and `@fakedata` are available to explicitly state 
+whether to use anonymous variables or fake data and construct our system under test.
+To use this you can either define the types or the arguments as function arguments to the decorator, or specify 
+argument annotations
+
+```python
+import unittest
+from autofaker import autodata
+
+class Calculator:
+  def add(self, number1: int, number2: int):
+    return number1 + number2
+
+class CalculatorTests(unittest.TestCase):
+    @autodata(Calculator, int, int)
+    def test_can_add_two_numbers_using_test_arguments(self, sut, number1, number2):
+        result = sut.add(number1, number2)
+        self.assertEqual(number1 + number2, result)
+
+    @autodata()
+    def test_can_add_two_numbers_using_annotated_arguments(self, 
+                                                           sut: Calculator, 
+                                                           number1: int, 
+                                                           number2: int):
+        result = sut.add(number1, number2)
+        self.assertEqual(number1 + number2, result)
+```
+
+There are times when completely anonymous variables don't make much sense, especially in data centric scenarios. 
+For these use cases this library uses [Faker](https://github.com/joke2k/faker) for generating fake data. This option 
+is enabled by setting `use_fake_data` to `True` when calling the `Autodata.create()` function
+
+```python
+from dataclasses import dataclass
+from autofaker import Autodata
+
+@dataclass
+class DataClass:
+    id: int
+    first_name: str
+    last_name: str
+    address: str
+    job: str
+
+data = Autodata.create(DataClass, use_fake_data=True)
+
+print(f'id:     {data.id}')
+print(f'name:   {data.name}')
+print(f'job:    {data.job}\n')
+```
+
+The following code above might output something like:
+
+```
+id:     8952
+name:   Justin Wise
+job:    Chief Operating Officer
+```
+
+## Supported data types
+
+Currently autofaker supports creating anonymous variables for the following data types:
+
+Built-in types:
+- int
+- float
+- str
+- complex
+- range
+- bytes
+- bytearray
+
+Datetime types:
+- datetime
+- date
+
+Classes:
+- Simple classes
+- @dataclass
+- Nested classes (and recursion)
+- Classes containing lists of other types
+- Enum classes
+
+Dataframes:
+- Pandas dataframe
+
+
+## Example usages
+
+Create anonymous built-in types like `int`, `float`, `str` and datetime types like `datetime` and `date`
+
+```python
+print(f'anonymous string:    {Autodata.create(str)}')
+print(f'anonymous int:       {Autodata.create(int)}')
+print(f'anonymous float:     {Autodata.create(float)}')
+print(f'anonymous complex:   {Autodata.create(complex)}')
+print(f'anonymous range:     {Autodata.create(range)}')
+print(f'anonymous bytes:     {Autodata.create(bytes)}')
+print(f'anonymous bytearray: {Autodata.create(bytearray)}')
+print(f'anonymous datetime:  {Autodata.create(datetime)}')
+print(f'anonymous date:      {Autodata.create(datetime.date)}')
+```
+
+The code above might output the following
+
+```
+anonymous string:    f91954f1-96df-463f-a427-665c99213395
+anonymous int:       2066712686
+anonymous float:     725758222.8712853
+anonymous datetime:  2017-06-19 02:40:41.000084
+anonymous date:      2019-11-10 00:00:00
+```
+
+Creates an anonymous class
+
+```python
+
+class SimpleClass:
+    id = -1
+    text = 'test'
+
+cls = Autodata.create(SimpleClass)
+print(f'id = {cls.id}')
+print(f'text = {cls.text}')
+```
+
+The code above might output the following
+
+```
+id = 2020177162
+text = ac54a65d-b4a3-4eda-a840-eb948ad10d5f
+```
+
+Create a collection of an anonymous class
+
+```python
+class SimpleClass:
+    id = -1
+    text = 'test'
+
+classes = Autodata.create_many(SimpleClass)
+for cls in classes:
+  print(f'id = {cls.id}')
+  print(f'text = {cls.text}')
+  print()
+```
+
+The code above might output the following
+
+```
+id = 242996515
+text = 5bb60504-ccca-4104-9b7f-b978e52a6518
+
+id = 836984239
+text = 079df61e-a87e-4f26-8196-3f44157aabd6
+
+id = 570703150
+text = a3b86f08-c73a-4730-bde7-4bdff5360ef4
+```
+
+Creates an anonymous dataclass
+
+```python
+from dataclasses import dataclass
+
+@dataclass
+class DataClass:
+    id: int
+    text: str
+
+cls = Autodata.create(DataClass)
+print(f'id = {cls.id}')
+print(f'text = {cls.text}')
+```
+
+The code above might output the following
+
+```
+id = 314075507
+text = 4a3b3cae-f4cf-4502-a7f3-61115a1e0d2a
+```
+
+Creates an anonymous dataclass using fake data
+
+```python
+@dataclass
+class DataClass:
+    id: int
+
+    name: str
+    address: str
+    job: str
+
+    country: str
+    currency_name: str
+    currency_code: str
+
+    email: str
+    safe_email: str
+    company_email: str
+
+    hostname: str
+    ipv4: str
+    ipv6: str
+
+    text: str
+
+
+data = Autodata.create(DataClass, use_fake_data=True)
+
+print(f'id:               {data.id}')
+print(f'name:             {data.name}')
+print(f'job:              {data.job}\n')
+print(f'address:\n{data.address}\n')
+
+print(f'country:          {data.country}')
+print(f'currency name:    {data.currency_name}')
+print(f'currency code:    {data.currency_code}\n')
+
+print(f'email:            {data.email}')
+print(f'safe email:       {data.safe_email}')
+print(f'work email:       {data.company_email}\n')
+
+print(f'hostname:         {data.hostname}')
+print(f'IPv4:             {data.ipv4}')
+print(f'IPv6:             {data.ipv6}\n')
+
+print(f'text:\n{data.text}')
+```
+
+The code above might output the following
+
+```
+id:               8952
+name:             Justin Wise
+job:              Chief Operating Officer
+
+address:
+65939 Hernandez Parks
+Rochaport, NC 41760
+
+country:          Equatorial Guinea
+currency name:    Burmese kyat
+currency code:    ERN
+
+email:            smithjohn@example.com
+safe email:       kent11@example.com
+work email:       marissagreen@brown-cole.com
+
+hostname:         db-90.hendricks-west.org
+IPv4:             66.139.143.242
+IPv6:             895d:82f7:7c13:e7cb:f35d:c93:aeb2:8eeb
+
+text:
+Movie author culture represent. Enjoy myself over physical green lead but home.
+Share wind factor far minute produce significant. Sense might fact leader.
+```
+
+Create an anonymous class with nested types
+
+```python
+
+class NestedClass:
+    id = -1
+    text = 'test'
+    inner = SimpleClass()
+
+cls = Autodata.create(NestedClass)
+print(f'id = {cls.id}')
+print(f'text = {cls.text}')
+print(f'inner.id = {cls.inner.id}')
+print(f'inner.text = {cls.inner.text}')
+```
+
+The code above might output the following
+
+```
+id = 1565737216
+text = e66ecd5c-c17a-4426-b755-36dfd2082672
+inner.id = 390282329
+inner.text = eef94b5c-aa95-427a-a9e6-d99e2cc1ffb2
+```
+
+Create a collection of an anonymous class with nested types
+
+```python
+class NestedClass:
+    id = -1
+    text = 'test'
+    inner = SimpleClass()
+
+classes = Autodata.create_many(NestedClass)
+for cls in classes:
+  print(f'id = {cls.id}')
+  print(f'text = {cls.text}')
+  print(f'inner.id = {cls.inner.id}')
+  print(f'inner.text = {cls.inner.text}')
+  print()
+```
+
+The code above might output the following
+
+```
+id = 1116454042
+text = ceeecf0c-7375-4f3a-8d4b-6d7a4f2b20fd
+inner.id = 1067027444
+inner.text = 079573ce-1ef4-408d-8984-1dbc7b0d0b80
+
+id = 730390288
+text = ff3ca474-a69d-4ff6-95b4-fbdb1bea7cdb
+inner.id = 1632771208
+inner.text = 9423e824-dc8f-4145-ba47-7301351a91f8
+
+id = 187364960
+text = b31ca191-5031-43a2-870a-7bc7c99e4110
+inner.id = 1705149100
+inner.text = e703a117-ba4f-4201-a31b-10ab8e54a673
+```
+
+Create a Pandas DataFrame using anonymous data generated from a specified type
+
+```python
+class DataClass:
+    id = -1
+    type = '' 
+    value = 0
+
+pdf = Autodata.create_pandas_dataframe(DataClass)
+print(pdf)
+```
+
+The code above might output the following
+
+```
+          id                                  type       value
+0  778090854  13537c5a-62e7-488b-836e-a4b17f2f3ae9  1049015695
+1  602015506  c043ca8d-e280-466a-8bba-ec1e0539fe28  1016359353
+2  387753717  986b3b1c-abf4-4bc1-95cf-0e979390e4f3   766159839
+```
+
+Create a Pandas DataFrame using fake data generated from a specified type
+
+```python
+class DataClass:
+    id = -1
+    type = '' 
+    value = 0
+
+pdf = Autodata.create_pandas_dataframe(DataClass, use_fake_data=True)
+print(pdf)
+```
+
+The code above might output the following
+
+```
+  first_name    id last_name          phone_number
+0   Lawrence  7670   Jimenez  001-172-307-0561x471
+1      Bryan  9084    Walker         (697)893-6767
+2       Paul  9824    Thomas    960.555.3577x65487
+```
+
+#
+
+For tips and tricks on software development, check out [my blog](https://christianhelle.com)
+
+If you find this useful and feel a bit generous then feel free to [buy me a coffee ☕](https://www.buymeacoffee.com/christianhelle)
+
+
+
+
+%prep
+%autosetup -n autofaker-1.0.14
+
+%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-autofaker -f filelist.lst
+%dir %{python3_sitelib}/*
+
+%files help -f doclist.lst
+%{_docdir}/*
+
+%changelog
+* Mon May 29 2023 Python_Bot <Python_Bot@openeuler.org> - 1.0.14-1
+- Package Spec generated
diff --git a/sources b/sources
new file mode 100644
index 0000000..b43a2c0
--- /dev/null
+++ b/sources
@@ -0,0 +1 @@
+5745787650808aedb2037567da7e2c7e  autofaker-1.0.14.tar.gz