diff options
| -rw-r--r-- | .gitignore | 1 | ||||
| -rw-r--r-- | python-autofaker.spec | 1299 | ||||
| -rw-r--r-- | sources | 1 |
3 files changed, 1301 insertions, 0 deletions
@@ -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 @@ -0,0 +1 @@ +5745787650808aedb2037567da7e2c7e autofaker-1.0.14.tar.gz |