12491947667

Committed 25 Dec 2024 10:01AM UTC coverage: 99.969%. Remained the same

Build # 12491947667

Build Type

push

github

Committed by

web-flow

Commit Message

Up reqs (#96)

Run Details

3256 of 3257 relevant lines covered (99.97%)

1.67 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

100.0

/src/faker_file/cli/helpers.py

import inspect
import os
import typing
from copy import deepcopy
from typing import Any, Dict, Tuple, Type

from faker import Faker

from ..base import FileMixin, StringValue
from ..providers.bin_file import BinFileProvider
from ..providers.csv_file import CsvFileProvider
from ..providers.docx_file import DocxFileProvider
from ..providers.eml_file import EmlFileProvider
from ..providers.epub_file import EpubFileProvider
from ..providers.generic_file import GenericFileProvider
from ..providers.ico_file import GraphicIcoFileProvider, IcoFileProvider
from ..providers.jpeg_file import GraphicJpegFileProvider, JpegFileProvider
from ..providers.mp3_file import Mp3FileProvider
from ..providers.odp_file import OdpFileProvider
from ..providers.ods_file import OdsFileProvider
from ..providers.odt_file import OdtFileProvider
from ..providers.pdf_file import GraphicPdfFileProvider, PdfFileProvider
from ..providers.png_file import GraphicPngFileProvider, PngFileProvider
from ..providers.pptx_file import PptxFileProvider
from ..providers.rtf_file import RtfFileProvider
from ..providers.svg_file import SvgFileProvider
from ..providers.tar_file import TarFileProvider
from ..providers.txt_file import TxtFileProvider
from ..providers.webp_file import GraphicWebpFileProvider, WebpFileProvider
from ..providers.xlsx_file import XlsxFileProvider
from ..providers.xml_file import XmlFileProvider
from ..providers.zip_file import ZipFileProvider

__author__ = "Artur Barseghyan <artur.barseghyan@gmail.com>"
__copyright__ = "2023 Artur Barseghyan"
__license__ = "MIT"
__all__ = (
    "generate_completion_file",
    "generate_file",
    "get_method_kwargs",
    "is_optional_type",
    "PROVIDERS",
)

KWARGS_DROP = {
    "self",  # Drop as irrelevant
    "storage",  # Drop as non-supported arg
    "return",  # Drop as irrelevant
    # "mp3_generator_cls",  # Drop as non-supported arg
    # "mp3_generator_kwargs",  # Drop as non-supported arg
    # "pdf_generator_cls",  # Drop as non-supported arg
    # "pdf_generator_kwargs",  # Drop as non-supported arg
    "format_func",  # Drop as non-supported arg
    "raw",  # Drop `raw`, because we will be forcing raw=True for streaming
}
OVERRIDES = {
    "DocxFileProvider.docx_file": {
        "annotations": {
            "content": str,
        },
        "model_props": {
            "content": None,
        },
    },
    "GenericFileProvider.generic_file": {
        "annotations": {
            "content": str,
        },
        "model_props": {},
    },
    "Mp3FileProvider.mp3_file": {
        "annotations": {
            "mp3_generator_cls": str,
        },
        "model_props": {
            "mp3_generator_cls": (
                "faker_file.providers.mp3_file.generators"
                ".gtts_generator.GttsMp3Generator"
            ),
        },
    },
    "OdtFileProvider.odt_file": {
        "annotations": {
            "content": str,
        },
        "model_props": {
            "content": None,
        },
    },
    "PdfFileProvider.pdf_file": {
        "annotations": {
            "pdf_generator_cls": str,
        },
        "model_props": {
            "pdf_generator_cls": (
                "faker_file.providers.pdf_file.generators"
                ".pdfkit_generator.PdfkitPdfGenerator"
            ),
        },
    },
}
PROVIDERS = {
    BinFileProvider.bin_file.__name__: BinFileProvider,
    CsvFileProvider.csv_file.__name__: CsvFileProvider,
    DocxFileProvider.docx_file.__name__: DocxFileProvider,
    EmlFileProvider.eml_file.__name__: EmlFileProvider,
    EpubFileProvider.epub_file.__name__: EpubFileProvider,
    GenericFileProvider.generic_file.__name__: GenericFileProvider,
    GraphicIcoFileProvider.graphic_ico_file.__name__: GraphicIcoFileProvider,
    GraphicJpegFileProvider.graphic_jpeg_file.__name__: (
        GraphicJpegFileProvider
    ),
    GraphicPdfFileProvider.graphic_pdf_file.__name__: GraphicPdfFileProvider,
    GraphicPngFileProvider.graphic_png_file.__name__: GraphicPngFileProvider,
    GraphicWebpFileProvider.graphic_webp_file.__name__: (
        GraphicWebpFileProvider
    ),
    IcoFileProvider.ico_file.__name__: IcoFileProvider,
    JpegFileProvider.jpeg_file.__name__: JpegFileProvider,
    Mp3FileProvider.mp3_file.__name__: Mp3FileProvider,
    OdpFileProvider.odp_file.__name__: OdpFileProvider,
    OdsFileProvider.ods_file.__name__: OdsFileProvider,
    OdtFileProvider.odt_file.__name__: OdtFileProvider,
    PdfFileProvider.pdf_file.__name__: PdfFileProvider,
    PngFileProvider.png_file.__name__: PngFileProvider,
    PptxFileProvider.pptx_file.__name__: PptxFileProvider,
    RtfFileProvider.rtf_file.__name__: RtfFileProvider,
    SvgFileProvider.svg_file.__name__: SvgFileProvider,
    TarFileProvider.tar_file.__name__: TarFileProvider,
    TxtFileProvider.txt_file.__name__: TxtFileProvider,
    WebpFileProvider.webp_file.__name__: WebpFileProvider,
    XlsxFileProvider.xlsx_file.__name__: XlsxFileProvider,
    XmlFileProvider.xml_file.__name__: XmlFileProvider,
    ZipFileProvider.zip_file.__name__: ZipFileProvider,
}


def get_method_kwargs(
    cls: Type[FileMixin], method_name: str
) -> Tuple[Dict[str, Any], Dict[str, Any]]:
    method = getattr(cls, method_name)
    method_specs = inspect.getfullargspec(method)

    kwargs = deepcopy(method_specs.args[1:])  # Omit `self`
    defaults = deepcopy(method_specs.defaults if method_specs.defaults else [])
    model_props = dict(zip(kwargs, defaults, strict=False))
    annotations = deepcopy(method_specs.annotations)

    # Override the type definition for mp3_generator_cls
    override = OVERRIDES.get(f"{cls.__name__}.{method_name}", None)
    if override:
        annotations.update(override["annotations"])
        model_props.update(override["model_props"])

    for kwarg_name in KWARGS_DROP:
        annotations.pop(kwarg_name, None)
        model_props.pop(kwarg_name, None)

    return model_props, annotations


def generate_file(method_name: str, **kwargs) -> StringValue:
    faker = Faker()
    cls = PROVIDERS[method_name]
    method = getattr(cls(faker), method_name)
    value = method(**kwargs)
    return value


def is_optional_type(t: Any) -> bool:
    if getattr(t, "__origin__", None) is typing.Union:
        return any(arg is type(None) for arg in t.__args__)  # noqa
    return False


def generate_completion_file():
    completion_script = f"""#!/bin/bash

_faker_file_completion() {{
    local cur prev providers commands
    cur="${{COMP_WORDS[COMP_CWORD]}}"
    prev="${{COMP_WORDS[COMP_CWORD - 1]}}"
    providers="{(' '.join(PROVIDERS.keys()))}"
    commands="generate-completion version"  # Add the commands here

    case $prev in"""

    for method_name, provider in PROVIDERS.items():
        method_kwargs, _ = get_method_kwargs(provider, method_name)
        completion_script += f"""
        {method_name})
            COMPREPLY=($(compgen -W "{(' '.join('--' + k for k in method_kwargs.keys()))} --nb_files" -- "$cur"))
            ;;
        """  # noqa

    # Add the case for commands
    completion_script += """
        generate-completion|version)
            COMPREPLY=()
            ;;
    """

    completion_script += """
        *)
            COMPREPLY=($(compgen -W "$providers $commands" -- "$cur"))
            ;;
    esac

    return 0
}

complete -F _faker_file_completion faker-file
"""

    user_home_dir = os.path.expanduser("~")
    file_path = os.path.join(user_home_dir, "faker_file_completion.sh")
    with open(file_path, "w") as f:
        f.write(completion_script)

    print(f"Generated bash completion file: {file_path}")

1	import inspect	1✔
2	import os	1✔
3	import typing	1✔
4	from copy import deepcopy	1✔
5	from typing import Any, Dict, Tuple, Type	1✔
6
7	from faker import Faker	1✔
8
9	from ..base import FileMixin, StringValue	1✔
10	from ..providers.bin_file import BinFileProvider	1✔
11	from ..providers.csv_file import CsvFileProvider	1✔
12	from ..providers.docx_file import DocxFileProvider	1✔
13	from ..providers.eml_file import EmlFileProvider	1✔
14	from ..providers.epub_file import EpubFileProvider	1✔
15	from ..providers.generic_file import GenericFileProvider	1✔
16	from ..providers.ico_file import GraphicIcoFileProvider, IcoFileProvider	1✔
17	from ..providers.jpeg_file import GraphicJpegFileProvider, JpegFileProvider	1✔
18	from ..providers.mp3_file import Mp3FileProvider	1✔
19	from ..providers.odp_file import OdpFileProvider	1✔
20	from ..providers.ods_file import OdsFileProvider	1✔
21	from ..providers.odt_file import OdtFileProvider	1✔
22	from ..providers.pdf_file import GraphicPdfFileProvider, PdfFileProvider	1✔
23	from ..providers.png_file import GraphicPngFileProvider, PngFileProvider	1✔
24	from ..providers.pptx_file import PptxFileProvider	1✔
25	from ..providers.rtf_file import RtfFileProvider	1✔
26	from ..providers.svg_file import SvgFileProvider	1✔
27	from ..providers.tar_file import TarFileProvider	1✔
28	from ..providers.txt_file import TxtFileProvider	1✔
29	from ..providers.webp_file import GraphicWebpFileProvider, WebpFileProvider	1✔
30	from ..providers.xlsx_file import XlsxFileProvider	1✔
31	from ..providers.xml_file import XmlFileProvider	1✔
32	from ..providers.zip_file import ZipFileProvider	1✔
33
34	__author__ = "Artur Barseghyan <artur.barseghyan@gmail.com>"	1✔
35	__copyright__ = "2023 Artur Barseghyan"	1✔
36	__license__ = "MIT"	1✔
37	__all__ = (	1✔
38	"generate_completion_file",
39	"generate_file",
40	"get_method_kwargs",
41	"is_optional_type",
42	"PROVIDERS",
43	)
44
45	KWARGS_DROP = {	1✔
46	"self", # Drop as irrelevant
47	"storage", # Drop as non-supported arg
48	"return", # Drop as irrelevant
49	# "mp3_generator_cls", # Drop as non-supported arg
50	# "mp3_generator_kwargs", # Drop as non-supported arg
51	# "pdf_generator_cls", # Drop as non-supported arg
52	# "pdf_generator_kwargs", # Drop as non-supported arg
53	"format_func", # Drop as non-supported arg
54	"raw", # Drop `raw`, because we will be forcing raw=True for streaming
55	}
56	OVERRIDES = {	1✔
57	"DocxFileProvider.docx_file": {
58	"annotations": {
59	"content": str,
60	},
61	"model_props": {
62	"content": None,
63	},
64	},
65	"GenericFileProvider.generic_file": {
66	"annotations": {
67	"content": str,
68	},
69	"model_props": {},
70	},
71	"Mp3FileProvider.mp3_file": {
72	"annotations": {
73	"mp3_generator_cls": str,
74	},
75	"model_props": {
76	"mp3_generator_cls": (
77	"faker_file.providers.mp3_file.generators"
78	".gtts_generator.GttsMp3Generator"
79	),
80	},
81	},
82	"OdtFileProvider.odt_file": {
83	"annotations": {
84	"content": str,
85	},
86	"model_props": {
87	"content": None,
88	},
89	},
90	"PdfFileProvider.pdf_file": {
91	"annotations": {
92	"pdf_generator_cls": str,
93	},
94	"model_props": {
95	"pdf_generator_cls": (
96	"faker_file.providers.pdf_file.generators"
97	".pdfkit_generator.PdfkitPdfGenerator"
98	),
99	},
100	},
101	}
102	PROVIDERS = {	1✔
103	BinFileProvider.bin_file.__name__: BinFileProvider,
104	CsvFileProvider.csv_file.__name__: CsvFileProvider,
105	DocxFileProvider.docx_file.__name__: DocxFileProvider,
106	EmlFileProvider.eml_file.__name__: EmlFileProvider,
107	EpubFileProvider.epub_file.__name__: EpubFileProvider,
108	GenericFileProvider.generic_file.__name__: GenericFileProvider,
109	GraphicIcoFileProvider.graphic_ico_file.__name__: GraphicIcoFileProvider,
110	GraphicJpegFileProvider.graphic_jpeg_file.__name__: (
111	GraphicJpegFileProvider
112	),
113	GraphicPdfFileProvider.graphic_pdf_file.__name__: GraphicPdfFileProvider,
114	GraphicPngFileProvider.graphic_png_file.__name__: GraphicPngFileProvider,
115	GraphicWebpFileProvider.graphic_webp_file.__name__: (
116	GraphicWebpFileProvider
117	),
118	IcoFileProvider.ico_file.__name__: IcoFileProvider,
119	JpegFileProvider.jpeg_file.__name__: JpegFileProvider,
120	Mp3FileProvider.mp3_file.__name__: Mp3FileProvider,
121	OdpFileProvider.odp_file.__name__: OdpFileProvider,
122	OdsFileProvider.ods_file.__name__: OdsFileProvider,
123	OdtFileProvider.odt_file.__name__: OdtFileProvider,
124	PdfFileProvider.pdf_file.__name__: PdfFileProvider,
125	PngFileProvider.png_file.__name__: PngFileProvider,
126	PptxFileProvider.pptx_file.__name__: PptxFileProvider,
127	RtfFileProvider.rtf_file.__name__: RtfFileProvider,
128	SvgFileProvider.svg_file.__name__: SvgFileProvider,
129	TarFileProvider.tar_file.__name__: TarFileProvider,
130	TxtFileProvider.txt_file.__name__: TxtFileProvider,
131	WebpFileProvider.webp_file.__name__: WebpFileProvider,
132	XlsxFileProvider.xlsx_file.__name__: XlsxFileProvider,
133	XmlFileProvider.xml_file.__name__: XmlFileProvider,
134	ZipFileProvider.zip_file.__name__: ZipFileProvider,
135	}
136
137
138	def get_method_kwargs(	1✔
139	cls: Type[FileMixin], method_name: str
140	) -> Tuple[Dict[str, Any], Dict[str, Any]]:
141	method = getattr(cls, method_name)	1✔
142	method_specs = inspect.getfullargspec(method)	1✔
143
144	kwargs = deepcopy(method_specs.args[1:]) # Omit `self`	1✔
145	defaults = deepcopy(method_specs.defaults if method_specs.defaults else [])	1✔
146	model_props = dict(zip(kwargs, defaults, strict=False))	1✔
147	annotations = deepcopy(method_specs.annotations)	1✔
148
149	# Override the type definition for mp3_generator_cls
150	override = OVERRIDES.get(f"{cls.__name__}.{method_name}", None)	1✔
151	if override:	1✔
152	annotations.update(override["annotations"])	1✔
153	model_props.update(override["model_props"])	1✔
154
155	for kwarg_name in KWARGS_DROP:	1✔
156	annotations.pop(kwarg_name, None)	1✔
157	model_props.pop(kwarg_name, None)	1✔
158
159	return model_props, annotations	1✔
160
161
162	def generate_file(method_name: str, **kwargs) -> StringValue:	1✔
163	faker = Faker()	1✔
164	cls = PROVIDERS[method_name]	1✔
165	method = getattr(cls(faker), method_name)	1✔
166	value = method(**kwargs)	1✔
167	return value	1✔
168
169
170	def is_optional_type(t: Any) -> bool:	1✔
171	if getattr(t, "__origin__", None) is typing.Union:	1✔
172	return any(arg is type(None) for arg in t.__args__) # noqa	1✔
173	return False	1✔
174
175
176	def generate_completion_file():	1✔
177	completion_script = f"""#!/bin/bash	1✔
178
179	_faker_file_completion() {{
180	local cur prev providers commands
181	cur="${{COMP_WORDS[COMP_CWORD]}}"
182	prev="${{COMP_WORDS[COMP_CWORD - 1]}}"
183	providers="{(' '.join(PROVIDERS.keys()))}"
184	commands="generate-completion version" # Add the commands here
185
186	case $prev in"""
187
188	for method_name, provider in PROVIDERS.items():	1✔
189	method_kwargs, _ = get_method_kwargs(provider, method_name)	1✔
190	completion_script += f"""	1✔
191	{method_name})
192	COMPREPLY=($(compgen -W "{(' '.join('--' + k for k in method_kwargs.keys()))} --nb_files" -- "$cur"))
193	;;
194	""" # noqa
195
196	# Add the case for commands
197	completion_script += """	1✔
198	generate-completion\|version)
199	COMPREPLY=()
200	;;
201	"""
202
203	completion_script += """	1✔
204	*)
205	COMPREPLY=($(compgen -W "$providers $commands" -- "$cur"))
206	;;
207	esac
208
209	return 0
210	}
211
212	complete -F _faker_file_completion faker-file
213	"""
214
215	user_home_dir = os.path.expanduser("~")	1✔
216	file_path = os.path.join(user_home_dir, "faker_file_completion.sh")	1✔
217	with open(file_path, "w") as f:	1✔
218	f.write(completion_script)	1✔
219
220	print(f"Generated bash completion file: {file_path}")	1✔

barseghyanartur / faker-file / 12491947667

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous