Merge pull request #91 from christianhelle/copilot/add-anonymous-instances-features

Add support for tuple, set, frozenset, dict, Decimal, UUID, Path, time, timedelta, and typing generics

Author: christianhelle

README.md

@@ -131,10 +131,27 @@ Built-in types:
 - range
 - bytes
 - bytearray
+- tuple
+- set
+- frozenset
+- dict
+- decimal.Decimal
+- uuid.UUID
+- pathlib.Path
 
 Datetime types:
 - datetime
 - date
+- time
+- timedelta
+
+Typing generics:
+- typing.Tuple[T, ...]
+- typing.Set[T]
+- typing.FrozenSet[T]
+- typing.Dict[K, V]
+- typing.Optional[T]
+- typing.List[T]
 
 Classes:
 - Simple classes
@@ -174,6 +191,61 @@ anonymous datetime:  2017-06-19 02:40:41.000084
 anonymous date:      2019-11-10 00:00:00
 ```
 
+Create anonymous instances of additional built-in and standard library types
+
+```python
+import decimal
+import uuid
+import pathlib
+from datetime import time, timedelta
+
+print(f'anonymous tuple:     {Autodata.create(tuple)}')
+print(f'anonymous set:       {Autodata.create(set)}')
+print(f'anonymous frozenset: {Autodata.create(frozenset)}')
+print(f'anonymous dict:      {Autodata.create(dict)}')
+print(f'anonymous Decimal:   {Autodata.create(decimal.Decimal)}')
+print(f'anonymous UUID:      {Autodata.create(uuid.UUID)}')
+print(f'anonymous Path:      {Autodata.create(pathlib.Path)}')
+print(f'anonymous time:      {Autodata.create(time)}')
+print(f'anonymous timedelta: {Autodata.create(timedelta)}')
+```
+
+The code above might output the following
+
+```
+anonymous tuple:     (9655, '1608f20f-c563-41ff-b3df-2be21be71437', 2309.52)
+anonymous set:       {'eff62089-1834-4b5c-854e-68ac8f28979f', ...}
+anonymous frozenset: frozenset({'0ef46f14-70ce-4d0b-a099-625d0f881602', ...})
+anonymous dict:      {'fd1a7430-5b5f-4dc0-974d-65184a406d25': 3431, ...}
+anonymous Decimal:   2508.6919872240996
+anonymous UUID:      751de33e-401e-42f2-acdb-3df9d1f9eb62
+anonymous Path:      ee388b30-eb11-46af-b2f0/e1ab4d2d-7a6f-4ee9
+anonymous time:      23:09:39.638523
+anonymous timedelta: 165 days, 1:19:58.470884
+```
+
+Create anonymous instances of typed generics
+
+```python
+from typing import Tuple, Set, FrozenSet, Dict, Optional
+
+print(f'Tuple[int, str]:  {Autodata.create(Tuple[int, str])}')
+print(f'Set[int]:         {Autodata.create(Set[int])}')
+print(f'FrozenSet[str]:   {Autodata.create(FrozenSet[str])}')
+print(f'Dict[str, int]:   {Autodata.create(Dict[str, int])}')
+print(f'Optional[int]:    {Autodata.create(Optional[int])}')
+```
+
+The code above might output the following
+
+```
+Tuple[int, str]:  (7032, '351236d0-378e-45f6-bf58-77e2ac2bfc48')
+Set[int]:         {1408, 8224, 5107}
+FrozenSet[str]:   frozenset({'5f5eaf3c-1926-4d34-ae32-ef5a3a549c5f', ...})
+Dict[str, int]:   {'65174a9b-76f3-4d1c-a1a4': 3817, ...}
+Optional[int]:    8051
+```
+
 Creates an anonymous class
 
 ```python
@@ -380,6 +452,62 @@ inner.id = 1705149100
 inner.text = e703a117-ba4f-4201-a31b-10ab8e54a673
 ```
 
+Create a dataclass using additional built-in types and typing generics
+
+```python
+import decimal
+import uuid
+import pathlib
+from datetime import time, timedelta
+from typing import Set, Dict, Tuple, Optional
+from dataclasses import dataclass
+from autofaker import Autodata
+
+@dataclass
+class AdvancedDataClass:
+    id: int
+    name: str
+    amount: decimal.Decimal
+    uid: uuid.UUID
+    file_path: pathlib.Path
+    created_time: time
+    duration: timedelta
+    tags: Set[str]
+    scores: Tuple[int, str]
+    metadata: Dict[str, int]
+    optional_name: Optional[str]
+
+data = Autodata.create(AdvancedDataClass)
+
+print(f'id:           {data.id}')
+print(f'name:         {data.name}')
+print(f'amount:       {data.amount}')
+print(f'uid:          {data.uid}')
+print(f'file_path:    {data.file_path}')
+print(f'created_time: {data.created_time}')
+print(f'duration:     {data.duration}')
+print(f'tags:         {data.tags}')
+print(f'scores:       {data.scores}')
+print(f'metadata:     {data.metadata}')
+print(f'optional:     {data.optional_name}')
+```
+
+The code above might output the following
+
+```
+id:           2225
+name:         28a78977-8218-471a-aa3b-5172bd267e9a
+amount:       8071.9111587519055
+uid:          4bfc05f9-ad4e-4906-96a0-74f4ef60974f
+file_path:    0da7ee48-1008-4e72/ffc6c087-b690-44d3
+created_time: 15:25:29.820442
+duration:     177 days, 23:33:16.414807
+tags:         {'191751c3-11a6-471b', '63508ce7-b14a-433f', ...}
+scores:       (4467, 'a1255ae9-b23c-4cfa-8861-213e12b41030')
+metadata:     {'193b3ddc-3172-49ef': 1744, ...}
+optional:     983e4c69-0426-4488-ba98-559e77075c03
+```
+
 Create a Pandas DataFrame using anonymous data generated from a specified type
 
 ```python

src/autofaker/builtins.py

@@ -1,3 +1,5 @@
+import decimal
+import pathlib
 import random
 import uuid
 
@@ -47,3 +49,57 @@ def generate(self):
 class MemoryViewGenerator(TypeDataGeneratorBase):
     def generate(self):
         return memoryview(BytesGenerator().generate())
+
+
+class TupleGenerator(TypeDataGeneratorBase):
+    def generate(self):
+        return (
+            IntegerGenerator().generate(),
+            StringGenerator().generate(),
+            FloatGenerator().generate(),
+        )
+
+
+class SetGenerator(TypeDataGeneratorBase):
+    def generate(self):
+        return {
+            StringGenerator().generate(),
+            StringGenerator().generate(),
+            StringGenerator().generate(),
+        }
+
+
+class FrozenSetGenerator(TypeDataGeneratorBase):
+    def generate(self):
+        return frozenset({
+            StringGenerator().generate(),
+            StringGenerator().generate(),
+            StringGenerator().generate(),
+        })
+
+
+class DictGenerator(TypeDataGeneratorBase):
+    def generate(self):
+        return {
+            StringGenerator().generate(): IntegerGenerator().generate(),
+            StringGenerator().generate(): IntegerGenerator().generate(),
+            StringGenerator().generate(): IntegerGenerator().generate(),
+        }
+
+
+class DecimalGenerator(TypeDataGeneratorBase):
+    def generate(self):
+        return decimal.Decimal(str(random.uniform(0, 10000)))
+
+
+class UUIDGenerator(TypeDataGeneratorBase):
+    def generate(self):
+        return uuid.uuid4()
+
+
+class PathGenerator(TypeDataGeneratorBase):
+    def generate(self):
+        return pathlib.Path(
+            StringGenerator().generate(),
+            StringGenerator().generate(),
+        )

src/autofaker/dates.py

@@ -5,7 +5,7 @@
 
 
 def is_date_type(type_name) -> bool:
-    return type_name in ["datetime", "date"]
+    return type_name in ["datetime", "date", "time", "timedelta"]
 
 
 class DatetimeGenerator(TypeDataGeneratorBase):
@@ -30,3 +30,22 @@ def generate(self):
             random.randint(1, 12),
             random.randint(1, 28),
         )
+
+
+class TimeGenerator(TypeDataGeneratorBase):
+    def generate(self):
+        return datetime.time(
+            random.randint(0, 23),
+            random.randint(0, 59),
+            random.randint(0, 59),
+            random.randint(0, 999999),
+        )
+
+
+class TimedeltaGenerator(TypeDataGeneratorBase):
+    def generate(self):
+        return datetime.timedelta(
+            days=random.randint(0, 365),
+            seconds=random.randint(0, 86399),
+            microseconds=random.randint(0, 999999),
+        )

src/autofaker/factory.py

@@ -3,10 +3,17 @@
     ByteArrayGenerator,
     BytesGenerator,
     ComplexGenerator,
+    DecimalGenerator,
+    DictGenerator,
     FloatGenerator,
+    FrozenSetGenerator,
     IntegerGenerator,
     MemoryViewGenerator,
+    PathGenerator,
     RangeGenerator,
+    SetGenerator,
+    TupleGenerator,
+    UUIDGenerator,
 )
 from autofaker.fakes import FakeIntegerGenerator, FakeStringGenerator, StringGenerator
 
@@ -24,6 +31,15 @@ def is_supported(type_name) -> bool:
             "bytes",
             "bytearray",
             "memoryview",
+            "tuple",
+            "set",
+            "frozenset",
+            "dict",
+            "decimal",
+            "uuid",
+            "posixpath",
+            "windowspath",
+            "path",
         ]
 
     @staticmethod
@@ -54,3 +70,17 @@ def create(type_name, field_name: str = None, use_fake_data: bool = False):
             return ByteArrayGenerator()
         if type_name == "memoryview":
             return MemoryViewGenerator()
+        if type_name == "tuple":
+            return TupleGenerator()
+        if type_name == "set":
+            return SetGenerator()
+        if type_name == "frozenset":
+            return FrozenSetGenerator()
+        if type_name == "dict":
+            return DictGenerator()
+        if type_name == "decimal":
+            return DecimalGenerator()
+        if type_name == "uuid":
+            return UUIDGenerator()
+        if type_name in ("posixpath", "windowspath", "path"):
+            return PathGenerator()