report.html

self = <test_orders_and_payment_flow.TestOrderAndPaymentFlowCertificationProgram object at 0x0000020BE09DC6D0>, value = 'A', initialize_pages = None
testdata = {'contact_no': '123456789', 'country': ['in', 'us', 'gb', 'au', 'de', 'sg', ...], 'db_type': 'mysql', 'dynamo_db_type': 'dynamo', ...}

@pytest.mark.test_details("0000","high","Order and Payment Flow","Pradeep")
@pytest.mark.parametrize("value", certification_program_course_read_csv())
def test_Orders_and_Payment_Flow_certification(self,value,initialize_pages,testdata):

'''
Objective: Make payment and validate the data in Dynamo db and mySql

Step 01: get url
Step 02: click on Enroll Now CTA
Step 03: Make payment
Step 04: Validate the Dynamo db and MySql daya for the payment
'''
self.add_rows_in_csv('Report.csv')
url_count = self._count_url_txt_file_subdomain('Orders_and_Payment_Flow_Certification.txt')
logging.info(f"Total URL Present is: {url_count}")

# Step 01: get url
counter = 0
> df = pd.read_csv('Orders_and_Payment_Flow_Certification.csv', on_bad_lines='skip')

test_prod\test_orders_and_payment_flow.py:50:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\util\_decorators.py:311: in wrapper
return func(*args, **kwargs)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:680: in read_csv
return _read(filepath_or_buffer, kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:575: in _read
parser = TextFileReader(filepath_or_buffer, **kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:933: in __init__
self._engine = self._make_engine(f, self.engine)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:1217: in _make_engine
self.handles = get_handle( # type: ignore[call-overload]
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

path_or_buf = 'Orders_and_Payment_Flow_Certification.csv', mode = 'r'

@doc(compression_options=_shared_docs["compression_options"] % "path_or_buf")
def get_handle(
path_or_buf: FilePath | BaseBuffer,
mode: str,
*,
encoding: str | None = None,
compression: CompressionOptions = None,
memory_map: bool = False,
is_text: bool = True,
errors: str | None = None,
storage_options: StorageOptions = None,
) -> IOHandles[str] | IOHandles[bytes]:
"""
Get file handle for given path/buffer and mode.

Parameters
----------
path_or_buf : str or file handle
File path or object.
mode : str
Mode to open path_or_buf with.
encoding : str or None
Encoding to use.
{compression_options}

.. versionchanged:: 1.0.0
May now be a dict with key 'method' as compression mode
and other keys as compression options if compression
mode is 'zip'.

.. versionchanged:: 1.1.0
Passing compression options as keys in dict is now
supported for compression modes 'gzip', 'bz2', 'zstd' and 'zip'.

.. versionchanged:: 1.4.0 Zstandard support.

memory_map : bool, default False
See parsers._parser_params for more information.
is_text : bool, default True
Whether the type of the content passed to the file/buffer is string or
bytes. This is not the same as `"b" not in mode`. If a string content is
passed to a binary file/buffer, a wrapper is inserted.
errors : str, default 'strict'
Specifies how encoding and decoding errors are to be handled.
See the errors argument for :func:`open` for a full list
of options.
storage_options: StorageOptions = None
Passed to _get_filepath_or_buffer

.. versionchanged:: 1.2.0

Returns the dataclass IOHandles
"""
# Windows does not default to utf-8. Set to utf-8 for a consistent behavior
encoding = encoding or "utf-8"

# read_csv does not know whether the buffer is opened in binary/text mode
if _is_binary_mode(path_or_buf, mode) and "b" not in mode:
mode += "b"

# validate encoding and errors
codecs.lookup(encoding)
if isinstance(errors, str):
codecs.lookup_error(errors)

# open URLs
ioargs = _get_filepath_or_buffer(
path_or_buf,
encoding=encoding,
compression=compression,
mode=mode,
storage_options=storage_options,
)

handle = ioargs.filepath_or_buffer
handles: list[BaseBuffer]

# memory mapping needs to be the first step
handle, memory_map, handles = _maybe_memory_map(
handle,
memory_map,
ioargs.encoding,
ioargs.mode,
errors,
ioargs.compression["method"] not in _compression_to_extension,
)

is_path = isinstance(handle, str)
compression_args = dict(ioargs.compression)
compression = compression_args.pop("method")

# Only for write methods
if "r" not in mode and is_path:
check_parent_directory(str(handle))

if compression:
if compression != "zstd":
# compression libraries do not like an explicit text-mode
ioargs.mode = ioargs.mode.replace("t", "")
elif compression == "zstd" and "b" not in ioargs.mode:
# python-zstandard defaults to text mode, but we always expect
# compression libraries to use binary mode.
ioargs.mode += "b"

# GZ Compression
if compression == "gzip":
if is_path:
assert isinstance(handle, str)
# error: Incompatible types in assignment (expression has type
# "GzipFile", variable has type "Union[str, BaseBuffer]")
handle = gzip.GzipFile( # type: ignore[assignment]
filename=handle,
mode=ioargs.mode,
**compression_args,
)
else:
handle = gzip.GzipFile(
# No overload variant of "GzipFile" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
fileobj=handle, # type: ignore[call-overload]
mode=ioargs.mode,
**compression_args,
)

# BZ Compression
elif compression == "bz2":
# No overload variant of "BZ2File" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
handle = bz2.BZ2File( # type: ignore[call-overload]
handle,
mode=ioargs.mode,
**compression_args,
)

# ZIP Compression
elif compression == "zip":
# error: Argument 1 to "_BytesZipFile" has incompatible type "Union[str,
# BaseBuffer]"; expected "Union[Union[str, PathLike[str]],
# ReadBuffer[bytes], WriteBuffer[bytes]]"
handle = _BytesZipFile(
handle, ioargs.mode, **compression_args # type: ignore[arg-type]
)
if handle.mode == "r":
handles.append(handle)
zip_names = handle.namelist()
if len(zip_names) == 1:
handle = handle.open(zip_names.pop())
elif len(zip_names) == 0:
raise ValueError(f"Zero files found in ZIP file {path_or_buf}")
else:
raise ValueError(
"Multiple files found in ZIP file. "
f"Only one file per ZIP: {zip_names}"
)

# XZ Compression
elif compression == "xz":
handle = get_lzma_file()(handle, ioargs.mode)

# Zstd Compression
elif compression == "zstd":
zstd = import_optional_dependency("zstandard")
if "r" in ioargs.mode:
open_args = {"dctx": zstd.ZstdDecompressor(**compression_args)}
else:
open_args = {"cctx": zstd.ZstdCompressor(**compression_args)}
handle = zstd.open(
handle,
mode=ioargs.mode,
**open_args,
)

# Unrecognized Compression
else:
msg = f"Unrecognized compression type: {compression}"
raise ValueError(msg)

assert not isinstance(handle, str)
handles.append(handle)

elif isinstance(handle, str):
# Check whether the filename is to be opened in binary mode.
# Binary mode does not support 'encoding' and 'newline'.
if ioargs.encoding and "b" not in ioargs.mode:
# Encoding
> handle = open(
handle,
ioargs.mode,
encoding=ioargs.encoding,
errors=errors,
newline="",
)
E FileNotFoundError: [Errno 2] No such file or directory: 'Orders_and_Payment_Flow_Certification.csv'

c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\common.py:789: FileNotFoundError
-------------------------------Captured log call--------------------------------
INFO  setup:test_orders_and_payment_flow.py:46 Total URL Present is: 5

self = <test_orders_and_payment_flow.TestOrderAndPaymentFlowCertificationProgram object at 0x0000020BE0DD2D00>, value = 'B', initialize_pages = None
testdata = {'contact_no': '123456789', 'country': ['in', 'us', 'gb', 'au', 'de', 'sg', ...], 'db_type': 'mysql', 'dynamo_db_type': 'dynamo', ...}

@pytest.mark.test_details("0000","high","Order and Payment Flow","Pradeep")
@pytest.mark.parametrize("value", certification_program_course_read_csv())
def test_Orders_and_Payment_Flow_certification(self,value,initialize_pages,testdata):

'''
Objective: Make payment and validate the data in Dynamo db and mySql

Step 01: get url
Step 02: click on Enroll Now CTA
Step 03: Make payment
Step 04: Validate the Dynamo db and MySql daya for the payment
'''
self.add_rows_in_csv('Report.csv')
url_count = self._count_url_txt_file_subdomain('Orders_and_Payment_Flow_Certification.txt')
logging.info(f"Total URL Present is: {url_count}")

# Step 01: get url
counter = 0
> df = pd.read_csv('Orders_and_Payment_Flow_Certification.csv', on_bad_lines='skip')

test_prod\test_orders_and_payment_flow.py:50:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\util\_decorators.py:311: in wrapper
return func(*args, **kwargs)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:680: in read_csv
return _read(filepath_or_buffer, kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:575: in _read
parser = TextFileReader(filepath_or_buffer, **kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:933: in __init__
self._engine = self._make_engine(f, self.engine)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:1217: in _make_engine
self.handles = get_handle( # type: ignore[call-overload]
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

path_or_buf = 'Orders_and_Payment_Flow_Certification.csv', mode = 'r'

@doc(compression_options=_shared_docs["compression_options"] % "path_or_buf")
def get_handle(
path_or_buf: FilePath | BaseBuffer,
mode: str,
*,
encoding: str | None = None,
compression: CompressionOptions = None,
memory_map: bool = False,
is_text: bool = True,
errors: str | None = None,
storage_options: StorageOptions = None,
) -> IOHandles[str] | IOHandles[bytes]:
"""
Get file handle for given path/buffer and mode.

Parameters
----------
path_or_buf : str or file handle
File path or object.
mode : str
Mode to open path_or_buf with.
encoding : str or None
Encoding to use.
{compression_options}

.. versionchanged:: 1.0.0
May now be a dict with key 'method' as compression mode
and other keys as compression options if compression
mode is 'zip'.

.. versionchanged:: 1.1.0
Passing compression options as keys in dict is now
supported for compression modes 'gzip', 'bz2', 'zstd' and 'zip'.

.. versionchanged:: 1.4.0 Zstandard support.

memory_map : bool, default False
See parsers._parser_params for more information.
is_text : bool, default True
Whether the type of the content passed to the file/buffer is string or
bytes. This is not the same as `"b" not in mode`. If a string content is
passed to a binary file/buffer, a wrapper is inserted.
errors : str, default 'strict'
Specifies how encoding and decoding errors are to be handled.
See the errors argument for :func:`open` for a full list
of options.
storage_options: StorageOptions = None
Passed to _get_filepath_or_buffer

.. versionchanged:: 1.2.0

Returns the dataclass IOHandles
"""
# Windows does not default to utf-8. Set to utf-8 for a consistent behavior
encoding = encoding or "utf-8"

# read_csv does not know whether the buffer is opened in binary/text mode
if _is_binary_mode(path_or_buf, mode) and "b" not in mode:
mode += "b"

# validate encoding and errors
codecs.lookup(encoding)
if isinstance(errors, str):
codecs.lookup_error(errors)

# open URLs
ioargs = _get_filepath_or_buffer(
path_or_buf,
encoding=encoding,
compression=compression,
mode=mode,
storage_options=storage_options,
)

handle = ioargs.filepath_or_buffer
handles: list[BaseBuffer]

# memory mapping needs to be the first step
handle, memory_map, handles = _maybe_memory_map(
handle,
memory_map,
ioargs.encoding,
ioargs.mode,
errors,
ioargs.compression["method"] not in _compression_to_extension,
)

is_path = isinstance(handle, str)
compression_args = dict(ioargs.compression)
compression = compression_args.pop("method")

# Only for write methods
if "r" not in mode and is_path:
check_parent_directory(str(handle))

if compression:
if compression != "zstd":
# compression libraries do not like an explicit text-mode
ioargs.mode = ioargs.mode.replace("t", "")
elif compression == "zstd" and "b" not in ioargs.mode:
# python-zstandard defaults to text mode, but we always expect
# compression libraries to use binary mode.
ioargs.mode += "b"

# GZ Compression
if compression == "gzip":
if is_path:
assert isinstance(handle, str)
# error: Incompatible types in assignment (expression has type
# "GzipFile", variable has type "Union[str, BaseBuffer]")
handle = gzip.GzipFile( # type: ignore[assignment]
filename=handle,
mode=ioargs.mode,
**compression_args,
)
else:
handle = gzip.GzipFile(
# No overload variant of "GzipFile" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
fileobj=handle, # type: ignore[call-overload]
mode=ioargs.mode,
**compression_args,
)

# BZ Compression
elif compression == "bz2":
# No overload variant of "BZ2File" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
handle = bz2.BZ2File( # type: ignore[call-overload]
handle,
mode=ioargs.mode,
**compression_args,
)

# ZIP Compression
elif compression == "zip":
# error: Argument 1 to "_BytesZipFile" has incompatible type "Union[str,
# BaseBuffer]"; expected "Union[Union[str, PathLike[str]],
# ReadBuffer[bytes], WriteBuffer[bytes]]"
handle = _BytesZipFile(
handle, ioargs.mode, **compression_args # type: ignore[arg-type]
)
if handle.mode == "r":
handles.append(handle)
zip_names = handle.namelist()
if len(zip_names) == 1:
handle = handle.open(zip_names.pop())
elif len(zip_names) == 0:
raise ValueError(f"Zero files found in ZIP file {path_or_buf}")
else:
raise ValueError(
"Multiple files found in ZIP file. "
f"Only one file per ZIP: {zip_names}"
)

# XZ Compression
elif compression == "xz":
handle = get_lzma_file()(handle, ioargs.mode)

# Zstd Compression
elif compression == "zstd":
zstd = import_optional_dependency("zstandard")
if "r" in ioargs.mode:
open_args = {"dctx": zstd.ZstdDecompressor(**compression_args)}
else:
open_args = {"cctx": zstd.ZstdCompressor(**compression_args)}
handle = zstd.open(
handle,
mode=ioargs.mode,
**open_args,
)

# Unrecognized Compression
else:
msg = f"Unrecognized compression type: {compression}"
raise ValueError(msg)

assert not isinstance(handle, str)
handles.append(handle)

elif isinstance(handle, str):
# Check whether the filename is to be opened in binary mode.
# Binary mode does not support 'encoding' and 'newline'.
if ioargs.encoding and "b" not in ioargs.mode:
# Encoding
> handle = open(
handle,
ioargs.mode,
encoding=ioargs.encoding,
errors=errors,
newline="",
)
E FileNotFoundError: [Errno 2] No such file or directory: 'Orders_and_Payment_Flow_Certification.csv'

c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\common.py:789: FileNotFoundError
-------------------------------Captured log call--------------------------------
INFO  setup:test_orders_and_payment_flow.py:46 Total URL Present is: 5

self = <test_orders_and_payment_flow.TestOrderAndPaymentFlowCertificationProgram object at 0x0000020BE0B6C460>, value = 'C', initialize_pages = None
testdata = {'contact_no': '123456789', 'country': ['in', 'us', 'gb', 'au', 'de', 'sg', ...], 'db_type': 'mysql', 'dynamo_db_type': 'dynamo', ...}

@pytest.mark.test_details("0000","high","Order and Payment Flow","Pradeep")
@pytest.mark.parametrize("value", certification_program_course_read_csv())
def test_Orders_and_Payment_Flow_certification(self,value,initialize_pages,testdata):

'''
Objective: Make payment and validate the data in Dynamo db and mySql

Step 01: get url
Step 02: click on Enroll Now CTA
Step 03: Make payment
Step 04: Validate the Dynamo db and MySql daya for the payment
'''
self.add_rows_in_csv('Report.csv')
url_count = self._count_url_txt_file_subdomain('Orders_and_Payment_Flow_Certification.txt')
logging.info(f"Total URL Present is: {url_count}")

# Step 01: get url
counter = 0
> df = pd.read_csv('Orders_and_Payment_Flow_Certification.csv', on_bad_lines='skip')

test_prod\test_orders_and_payment_flow.py:50:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\util\_decorators.py:311: in wrapper
return func(*args, **kwargs)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:680: in read_csv
return _read(filepath_or_buffer, kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:575: in _read
parser = TextFileReader(filepath_or_buffer, **kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:933: in __init__
self._engine = self._make_engine(f, self.engine)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:1217: in _make_engine
self.handles = get_handle( # type: ignore[call-overload]
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

path_or_buf = 'Orders_and_Payment_Flow_Certification.csv', mode = 'r'

@doc(compression_options=_shared_docs["compression_options"] % "path_or_buf")
def get_handle(
path_or_buf: FilePath | BaseBuffer,
mode: str,
*,
encoding: str | None = None,
compression: CompressionOptions = None,
memory_map: bool = False,
is_text: bool = True,
errors: str | None = None,
storage_options: StorageOptions = None,
) -> IOHandles[str] | IOHandles[bytes]:
"""
Get file handle for given path/buffer and mode.

Parameters
----------
path_or_buf : str or file handle
File path or object.
mode : str
Mode to open path_or_buf with.
encoding : str or None
Encoding to use.
{compression_options}

.. versionchanged:: 1.0.0
May now be a dict with key 'method' as compression mode
and other keys as compression options if compression
mode is 'zip'.

.. versionchanged:: 1.1.0
Passing compression options as keys in dict is now
supported for compression modes 'gzip', 'bz2', 'zstd' and 'zip'.

.. versionchanged:: 1.4.0 Zstandard support.

memory_map : bool, default False
See parsers._parser_params for more information.
is_text : bool, default True
Whether the type of the content passed to the file/buffer is string or
bytes. This is not the same as `"b" not in mode`. If a string content is
passed to a binary file/buffer, a wrapper is inserted.
errors : str, default 'strict'
Specifies how encoding and decoding errors are to be handled.
See the errors argument for :func:`open` for a full list
of options.
storage_options: StorageOptions = None
Passed to _get_filepath_or_buffer

.. versionchanged:: 1.2.0

Returns the dataclass IOHandles
"""
# Windows does not default to utf-8. Set to utf-8 for a consistent behavior
encoding = encoding or "utf-8"

# read_csv does not know whether the buffer is opened in binary/text mode
if _is_binary_mode(path_or_buf, mode) and "b" not in mode:
mode += "b"

# validate encoding and errors
codecs.lookup(encoding)
if isinstance(errors, str):
codecs.lookup_error(errors)

# open URLs
ioargs = _get_filepath_or_buffer(
path_or_buf,
encoding=encoding,
compression=compression,
mode=mode,
storage_options=storage_options,
)

handle = ioargs.filepath_or_buffer
handles: list[BaseBuffer]

# memory mapping needs to be the first step
handle, memory_map, handles = _maybe_memory_map(
handle,
memory_map,
ioargs.encoding,
ioargs.mode,
errors,
ioargs.compression["method"] not in _compression_to_extension,
)

is_path = isinstance(handle, str)
compression_args = dict(ioargs.compression)
compression = compression_args.pop("method")

# Only for write methods
if "r" not in mode and is_path:
check_parent_directory(str(handle))

if compression:
if compression != "zstd":
# compression libraries do not like an explicit text-mode
ioargs.mode = ioargs.mode.replace("t", "")
elif compression == "zstd" and "b" not in ioargs.mode:
# python-zstandard defaults to text mode, but we always expect
# compression libraries to use binary mode.
ioargs.mode += "b"

# GZ Compression
if compression == "gzip":
if is_path:
assert isinstance(handle, str)
# error: Incompatible types in assignment (expression has type
# "GzipFile", variable has type "Union[str, BaseBuffer]")
handle = gzip.GzipFile( # type: ignore[assignment]
filename=handle,
mode=ioargs.mode,
**compression_args,
)
else:
handle = gzip.GzipFile(
# No overload variant of "GzipFile" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
fileobj=handle, # type: ignore[call-overload]
mode=ioargs.mode,
**compression_args,
)

# BZ Compression
elif compression == "bz2":
# No overload variant of "BZ2File" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
handle = bz2.BZ2File( # type: ignore[call-overload]
handle,
mode=ioargs.mode,
**compression_args,
)

# ZIP Compression
elif compression == "zip":
# error: Argument 1 to "_BytesZipFile" has incompatible type "Union[str,
# BaseBuffer]"; expected "Union[Union[str, PathLike[str]],
# ReadBuffer[bytes], WriteBuffer[bytes]]"
handle = _BytesZipFile(
handle, ioargs.mode, **compression_args # type: ignore[arg-type]
)
if handle.mode == "r":
handles.append(handle)
zip_names = handle.namelist()
if len(zip_names) == 1:
handle = handle.open(zip_names.pop())
elif len(zip_names) == 0:
raise ValueError(f"Zero files found in ZIP file {path_or_buf}")
else:
raise ValueError(
"Multiple files found in ZIP file. "
f"Only one file per ZIP: {zip_names}"
)

# XZ Compression
elif compression == "xz":
handle = get_lzma_file()(handle, ioargs.mode)

# Zstd Compression
elif compression == "zstd":
zstd = import_optional_dependency("zstandard")
if "r" in ioargs.mode:
open_args = {"dctx": zstd.ZstdDecompressor(**compression_args)}
else:
open_args = {"cctx": zstd.ZstdCompressor(**compression_args)}
handle = zstd.open(
handle,
mode=ioargs.mode,
**open_args,
)

# Unrecognized Compression
else:
msg = f"Unrecognized compression type: {compression}"
raise ValueError(msg)

assert not isinstance(handle, str)
handles.append(handle)

elif isinstance(handle, str):
# Check whether the filename is to be opened in binary mode.
# Binary mode does not support 'encoding' and 'newline'.
if ioargs.encoding and "b" not in ioargs.mode:
# Encoding
> handle = open(
handle,
ioargs.mode,
encoding=ioargs.encoding,
errors=errors,
newline="",
)
E FileNotFoundError: [Errno 2] No such file or directory: 'Orders_and_Payment_Flow_Certification.csv'

c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\common.py:789: FileNotFoundError
-------------------------------Captured log call--------------------------------
INFO  setup:test_orders_and_payment_flow.py:46 Total URL Present is: 5

self = <test_orders_and_payment_flow.TestOrderAndPaymentFlowCertificationProgram object at 0x0000020BE0DBD550>, value = 'D', initialize_pages = None
testdata = {'contact_no': '123456789', 'country': ['in', 'us', 'gb', 'au', 'de', 'sg', ...], 'db_type': 'mysql', 'dynamo_db_type': 'dynamo', ...}

@pytest.mark.test_details("0000","high","Order and Payment Flow","Pradeep")
@pytest.mark.parametrize("value", certification_program_course_read_csv())
def test_Orders_and_Payment_Flow_certification(self,value,initialize_pages,testdata):

'''
Objective: Make payment and validate the data in Dynamo db and mySql

Step 01: get url
Step 02: click on Enroll Now CTA
Step 03: Make payment
Step 04: Validate the Dynamo db and MySql daya for the payment
'''
self.add_rows_in_csv('Report.csv')
url_count = self._count_url_txt_file_subdomain('Orders_and_Payment_Flow_Certification.txt')
logging.info(f"Total URL Present is: {url_count}")

# Step 01: get url
counter = 0
> df = pd.read_csv('Orders_and_Payment_Flow_Certification.csv', on_bad_lines='skip')

test_prod\test_orders_and_payment_flow.py:50:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\util\_decorators.py:311: in wrapper
return func(*args, **kwargs)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:680: in read_csv
return _read(filepath_or_buffer, kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:575: in _read
parser = TextFileReader(filepath_or_buffer, **kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:933: in __init__
self._engine = self._make_engine(f, self.engine)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:1217: in _make_engine
self.handles = get_handle( # type: ignore[call-overload]
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

path_or_buf = 'Orders_and_Payment_Flow_Certification.csv', mode = 'r'

@doc(compression_options=_shared_docs["compression_options"] % "path_or_buf")
def get_handle(
path_or_buf: FilePath | BaseBuffer,
mode: str,
*,
encoding: str | None = None,
compression: CompressionOptions = None,
memory_map: bool = False,
is_text: bool = True,
errors: str | None = None,
storage_options: StorageOptions = None,
) -> IOHandles[str] | IOHandles[bytes]:
"""
Get file handle for given path/buffer and mode.

Parameters
----------
path_or_buf : str or file handle
File path or object.
mode : str
Mode to open path_or_buf with.
encoding : str or None
Encoding to use.
{compression_options}

.. versionchanged:: 1.0.0
May now be a dict with key 'method' as compression mode
and other keys as compression options if compression
mode is 'zip'.

.. versionchanged:: 1.1.0
Passing compression options as keys in dict is now
supported for compression modes 'gzip', 'bz2', 'zstd' and 'zip'.

.. versionchanged:: 1.4.0 Zstandard support.

memory_map : bool, default False
See parsers._parser_params for more information.
is_text : bool, default True
Whether the type of the content passed to the file/buffer is string or
bytes. This is not the same as `"b" not in mode`. If a string content is
passed to a binary file/buffer, a wrapper is inserted.
errors : str, default 'strict'
Specifies how encoding and decoding errors are to be handled.
See the errors argument for :func:`open` for a full list
of options.
storage_options: StorageOptions = None
Passed to _get_filepath_or_buffer

.. versionchanged:: 1.2.0

Returns the dataclass IOHandles
"""
# Windows does not default to utf-8. Set to utf-8 for a consistent behavior
encoding = encoding or "utf-8"

# read_csv does not know whether the buffer is opened in binary/text mode
if _is_binary_mode(path_or_buf, mode) and "b" not in mode:
mode += "b"

# validate encoding and errors
codecs.lookup(encoding)
if isinstance(errors, str):
codecs.lookup_error(errors)

# open URLs
ioargs = _get_filepath_or_buffer(
path_or_buf,
encoding=encoding,
compression=compression,
mode=mode,
storage_options=storage_options,
)

handle = ioargs.filepath_or_buffer
handles: list[BaseBuffer]

# memory mapping needs to be the first step
handle, memory_map, handles = _maybe_memory_map(
handle,
memory_map,
ioargs.encoding,
ioargs.mode,
errors,
ioargs.compression["method"] not in _compression_to_extension,
)

is_path = isinstance(handle, str)
compression_args = dict(ioargs.compression)
compression = compression_args.pop("method")

# Only for write methods
if "r" not in mode and is_path:
check_parent_directory(str(handle))

if compression:
if compression != "zstd":
# compression libraries do not like an explicit text-mode
ioargs.mode = ioargs.mode.replace("t", "")
elif compression == "zstd" and "b" not in ioargs.mode:
# python-zstandard defaults to text mode, but we always expect
# compression libraries to use binary mode.
ioargs.mode += "b"

# GZ Compression
if compression == "gzip":
if is_path:
assert isinstance(handle, str)
# error: Incompatible types in assignment (expression has type
# "GzipFile", variable has type "Union[str, BaseBuffer]")
handle = gzip.GzipFile( # type: ignore[assignment]
filename=handle,
mode=ioargs.mode,
**compression_args,
)
else:
handle = gzip.GzipFile(
# No overload variant of "GzipFile" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
fileobj=handle, # type: ignore[call-overload]
mode=ioargs.mode,
**compression_args,
)

# BZ Compression
elif compression == "bz2":
# No overload variant of "BZ2File" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
handle = bz2.BZ2File( # type: ignore[call-overload]
handle,
mode=ioargs.mode,
**compression_args,
)

# ZIP Compression
elif compression == "zip":
# error: Argument 1 to "_BytesZipFile" has incompatible type "Union[str,
# BaseBuffer]"; expected "Union[Union[str, PathLike[str]],
# ReadBuffer[bytes], WriteBuffer[bytes]]"
handle = _BytesZipFile(
handle, ioargs.mode, **compression_args # type: ignore[arg-type]
)
if handle.mode == "r":
handles.append(handle)
zip_names = handle.namelist()
if len(zip_names) == 1:
handle = handle.open(zip_names.pop())
elif len(zip_names) == 0:
raise ValueError(f"Zero files found in ZIP file {path_or_buf}")
else:
raise ValueError(
"Multiple files found in ZIP file. "
f"Only one file per ZIP: {zip_names}"
)

# XZ Compression
elif compression == "xz":
handle = get_lzma_file()(handle, ioargs.mode)

# Zstd Compression
elif compression == "zstd":
zstd = import_optional_dependency("zstandard")
if "r" in ioargs.mode:
open_args = {"dctx": zstd.ZstdDecompressor(**compression_args)}
else:
open_args = {"cctx": zstd.ZstdCompressor(**compression_args)}
handle = zstd.open(
handle,
mode=ioargs.mode,
**open_args,
)

# Unrecognized Compression
else:
msg = f"Unrecognized compression type: {compression}"
raise ValueError(msg)

assert not isinstance(handle, str)
handles.append(handle)

elif isinstance(handle, str):
# Check whether the filename is to be opened in binary mode.
# Binary mode does not support 'encoding' and 'newline'.
if ioargs.encoding and "b" not in ioargs.mode:
# Encoding
> handle = open(
handle,
ioargs.mode,
encoding=ioargs.encoding,
errors=errors,
newline="",
)
E FileNotFoundError: [Errno 2] No such file or directory: 'Orders_and_Payment_Flow_Certification.csv'

c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\common.py:789: FileNotFoundError
-------------------------------Captured log call--------------------------------
INFO  setup:test_orders_and_payment_flow.py:46 Total URL Present is: 5

self = <test_orders_and_payment_flow.TestOrderAndPaymentFlowCertificationProgram object at 0x0000020BE0DBED90>, value = 'E', initialize_pages = None
testdata = {'contact_no': '123456789', 'country': ['in', 'us', 'gb', 'au', 'de', 'sg', ...], 'db_type': 'mysql', 'dynamo_db_type': 'dynamo', ...}

@pytest.mark.test_details("0000","high","Order and Payment Flow","Pradeep")
@pytest.mark.parametrize("value", certification_program_course_read_csv())
def test_Orders_and_Payment_Flow_certification(self,value,initialize_pages,testdata):

'''
Objective: Make payment and validate the data in Dynamo db and mySql

Step 01: get url
Step 02: click on Enroll Now CTA
Step 03: Make payment
Step 04: Validate the Dynamo db and MySql daya for the payment
'''
self.add_rows_in_csv('Report.csv')
url_count = self._count_url_txt_file_subdomain('Orders_and_Payment_Flow_Certification.txt')
logging.info(f"Total URL Present is: {url_count}")

# Step 01: get url
counter = 0
> df = pd.read_csv('Orders_and_Payment_Flow_Certification.csv', on_bad_lines='skip')

test_prod\test_orders_and_payment_flow.py:50:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\util\_decorators.py:311: in wrapper
return func(*args, **kwargs)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:680: in read_csv
return _read(filepath_or_buffer, kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:575: in _read
parser = TextFileReader(filepath_or_buffer, **kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:933: in __init__
self._engine = self._make_engine(f, self.engine)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:1217: in _make_engine
self.handles = get_handle( # type: ignore[call-overload]
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

path_or_buf = 'Orders_and_Payment_Flow_Certification.csv', mode = 'r'

@doc(compression_options=_shared_docs["compression_options"] % "path_or_buf")
def get_handle(
path_or_buf: FilePath | BaseBuffer,
mode: str,
*,
encoding: str | None = None,
compression: CompressionOptions = None,
memory_map: bool = False,
is_text: bool = True,
errors: str | None = None,
storage_options: StorageOptions = None,
) -> IOHandles[str] | IOHandles[bytes]:
"""
Get file handle for given path/buffer and mode.

Parameters
----------
path_or_buf : str or file handle
File path or object.
mode : str
Mode to open path_or_buf with.
encoding : str or None
Encoding to use.
{compression_options}

.. versionchanged:: 1.0.0
May now be a dict with key 'method' as compression mode
and other keys as compression options if compression
mode is 'zip'.

.. versionchanged:: 1.1.0
Passing compression options as keys in dict is now
supported for compression modes 'gzip', 'bz2', 'zstd' and 'zip'.

.. versionchanged:: 1.4.0 Zstandard support.

memory_map : bool, default False
See parsers._parser_params for more information.
is_text : bool, default True
Whether the type of the content passed to the file/buffer is string or
bytes. This is not the same as `"b" not in mode`. If a string content is
passed to a binary file/buffer, a wrapper is inserted.
errors : str, default 'strict'
Specifies how encoding and decoding errors are to be handled.
See the errors argument for :func:`open` for a full list
of options.
storage_options: StorageOptions = None
Passed to _get_filepath_or_buffer

.. versionchanged:: 1.2.0

Returns the dataclass IOHandles
"""
# Windows does not default to utf-8. Set to utf-8 for a consistent behavior
encoding = encoding or "utf-8"

# read_csv does not know whether the buffer is opened in binary/text mode
if _is_binary_mode(path_or_buf, mode) and "b" not in mode:
mode += "b"

# validate encoding and errors
codecs.lookup(encoding)
if isinstance(errors, str):
codecs.lookup_error(errors)

# open URLs
ioargs = _get_filepath_or_buffer(
path_or_buf,
encoding=encoding,
compression=compression,
mode=mode,
storage_options=storage_options,
)

handle = ioargs.filepath_or_buffer
handles: list[BaseBuffer]

# memory mapping needs to be the first step
handle, memory_map, handles = _maybe_memory_map(
handle,
memory_map,
ioargs.encoding,
ioargs.mode,
errors,
ioargs.compression["method"] not in _compression_to_extension,
)

is_path = isinstance(handle, str)
compression_args = dict(ioargs.compression)
compression = compression_args.pop("method")

# Only for write methods
if "r" not in mode and is_path:
check_parent_directory(str(handle))

if compression:
if compression != "zstd":
# compression libraries do not like an explicit text-mode
ioargs.mode = ioargs.mode.replace("t", "")
elif compression == "zstd" and "b" not in ioargs.mode:
# python-zstandard defaults to text mode, but we always expect
# compression libraries to use binary mode.
ioargs.mode += "b"

# GZ Compression
if compression == "gzip":
if is_path:
assert isinstance(handle, str)
# error: Incompatible types in assignment (expression has type
# "GzipFile", variable has type "Union[str, BaseBuffer]")
handle = gzip.GzipFile( # type: ignore[assignment]
filename=handle,
mode=ioargs.mode,
**compression_args,
)
else:
handle = gzip.GzipFile(
# No overload variant of "GzipFile" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
fileobj=handle, # type: ignore[call-overload]
mode=ioargs.mode,
**compression_args,
)

# BZ Compression
elif compression == "bz2":
# No overload variant of "BZ2File" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
handle = bz2.BZ2File( # type: ignore[call-overload]
handle,
mode=ioargs.mode,
**compression_args,
)

# ZIP Compression
elif compression == "zip":
# error: Argument 1 to "_BytesZipFile" has incompatible type "Union[str,
# BaseBuffer]"; expected "Union[Union[str, PathLike[str]],
# ReadBuffer[bytes], WriteBuffer[bytes]]"
handle = _BytesZipFile(
handle, ioargs.mode, **compression_args # type: ignore[arg-type]
)
if handle.mode == "r":
handles.append(handle)
zip_names = handle.namelist()
if len(zip_names) == 1:
handle = handle.open(zip_names.pop())
elif len(zip_names) == 0:
raise ValueError(f"Zero files found in ZIP file {path_or_buf}")
else:
raise ValueError(
"Multiple files found in ZIP file. "
f"Only one file per ZIP: {zip_names}"
)

# XZ Compression
elif compression == "xz":
handle = get_lzma_file()(handle, ioargs.mode)

# Zstd Compression
elif compression == "zstd":
zstd = import_optional_dependency("zstandard")
if "r" in ioargs.mode:
open_args = {"dctx": zstd.ZstdDecompressor(**compression_args)}
else:
open_args = {"cctx": zstd.ZstdCompressor(**compression_args)}
handle = zstd.open(
handle,
mode=ioargs.mode,
**open_args,
)

# Unrecognized Compression
else:
msg = f"Unrecognized compression type: {compression}"
raise ValueError(msg)

assert not isinstance(handle, str)
handles.append(handle)

elif isinstance(handle, str):
# Check whether the filename is to be opened in binary mode.
# Binary mode does not support 'encoding' and 'newline'.
if ioargs.encoding and "b" not in ioargs.mode:
# Encoding
> handle = open(
handle,
ioargs.mode,
encoding=ioargs.encoding,
errors=errors,
newline="",
)
E FileNotFoundError: [Errno 2] No such file or directory: 'Orders_and_Payment_Flow_Certification.csv'

c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\common.py:789: FileNotFoundError
-------------------------------Captured log call--------------------------------
INFO  setup:test_orders_and_payment_flow.py:46 Total URL Present is: 5

self = <test_orders_and_payment_flow.TestOrderAndPaymentFlowCertificationProgram object at 0x0000020BE0BCF1C0>, value = 'F', initialize_pages = None
testdata = {'contact_no': '123456789', 'country': ['in', 'us', 'gb', 'au', 'de', 'sg', ...], 'db_type': 'mysql', 'dynamo_db_type': 'dynamo', ...}

@pytest.mark.test_details("0000","high","Order and Payment Flow","Pradeep")
@pytest.mark.parametrize("value", certification_program_course_read_csv())
def test_Orders_and_Payment_Flow_certification(self,value,initialize_pages,testdata):

'''
Objective: Make payment and validate the data in Dynamo db and mySql

Step 01: get url
Step 02: click on Enroll Now CTA
Step 03: Make payment
Step 04: Validate the Dynamo db and MySql daya for the payment
'''
self.add_rows_in_csv('Report.csv')
url_count = self._count_url_txt_file_subdomain('Orders_and_Payment_Flow_Certification.txt')
logging.info(f"Total URL Present is: {url_count}")

# Step 01: get url
counter = 0
> df = pd.read_csv('Orders_and_Payment_Flow_Certification.csv', on_bad_lines='skip')

test_prod\test_orders_and_payment_flow.py:50:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\util\_decorators.py:311: in wrapper
return func(*args, **kwargs)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:680: in read_csv
return _read(filepath_or_buffer, kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:575: in _read
parser = TextFileReader(filepath_or_buffer, **kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:933: in __init__
self._engine = self._make_engine(f, self.engine)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:1217: in _make_engine
self.handles = get_handle( # type: ignore[call-overload]
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

path_or_buf = 'Orders_and_Payment_Flow_Certification.csv', mode = 'r'

@doc(compression_options=_shared_docs["compression_options"] % "path_or_buf")
def get_handle(
path_or_buf: FilePath | BaseBuffer,
mode: str,
*,
encoding: str | None = None,
compression: CompressionOptions = None,
memory_map: bool = False,
is_text: bool = True,
errors: str | None = None,
storage_options: StorageOptions = None,
) -> IOHandles[str] | IOHandles[bytes]:
"""
Get file handle for given path/buffer and mode.

Parameters
----------
path_or_buf : str or file handle
File path or object.
mode : str
Mode to open path_or_buf with.
encoding : str or None
Encoding to use.
{compression_options}

.. versionchanged:: 1.0.0
May now be a dict with key 'method' as compression mode
and other keys as compression options if compression
mode is 'zip'.

.. versionchanged:: 1.1.0
Passing compression options as keys in dict is now
supported for compression modes 'gzip', 'bz2', 'zstd' and 'zip'.

.. versionchanged:: 1.4.0 Zstandard support.

memory_map : bool, default False
See parsers._parser_params for more information.
is_text : bool, default True
Whether the type of the content passed to the file/buffer is string or
bytes. This is not the same as `"b" not in mode`. If a string content is
passed to a binary file/buffer, a wrapper is inserted.
errors : str, default 'strict'
Specifies how encoding and decoding errors are to be handled.
See the errors argument for :func:`open` for a full list
of options.
storage_options: StorageOptions = None
Passed to _get_filepath_or_buffer

.. versionchanged:: 1.2.0

Returns the dataclass IOHandles
"""
# Windows does not default to utf-8. Set to utf-8 for a consistent behavior
encoding = encoding or "utf-8"

# read_csv does not know whether the buffer is opened in binary/text mode
if _is_binary_mode(path_or_buf, mode) and "b" not in mode:
mode += "b"

# validate encoding and errors
codecs.lookup(encoding)
if isinstance(errors, str):
codecs.lookup_error(errors)

# open URLs
ioargs = _get_filepath_or_buffer(
path_or_buf,
encoding=encoding,
compression=compression,
mode=mode,
storage_options=storage_options,
)

handle = ioargs.filepath_or_buffer
handles: list[BaseBuffer]

# memory mapping needs to be the first step
handle, memory_map, handles = _maybe_memory_map(
handle,
memory_map,
ioargs.encoding,
ioargs.mode,
errors,
ioargs.compression["method"] not in _compression_to_extension,
)

is_path = isinstance(handle, str)
compression_args = dict(ioargs.compression)
compression = compression_args.pop("method")

# Only for write methods
if "r" not in mode and is_path:
check_parent_directory(str(handle))

if compression:
if compression != "zstd":
# compression libraries do not like an explicit text-mode
ioargs.mode = ioargs.mode.replace("t", "")
elif compression == "zstd" and "b" not in ioargs.mode:
# python-zstandard defaults to text mode, but we always expect
# compression libraries to use binary mode.
ioargs.mode += "b"

# GZ Compression
if compression == "gzip":
if is_path:
assert isinstance(handle, str)
# error: Incompatible types in assignment (expression has type
# "GzipFile", variable has type "Union[str, BaseBuffer]")
handle = gzip.GzipFile( # type: ignore[assignment]
filename=handle,
mode=ioargs.mode,
**compression_args,
)
else:
handle = gzip.GzipFile(
# No overload variant of "GzipFile" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
fileobj=handle, # type: ignore[call-overload]
mode=ioargs.mode,
**compression_args,
)

# BZ Compression
elif compression == "bz2":
# No overload variant of "BZ2File" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
handle = bz2.BZ2File( # type: ignore[call-overload]
handle,
mode=ioargs.mode,
**compression_args,
)

# ZIP Compression
elif compression == "zip":
# error: Argument 1 to "_BytesZipFile" has incompatible type "Union[str,
# BaseBuffer]"; expected "Union[Union[str, PathLike[str]],
# ReadBuffer[bytes], WriteBuffer[bytes]]"
handle = _BytesZipFile(
handle, ioargs.mode, **compression_args # type: ignore[arg-type]
)
if handle.mode == "r":
handles.append(handle)
zip_names = handle.namelist()
if len(zip_names) == 1:
handle = handle.open(zip_names.pop())
elif len(zip_names) == 0:
raise ValueError(f"Zero files found in ZIP file {path_or_buf}")
else:
raise ValueError(
"Multiple files found in ZIP file. "
f"Only one file per ZIP: {zip_names}"
)

# XZ Compression
elif compression == "xz":
handle = get_lzma_file()(handle, ioargs.mode)

# Zstd Compression
elif compression == "zstd":
zstd = import_optional_dependency("zstandard")
if "r" in ioargs.mode:
open_args = {"dctx": zstd.ZstdDecompressor(**compression_args)}
else:
open_args = {"cctx": zstd.ZstdCompressor(**compression_args)}
handle = zstd.open(
handle,
mode=ioargs.mode,
**open_args,
)

# Unrecognized Compression
else:
msg = f"Unrecognized compression type: {compression}"
raise ValueError(msg)

assert not isinstance(handle, str)
handles.append(handle)

elif isinstance(handle, str):
# Check whether the filename is to be opened in binary mode.
# Binary mode does not support 'encoding' and 'newline'.
if ioargs.encoding and "b" not in ioargs.mode:
# Encoding
> handle = open(
handle,
ioargs.mode,
encoding=ioargs.encoding,
errors=errors,
newline="",
)
E FileNotFoundError: [Errno 2] No such file or directory: 'Orders_and_Payment_Flow_Certification.csv'

c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\common.py:789: FileNotFoundError
-------------------------------Captured log call--------------------------------
INFO  setup:test_orders_and_payment_flow.py:46 Total URL Present is: 5

self = <test_orders_and_payment_flow.TestOrderAndPaymentFlowCertificationProgram object at 0x0000020BE0FAF1C0>, value = 'G', initialize_pages = None
testdata = {'contact_no': '123456789', 'country': ['in', 'us', 'gb', 'au', 'de', 'sg', ...], 'db_type': 'mysql', 'dynamo_db_type': 'dynamo', ...}

@pytest.mark.test_details("0000","high","Order and Payment Flow","Pradeep")
@pytest.mark.parametrize("value", certification_program_course_read_csv())
def test_Orders_and_Payment_Flow_certification(self,value,initialize_pages,testdata):

'''
Objective: Make payment and validate the data in Dynamo db and mySql

Step 01: get url
Step 02: click on Enroll Now CTA
Step 03: Make payment
Step 04: Validate the Dynamo db and MySql daya for the payment
'''
self.add_rows_in_csv('Report.csv')
url_count = self._count_url_txt_file_subdomain('Orders_and_Payment_Flow_Certification.txt')
logging.info(f"Total URL Present is: {url_count}")

# Step 01: get url
counter = 0
> df = pd.read_csv('Orders_and_Payment_Flow_Certification.csv', on_bad_lines='skip')

test_prod\test_orders_and_payment_flow.py:50:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\util\_decorators.py:311: in wrapper
return func(*args, **kwargs)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:680: in read_csv
return _read(filepath_or_buffer, kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:575: in _read
parser = TextFileReader(filepath_or_buffer, **kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:933: in __init__
self._engine = self._make_engine(f, self.engine)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:1217: in _make_engine
self.handles = get_handle( # type: ignore[call-overload]
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

path_or_buf = 'Orders_and_Payment_Flow_Certification.csv', mode = 'r'

@doc(compression_options=_shared_docs["compression_options"] % "path_or_buf")
def get_handle(
path_or_buf: FilePath | BaseBuffer,
mode: str,
*,
encoding: str | None = None,
compression: CompressionOptions = None,
memory_map: bool = False,
is_text: bool = True,
errors: str | None = None,
storage_options: StorageOptions = None,
) -> IOHandles[str] | IOHandles[bytes]:
"""
Get file handle for given path/buffer and mode.

Parameters
----------
path_or_buf : str or file handle
File path or object.
mode : str
Mode to open path_or_buf with.
encoding : str or None
Encoding to use.
{compression_options}

.. versionchanged:: 1.0.0
May now be a dict with key 'method' as compression mode
and other keys as compression options if compression
mode is 'zip'.

.. versionchanged:: 1.1.0
Passing compression options as keys in dict is now
supported for compression modes 'gzip', 'bz2', 'zstd' and 'zip'.

.. versionchanged:: 1.4.0 Zstandard support.

memory_map : bool, default False
See parsers._parser_params for more information.
is_text : bool, default True
Whether the type of the content passed to the file/buffer is string or
bytes. This is not the same as `"b" not in mode`. If a string content is
passed to a binary file/buffer, a wrapper is inserted.
errors : str, default 'strict'
Specifies how encoding and decoding errors are to be handled.
See the errors argument for :func:`open` for a full list
of options.
storage_options: StorageOptions = None
Passed to _get_filepath_or_buffer

.. versionchanged:: 1.2.0

Returns the dataclass IOHandles
"""
# Windows does not default to utf-8. Set to utf-8 for a consistent behavior
encoding = encoding or "utf-8"

# read_csv does not know whether the buffer is opened in binary/text mode
if _is_binary_mode(path_or_buf, mode) and "b" not in mode:
mode += "b"

# validate encoding and errors
codecs.lookup(encoding)
if isinstance(errors, str):
codecs.lookup_error(errors)

# open URLs
ioargs = _get_filepath_or_buffer(
path_or_buf,
encoding=encoding,
compression=compression,
mode=mode,
storage_options=storage_options,
)

handle = ioargs.filepath_or_buffer
handles: list[BaseBuffer]

# memory mapping needs to be the first step
handle, memory_map, handles = _maybe_memory_map(
handle,
memory_map,
ioargs.encoding,
ioargs.mode,
errors,
ioargs.compression["method"] not in _compression_to_extension,
)

is_path = isinstance(handle, str)
compression_args = dict(ioargs.compression)
compression = compression_args.pop("method")

# Only for write methods
if "r" not in mode and is_path:
check_parent_directory(str(handle))

if compression:
if compression != "zstd":
# compression libraries do not like an explicit text-mode
ioargs.mode = ioargs.mode.replace("t", "")
elif compression == "zstd" and "b" not in ioargs.mode:
# python-zstandard defaults to text mode, but we always expect
# compression libraries to use binary mode.
ioargs.mode += "b"

# GZ Compression
if compression == "gzip":
if is_path:
assert isinstance(handle, str)
# error: Incompatible types in assignment (expression has type
# "GzipFile", variable has type "Union[str, BaseBuffer]")
handle = gzip.GzipFile( # type: ignore[assignment]
filename=handle,
mode=ioargs.mode,
**compression_args,
)
else:
handle = gzip.GzipFile(
# No overload variant of "GzipFile" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
fileobj=handle, # type: ignore[call-overload]
mode=ioargs.mode,
**compression_args,
)

# BZ Compression
elif compression == "bz2":
# No overload variant of "BZ2File" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
handle = bz2.BZ2File( # type: ignore[call-overload]
handle,
mode=ioargs.mode,
**compression_args,
)

# ZIP Compression
elif compression == "zip":
# error: Argument 1 to "_BytesZipFile" has incompatible type "Union[str,
# BaseBuffer]"; expected "Union[Union[str, PathLike[str]],
# ReadBuffer[bytes], WriteBuffer[bytes]]"
handle = _BytesZipFile(
handle, ioargs.mode, **compression_args # type: ignore[arg-type]
)
if handle.mode == "r":
handles.append(handle)
zip_names = handle.namelist()
if len(zip_names) == 1:
handle = handle.open(zip_names.pop())
elif len(zip_names) == 0:
raise ValueError(f"Zero files found in ZIP file {path_or_buf}")
else:
raise ValueError(
"Multiple files found in ZIP file. "
f"Only one file per ZIP: {zip_names}"
)

# XZ Compression
elif compression == "xz":
handle = get_lzma_file()(handle, ioargs.mode)

# Zstd Compression
elif compression == "zstd":
zstd = import_optional_dependency("zstandard")
if "r" in ioargs.mode:
open_args = {"dctx": zstd.ZstdDecompressor(**compression_args)}
else:
open_args = {"cctx": zstd.ZstdCompressor(**compression_args)}
handle = zstd.open(
handle,
mode=ioargs.mode,
**open_args,
)

# Unrecognized Compression
else:
msg = f"Unrecognized compression type: {compression}"
raise ValueError(msg)

assert not isinstance(handle, str)
handles.append(handle)

elif isinstance(handle, str):
# Check whether the filename is to be opened in binary mode.
# Binary mode does not support 'encoding' and 'newline'.
if ioargs.encoding and "b" not in ioargs.mode:
# Encoding
> handle = open(
handle,
ioargs.mode,
encoding=ioargs.encoding,
errors=errors,
newline="",
)
E FileNotFoundError: [Errno 2] No such file or directory: 'Orders_and_Payment_Flow_Certification.csv'

c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\common.py:789: FileNotFoundError
-------------------------------Captured log call--------------------------------
INFO  setup:test_orders_and_payment_flow.py:46 Total URL Present is: 5

self = <test_orders_and_payment_flow.TestOrderAndPaymentFlowCertificationProgram object at 0x0000020BE0C3D850>, value = 'H', initialize_pages = None
testdata = {'contact_no': '123456789', 'country': ['in', 'us', 'gb', 'au', 'de', 'sg', ...], 'db_type': 'mysql', 'dynamo_db_type': 'dynamo', ...}

@pytest.mark.test_details("0000","high","Order and Payment Flow","Pradeep")
@pytest.mark.parametrize("value", certification_program_course_read_csv())
def test_Orders_and_Payment_Flow_certification(self,value,initialize_pages,testdata):

'''
Objective: Make payment and validate the data in Dynamo db and mySql

Step 01: get url
Step 02: click on Enroll Now CTA
Step 03: Make payment
Step 04: Validate the Dynamo db and MySql daya for the payment
'''
self.add_rows_in_csv('Report.csv')
url_count = self._count_url_txt_file_subdomain('Orders_and_Payment_Flow_Certification.txt')
logging.info(f"Total URL Present is: {url_count}")

# Step 01: get url
counter = 0
> df = pd.read_csv('Orders_and_Payment_Flow_Certification.csv', on_bad_lines='skip')

test_prod\test_orders_and_payment_flow.py:50:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\util\_decorators.py:311: in wrapper
return func(*args, **kwargs)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:680: in read_csv
return _read(filepath_or_buffer, kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:575: in _read
parser = TextFileReader(filepath_or_buffer, **kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:933: in __init__
self._engine = self._make_engine(f, self.engine)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:1217: in _make_engine
self.handles = get_handle( # type: ignore[call-overload]
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

path_or_buf = 'Orders_and_Payment_Flow_Certification.csv', mode = 'r'

@doc(compression_options=_shared_docs["compression_options"] % "path_or_buf")
def get_handle(
path_or_buf: FilePath | BaseBuffer,
mode: str,
*,
encoding: str | None = None,
compression: CompressionOptions = None,
memory_map: bool = False,
is_text: bool = True,
errors: str | None = None,
storage_options: StorageOptions = None,
) -> IOHandles[str] | IOHandles[bytes]:
"""
Get file handle for given path/buffer and mode.

Parameters
----------
path_or_buf : str or file handle
File path or object.
mode : str
Mode to open path_or_buf with.
encoding : str or None
Encoding to use.
{compression_options}

.. versionchanged:: 1.0.0
May now be a dict with key 'method' as compression mode
and other keys as compression options if compression
mode is 'zip'.

.. versionchanged:: 1.1.0
Passing compression options as keys in dict is now
supported for compression modes 'gzip', 'bz2', 'zstd' and 'zip'.

.. versionchanged:: 1.4.0 Zstandard support.

memory_map : bool, default False
See parsers._parser_params for more information.
is_text : bool, default True
Whether the type of the content passed to the file/buffer is string or
bytes. This is not the same as `"b" not in mode`. If a string content is
passed to a binary file/buffer, a wrapper is inserted.
errors : str, default 'strict'
Specifies how encoding and decoding errors are to be handled.
See the errors argument for :func:`open` for a full list
of options.
storage_options: StorageOptions = None
Passed to _get_filepath_or_buffer

.. versionchanged:: 1.2.0

Returns the dataclass IOHandles
"""
# Windows does not default to utf-8. Set to utf-8 for a consistent behavior
encoding = encoding or "utf-8"

# read_csv does not know whether the buffer is opened in binary/text mode
if _is_binary_mode(path_or_buf, mode) and "b" not in mode:
mode += "b"

# validate encoding and errors
codecs.lookup(encoding)
if isinstance(errors, str):
codecs.lookup_error(errors)

# open URLs
ioargs = _get_filepath_or_buffer(
path_or_buf,
encoding=encoding,
compression=compression,
mode=mode,
storage_options=storage_options,
)

handle = ioargs.filepath_or_buffer
handles: list[BaseBuffer]

# memory mapping needs to be the first step
handle, memory_map, handles = _maybe_memory_map(
handle,
memory_map,
ioargs.encoding,
ioargs.mode,
errors,
ioargs.compression["method"] not in _compression_to_extension,
)

is_path = isinstance(handle, str)
compression_args = dict(ioargs.compression)
compression = compression_args.pop("method")

# Only for write methods
if "r" not in mode and is_path:
check_parent_directory(str(handle))

if compression:
if compression != "zstd":
# compression libraries do not like an explicit text-mode
ioargs.mode = ioargs.mode.replace("t", "")
elif compression == "zstd" and "b" not in ioargs.mode:
# python-zstandard defaults to text mode, but we always expect
# compression libraries to use binary mode.
ioargs.mode += "b"

# GZ Compression
if compression == "gzip":
if is_path:
assert isinstance(handle, str)
# error: Incompatible types in assignment (expression has type
# "GzipFile", variable has type "Union[str, BaseBuffer]")
handle = gzip.GzipFile( # type: ignore[assignment]
filename=handle,
mode=ioargs.mode,
**compression_args,
)
else:
handle = gzip.GzipFile(
# No overload variant of "GzipFile" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
fileobj=handle, # type: ignore[call-overload]
mode=ioargs.mode,
**compression_args,
)

# BZ Compression
elif compression == "bz2":
# No overload variant of "BZ2File" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
handle = bz2.BZ2File( # type: ignore[call-overload]
handle,
mode=ioargs.mode,
**compression_args,
)

# ZIP Compression
elif compression == "zip":
# error: Argument 1 to "_BytesZipFile" has incompatible type "Union[str,
# BaseBuffer]"; expected "Union[Union[str, PathLike[str]],
# ReadBuffer[bytes], WriteBuffer[bytes]]"
handle = _BytesZipFile(
handle, ioargs.mode, **compression_args # type: ignore[arg-type]
)
if handle.mode == "r":
handles.append(handle)
zip_names = handle.namelist()
if len(zip_names) == 1:
handle = handle.open(zip_names.pop())
elif len(zip_names) == 0:
raise ValueError(f"Zero files found in ZIP file {path_or_buf}")
else:
raise ValueError(
"Multiple files found in ZIP file. "
f"Only one file per ZIP: {zip_names}"
)

# XZ Compression
elif compression == "xz":
handle = get_lzma_file()(handle, ioargs.mode)

# Zstd Compression
elif compression == "zstd":
zstd = import_optional_dependency("zstandard")
if "r" in ioargs.mode:
open_args = {"dctx": zstd.ZstdDecompressor(**compression_args)}
else:
open_args = {"cctx": zstd.ZstdCompressor(**compression_args)}
handle = zstd.open(
handle,
mode=ioargs.mode,
**open_args,
)

# Unrecognized Compression
else:
msg = f"Unrecognized compression type: {compression}"
raise ValueError(msg)

assert not isinstance(handle, str)
handles.append(handle)

elif isinstance(handle, str):
# Check whether the filename is to be opened in binary mode.
# Binary mode does not support 'encoding' and 'newline'.
if ioargs.encoding and "b" not in ioargs.mode:
# Encoding
> handle = open(
handle,
ioargs.mode,
encoding=ioargs.encoding,
errors=errors,
newline="",
)
E FileNotFoundError: [Errno 2] No such file or directory: 'Orders_and_Payment_Flow_Certification.csv'

c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\common.py:789: FileNotFoundError
-------------------------------Captured log call--------------------------------
INFO  setup:test_orders_and_payment_flow.py:46 Total URL Present is: 5

self = <test_orders_and_payment_flow.TestOrderAndPaymentFlowCertificationProgram object at 0x0000020BE0E51310>, value = 'I', initialize_pages = None
testdata = {'contact_no': '123456789', 'country': ['in', 'us', 'gb', 'au', 'de', 'sg', ...], 'db_type': 'mysql', 'dynamo_db_type': 'dynamo', ...}

@pytest.mark.test_details("0000","high","Order and Payment Flow","Pradeep")
@pytest.mark.parametrize("value", certification_program_course_read_csv())
def test_Orders_and_Payment_Flow_certification(self,value,initialize_pages,testdata):

'''
Objective: Make payment and validate the data in Dynamo db and mySql

Step 01: get url
Step 02: click on Enroll Now CTA
Step 03: Make payment
Step 04: Validate the Dynamo db and MySql daya for the payment
'''
self.add_rows_in_csv('Report.csv')
url_count = self._count_url_txt_file_subdomain('Orders_and_Payment_Flow_Certification.txt')
logging.info(f"Total URL Present is: {url_count}")

# Step 01: get url
counter = 0
> df = pd.read_csv('Orders_and_Payment_Flow_Certification.csv', on_bad_lines='skip')

test_prod\test_orders_and_payment_flow.py:50:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\util\_decorators.py:311: in wrapper
return func(*args, **kwargs)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:680: in read_csv
return _read(filepath_or_buffer, kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:575: in _read
parser = TextFileReader(filepath_or_buffer, **kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:933: in __init__
self._engine = self._make_engine(f, self.engine)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:1217: in _make_engine
self.handles = get_handle( # type: ignore[call-overload]
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

path_or_buf = 'Orders_and_Payment_Flow_Certification.csv', mode = 'r'

@doc(compression_options=_shared_docs["compression_options"] % "path_or_buf")
def get_handle(
path_or_buf: FilePath | BaseBuffer,
mode: str,
*,
encoding: str | None = None,
compression: CompressionOptions = None,
memory_map: bool = False,
is_text: bool = True,
errors: str | None = None,
storage_options: StorageOptions = None,
) -> IOHandles[str] | IOHandles[bytes]:
"""
Get file handle for given path/buffer and mode.

Parameters
----------
path_or_buf : str or file handle
File path or object.
mode : str
Mode to open path_or_buf with.
encoding : str or None
Encoding to use.
{compression_options}

.. versionchanged:: 1.0.0
May now be a dict with key 'method' as compression mode
and other keys as compression options if compression
mode is 'zip'.

.. versionchanged:: 1.1.0
Passing compression options as keys in dict is now
supported for compression modes 'gzip', 'bz2', 'zstd' and 'zip'.

.. versionchanged:: 1.4.0 Zstandard support.

memory_map : bool, default False
See parsers._parser_params for more information.
is_text : bool, default True
Whether the type of the content passed to the file/buffer is string or
bytes. This is not the same as `"b" not in mode`. If a string content is
passed to a binary file/buffer, a wrapper is inserted.
errors : str, default 'strict'
Specifies how encoding and decoding errors are to be handled.
See the errors argument for :func:`open` for a full list
of options.
storage_options: StorageOptions = None
Passed to _get_filepath_or_buffer

.. versionchanged:: 1.2.0

Returns the dataclass IOHandles
"""
# Windows does not default to utf-8. Set to utf-8 for a consistent behavior
encoding = encoding or "utf-8"

# read_csv does not know whether the buffer is opened in binary/text mode
if _is_binary_mode(path_or_buf, mode) and "b" not in mode:
mode += "b"

# validate encoding and errors
codecs.lookup(encoding)
if isinstance(errors, str):
codecs.lookup_error(errors)

# open URLs
ioargs = _get_filepath_or_buffer(
path_or_buf,
encoding=encoding,
compression=compression,
mode=mode,
storage_options=storage_options,
)

handle = ioargs.filepath_or_buffer
handles: list[BaseBuffer]

# memory mapping needs to be the first step
handle, memory_map, handles = _maybe_memory_map(
handle,
memory_map,
ioargs.encoding,
ioargs.mode,
errors,
ioargs.compression["method"] not in _compression_to_extension,
)

is_path = isinstance(handle, str)
compression_args = dict(ioargs.compression)
compression = compression_args.pop("method")

# Only for write methods
if "r" not in mode and is_path:
check_parent_directory(str(handle))

if compression:
if compression != "zstd":
# compression libraries do not like an explicit text-mode
ioargs.mode = ioargs.mode.replace("t", "")
elif compression == "zstd" and "b" not in ioargs.mode:
# python-zstandard defaults to text mode, but we always expect
# compression libraries to use binary mode.
ioargs.mode += "b"

# GZ Compression
if compression == "gzip":
if is_path:
assert isinstance(handle, str)
# error: Incompatible types in assignment (expression has type
# "GzipFile", variable has type "Union[str, BaseBuffer]")
handle = gzip.GzipFile( # type: ignore[assignment]
filename=handle,
mode=ioargs.mode,
**compression_args,
)
else:
handle = gzip.GzipFile(
# No overload variant of "GzipFile" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
fileobj=handle, # type: ignore[call-overload]
mode=ioargs.mode,
**compression_args,
)

# BZ Compression
elif compression == "bz2":
# No overload variant of "BZ2File" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
handle = bz2.BZ2File( # type: ignore[call-overload]
handle,
mode=ioargs.mode,
**compression_args,
)

# ZIP Compression
elif compression == "zip":
# error: Argument 1 to "_BytesZipFile" has incompatible type "Union[str,
# BaseBuffer]"; expected "Union[Union[str, PathLike[str]],
# ReadBuffer[bytes], WriteBuffer[bytes]]"
handle = _BytesZipFile(
handle, ioargs.mode, **compression_args # type: ignore[arg-type]
)
if handle.mode == "r":
handles.append(handle)
zip_names = handle.namelist()
if len(zip_names) == 1:
handle = handle.open(zip_names.pop())
elif len(zip_names) == 0:
raise ValueError(f"Zero files found in ZIP file {path_or_buf}")
else:
raise ValueError(
"Multiple files found in ZIP file. "
f"Only one file per ZIP: {zip_names}"
)

# XZ Compression
elif compression == "xz":
handle = get_lzma_file()(handle, ioargs.mode)

# Zstd Compression
elif compression == "zstd":
zstd = import_optional_dependency("zstandard")
if "r" in ioargs.mode:
open_args = {"dctx": zstd.ZstdDecompressor(**compression_args)}
else:
open_args = {"cctx": zstd.ZstdCompressor(**compression_args)}
handle = zstd.open(
handle,
mode=ioargs.mode,
**open_args,
)

# Unrecognized Compression
else:
msg = f"Unrecognized compression type: {compression}"
raise ValueError(msg)

assert not isinstance(handle, str)
handles.append(handle)

elif isinstance(handle, str):
# Check whether the filename is to be opened in binary mode.
# Binary mode does not support 'encoding' and 'newline'.
if ioargs.encoding and "b" not in ioargs.mode:
# Encoding
> handle = open(
handle,
ioargs.mode,
encoding=ioargs.encoding,
errors=errors,
newline="",
)
E FileNotFoundError: [Errno 2] No such file or directory: 'Orders_and_Payment_Flow_Certification.csv'

c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\common.py:789: FileNotFoundError
-------------------------------Captured log call--------------------------------
INFO  setup:test_orders_and_payment_flow.py:46 Total URL Present is: 5

self = <test_orders_and_payment_flow.TestOrderAndPaymentFlowCertificationProgram object at 0x0000020BE0EE8D30>, value = 'J', initialize_pages = None
testdata = {'contact_no': '123456789', 'country': ['in', 'us', 'gb', 'au', 'de', 'sg', ...], 'db_type': 'mysql', 'dynamo_db_type': 'dynamo', ...}

@pytest.mark.test_details("0000","high","Order and Payment Flow","Pradeep")
@pytest.mark.parametrize("value", certification_program_course_read_csv())
def test_Orders_and_Payment_Flow_certification(self,value,initialize_pages,testdata):

'''
Objective: Make payment and validate the data in Dynamo db and mySql

Step 01: get url
Step 02: click on Enroll Now CTA
Step 03: Make payment
Step 04: Validate the Dynamo db and MySql daya for the payment
'''
self.add_rows_in_csv('Report.csv')
url_count = self._count_url_txt_file_subdomain('Orders_and_Payment_Flow_Certification.txt')
logging.info(f"Total URL Present is: {url_count}")

# Step 01: get url
counter = 0
> df = pd.read_csv('Orders_and_Payment_Flow_Certification.csv', on_bad_lines='skip')

test_prod\test_orders_and_payment_flow.py:50:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\util\_decorators.py:311: in wrapper
return func(*args, **kwargs)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:680: in read_csv
return _read(filepath_or_buffer, kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:575: in _read
parser = TextFileReader(filepath_or_buffer, **kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:933: in __init__
self._engine = self._make_engine(f, self.engine)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:1217: in _make_engine
self.handles = get_handle( # type: ignore[call-overload]
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

path_or_buf = 'Orders_and_Payment_Flow_Certification.csv', mode = 'r'

@doc(compression_options=_shared_docs["compression_options"] % "path_or_buf")
def get_handle(
path_or_buf: FilePath | BaseBuffer,
mode: str,
*,
encoding: str | None = None,
compression: CompressionOptions = None,
memory_map: bool = False,
is_text: bool = True,
errors: str | None = None,
storage_options: StorageOptions = None,
) -> IOHandles[str] | IOHandles[bytes]:
"""
Get file handle for given path/buffer and mode.

Parameters
----------
path_or_buf : str or file handle
File path or object.
mode : str
Mode to open path_or_buf with.
encoding : str or None
Encoding to use.
{compression_options}

.. versionchanged:: 1.0.0
May now be a dict with key 'method' as compression mode
and other keys as compression options if compression
mode is 'zip'.

.. versionchanged:: 1.1.0
Passing compression options as keys in dict is now
supported for compression modes 'gzip', 'bz2', 'zstd' and 'zip'.

.. versionchanged:: 1.4.0 Zstandard support.

memory_map : bool, default False
See parsers._parser_params for more information.
is_text : bool, default True
Whether the type of the content passed to the file/buffer is string or
bytes. This is not the same as `"b" not in mode`. If a string content is
passed to a binary file/buffer, a wrapper is inserted.
errors : str, default 'strict'
Specifies how encoding and decoding errors are to be handled.
See the errors argument for :func:`open` for a full list
of options.
storage_options: StorageOptions = None
Passed to _get_filepath_or_buffer

.. versionchanged:: 1.2.0

Returns the dataclass IOHandles
"""
# Windows does not default to utf-8. Set to utf-8 for a consistent behavior
encoding = encoding or "utf-8"

# read_csv does not know whether the buffer is opened in binary/text mode
if _is_binary_mode(path_or_buf, mode) and "b" not in mode:
mode += "b"

# validate encoding and errors
codecs.lookup(encoding)
if isinstance(errors, str):
codecs.lookup_error(errors)

# open URLs
ioargs = _get_filepath_or_buffer(
path_or_buf,
encoding=encoding,
compression=compression,
mode=mode,
storage_options=storage_options,
)

handle = ioargs.filepath_or_buffer
handles: list[BaseBuffer]

# memory mapping needs to be the first step
handle, memory_map, handles = _maybe_memory_map(
handle,
memory_map,
ioargs.encoding,
ioargs.mode,
errors,
ioargs.compression["method"] not in _compression_to_extension,
)

is_path = isinstance(handle, str)
compression_args = dict(ioargs.compression)
compression = compression_args.pop("method")

# Only for write methods
if "r" not in mode and is_path:
check_parent_directory(str(handle))

if compression:
if compression != "zstd":
# compression libraries do not like an explicit text-mode
ioargs.mode = ioargs.mode.replace("t", "")
elif compression == "zstd" and "b" not in ioargs.mode:
# python-zstandard defaults to text mode, but we always expect
# compression libraries to use binary mode.
ioargs.mode += "b"

# GZ Compression
if compression == "gzip":
if is_path:
assert isinstance(handle, str)
# error: Incompatible types in assignment (expression has type
# "GzipFile", variable has type "Union[str, BaseBuffer]")
handle = gzip.GzipFile( # type: ignore[assignment]
filename=handle,
mode=ioargs.mode,
**compression_args,
)
else:
handle = gzip.GzipFile(
# No overload variant of "GzipFile" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
fileobj=handle, # type: ignore[call-overload]
mode=ioargs.mode,
**compression_args,
)

# BZ Compression
elif compression == "bz2":
# No overload variant of "BZ2File" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
handle = bz2.BZ2File( # type: ignore[call-overload]
handle,
mode=ioargs.mode,
**compression_args,
)

# ZIP Compression
elif compression == "zip":
# error: Argument 1 to "_BytesZipFile" has incompatible type "Union[str,
# BaseBuffer]"; expected "Union[Union[str, PathLike[str]],
# ReadBuffer[bytes], WriteBuffer[bytes]]"
handle = _BytesZipFile(
handle, ioargs.mode, **compression_args # type: ignore[arg-type]
)
if handle.mode == "r":
handles.append(handle)
zip_names = handle.namelist()
if len(zip_names) == 1:
handle = handle.open(zip_names.pop())
elif len(zip_names) == 0:
raise ValueError(f"Zero files found in ZIP file {path_or_buf}")
else:
raise ValueError(
"Multiple files found in ZIP file. "
f"Only one file per ZIP: {zip_names}"
)

# XZ Compression
elif compression == "xz":
handle = get_lzma_file()(handle, ioargs.mode)

# Zstd Compression
elif compression == "zstd":
zstd = import_optional_dependency("zstandard")
if "r" in ioargs.mode:
open_args = {"dctx": zstd.ZstdDecompressor(**compression_args)}
else:
open_args = {"cctx": zstd.ZstdCompressor(**compression_args)}
handle = zstd.open(
handle,
mode=ioargs.mode,
**open_args,
)

# Unrecognized Compression
else:
msg = f"Unrecognized compression type: {compression}"
raise ValueError(msg)

assert not isinstance(handle, str)
handles.append(handle)

elif isinstance(handle, str):
# Check whether the filename is to be opened in binary mode.
# Binary mode does not support 'encoding' and 'newline'.
if ioargs.encoding and "b" not in ioargs.mode:
# Encoding
> handle = open(
handle,
ioargs.mode,
encoding=ioargs.encoding,
errors=errors,
newline="",
)
E FileNotFoundError: [Errno 2] No such file or directory: 'Orders_and_Payment_Flow_Certification.csv'

c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\common.py:789: FileNotFoundError
-------------------------------Captured log call--------------------------------
INFO  setup:test_orders_and_payment_flow.py:46 Total URL Present is: 5

self = <test_orders_and_payment_flow.TestOrderAndPaymentFlowCertificationProgram object at 0x0000020BE0EEB1F0>, value = 'K', initialize_pages = None
testdata = {'contact_no': '123456789', 'country': ['in', 'us', 'gb', 'au', 'de', 'sg', ...], 'db_type': 'mysql', 'dynamo_db_type': 'dynamo', ...}

@pytest.mark.test_details("0000","high","Order and Payment Flow","Pradeep")
@pytest.mark.parametrize("value", certification_program_course_read_csv())
def test_Orders_and_Payment_Flow_certification(self,value,initialize_pages,testdata):

'''
Objective: Make payment and validate the data in Dynamo db and mySql

Step 01: get url
Step 02: click on Enroll Now CTA
Step 03: Make payment
Step 04: Validate the Dynamo db and MySql daya for the payment
'''
self.add_rows_in_csv('Report.csv')
url_count = self._count_url_txt_file_subdomain('Orders_and_Payment_Flow_Certification.txt')
logging.info(f"Total URL Present is: {url_count}")

# Step 01: get url
counter = 0
> df = pd.read_csv('Orders_and_Payment_Flow_Certification.csv', on_bad_lines='skip')

test_prod\test_orders_and_payment_flow.py:50:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\util\_decorators.py:311: in wrapper
return func(*args, **kwargs)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:680: in read_csv
return _read(filepath_or_buffer, kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:575: in _read
parser = TextFileReader(filepath_or_buffer, **kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:933: in __init__
self._engine = self._make_engine(f, self.engine)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:1217: in _make_engine
self.handles = get_handle( # type: ignore[call-overload]
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

path_or_buf = 'Orders_and_Payment_Flow_Certification.csv', mode = 'r'

@doc(compression_options=_shared_docs["compression_options"] % "path_or_buf")
def get_handle(
path_or_buf: FilePath | BaseBuffer,
mode: str,
*,
encoding: str | None = None,
compression: CompressionOptions = None,
memory_map: bool = False,
is_text: bool = True,
errors: str | None = None,
storage_options: StorageOptions = None,
) -> IOHandles[str] | IOHandles[bytes]:
"""
Get file handle for given path/buffer and mode.

Parameters
----------
path_or_buf : str or file handle
File path or object.
mode : str
Mode to open path_or_buf with.
encoding : str or None
Encoding to use.
{compression_options}

.. versionchanged:: 1.0.0
May now be a dict with key 'method' as compression mode
and other keys as compression options if compression
mode is 'zip'.

.. versionchanged:: 1.1.0
Passing compression options as keys in dict is now
supported for compression modes 'gzip', 'bz2', 'zstd' and 'zip'.

.. versionchanged:: 1.4.0 Zstandard support.

memory_map : bool, default False
See parsers._parser_params for more information.
is_text : bool, default True
Whether the type of the content passed to the file/buffer is string or
bytes. This is not the same as `"b" not in mode`. If a string content is
passed to a binary file/buffer, a wrapper is inserted.
errors : str, default 'strict'
Specifies how encoding and decoding errors are to be handled.
See the errors argument for :func:`open` for a full list
of options.
storage_options: StorageOptions = None
Passed to _get_filepath_or_buffer

.. versionchanged:: 1.2.0

Returns the dataclass IOHandles
"""
# Windows does not default to utf-8. Set to utf-8 for a consistent behavior
encoding = encoding or "utf-8"

# read_csv does not know whether the buffer is opened in binary/text mode
if _is_binary_mode(path_or_buf, mode) and "b" not in mode:
mode += "b"

# validate encoding and errors
codecs.lookup(encoding)
if isinstance(errors, str):
codecs.lookup_error(errors)

# open URLs
ioargs = _get_filepath_or_buffer(
path_or_buf,
encoding=encoding,
compression=compression,
mode=mode,
storage_options=storage_options,
)

handle = ioargs.filepath_or_buffer
handles: list[BaseBuffer]

# memory mapping needs to be the first step
handle, memory_map, handles = _maybe_memory_map(
handle,
memory_map,
ioargs.encoding,
ioargs.mode,
errors,
ioargs.compression["method"] not in _compression_to_extension,
)

is_path = isinstance(handle, str)
compression_args = dict(ioargs.compression)
compression = compression_args.pop("method")

# Only for write methods
if "r" not in mode and is_path:
check_parent_directory(str(handle))

if compression:
if compression != "zstd":
# compression libraries do not like an explicit text-mode
ioargs.mode = ioargs.mode.replace("t", "")
elif compression == "zstd" and "b" not in ioargs.mode:
# python-zstandard defaults to text mode, but we always expect
# compression libraries to use binary mode.
ioargs.mode += "b"

# GZ Compression
if compression == "gzip":
if is_path:
assert isinstance(handle, str)
# error: Incompatible types in assignment (expression has type
# "GzipFile", variable has type "Union[str, BaseBuffer]")
handle = gzip.GzipFile( # type: ignore[assignment]
filename=handle,
mode=ioargs.mode,
**compression_args,
)
else:
handle = gzip.GzipFile(
# No overload variant of "GzipFile" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
fileobj=handle, # type: ignore[call-overload]
mode=ioargs.mode,
**compression_args,
)

# BZ Compression
elif compression == "bz2":
# No overload variant of "BZ2File" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
handle = bz2.BZ2File( # type: ignore[call-overload]
handle,
mode=ioargs.mode,
**compression_args,
)

# ZIP Compression
elif compression == "zip":
# error: Argument 1 to "_BytesZipFile" has incompatible type "Union[str,
# BaseBuffer]"; expected "Union[Union[str, PathLike[str]],
# ReadBuffer[bytes], WriteBuffer[bytes]]"
handle = _BytesZipFile(
handle, ioargs.mode, **compression_args # type: ignore[arg-type]
)
if handle.mode == "r":
handles.append(handle)
zip_names = handle.namelist()
if len(zip_names) == 1:
handle = handle.open(zip_names.pop())
elif len(zip_names) == 0:
raise ValueError(f"Zero files found in ZIP file {path_or_buf}")
else:
raise ValueError(
"Multiple files found in ZIP file. "
f"Only one file per ZIP: {zip_names}"
)

# XZ Compression
elif compression == "xz":
handle = get_lzma_file()(handle, ioargs.mode)

# Zstd Compression
elif compression == "zstd":
zstd = import_optional_dependency("zstandard")
if "r" in ioargs.mode:
open_args = {"dctx": zstd.ZstdDecompressor(**compression_args)}
else:
open_args = {"cctx": zstd.ZstdCompressor(**compression_args)}
handle = zstd.open(
handle,
mode=ioargs.mode,
**open_args,
)

# Unrecognized Compression
else:
msg = f"Unrecognized compression type: {compression}"
raise ValueError(msg)

assert not isinstance(handle, str)
handles.append(handle)

elif isinstance(handle, str):
# Check whether the filename is to be opened in binary mode.
# Binary mode does not support 'encoding' and 'newline'.
if ioargs.encoding and "b" not in ioargs.mode:
# Encoding
> handle = open(
handle,
ioargs.mode,
encoding=ioargs.encoding,
errors=errors,
newline="",
)
E FileNotFoundError: [Errno 2] No such file or directory: 'Orders_and_Payment_Flow_Certification.csv'

c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\common.py:789: FileNotFoundError
-------------------------------Captured log call--------------------------------
INFO  setup:test_orders_and_payment_flow.py:46 Total URL Present is: 5

self = <test_orders_and_payment_flow.TestOrderAndPaymentFlowCertificationProgram object at 0x0000020BE1180820>, value = 'L', initialize_pages = None
testdata = {'contact_no': '123456789', 'country': ['in', 'us', 'gb', 'au', 'de', 'sg', ...], 'db_type': 'mysql', 'dynamo_db_type': 'dynamo', ...}

@pytest.mark.test_details("0000","high","Order and Payment Flow","Pradeep")
@pytest.mark.parametrize("value", certification_program_course_read_csv())
def test_Orders_and_Payment_Flow_certification(self,value,initialize_pages,testdata):

'''
Objective: Make payment and validate the data in Dynamo db and mySql

Step 01: get url
Step 02: click on Enroll Now CTA
Step 03: Make payment
Step 04: Validate the Dynamo db and MySql daya for the payment
'''
self.add_rows_in_csv('Report.csv')
url_count = self._count_url_txt_file_subdomain('Orders_and_Payment_Flow_Certification.txt')
logging.info(f"Total URL Present is: {url_count}")

# Step 01: get url
counter = 0
> df = pd.read_csv('Orders_and_Payment_Flow_Certification.csv', on_bad_lines='skip')

test_prod\test_orders_and_payment_flow.py:50:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\util\_decorators.py:311: in wrapper
return func(*args, **kwargs)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:680: in read_csv
return _read(filepath_or_buffer, kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:575: in _read
parser = TextFileReader(filepath_or_buffer, **kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:933: in __init__
self._engine = self._make_engine(f, self.engine)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:1217: in _make_engine
self.handles = get_handle( # type: ignore[call-overload]
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

path_or_buf = 'Orders_and_Payment_Flow_Certification.csv', mode = 'r'

@doc(compression_options=_shared_docs["compression_options"] % "path_or_buf")
def get_handle(
path_or_buf: FilePath | BaseBuffer,
mode: str,
*,
encoding: str | None = None,
compression: CompressionOptions = None,
memory_map: bool = False,
is_text: bool = True,
errors: str | None = None,
storage_options: StorageOptions = None,
) -> IOHandles[str] | IOHandles[bytes]:
"""
Get file handle for given path/buffer and mode.

Parameters
----------
path_or_buf : str or file handle
File path or object.
mode : str
Mode to open path_or_buf with.
encoding : str or None
Encoding to use.
{compression_options}

.. versionchanged:: 1.0.0
May now be a dict with key 'method' as compression mode
and other keys as compression options if compression
mode is 'zip'.

.. versionchanged:: 1.1.0
Passing compression options as keys in dict is now
supported for compression modes 'gzip', 'bz2', 'zstd' and 'zip'.

.. versionchanged:: 1.4.0 Zstandard support.

memory_map : bool, default False
See parsers._parser_params for more information.
is_text : bool, default True
Whether the type of the content passed to the file/buffer is string or
bytes. This is not the same as `"b" not in mode`. If a string content is
passed to a binary file/buffer, a wrapper is inserted.
errors : str, default 'strict'
Specifies how encoding and decoding errors are to be handled.
See the errors argument for :func:`open` for a full list
of options.
storage_options: StorageOptions = None
Passed to _get_filepath_or_buffer

.. versionchanged:: 1.2.0

Returns the dataclass IOHandles
"""
# Windows does not default to utf-8. Set to utf-8 for a consistent behavior
encoding = encoding or "utf-8"

# read_csv does not know whether the buffer is opened in binary/text mode
if _is_binary_mode(path_or_buf, mode) and "b" not in mode:
mode += "b"

# validate encoding and errors
codecs.lookup(encoding)
if isinstance(errors, str):
codecs.lookup_error(errors)

# open URLs
ioargs = _get_filepath_or_buffer(
path_or_buf,
encoding=encoding,
compression=compression,
mode=mode,
storage_options=storage_options,
)

handle = ioargs.filepath_or_buffer
handles: list[BaseBuffer]

# memory mapping needs to be the first step
handle, memory_map, handles = _maybe_memory_map(
handle,
memory_map,
ioargs.encoding,
ioargs.mode,
errors,
ioargs.compression["method"] not in _compression_to_extension,
)

is_path = isinstance(handle, str)
compression_args = dict(ioargs.compression)
compression = compression_args.pop("method")

# Only for write methods
if "r" not in mode and is_path:
check_parent_directory(str(handle))

if compression:
if compression != "zstd":
# compression libraries do not like an explicit text-mode
ioargs.mode = ioargs.mode.replace("t", "")
elif compression == "zstd" and "b" not in ioargs.mode:
# python-zstandard defaults to text mode, but we always expect
# compression libraries to use binary mode.
ioargs.mode += "b"

# GZ Compression
if compression == "gzip":
if is_path:
assert isinstance(handle, str)
# error: Incompatible types in assignment (expression has type
# "GzipFile", variable has type "Union[str, BaseBuffer]")
handle = gzip.GzipFile( # type: ignore[assignment]
filename=handle,
mode=ioargs.mode,
**compression_args,
)
else:
handle = gzip.GzipFile(
# No overload variant of "GzipFile" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
fileobj=handle, # type: ignore[call-overload]
mode=ioargs.mode,
**compression_args,
)

# BZ Compression
elif compression == "bz2":
# No overload variant of "BZ2File" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
handle = bz2.BZ2File( # type: ignore[call-overload]
handle,
mode=ioargs.mode,
**compression_args,
)

# ZIP Compression
elif compression == "zip":
# error: Argument 1 to "_BytesZipFile" has incompatible type "Union[str,
# BaseBuffer]"; expected "Union[Union[str, PathLike[str]],
# ReadBuffer[bytes], WriteBuffer[bytes]]"
handle = _BytesZipFile(
handle, ioargs.mode, **compression_args # type: ignore[arg-type]
)
if handle.mode == "r":
handles.append(handle)
zip_names = handle.namelist()
if len(zip_names) == 1:
handle = handle.open(zip_names.pop())
elif len(zip_names) == 0:
raise ValueError(f"Zero files found in ZIP file {path_or_buf}")
else:
raise ValueError(
"Multiple files found in ZIP file. "
f"Only one file per ZIP: {zip_names}"
)

# XZ Compression
elif compression == "xz":
handle = get_lzma_file()(handle, ioargs.mode)

# Zstd Compression
elif compression == "zstd":
zstd = import_optional_dependency("zstandard")
if "r" in ioargs.mode:
open_args = {"dctx": zstd.ZstdDecompressor(**compression_args)}
else:
open_args = {"cctx": zstd.ZstdCompressor(**compression_args)}
handle = zstd.open(
handle,
mode=ioargs.mode,
**open_args,
)

# Unrecognized Compression
else:
msg = f"Unrecognized compression type: {compression}"
raise ValueError(msg)

assert not isinstance(handle, str)
handles.append(handle)

elif isinstance(handle, str):
# Check whether the filename is to be opened in binary mode.
# Binary mode does not support 'encoding' and 'newline'.
if ioargs.encoding and "b" not in ioargs.mode:
# Encoding
> handle = open(
handle,
ioargs.mode,
encoding=ioargs.encoding,
errors=errors,
newline="",
)
E FileNotFoundError: [Errno 2] No such file or directory: 'Orders_and_Payment_Flow_Certification.csv'

c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\common.py:789: FileNotFoundError
-------------------------------Captured log call--------------------------------
INFO  setup:test_orders_and_payment_flow.py:46 Total URL Present is: 5

self = <test_orders_and_payment_flow.TestOrderAndPaymentFlowCertificationProgram object at 0x0000020BE0F85BE0>, value = 'M', initialize_pages = None
testdata = {'contact_no': '123456789', 'country': ['in', 'us', 'gb', 'au', 'de', 'sg', ...], 'db_type': 'mysql', 'dynamo_db_type': 'dynamo', ...}

@pytest.mark.test_details("0000","high","Order and Payment Flow","Pradeep")
@pytest.mark.parametrize("value", certification_program_course_read_csv())
def test_Orders_and_Payment_Flow_certification(self,value,initialize_pages,testdata):

'''
Objective: Make payment and validate the data in Dynamo db and mySql

Step 01: get url
Step 02: click on Enroll Now CTA
Step 03: Make payment
Step 04: Validate the Dynamo db and MySql daya for the payment
'''
self.add_rows_in_csv('Report.csv')
url_count = self._count_url_txt_file_subdomain('Orders_and_Payment_Flow_Certification.txt')
logging.info(f"Total URL Present is: {url_count}")

# Step 01: get url
counter = 0
> df = pd.read_csv('Orders_and_Payment_Flow_Certification.csv', on_bad_lines='skip')

test_prod\test_orders_and_payment_flow.py:50:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\util\_decorators.py:311: in wrapper
return func(*args, **kwargs)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:680: in read_csv
return _read(filepath_or_buffer, kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:575: in _read
parser = TextFileReader(filepath_or_buffer, **kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:933: in __init__
self._engine = self._make_engine(f, self.engine)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:1217: in _make_engine
self.handles = get_handle( # type: ignore[call-overload]
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

path_or_buf = 'Orders_and_Payment_Flow_Certification.csv', mode = 'r'

@doc(compression_options=_shared_docs["compression_options"] % "path_or_buf")
def get_handle(
path_or_buf: FilePath | BaseBuffer,
mode: str,
*,
encoding: str | None = None,
compression: CompressionOptions = None,
memory_map: bool = False,
is_text: bool = True,
errors: str | None = None,
storage_options: StorageOptions = None,
) -> IOHandles[str] | IOHandles[bytes]:
"""
Get file handle for given path/buffer and mode.

Parameters
----------
path_or_buf : str or file handle
File path or object.
mode : str
Mode to open path_or_buf with.
encoding : str or None
Encoding to use.
{compression_options}

.. versionchanged:: 1.0.0
May now be a dict with key 'method' as compression mode
and other keys as compression options if compression
mode is 'zip'.

.. versionchanged:: 1.1.0
Passing compression options as keys in dict is now
supported for compression modes 'gzip', 'bz2', 'zstd' and 'zip'.

.. versionchanged:: 1.4.0 Zstandard support.

memory_map : bool, default False
See parsers._parser_params for more information.
is_text : bool, default True
Whether the type of the content passed to the file/buffer is string or
bytes. This is not the same as `"b" not in mode`. If a string content is
passed to a binary file/buffer, a wrapper is inserted.
errors : str, default 'strict'
Specifies how encoding and decoding errors are to be handled.
See the errors argument for :func:`open` for a full list
of options.
storage_options: StorageOptions = None
Passed to _get_filepath_or_buffer

.. versionchanged:: 1.2.0

Returns the dataclass IOHandles
"""
# Windows does not default to utf-8. Set to utf-8 for a consistent behavior
encoding = encoding or "utf-8"

# read_csv does not know whether the buffer is opened in binary/text mode
if _is_binary_mode(path_or_buf, mode) and "b" not in mode:
mode += "b"

# validate encoding and errors
codecs.lookup(encoding)
if isinstance(errors, str):
codecs.lookup_error(errors)

# open URLs
ioargs = _get_filepath_or_buffer(
path_or_buf,
encoding=encoding,
compression=compression,
mode=mode,
storage_options=storage_options,
)

handle = ioargs.filepath_or_buffer
handles: list[BaseBuffer]

# memory mapping needs to be the first step
handle, memory_map, handles = _maybe_memory_map(
handle,
memory_map,
ioargs.encoding,
ioargs.mode,
errors,
ioargs.compression["method"] not in _compression_to_extension,
)

is_path = isinstance(handle, str)
compression_args = dict(ioargs.compression)
compression = compression_args.pop("method")

# Only for write methods
if "r" not in mode and is_path:
check_parent_directory(str(handle))

if compression:
if compression != "zstd":
# compression libraries do not like an explicit text-mode
ioargs.mode = ioargs.mode.replace("t", "")
elif compression == "zstd" and "b" not in ioargs.mode:
# python-zstandard defaults to text mode, but we always expect
# compression libraries to use binary mode.
ioargs.mode += "b"

# GZ Compression
if compression == "gzip":
if is_path:
assert isinstance(handle, str)
# error: Incompatible types in assignment (expression has type
# "GzipFile", variable has type "Union[str, BaseBuffer]")
handle = gzip.GzipFile( # type: ignore[assignment]
filename=handle,
mode=ioargs.mode,
**compression_args,
)
else:
handle = gzip.GzipFile(
# No overload variant of "GzipFile" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
fileobj=handle, # type: ignore[call-overload]
mode=ioargs.mode,
**compression_args,
)

# BZ Compression
elif compression == "bz2":
# No overload variant of "BZ2File" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
handle = bz2.BZ2File( # type: ignore[call-overload]
handle,
mode=ioargs.mode,
**compression_args,
)

# ZIP Compression
elif compression == "zip":
# error: Argument 1 to "_BytesZipFile" has incompatible type "Union[str,
# BaseBuffer]"; expected "Union[Union[str, PathLike[str]],
# ReadBuffer[bytes], WriteBuffer[bytes]]"
handle = _BytesZipFile(
handle, ioargs.mode, **compression_args # type: ignore[arg-type]
)
if handle.mode == "r":
handles.append(handle)
zip_names = handle.namelist()
if len(zip_names) == 1:
handle = handle.open(zip_names.pop())
elif len(zip_names) == 0:
raise ValueError(f"Zero files found in ZIP file {path_or_buf}")
else:
raise ValueError(
"Multiple files found in ZIP file. "
f"Only one file per ZIP: {zip_names}"
)

# XZ Compression
elif compression == "xz":
handle = get_lzma_file()(handle, ioargs.mode)

# Zstd Compression
elif compression == "zstd":
zstd = import_optional_dependency("zstandard")
if "r" in ioargs.mode:
open_args = {"dctx": zstd.ZstdDecompressor(**compression_args)}
else:
open_args = {"cctx": zstd.ZstdCompressor(**compression_args)}
handle = zstd.open(
handle,
mode=ioargs.mode,
**open_args,
)

# Unrecognized Compression
else:
msg = f"Unrecognized compression type: {compression}"
raise ValueError(msg)

assert not isinstance(handle, str)
handles.append(handle)

elif isinstance(handle, str):
# Check whether the filename is to be opened in binary mode.
# Binary mode does not support 'encoding' and 'newline'.
if ioargs.encoding and "b" not in ioargs.mode:
# Encoding
> handle = open(
handle,
ioargs.mode,
encoding=ioargs.encoding,
errors=errors,
newline="",
)
E FileNotFoundError: [Errno 2] No such file or directory: 'Orders_and_Payment_Flow_Certification.csv'

c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\common.py:789: FileNotFoundError
-------------------------------Captured log call--------------------------------
INFO  setup:test_orders_and_payment_flow.py:46 Total URL Present is: 5

self = <test_orders_and_payment_flow.TestOrderAndPaymentFlowCertificationProgram object at 0x0000020BE106DEE0>, value = 'N', initialize_pages = None
testdata = {'contact_no': '123456789', 'country': ['in', 'us', 'gb', 'au', 'de', 'sg', ...], 'db_type': 'mysql', 'dynamo_db_type': 'dynamo', ...}

@pytest.mark.test_details("0000","high","Order and Payment Flow","Pradeep")
@pytest.mark.parametrize("value", certification_program_course_read_csv())
def test_Orders_and_Payment_Flow_certification(self,value,initialize_pages,testdata):

'''
Objective: Make payment and validate the data in Dynamo db and mySql

Step 01: get url
Step 02: click on Enroll Now CTA
Step 03: Make payment
Step 04: Validate the Dynamo db and MySql daya for the payment
'''
self.add_rows_in_csv('Report.csv')
url_count = self._count_url_txt_file_subdomain('Orders_and_Payment_Flow_Certification.txt')
logging.info(f"Total URL Present is: {url_count}")

# Step 01: get url
counter = 0
> df = pd.read_csv('Orders_and_Payment_Flow_Certification.csv', on_bad_lines='skip')

test_prod\test_orders_and_payment_flow.py:50:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\util\_decorators.py:311: in wrapper
return func(*args, **kwargs)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:680: in read_csv
return _read(filepath_or_buffer, kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:575: in _read
parser = TextFileReader(filepath_or_buffer, **kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:933: in __init__
self._engine = self._make_engine(f, self.engine)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:1217: in _make_engine
self.handles = get_handle( # type: ignore[call-overload]
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

path_or_buf = 'Orders_and_Payment_Flow_Certification.csv', mode = 'r'

@doc(compression_options=_shared_docs["compression_options"] % "path_or_buf")
def get_handle(
path_or_buf: FilePath | BaseBuffer,
mode: str,
*,
encoding: str | None = None,
compression: CompressionOptions = None,
memory_map: bool = False,
is_text: bool = True,
errors: str | None = None,
storage_options: StorageOptions = None,
) -> IOHandles[str] | IOHandles[bytes]:
"""
Get file handle for given path/buffer and mode.

Parameters
----------
path_or_buf : str or file handle
File path or object.
mode : str
Mode to open path_or_buf with.
encoding : str or None
Encoding to use.
{compression_options}

.. versionchanged:: 1.0.0
May now be a dict with key 'method' as compression mode
and other keys as compression options if compression
mode is 'zip'.

.. versionchanged:: 1.1.0
Passing compression options as keys in dict is now
supported for compression modes 'gzip', 'bz2', 'zstd' and 'zip'.

.. versionchanged:: 1.4.0 Zstandard support.

memory_map : bool, default False
See parsers._parser_params for more information.
is_text : bool, default True
Whether the type of the content passed to the file/buffer is string or
bytes. This is not the same as `"b" not in mode`. If a string content is
passed to a binary file/buffer, a wrapper is inserted.
errors : str, default 'strict'
Specifies how encoding and decoding errors are to be handled.
See the errors argument for :func:`open` for a full list
of options.
storage_options: StorageOptions = None
Passed to _get_filepath_or_buffer

.. versionchanged:: 1.2.0

Returns the dataclass IOHandles
"""
# Windows does not default to utf-8. Set to utf-8 for a consistent behavior
encoding = encoding or "utf-8"

# read_csv does not know whether the buffer is opened in binary/text mode
if _is_binary_mode(path_or_buf, mode) and "b" not in mode:
mode += "b"

# validate encoding and errors
codecs.lookup(encoding)
if isinstance(errors, str):
codecs.lookup_error(errors)

# open URLs
ioargs = _get_filepath_or_buffer(
path_or_buf,
encoding=encoding,
compression=compression,
mode=mode,
storage_options=storage_options,
)

handle = ioargs.filepath_or_buffer
handles: list[BaseBuffer]

# memory mapping needs to be the first step
handle, memory_map, handles = _maybe_memory_map(
handle,
memory_map,
ioargs.encoding,
ioargs.mode,
errors,
ioargs.compression["method"] not in _compression_to_extension,
)

is_path = isinstance(handle, str)
compression_args = dict(ioargs.compression)
compression = compression_args.pop("method")

# Only for write methods
if "r" not in mode and is_path:
check_parent_directory(str(handle))

if compression:
if compression != "zstd":
# compression libraries do not like an explicit text-mode
ioargs.mode = ioargs.mode.replace("t", "")
elif compression == "zstd" and "b" not in ioargs.mode:
# python-zstandard defaults to text mode, but we always expect
# compression libraries to use binary mode.
ioargs.mode += "b"

# GZ Compression
if compression == "gzip":
if is_path:
assert isinstance(handle, str)
# error: Incompatible types in assignment (expression has type
# "GzipFile", variable has type "Union[str, BaseBuffer]")
handle = gzip.GzipFile( # type: ignore[assignment]
filename=handle,
mode=ioargs.mode,
**compression_args,
)
else:
handle = gzip.GzipFile(
# No overload variant of "GzipFile" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
fileobj=handle, # type: ignore[call-overload]
mode=ioargs.mode,
**compression_args,
)

# BZ Compression
elif compression == "bz2":
# No overload variant of "BZ2File" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
handle = bz2.BZ2File( # type: ignore[call-overload]
handle,
mode=ioargs.mode,
**compression_args,
)

# ZIP Compression
elif compression == "zip":
# error: Argument 1 to "_BytesZipFile" has incompatible type "Union[str,
# BaseBuffer]"; expected "Union[Union[str, PathLike[str]],
# ReadBuffer[bytes], WriteBuffer[bytes]]"
handle = _BytesZipFile(
handle, ioargs.mode, **compression_args # type: ignore[arg-type]
)
if handle.mode == "r":
handles.append(handle)
zip_names = handle.namelist()
if len(zip_names) == 1:
handle = handle.open(zip_names.pop())
elif len(zip_names) == 0:
raise ValueError(f"Zero files found in ZIP file {path_or_buf}")
else:
raise ValueError(
"Multiple files found in ZIP file. "
f"Only one file per ZIP: {zip_names}"
)

# XZ Compression
elif compression == "xz":
handle = get_lzma_file()(handle, ioargs.mode)

# Zstd Compression
elif compression == "zstd":
zstd = import_optional_dependency("zstandard")
if "r" in ioargs.mode:
open_args = {"dctx": zstd.ZstdDecompressor(**compression_args)}
else:
open_args = {"cctx": zstd.ZstdCompressor(**compression_args)}
handle = zstd.open(
handle,
mode=ioargs.mode,
**open_args,
)

# Unrecognized Compression
else:
msg = f"Unrecognized compression type: {compression}"
raise ValueError(msg)

assert not isinstance(handle, str)
handles.append(handle)

elif isinstance(handle, str):
# Check whether the filename is to be opened in binary mode.
# Binary mode does not support 'encoding' and 'newline'.
if ioargs.encoding and "b" not in ioargs.mode:
# Encoding
> handle = open(
handle,
ioargs.mode,
encoding=ioargs.encoding,
errors=errors,
newline="",
)
E FileNotFoundError: [Errno 2] No such file or directory: 'Orders_and_Payment_Flow_Certification.csv'

c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\common.py:789: FileNotFoundError
-------------------------------Captured log call--------------------------------
INFO  setup:test_orders_and_payment_flow.py:46 Total URL Present is: 5

self = <test_orders_and_payment_flow.TestOrderAndPaymentFlowCertificationProgram object at 0x0000020BE1040820>, value = 'O', initialize_pages = None
testdata = {'contact_no': '123456789', 'country': ['in', 'us', 'gb', 'au', 'de', 'sg', ...], 'db_type': 'mysql', 'dynamo_db_type': 'dynamo', ...}

@pytest.mark.test_details("0000","high","Order and Payment Flow","Pradeep")
@pytest.mark.parametrize("value", certification_program_course_read_csv())
def test_Orders_and_Payment_Flow_certification(self,value,initialize_pages,testdata):

'''
Objective: Make payment and validate the data in Dynamo db and mySql

Step 01: get url
Step 02: click on Enroll Now CTA
Step 03: Make payment
Step 04: Validate the Dynamo db and MySql daya for the payment
'''
self.add_rows_in_csv('Report.csv')
url_count = self._count_url_txt_file_subdomain('Orders_and_Payment_Flow_Certification.txt')
logging.info(f"Total URL Present is: {url_count}")

# Step 01: get url
counter = 0
> df = pd.read_csv('Orders_and_Payment_Flow_Certification.csv', on_bad_lines='skip')

test_prod\test_orders_and_payment_flow.py:50:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\util\_decorators.py:311: in wrapper
return func(*args, **kwargs)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:680: in read_csv
return _read(filepath_or_buffer, kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:575: in _read
parser = TextFileReader(filepath_or_buffer, **kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:933: in __init__
self._engine = self._make_engine(f, self.engine)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:1217: in _make_engine
self.handles = get_handle( # type: ignore[call-overload]
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

path_or_buf = 'Orders_and_Payment_Flow_Certification.csv', mode = 'r'

@doc(compression_options=_shared_docs["compression_options"] % "path_or_buf")
def get_handle(
path_or_buf: FilePath | BaseBuffer,
mode: str,
*,
encoding: str | None = None,
compression: CompressionOptions = None,
memory_map: bool = False,
is_text: bool = True,
errors: str | None = None,
storage_options: StorageOptions = None,
) -> IOHandles[str] | IOHandles[bytes]:
"""
Get file handle for given path/buffer and mode.

Parameters
----------
path_or_buf : str or file handle
File path or object.
mode : str
Mode to open path_or_buf with.
encoding : str or None
Encoding to use.
{compression_options}

.. versionchanged:: 1.0.0
May now be a dict with key 'method' as compression mode
and other keys as compression options if compression
mode is 'zip'.

.. versionchanged:: 1.1.0
Passing compression options as keys in dict is now
supported for compression modes 'gzip', 'bz2', 'zstd' and 'zip'.

.. versionchanged:: 1.4.0 Zstandard support.

memory_map : bool, default False
See parsers._parser_params for more information.
is_text : bool, default True
Whether the type of the content passed to the file/buffer is string or
bytes. This is not the same as `"b" not in mode`. If a string content is
passed to a binary file/buffer, a wrapper is inserted.
errors : str, default 'strict'
Specifies how encoding and decoding errors are to be handled.
See the errors argument for :func:`open` for a full list
of options.
storage_options: StorageOptions = None
Passed to _get_filepath_or_buffer

.. versionchanged:: 1.2.0

Returns the dataclass IOHandles
"""
# Windows does not default to utf-8. Set to utf-8 for a consistent behavior
encoding = encoding or "utf-8"

# read_csv does not know whether the buffer is opened in binary/text mode
if _is_binary_mode(path_or_buf, mode) and "b" not in mode:
mode += "b"

# validate encoding and errors
codecs.lookup(encoding)
if isinstance(errors, str):
codecs.lookup_error(errors)

# open URLs
ioargs = _get_filepath_or_buffer(
path_or_buf,
encoding=encoding,
compression=compression,
mode=mode,
storage_options=storage_options,
)

handle = ioargs.filepath_or_buffer
handles: list[BaseBuffer]

# memory mapping needs to be the first step
handle, memory_map, handles = _maybe_memory_map(
handle,
memory_map,
ioargs.encoding,
ioargs.mode,
errors,
ioargs.compression["method"] not in _compression_to_extension,
)

is_path = isinstance(handle, str)
compression_args = dict(ioargs.compression)
compression = compression_args.pop("method")

# Only for write methods
if "r" not in mode and is_path:
check_parent_directory(str(handle))

if compression:
if compression != "zstd":
# compression libraries do not like an explicit text-mode
ioargs.mode = ioargs.mode.replace("t", "")
elif compression == "zstd" and "b" not in ioargs.mode:
# python-zstandard defaults to text mode, but we always expect
# compression libraries to use binary mode.
ioargs.mode += "b"

# GZ Compression
if compression == "gzip":
if is_path:
assert isinstance(handle, str)
# error: Incompatible types in assignment (expression has type
# "GzipFile", variable has type "Union[str, BaseBuffer]")
handle = gzip.GzipFile( # type: ignore[assignment]
filename=handle,
mode=ioargs.mode,
**compression_args,
)
else:
handle = gzip.GzipFile(
# No overload variant of "GzipFile" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
fileobj=handle, # type: ignore[call-overload]
mode=ioargs.mode,
**compression_args,
)

# BZ Compression
elif compression == "bz2":
# No overload variant of "BZ2File" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
handle = bz2.BZ2File( # type: ignore[call-overload]
handle,
mode=ioargs.mode,
**compression_args,
)

# ZIP Compression
elif compression == "zip":
# error: Argument 1 to "_BytesZipFile" has incompatible type "Union[str,
# BaseBuffer]"; expected "Union[Union[str, PathLike[str]],
# ReadBuffer[bytes], WriteBuffer[bytes]]"
handle = _BytesZipFile(
handle, ioargs.mode, **compression_args # type: ignore[arg-type]
)
if handle.mode == "r":
handles.append(handle)
zip_names = handle.namelist()
if len(zip_names) == 1:
handle = handle.open(zip_names.pop())
elif len(zip_names) == 0:
raise ValueError(f"Zero files found in ZIP file {path_or_buf}")
else:
raise ValueError(
"Multiple files found in ZIP file. "
f"Only one file per ZIP: {zip_names}"
)

# XZ Compression
elif compression == "xz":
handle = get_lzma_file()(handle, ioargs.mode)

# Zstd Compression
elif compression == "zstd":
zstd = import_optional_dependency("zstandard")
if "r" in ioargs.mode:
open_args = {"dctx": zstd.ZstdDecompressor(**compression_args)}
else:
open_args = {"cctx": zstd.ZstdCompressor(**compression_args)}
handle = zstd.open(
handle,
mode=ioargs.mode,
**open_args,
)

# Unrecognized Compression
else:
msg = f"Unrecognized compression type: {compression}"
raise ValueError(msg)

assert not isinstance(handle, str)
handles.append(handle)

elif isinstance(handle, str):
# Check whether the filename is to be opened in binary mode.
# Binary mode does not support 'encoding' and 'newline'.
if ioargs.encoding and "b" not in ioargs.mode:
# Encoding
> handle = open(
handle,
ioargs.mode,
encoding=ioargs.encoding,
errors=errors,
newline="",
)
E FileNotFoundError: [Errno 2] No such file or directory: 'Orders_and_Payment_Flow_Certification.csv'

c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\common.py:789: FileNotFoundError
-------------------------------Captured log call--------------------------------
INFO  setup:test_orders_and_payment_flow.py:46 Total URL Present is: 5

self = <test_orders_and_payment_flow.TestOrderAndPaymentFlowCertificationProgram object at 0x0000020BE1072BE0>, value = 'P', initialize_pages = None
testdata = {'contact_no': '123456789', 'country': ['in', 'us', 'gb', 'au', 'de', 'sg', ...], 'db_type': 'mysql', 'dynamo_db_type': 'dynamo', ...}

@pytest.mark.test_details("0000","high","Order and Payment Flow","Pradeep")
@pytest.mark.parametrize("value", certification_program_course_read_csv())
def test_Orders_and_Payment_Flow_certification(self,value,initialize_pages,testdata):

'''
Objective: Make payment and validate the data in Dynamo db and mySql

Step 01: get url
Step 02: click on Enroll Now CTA
Step 03: Make payment
Step 04: Validate the Dynamo db and MySql daya for the payment
'''
self.add_rows_in_csv('Report.csv')
url_count = self._count_url_txt_file_subdomain('Orders_and_Payment_Flow_Certification.txt')
logging.info(f"Total URL Present is: {url_count}")

# Step 01: get url
counter = 0
> df = pd.read_csv('Orders_and_Payment_Flow_Certification.csv', on_bad_lines='skip')

test_prod\test_orders_and_payment_flow.py:50:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\util\_decorators.py:311: in wrapper
return func(*args, **kwargs)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:680: in read_csv
return _read(filepath_or_buffer, kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:575: in _read
parser = TextFileReader(filepath_or_buffer, **kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:933: in __init__
self._engine = self._make_engine(f, self.engine)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:1217: in _make_engine
self.handles = get_handle( # type: ignore[call-overload]
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

path_or_buf = 'Orders_and_Payment_Flow_Certification.csv', mode = 'r'

@doc(compression_options=_shared_docs["compression_options"] % "path_or_buf")
def get_handle(
path_or_buf: FilePath | BaseBuffer,
mode: str,
*,
encoding: str | None = None,
compression: CompressionOptions = None,
memory_map: bool = False,
is_text: bool = True,
errors: str | None = None,
storage_options: StorageOptions = None,
) -> IOHandles[str] | IOHandles[bytes]:
"""
Get file handle for given path/buffer and mode.

Parameters
----------
path_or_buf : str or file handle
File path or object.
mode : str
Mode to open path_or_buf with.
encoding : str or None
Encoding to use.
{compression_options}

.. versionchanged:: 1.0.0
May now be a dict with key 'method' as compression mode
and other keys as compression options if compression
mode is 'zip'.

.. versionchanged:: 1.1.0
Passing compression options as keys in dict is now
supported for compression modes 'gzip', 'bz2', 'zstd' and 'zip'.

.. versionchanged:: 1.4.0 Zstandard support.

memory_map : bool, default False
See parsers._parser_params for more information.
is_text : bool, default True
Whether the type of the content passed to the file/buffer is string or
bytes. This is not the same as `"b" not in mode`. If a string content is
passed to a binary file/buffer, a wrapper is inserted.
errors : str, default 'strict'
Specifies how encoding and decoding errors are to be handled.
See the errors argument for :func:`open` for a full list
of options.
storage_options: StorageOptions = None
Passed to _get_filepath_or_buffer

.. versionchanged:: 1.2.0

Returns the dataclass IOHandles
"""
# Windows does not default to utf-8. Set to utf-8 for a consistent behavior
encoding = encoding or "utf-8"

# read_csv does not know whether the buffer is opened in binary/text mode
if _is_binary_mode(path_or_buf, mode) and "b" not in mode:
mode += "b"

# validate encoding and errors
codecs.lookup(encoding)
if isinstance(errors, str):
codecs.lookup_error(errors)

# open URLs
ioargs = _get_filepath_or_buffer(
path_or_buf,
encoding=encoding,
compression=compression,
mode=mode,
storage_options=storage_options,
)

handle = ioargs.filepath_or_buffer
handles: list[BaseBuffer]

# memory mapping needs to be the first step
handle, memory_map, handles = _maybe_memory_map(
handle,
memory_map,
ioargs.encoding,
ioargs.mode,
errors,
ioargs.compression["method"] not in _compression_to_extension,
)

is_path = isinstance(handle, str)
compression_args = dict(ioargs.compression)
compression = compression_args.pop("method")

# Only for write methods
if "r" not in mode and is_path:
check_parent_directory(str(handle))

if compression:
if compression != "zstd":
# compression libraries do not like an explicit text-mode
ioargs.mode = ioargs.mode.replace("t", "")
elif compression == "zstd" and "b" not in ioargs.mode:
# python-zstandard defaults to text mode, but we always expect
# compression libraries to use binary mode.
ioargs.mode += "b"

# GZ Compression
if compression == "gzip":
if is_path:
assert isinstance(handle, str)
# error: Incompatible types in assignment (expression has type
# "GzipFile", variable has type "Union[str, BaseBuffer]")
handle = gzip.GzipFile( # type: ignore[assignment]
filename=handle,
mode=ioargs.mode,
**compression_args,
)
else:
handle = gzip.GzipFile(
# No overload variant of "GzipFile" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
fileobj=handle, # type: ignore[call-overload]
mode=ioargs.mode,
**compression_args,
)

# BZ Compression
elif compression == "bz2":
# No overload variant of "BZ2File" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
handle = bz2.BZ2File( # type: ignore[call-overload]
handle,
mode=ioargs.mode,
**compression_args,
)

# ZIP Compression
elif compression == "zip":
# error: Argument 1 to "_BytesZipFile" has incompatible type "Union[str,
# BaseBuffer]"; expected "Union[Union[str, PathLike[str]],
# ReadBuffer[bytes], WriteBuffer[bytes]]"
handle = _BytesZipFile(
handle, ioargs.mode, **compression_args # type: ignore[arg-type]
)
if handle.mode == "r":
handles.append(handle)
zip_names = handle.namelist()
if len(zip_names) == 1:
handle = handle.open(zip_names.pop())
elif len(zip_names) == 0:
raise ValueError(f"Zero files found in ZIP file {path_or_buf}")
else:
raise ValueError(
"Multiple files found in ZIP file. "
f"Only one file per ZIP: {zip_names}"
)

# XZ Compression
elif compression == "xz":
handle = get_lzma_file()(handle, ioargs.mode)

# Zstd Compression
elif compression == "zstd":
zstd = import_optional_dependency("zstandard")
if "r" in ioargs.mode:
open_args = {"dctx": zstd.ZstdDecompressor(**compression_args)}
else:
open_args = {"cctx": zstd.ZstdCompressor(**compression_args)}
handle = zstd.open(
handle,
mode=ioargs.mode,
**open_args,
)

# Unrecognized Compression
else:
msg = f"Unrecognized compression type: {compression}"
raise ValueError(msg)

assert not isinstance(handle, str)
handles.append(handle)

elif isinstance(handle, str):
# Check whether the filename is to be opened in binary mode.
# Binary mode does not support 'encoding' and 'newline'.
if ioargs.encoding and "b" not in ioargs.mode:
# Encoding
> handle = open(
handle,
ioargs.mode,
encoding=ioargs.encoding,
errors=errors,
newline="",
)
E FileNotFoundError: [Errno 2] No such file or directory: 'Orders_and_Payment_Flow_Certification.csv'

c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\common.py:789: FileNotFoundError
-------------------------------Captured log call--------------------------------
INFO  setup:test_orders_and_payment_flow.py:46 Total URL Present is: 5

self = <test_orders_and_payment_flow.TestOrderAndPaymentFlowCertificationProgram object at 0x0000020BE1013520>, value = 'Q', initialize_pages = None
testdata = {'contact_no': '123456789', 'country': ['in', 'us', 'gb', 'au', 'de', 'sg', ...], 'db_type': 'mysql', 'dynamo_db_type': 'dynamo', ...}

@pytest.mark.test_details("0000","high","Order and Payment Flow","Pradeep")
@pytest.mark.parametrize("value", certification_program_course_read_csv())
def test_Orders_and_Payment_Flow_certification(self,value,initialize_pages,testdata):

'''
Objective: Make payment and validate the data in Dynamo db and mySql

Step 01: get url
Step 02: click on Enroll Now CTA
Step 03: Make payment
Step 04: Validate the Dynamo db and MySql daya for the payment
'''
self.add_rows_in_csv('Report.csv')
url_count = self._count_url_txt_file_subdomain('Orders_and_Payment_Flow_Certification.txt')
logging.info(f"Total URL Present is: {url_count}")

# Step 01: get url
counter = 0
> df = pd.read_csv('Orders_and_Payment_Flow_Certification.csv', on_bad_lines='skip')

test_prod\test_orders_and_payment_flow.py:50:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\util\_decorators.py:311: in wrapper
return func(*args, **kwargs)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:680: in read_csv
return _read(filepath_or_buffer, kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:575: in _read
parser = TextFileReader(filepath_or_buffer, **kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:933: in __init__
self._engine = self._make_engine(f, self.engine)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:1217: in _make_engine
self.handles = get_handle( # type: ignore[call-overload]
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

path_or_buf = 'Orders_and_Payment_Flow_Certification.csv', mode = 'r'

@doc(compression_options=_shared_docs["compression_options"] % "path_or_buf")
def get_handle(
path_or_buf: FilePath | BaseBuffer,
mode: str,
*,
encoding: str | None = None,
compression: CompressionOptions = None,
memory_map: bool = False,
is_text: bool = True,
errors: str | None = None,
storage_options: StorageOptions = None,
) -> IOHandles[str] | IOHandles[bytes]:
"""
Get file handle for given path/buffer and mode.

Parameters
----------
path_or_buf : str or file handle
File path or object.
mode : str
Mode to open path_or_buf with.
encoding : str or None
Encoding to use.
{compression_options}

.. versionchanged:: 1.0.0
May now be a dict with key 'method' as compression mode
and other keys as compression options if compression
mode is 'zip'.

.. versionchanged:: 1.1.0
Passing compression options as keys in dict is now
supported for compression modes 'gzip', 'bz2', 'zstd' and 'zip'.

.. versionchanged:: 1.4.0 Zstandard support.

memory_map : bool, default False
See parsers._parser_params for more information.
is_text : bool, default True
Whether the type of the content passed to the file/buffer is string or
bytes. This is not the same as `"b" not in mode`. If a string content is
passed to a binary file/buffer, a wrapper is inserted.
errors : str, default 'strict'
Specifies how encoding and decoding errors are to be handled.
See the errors argument for :func:`open` for a full list
of options.
storage_options: StorageOptions = None
Passed to _get_filepath_or_buffer

.. versionchanged:: 1.2.0

Returns the dataclass IOHandles
"""
# Windows does not default to utf-8. Set to utf-8 for a consistent behavior
encoding = encoding or "utf-8"

# read_csv does not know whether the buffer is opened in binary/text mode
if _is_binary_mode(path_or_buf, mode) and "b" not in mode:
mode += "b"

# validate encoding and errors
codecs.lookup(encoding)
if isinstance(errors, str):
codecs.lookup_error(errors)

# open URLs
ioargs = _get_filepath_or_buffer(
path_or_buf,
encoding=encoding,
compression=compression,
mode=mode,
storage_options=storage_options,
)

handle = ioargs.filepath_or_buffer
handles: list[BaseBuffer]

# memory mapping needs to be the first step
handle, memory_map, handles = _maybe_memory_map(
handle,
memory_map,
ioargs.encoding,
ioargs.mode,
errors,
ioargs.compression["method"] not in _compression_to_extension,
)

is_path = isinstance(handle, str)
compression_args = dict(ioargs.compression)
compression = compression_args.pop("method")

# Only for write methods
if "r" not in mode and is_path:
check_parent_directory(str(handle))

if compression:
if compression != "zstd":
# compression libraries do not like an explicit text-mode
ioargs.mode = ioargs.mode.replace("t", "")
elif compression == "zstd" and "b" not in ioargs.mode:
# python-zstandard defaults to text mode, but we always expect
# compression libraries to use binary mode.
ioargs.mode += "b"

# GZ Compression
if compression == "gzip":
if is_path:
assert isinstance(handle, str)
# error: Incompatible types in assignment (expression has type
# "GzipFile", variable has type "Union[str, BaseBuffer]")
handle = gzip.GzipFile( # type: ignore[assignment]
filename=handle,
mode=ioargs.mode,
**compression_args,
)
else:
handle = gzip.GzipFile(
# No overload variant of "GzipFile" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
fileobj=handle, # type: ignore[call-overload]
mode=ioargs.mode,
**compression_args,
)

# BZ Compression
elif compression == "bz2":
# No overload variant of "BZ2File" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
handle = bz2.BZ2File( # type: ignore[call-overload]
handle,
mode=ioargs.mode,
**compression_args,
)

# ZIP Compression
elif compression == "zip":
# error: Argument 1 to "_BytesZipFile" has incompatible type "Union[str,
# BaseBuffer]"; expected "Union[Union[str, PathLike[str]],
# ReadBuffer[bytes], WriteBuffer[bytes]]"
handle = _BytesZipFile(
handle, ioargs.mode, **compression_args # type: ignore[arg-type]
)
if handle.mode == "r":
handles.append(handle)
zip_names = handle.namelist()
if len(zip_names) == 1:
handle = handle.open(zip_names.pop())
elif len(zip_names) == 0:
raise ValueError(f"Zero files found in ZIP file {path_or_buf}")
else:
raise ValueError(
"Multiple files found in ZIP file. "
f"Only one file per ZIP: {zip_names}"
)

# XZ Compression
elif compression == "xz":
handle = get_lzma_file()(handle, ioargs.mode)

# Zstd Compression
elif compression == "zstd":
zstd = import_optional_dependency("zstandard")
if "r" in ioargs.mode:
open_args = {"dctx": zstd.ZstdDecompressor(**compression_args)}
else:
open_args = {"cctx": zstd.ZstdCompressor(**compression_args)}
handle = zstd.open(
handle,
mode=ioargs.mode,
**open_args,
)

# Unrecognized Compression
else:
msg = f"Unrecognized compression type: {compression}"
raise ValueError(msg)

assert not isinstance(handle, str)
handles.append(handle)

elif isinstance(handle, str):
# Check whether the filename is to be opened in binary mode.
# Binary mode does not support 'encoding' and 'newline'.
if ioargs.encoding and "b" not in ioargs.mode:
# Encoding
> handle = open(
handle,
ioargs.mode,
encoding=ioargs.encoding,
errors=errors,
newline="",
)
E FileNotFoundError: [Errno 2] No such file or directory: 'Orders_and_Payment_Flow_Certification.csv'

c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\common.py:789: FileNotFoundError
-------------------------------Captured log call--------------------------------
INFO  setup:test_orders_and_payment_flow.py:46 Total URL Present is: 5

self = <test_orders_and_payment_flow.TestOrderAndPaymentFlowCertificationProgram object at 0x0000020BE1183880>, value = 'R', initialize_pages = None
testdata = {'contact_no': '123456789', 'country': ['in', 'us', 'gb', 'au', 'de', 'sg', ...], 'db_type': 'mysql', 'dynamo_db_type': 'dynamo', ...}

@pytest.mark.test_details("0000","high","Order and Payment Flow","Pradeep")
@pytest.mark.parametrize("value", certification_program_course_read_csv())
def test_Orders_and_Payment_Flow_certification(self,value,initialize_pages,testdata):

'''
Objective: Make payment and validate the data in Dynamo db and mySql

Step 01: get url
Step 02: click on Enroll Now CTA
Step 03: Make payment
Step 04: Validate the Dynamo db and MySql daya for the payment
'''
self.add_rows_in_csv('Report.csv')
url_count = self._count_url_txt_file_subdomain('Orders_and_Payment_Flow_Certification.txt')
logging.info(f"Total URL Present is: {url_count}")

# Step 01: get url
counter = 0
> df = pd.read_csv('Orders_and_Payment_Flow_Certification.csv', on_bad_lines='skip')

test_prod\test_orders_and_payment_flow.py:50:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\util\_decorators.py:311: in wrapper
return func(*args, **kwargs)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:680: in read_csv
return _read(filepath_or_buffer, kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:575: in _read
parser = TextFileReader(filepath_or_buffer, **kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:933: in __init__
self._engine = self._make_engine(f, self.engine)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:1217: in _make_engine
self.handles = get_handle( # type: ignore[call-overload]
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

path_or_buf = 'Orders_and_Payment_Flow_Certification.csv', mode = 'r'

@doc(compression_options=_shared_docs["compression_options"] % "path_or_buf")
def get_handle(
path_or_buf: FilePath | BaseBuffer,
mode: str,
*,
encoding: str | None = None,
compression: CompressionOptions = None,
memory_map: bool = False,
is_text: bool = True,
errors: str | None = None,
storage_options: StorageOptions = None,
) -> IOHandles[str] | IOHandles[bytes]:
"""
Get file handle for given path/buffer and mode.

Parameters
----------
path_or_buf : str or file handle
File path or object.
mode : str
Mode to open path_or_buf with.
encoding : str or None
Encoding to use.
{compression_options}

.. versionchanged:: 1.0.0
May now be a dict with key 'method' as compression mode
and other keys as compression options if compression
mode is 'zip'.

.. versionchanged:: 1.1.0
Passing compression options as keys in dict is now
supported for compression modes 'gzip', 'bz2', 'zstd' and 'zip'.

.. versionchanged:: 1.4.0 Zstandard support.

memory_map : bool, default False
See parsers._parser_params for more information.
is_text : bool, default True
Whether the type of the content passed to the file/buffer is string or
bytes. This is not the same as `"b" not in mode`. If a string content is
passed to a binary file/buffer, a wrapper is inserted.
errors : str, default 'strict'
Specifies how encoding and decoding errors are to be handled.
See the errors argument for :func:`open` for a full list
of options.
storage_options: StorageOptions = None
Passed to _get_filepath_or_buffer

.. versionchanged:: 1.2.0

Returns the dataclass IOHandles
"""
# Windows does not default to utf-8. Set to utf-8 for a consistent behavior
encoding = encoding or "utf-8"

# read_csv does not know whether the buffer is opened in binary/text mode
if _is_binary_mode(path_or_buf, mode) and "b" not in mode:
mode += "b"

# validate encoding and errors
codecs.lookup(encoding)
if isinstance(errors, str):
codecs.lookup_error(errors)

# open URLs
ioargs = _get_filepath_or_buffer(
path_or_buf,
encoding=encoding,
compression=compression,
mode=mode,
storage_options=storage_options,
)

handle = ioargs.filepath_or_buffer
handles: list[BaseBuffer]

# memory mapping needs to be the first step
handle, memory_map, handles = _maybe_memory_map(
handle,
memory_map,
ioargs.encoding,
ioargs.mode,
errors,
ioargs.compression["method"] not in _compression_to_extension,
)

is_path = isinstance(handle, str)
compression_args = dict(ioargs.compression)
compression = compression_args.pop("method")

# Only for write methods
if "r" not in mode and is_path:
check_parent_directory(str(handle))

if compression:
if compression != "zstd":
# compression libraries do not like an explicit text-mode
ioargs.mode = ioargs.mode.replace("t", "")
elif compression == "zstd" and "b" not in ioargs.mode:
# python-zstandard defaults to text mode, but we always expect
# compression libraries to use binary mode.
ioargs.mode += "b"

# GZ Compression
if compression == "gzip":
if is_path:
assert isinstance(handle, str)
# error: Incompatible types in assignment (expression has type
# "GzipFile", variable has type "Union[str, BaseBuffer]")
handle = gzip.GzipFile( # type: ignore[assignment]
filename=handle,
mode=ioargs.mode,
**compression_args,
)
else:
handle = gzip.GzipFile(
# No overload variant of "GzipFile" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
fileobj=handle, # type: ignore[call-overload]
mode=ioargs.mode,
**compression_args,
)

# BZ Compression
elif compression == "bz2":
# No overload variant of "BZ2File" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
handle = bz2.BZ2File( # type: ignore[call-overload]
handle,
mode=ioargs.mode,
**compression_args,
)

# ZIP Compression
elif compression == "zip":
# error: Argument 1 to "_BytesZipFile" has incompatible type "Union[str,
# BaseBuffer]"; expected "Union[Union[str, PathLike[str]],
# ReadBuffer[bytes], WriteBuffer[bytes]]"
handle = _BytesZipFile(
handle, ioargs.mode, **compression_args # type: ignore[arg-type]
)
if handle.mode == "r":
handles.append(handle)
zip_names = handle.namelist()
if len(zip_names) == 1:
handle = handle.open(zip_names.pop())
elif len(zip_names) == 0:
raise ValueError(f"Zero files found in ZIP file {path_or_buf}")
else:
raise ValueError(
"Multiple files found in ZIP file. "
f"Only one file per ZIP: {zip_names}"
)

# XZ Compression
elif compression == "xz":
handle = get_lzma_file()(handle, ioargs.mode)

# Zstd Compression
elif compression == "zstd":
zstd = import_optional_dependency("zstandard")
if "r" in ioargs.mode:
open_args = {"dctx": zstd.ZstdDecompressor(**compression_args)}
else:
open_args = {"cctx": zstd.ZstdCompressor(**compression_args)}
handle = zstd.open(
handle,
mode=ioargs.mode,
**open_args,
)

# Unrecognized Compression
else:
msg = f"Unrecognized compression type: {compression}"
raise ValueError(msg)

assert not isinstance(handle, str)
handles.append(handle)

elif isinstance(handle, str):
# Check whether the filename is to be opened in binary mode.
# Binary mode does not support 'encoding' and 'newline'.
if ioargs.encoding and "b" not in ioargs.mode:
# Encoding
> handle = open(
handle,
ioargs.mode,
encoding=ioargs.encoding,
errors=errors,
newline="",
)
E FileNotFoundError: [Errno 2] No such file or directory: 'Orders_and_Payment_Flow_Certification.csv'

c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\common.py:789: FileNotFoundError
-------------------------------Captured log call--------------------------------
INFO  setup:test_orders_and_payment_flow.py:46 Total URL Present is: 5

self = <test_orders_and_payment_flow.TestOrderAndPaymentFlowCertificationProgram object at 0x0000020BE0F5B340>, value = 'S', initialize_pages = None
testdata = {'contact_no': '123456789', 'country': ['in', 'us', 'gb', 'au', 'de', 'sg', ...], 'db_type': 'mysql', 'dynamo_db_type': 'dynamo', ...}

@pytest.mark.test_details("0000","high","Order and Payment Flow","Pradeep")
@pytest.mark.parametrize("value", certification_program_course_read_csv())
def test_Orders_and_Payment_Flow_certification(self,value,initialize_pages,testdata):

'''
Objective: Make payment and validate the data in Dynamo db and mySql

Step 01: get url
Step 02: click on Enroll Now CTA
Step 03: Make payment
Step 04: Validate the Dynamo db and MySql daya for the payment
'''
self.add_rows_in_csv('Report.csv')
url_count = self._count_url_txt_file_subdomain('Orders_and_Payment_Flow_Certification.txt')
logging.info(f"Total URL Present is: {url_count}")

# Step 01: get url
counter = 0
> df = pd.read_csv('Orders_and_Payment_Flow_Certification.csv', on_bad_lines='skip')

test_prod\test_orders_and_payment_flow.py:50:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\util\_decorators.py:311: in wrapper
return func(*args, **kwargs)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:680: in read_csv
return _read(filepath_or_buffer, kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:575: in _read
parser = TextFileReader(filepath_or_buffer, **kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:933: in __init__
self._engine = self._make_engine(f, self.engine)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:1217: in _make_engine
self.handles = get_handle( # type: ignore[call-overload]
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

path_or_buf = 'Orders_and_Payment_Flow_Certification.csv', mode = 'r'

@doc(compression_options=_shared_docs["compression_options"] % "path_or_buf")
def get_handle(
path_or_buf: FilePath | BaseBuffer,
mode: str,
*,
encoding: str | None = None,
compression: CompressionOptions = None,
memory_map: bool = False,
is_text: bool = True,
errors: str | None = None,
storage_options: StorageOptions = None,
) -> IOHandles[str] | IOHandles[bytes]:
"""
Get file handle for given path/buffer and mode.

Parameters
----------
path_or_buf : str or file handle
File path or object.
mode : str
Mode to open path_or_buf with.
encoding : str or None
Encoding to use.
{compression_options}

.. versionchanged:: 1.0.0
May now be a dict with key 'method' as compression mode
and other keys as compression options if compression
mode is 'zip'.

.. versionchanged:: 1.1.0
Passing compression options as keys in dict is now
supported for compression modes 'gzip', 'bz2', 'zstd' and 'zip'.

.. versionchanged:: 1.4.0 Zstandard support.

memory_map : bool, default False
See parsers._parser_params for more information.
is_text : bool, default True
Whether the type of the content passed to the file/buffer is string or
bytes. This is not the same as `"b" not in mode`. If a string content is
passed to a binary file/buffer, a wrapper is inserted.
errors : str, default 'strict'
Specifies how encoding and decoding errors are to be handled.
See the errors argument for :func:`open` for a full list
of options.
storage_options: StorageOptions = None
Passed to _get_filepath_or_buffer

.. versionchanged:: 1.2.0

Returns the dataclass IOHandles
"""
# Windows does not default to utf-8. Set to utf-8 for a consistent behavior
encoding = encoding or "utf-8"

# read_csv does not know whether the buffer is opened in binary/text mode
if _is_binary_mode(path_or_buf, mode) and "b" not in mode:
mode += "b"

# validate encoding and errors
codecs.lookup(encoding)
if isinstance(errors, str):
codecs.lookup_error(errors)

# open URLs
ioargs = _get_filepath_or_buffer(
path_or_buf,
encoding=encoding,
compression=compression,
mode=mode,
storage_options=storage_options,
)

handle = ioargs.filepath_or_buffer
handles: list[BaseBuffer]

# memory mapping needs to be the first step
handle, memory_map, handles = _maybe_memory_map(
handle,
memory_map,
ioargs.encoding,
ioargs.mode,
errors,
ioargs.compression["method"] not in _compression_to_extension,
)

is_path = isinstance(handle, str)
compression_args = dict(ioargs.compression)
compression = compression_args.pop("method")

# Only for write methods
if "r" not in mode and is_path:
check_parent_directory(str(handle))

if compression:
if compression != "zstd":
# compression libraries do not like an explicit text-mode
ioargs.mode = ioargs.mode.replace("t", "")
elif compression == "zstd" and "b" not in ioargs.mode:
# python-zstandard defaults to text mode, but we always expect
# compression libraries to use binary mode.
ioargs.mode += "b"

# GZ Compression
if compression == "gzip":
if is_path:
assert isinstance(handle, str)
# error: Incompatible types in assignment (expression has type
# "GzipFile", variable has type "Union[str, BaseBuffer]")
handle = gzip.GzipFile( # type: ignore[assignment]
filename=handle,
mode=ioargs.mode,
**compression_args,
)
else:
handle = gzip.GzipFile(
# No overload variant of "GzipFile" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
fileobj=handle, # type: ignore[call-overload]
mode=ioargs.mode,
**compression_args,
)

# BZ Compression
elif compression == "bz2":
# No overload variant of "BZ2File" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
handle = bz2.BZ2File( # type: ignore[call-overload]
handle,
mode=ioargs.mode,
**compression_args,
)

# ZIP Compression
elif compression == "zip":
# error: Argument 1 to "_BytesZipFile" has incompatible type "Union[str,
# BaseBuffer]"; expected "Union[Union[str, PathLike[str]],
# ReadBuffer[bytes], WriteBuffer[bytes]]"
handle = _BytesZipFile(
handle, ioargs.mode, **compression_args # type: ignore[arg-type]
)
if handle.mode == "r":
handles.append(handle)
zip_names = handle.namelist()
if len(zip_names) == 1:
handle = handle.open(zip_names.pop())
elif len(zip_names) == 0:
raise ValueError(f"Zero files found in ZIP file {path_or_buf}")
else:
raise ValueError(
"Multiple files found in ZIP file. "
f"Only one file per ZIP: {zip_names}"
)

# XZ Compression
elif compression == "xz":
handle = get_lzma_file()(handle, ioargs.mode)

# Zstd Compression
elif compression == "zstd":
zstd = import_optional_dependency("zstandard")
if "r" in ioargs.mode:
open_args = {"dctx": zstd.ZstdDecompressor(**compression_args)}
else:
open_args = {"cctx": zstd.ZstdCompressor(**compression_args)}
handle = zstd.open(
handle,
mode=ioargs.mode,
**open_args,
)

# Unrecognized Compression
else:
msg = f"Unrecognized compression type: {compression}"
raise ValueError(msg)

assert not isinstance(handle, str)
handles.append(handle)

elif isinstance(handle, str):
# Check whether the filename is to be opened in binary mode.
# Binary mode does not support 'encoding' and 'newline'.
if ioargs.encoding and "b" not in ioargs.mode:
# Encoding
> handle = open(
handle,
ioargs.mode,
encoding=ioargs.encoding,
errors=errors,
newline="",
)
E FileNotFoundError: [Errno 2] No such file or directory: 'Orders_and_Payment_Flow_Certification.csv'

c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\common.py:789: FileNotFoundError
-------------------------------Captured log call--------------------------------
INFO  setup:test_orders_and_payment_flow.py:46 Total URL Present is: 5

self = <test_orders_and_payment_flow.TestOrderAndPaymentFlowCertificationProgram object at 0x0000020BE0D15130>, value = 'T', initialize_pages = None
testdata = {'contact_no': '123456789', 'country': ['in', 'us', 'gb', 'au', 'de', 'sg', ...], 'db_type': 'mysql', 'dynamo_db_type': 'dynamo', ...}

@pytest.mark.test_details("0000","high","Order and Payment Flow","Pradeep")
@pytest.mark.parametrize("value", certification_program_course_read_csv())
def test_Orders_and_Payment_Flow_certification(self,value,initialize_pages,testdata):

'''
Objective: Make payment and validate the data in Dynamo db and mySql

Step 01: get url
Step 02: click on Enroll Now CTA
Step 03: Make payment
Step 04: Validate the Dynamo db and MySql daya for the payment
'''
self.add_rows_in_csv('Report.csv')
url_count = self._count_url_txt_file_subdomain('Orders_and_Payment_Flow_Certification.txt')
logging.info(f"Total URL Present is: {url_count}")

# Step 01: get url
counter = 0
> df = pd.read_csv('Orders_and_Payment_Flow_Certification.csv', on_bad_lines='skip')

test_prod\test_orders_and_payment_flow.py:50:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\util\_decorators.py:311: in wrapper
return func(*args, **kwargs)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:680: in read_csv
return _read(filepath_or_buffer, kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:575: in _read
parser = TextFileReader(filepath_or_buffer, **kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:933: in __init__
self._engine = self._make_engine(f, self.engine)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:1217: in _make_engine
self.handles = get_handle( # type: ignore[call-overload]
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

path_or_buf = 'Orders_and_Payment_Flow_Certification.csv', mode = 'r'

@doc(compression_options=_shared_docs["compression_options"] % "path_or_buf")
def get_handle(
path_or_buf: FilePath | BaseBuffer,
mode: str,
*,
encoding: str | None = None,
compression: CompressionOptions = None,
memory_map: bool = False,
is_text: bool = True,
errors: str | None = None,
storage_options: StorageOptions = None,
) -> IOHandles[str] | IOHandles[bytes]:
"""
Get file handle for given path/buffer and mode.

Parameters
----------
path_or_buf : str or file handle
File path or object.
mode : str
Mode to open path_or_buf with.
encoding : str or None
Encoding to use.
{compression_options}

.. versionchanged:: 1.0.0
May now be a dict with key 'method' as compression mode
and other keys as compression options if compression
mode is 'zip'.

.. versionchanged:: 1.1.0
Passing compression options as keys in dict is now
supported for compression modes 'gzip', 'bz2', 'zstd' and 'zip'.

.. versionchanged:: 1.4.0 Zstandard support.

memory_map : bool, default False
See parsers._parser_params for more information.
is_text : bool, default True
Whether the type of the content passed to the file/buffer is string or
bytes. This is not the same as `"b" not in mode`. If a string content is
passed to a binary file/buffer, a wrapper is inserted.
errors : str, default 'strict'
Specifies how encoding and decoding errors are to be handled.
See the errors argument for :func:`open` for a full list
of options.
storage_options: StorageOptions = None
Passed to _get_filepath_or_buffer

.. versionchanged:: 1.2.0

Returns the dataclass IOHandles
"""
# Windows does not default to utf-8. Set to utf-8 for a consistent behavior
encoding = encoding or "utf-8"

# read_csv does not know whether the buffer is opened in binary/text mode
if _is_binary_mode(path_or_buf, mode) and "b" not in mode:
mode += "b"

# validate encoding and errors
codecs.lookup(encoding)
if isinstance(errors, str):
codecs.lookup_error(errors)

# open URLs
ioargs = _get_filepath_or_buffer(
path_or_buf,
encoding=encoding,
compression=compression,
mode=mode,
storage_options=storage_options,
)

handle = ioargs.filepath_or_buffer
handles: list[BaseBuffer]

# memory mapping needs to be the first step
handle, memory_map, handles = _maybe_memory_map(
handle,
memory_map,
ioargs.encoding,
ioargs.mode,
errors,
ioargs.compression["method"] not in _compression_to_extension,
)

is_path = isinstance(handle, str)
compression_args = dict(ioargs.compression)
compression = compression_args.pop("method")

# Only for write methods
if "r" not in mode and is_path:
check_parent_directory(str(handle))

if compression:
if compression != "zstd":
# compression libraries do not like an explicit text-mode
ioargs.mode = ioargs.mode.replace("t", "")
elif compression == "zstd" and "b" not in ioargs.mode:
# python-zstandard defaults to text mode, but we always expect
# compression libraries to use binary mode.
ioargs.mode += "b"

# GZ Compression
if compression == "gzip":
if is_path:
assert isinstance(handle, str)
# error: Incompatible types in assignment (expression has type
# "GzipFile", variable has type "Union[str, BaseBuffer]")
handle = gzip.GzipFile( # type: ignore[assignment]
filename=handle,
mode=ioargs.mode,
**compression_args,
)
else:
handle = gzip.GzipFile(
# No overload variant of "GzipFile" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
fileobj=handle, # type: ignore[call-overload]
mode=ioargs.mode,
**compression_args,
)

# BZ Compression
elif compression == "bz2":
# No overload variant of "BZ2File" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
handle = bz2.BZ2File( # type: ignore[call-overload]
handle,
mode=ioargs.mode,
**compression_args,
)

# ZIP Compression
elif compression == "zip":
# error: Argument 1 to "_BytesZipFile" has incompatible type "Union[str,
# BaseBuffer]"; expected "Union[Union[str, PathLike[str]],
# ReadBuffer[bytes], WriteBuffer[bytes]]"
handle = _BytesZipFile(
handle, ioargs.mode, **compression_args # type: ignore[arg-type]
)
if handle.mode == "r":
handles.append(handle)
zip_names = handle.namelist()
if len(zip_names) == 1:
handle = handle.open(zip_names.pop())
elif len(zip_names) == 0:
raise ValueError(f"Zero files found in ZIP file {path_or_buf}")
else:
raise ValueError(
"Multiple files found in ZIP file. "
f"Only one file per ZIP: {zip_names}"
)

# XZ Compression
elif compression == "xz":
handle = get_lzma_file()(handle, ioargs.mode)

# Zstd Compression
elif compression == "zstd":
zstd = import_optional_dependency("zstandard")
if "r" in ioargs.mode:
open_args = {"dctx": zstd.ZstdDecompressor(**compression_args)}
else:
open_args = {"cctx": zstd.ZstdCompressor(**compression_args)}
handle = zstd.open(
handle,
mode=ioargs.mode,
**open_args,
)

# Unrecognized Compression
else:
msg = f"Unrecognized compression type: {compression}"
raise ValueError(msg)

assert not isinstance(handle, str)
handles.append(handle)

elif isinstance(handle, str):
# Check whether the filename is to be opened in binary mode.
# Binary mode does not support 'encoding' and 'newline'.
if ioargs.encoding and "b" not in ioargs.mode:
# Encoding
> handle = open(
handle,
ioargs.mode,
encoding=ioargs.encoding,
errors=errors,
newline="",
)
E FileNotFoundError: [Errno 2] No such file or directory: 'Orders_and_Payment_Flow_Certification.csv'

c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\common.py:789: FileNotFoundError
-------------------------------Captured log call--------------------------------
INFO  setup:test_orders_and_payment_flow.py:46 Total URL Present is: 5

self = <test_orders_and_payment_flow.TestOrderAndPaymentFlowCertificationProgram object at 0x0000020BE13C39A0>, value = 'U', initialize_pages = None
testdata = {'contact_no': '123456789', 'country': ['in', 'us', 'gb', 'au', 'de', 'sg', ...], 'db_type': 'mysql', 'dynamo_db_type': 'dynamo', ...}

@pytest.mark.test_details("0000","high","Order and Payment Flow","Pradeep")
@pytest.mark.parametrize("value", certification_program_course_read_csv())
def test_Orders_and_Payment_Flow_certification(self,value,initialize_pages,testdata):

'''
Objective: Make payment and validate the data in Dynamo db and mySql

Step 01: get url
Step 02: click on Enroll Now CTA
Step 03: Make payment
Step 04: Validate the Dynamo db and MySql daya for the payment
'''
self.add_rows_in_csv('Report.csv')
url_count = self._count_url_txt_file_subdomain('Orders_and_Payment_Flow_Certification.txt')
logging.info(f"Total URL Present is: {url_count}")

# Step 01: get url
counter = 0
> df = pd.read_csv('Orders_and_Payment_Flow_Certification.csv', on_bad_lines='skip')

test_prod\test_orders_and_payment_flow.py:50:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\util\_decorators.py:311: in wrapper
return func(*args, **kwargs)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:680: in read_csv
return _read(filepath_or_buffer, kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:575: in _read
parser = TextFileReader(filepath_or_buffer, **kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:933: in __init__
self._engine = self._make_engine(f, self.engine)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:1217: in _make_engine
self.handles = get_handle( # type: ignore[call-overload]
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

path_or_buf = 'Orders_and_Payment_Flow_Certification.csv', mode = 'r'

@doc(compression_options=_shared_docs["compression_options"] % "path_or_buf")
def get_handle(
path_or_buf: FilePath | BaseBuffer,
mode: str,
*,
encoding: str | None = None,
compression: CompressionOptions = None,
memory_map: bool = False,
is_text: bool = True,
errors: str | None = None,
storage_options: StorageOptions = None,
) -> IOHandles[str] | IOHandles[bytes]:
"""
Get file handle for given path/buffer and mode.

Parameters
----------
path_or_buf : str or file handle
File path or object.
mode : str
Mode to open path_or_buf with.
encoding : str or None
Encoding to use.
{compression_options}

.. versionchanged:: 1.0.0
May now be a dict with key 'method' as compression mode
and other keys as compression options if compression
mode is 'zip'.

.. versionchanged:: 1.1.0
Passing compression options as keys in dict is now
supported for compression modes 'gzip', 'bz2', 'zstd' and 'zip'.

.. versionchanged:: 1.4.0 Zstandard support.

memory_map : bool, default False
See parsers._parser_params for more information.
is_text : bool, default True
Whether the type of the content passed to the file/buffer is string or
bytes. This is not the same as `"b" not in mode`. If a string content is
passed to a binary file/buffer, a wrapper is inserted.
errors : str, default 'strict'
Specifies how encoding and decoding errors are to be handled.
See the errors argument for :func:`open` for a full list
of options.
storage_options: StorageOptions = None
Passed to _get_filepath_or_buffer

.. versionchanged:: 1.2.0

Returns the dataclass IOHandles
"""
# Windows does not default to utf-8. Set to utf-8 for a consistent behavior
encoding = encoding or "utf-8"

# read_csv does not know whether the buffer is opened in binary/text mode
if _is_binary_mode(path_or_buf, mode) and "b" not in mode:
mode += "b"

# validate encoding and errors
codecs.lookup(encoding)
if isinstance(errors, str):
codecs.lookup_error(errors)

# open URLs
ioargs = _get_filepath_or_buffer(
path_or_buf,
encoding=encoding,
compression=compression,
mode=mode,
storage_options=storage_options,
)

handle = ioargs.filepath_or_buffer
handles: list[BaseBuffer]

# memory mapping needs to be the first step
handle, memory_map, handles = _maybe_memory_map(
handle,
memory_map,
ioargs.encoding,
ioargs.mode,
errors,
ioargs.compression["method"] not in _compression_to_extension,
)

is_path = isinstance(handle, str)
compression_args = dict(ioargs.compression)
compression = compression_args.pop("method")

# Only for write methods
if "r" not in mode and is_path:
check_parent_directory(str(handle))

if compression:
if compression != "zstd":
# compression libraries do not like an explicit text-mode
ioargs.mode = ioargs.mode.replace("t", "")
elif compression == "zstd" and "b" not in ioargs.mode:
# python-zstandard defaults to text mode, but we always expect
# compression libraries to use binary mode.
ioargs.mode += "b"

# GZ Compression
if compression == "gzip":
if is_path:
assert isinstance(handle, str)
# error: Incompatible types in assignment (expression has type
# "GzipFile", variable has type "Union[str, BaseBuffer]")
handle = gzip.GzipFile( # type: ignore[assignment]
filename=handle,
mode=ioargs.mode,
**compression_args,
)
else:
handle = gzip.GzipFile(
# No overload variant of "GzipFile" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
fileobj=handle, # type: ignore[call-overload]
mode=ioargs.mode,
**compression_args,
)

# BZ Compression
elif compression == "bz2":
# No overload variant of "BZ2File" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
handle = bz2.BZ2File( # type: ignore[call-overload]
handle,
mode=ioargs.mode,
**compression_args,
)

# ZIP Compression
elif compression == "zip":
# error: Argument 1 to "_BytesZipFile" has incompatible type "Union[str,
# BaseBuffer]"; expected "Union[Union[str, PathLike[str]],
# ReadBuffer[bytes], WriteBuffer[bytes]]"
handle = _BytesZipFile(
handle, ioargs.mode, **compression_args # type: ignore[arg-type]
)
if handle.mode == "r":
handles.append(handle)
zip_names = handle.namelist()
if len(zip_names) == 1:
handle = handle.open(zip_names.pop())
elif len(zip_names) == 0:
raise ValueError(f"Zero files found in ZIP file {path_or_buf}")
else:
raise ValueError(
"Multiple files found in ZIP file. "
f"Only one file per ZIP: {zip_names}"
)

# XZ Compression
elif compression == "xz":
handle = get_lzma_file()(handle, ioargs.mode)

# Zstd Compression
elif compression == "zstd":
zstd = import_optional_dependency("zstandard")
if "r" in ioargs.mode:
open_args = {"dctx": zstd.ZstdDecompressor(**compression_args)}
else:
open_args = {"cctx": zstd.ZstdCompressor(**compression_args)}
handle = zstd.open(
handle,
mode=ioargs.mode,
**open_args,
)

# Unrecognized Compression
else:
msg = f"Unrecognized compression type: {compression}"
raise ValueError(msg)

assert not isinstance(handle, str)
handles.append(handle)

elif isinstance(handle, str):
# Check whether the filename is to be opened in binary mode.
# Binary mode does not support 'encoding' and 'newline'.
if ioargs.encoding and "b" not in ioargs.mode:
# Encoding
> handle = open(
handle,
ioargs.mode,
encoding=ioargs.encoding,
errors=errors,
newline="",
)
E FileNotFoundError: [Errno 2] No such file or directory: 'Orders_and_Payment_Flow_Certification.csv'

c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\common.py:789: FileNotFoundError
-------------------------------Captured log call--------------------------------
INFO  setup:test_orders_and_payment_flow.py:46 Total URL Present is: 5

self = <test_orders_and_payment_flow.TestOrderAndPaymentFlowCertificationProgram object at 0x0000020BE13D54C0>, value = 'V', initialize_pages = None
testdata = {'contact_no': '123456789', 'country': ['in', 'us', 'gb', 'au', 'de', 'sg', ...], 'db_type': 'mysql', 'dynamo_db_type': 'dynamo', ...}

@pytest.mark.test_details("0000","high","Order and Payment Flow","Pradeep")
@pytest.mark.parametrize("value", certification_program_course_read_csv())
def test_Orders_and_Payment_Flow_certification(self,value,initialize_pages,testdata):

'''
Objective: Make payment and validate the data in Dynamo db and mySql

Step 01: get url
Step 02: click on Enroll Now CTA
Step 03: Make payment
Step 04: Validate the Dynamo db and MySql daya for the payment
'''
self.add_rows_in_csv('Report.csv')
url_count = self._count_url_txt_file_subdomain('Orders_and_Payment_Flow_Certification.txt')
logging.info(f"Total URL Present is: {url_count}")

# Step 01: get url
counter = 0
> df = pd.read_csv('Orders_and_Payment_Flow_Certification.csv', on_bad_lines='skip')

test_prod\test_orders_and_payment_flow.py:50:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\util\_decorators.py:311: in wrapper
return func(*args, **kwargs)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:680: in read_csv
return _read(filepath_or_buffer, kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:575: in _read
parser = TextFileReader(filepath_or_buffer, **kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:933: in __init__
self._engine = self._make_engine(f, self.engine)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:1217: in _make_engine
self.handles = get_handle( # type: ignore[call-overload]
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

path_or_buf = 'Orders_and_Payment_Flow_Certification.csv', mode = 'r'

@doc(compression_options=_shared_docs["compression_options"] % "path_or_buf")
def get_handle(
path_or_buf: FilePath | BaseBuffer,
mode: str,
*,
encoding: str | None = None,
compression: CompressionOptions = None,
memory_map: bool = False,
is_text: bool = True,
errors: str | None = None,
storage_options: StorageOptions = None,
) -> IOHandles[str] | IOHandles[bytes]:
"""
Get file handle for given path/buffer and mode.

Parameters
----------
path_or_buf : str or file handle
File path or object.
mode : str
Mode to open path_or_buf with.
encoding : str or None
Encoding to use.
{compression_options}

.. versionchanged:: 1.0.0
May now be a dict with key 'method' as compression mode
and other keys as compression options if compression
mode is 'zip'.

.. versionchanged:: 1.1.0
Passing compression options as keys in dict is now
supported for compression modes 'gzip', 'bz2', 'zstd' and 'zip'.

.. versionchanged:: 1.4.0 Zstandard support.

memory_map : bool, default False
See parsers._parser_params for more information.
is_text : bool, default True
Whether the type of the content passed to the file/buffer is string or
bytes. This is not the same as `"b" not in mode`. If a string content is
passed to a binary file/buffer, a wrapper is inserted.
errors : str, default 'strict'
Specifies how encoding and decoding errors are to be handled.
See the errors argument for :func:`open` for a full list
of options.
storage_options: StorageOptions = None
Passed to _get_filepath_or_buffer

.. versionchanged:: 1.2.0

Returns the dataclass IOHandles
"""
# Windows does not default to utf-8. Set to utf-8 for a consistent behavior
encoding = encoding or "utf-8"

# read_csv does not know whether the buffer is opened in binary/text mode
if _is_binary_mode(path_or_buf, mode) and "b" not in mode:
mode += "b"

# validate encoding and errors
codecs.lookup(encoding)
if isinstance(errors, str):
codecs.lookup_error(errors)

# open URLs
ioargs = _get_filepath_or_buffer(
path_or_buf,
encoding=encoding,
compression=compression,
mode=mode,
storage_options=storage_options,
)

handle = ioargs.filepath_or_buffer
handles: list[BaseBuffer]

# memory mapping needs to be the first step
handle, memory_map, handles = _maybe_memory_map(
handle,
memory_map,
ioargs.encoding,
ioargs.mode,
errors,
ioargs.compression["method"] not in _compression_to_extension,
)

is_path = isinstance(handle, str)
compression_args = dict(ioargs.compression)
compression = compression_args.pop("method")

# Only for write methods
if "r" not in mode and is_path:
check_parent_directory(str(handle))

if compression:
if compression != "zstd":
# compression libraries do not like an explicit text-mode
ioargs.mode = ioargs.mode.replace("t", "")
elif compression == "zstd" and "b" not in ioargs.mode:
# python-zstandard defaults to text mode, but we always expect
# compression libraries to use binary mode.
ioargs.mode += "b"

# GZ Compression
if compression == "gzip":
if is_path:
assert isinstance(handle, str)
# error: Incompatible types in assignment (expression has type
# "GzipFile", variable has type "Union[str, BaseBuffer]")
handle = gzip.GzipFile( # type: ignore[assignment]
filename=handle,
mode=ioargs.mode,
**compression_args,
)
else:
handle = gzip.GzipFile(
# No overload variant of "GzipFile" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
fileobj=handle, # type: ignore[call-overload]
mode=ioargs.mode,
**compression_args,
)

# BZ Compression
elif compression == "bz2":
# No overload variant of "BZ2File" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
handle = bz2.BZ2File( # type: ignore[call-overload]
handle,
mode=ioargs.mode,
**compression_args,
)

# ZIP Compression
elif compression == "zip":
# error: Argument 1 to "_BytesZipFile" has incompatible type "Union[str,
# BaseBuffer]"; expected "Union[Union[str, PathLike[str]],
# ReadBuffer[bytes], WriteBuffer[bytes]]"
handle = _BytesZipFile(
handle, ioargs.mode, **compression_args # type: ignore[arg-type]
)
if handle.mode == "r":
handles.append(handle)
zip_names = handle.namelist()
if len(zip_names) == 1:
handle = handle.open(zip_names.pop())
elif len(zip_names) == 0:
raise ValueError(f"Zero files found in ZIP file {path_or_buf}")
else:
raise ValueError(
"Multiple files found in ZIP file. "
f"Only one file per ZIP: {zip_names}"
)

# XZ Compression
elif compression == "xz":
handle = get_lzma_file()(handle, ioargs.mode)

# Zstd Compression
elif compression == "zstd":
zstd = import_optional_dependency("zstandard")
if "r" in ioargs.mode:
open_args = {"dctx": zstd.ZstdDecompressor(**compression_args)}
else:
open_args = {"cctx": zstd.ZstdCompressor(**compression_args)}
handle = zstd.open(
handle,
mode=ioargs.mode,
**open_args,
)

# Unrecognized Compression
else:
msg = f"Unrecognized compression type: {compression}"
raise ValueError(msg)

assert not isinstance(handle, str)
handles.append(handle)

elif isinstance(handle, str):
# Check whether the filename is to be opened in binary mode.
# Binary mode does not support 'encoding' and 'newline'.
if ioargs.encoding and "b" not in ioargs.mode:
# Encoding
> handle = open(
handle,
ioargs.mode,
encoding=ioargs.encoding,
errors=errors,
newline="",
)
E FileNotFoundError: [Errno 2] No such file or directory: 'Orders_and_Payment_Flow_Certification.csv'

c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\common.py:789: FileNotFoundError
-------------------------------Captured log call--------------------------------
INFO  setup:test_orders_and_payment_flow.py:46 Total URL Present is: 5

self = <test_orders_and_payment_flow.TestOrderAndPaymentFlowCertificationProgram object at 0x0000020BE0FC4C40>, value = 'W', initialize_pages = None
testdata = {'contact_no': '123456789', 'country': ['in', 'us', 'gb', 'au', 'de', 'sg', ...], 'db_type': 'mysql', 'dynamo_db_type': 'dynamo', ...}

@pytest.mark.test_details("0000","high","Order and Payment Flow","Pradeep")
@pytest.mark.parametrize("value", certification_program_course_read_csv())
def test_Orders_and_Payment_Flow_certification(self,value,initialize_pages,testdata):

'''
Objective: Make payment and validate the data in Dynamo db and mySql

Step 01: get url
Step 02: click on Enroll Now CTA
Step 03: Make payment
Step 04: Validate the Dynamo db and MySql daya for the payment
'''
self.add_rows_in_csv('Report.csv')
url_count = self._count_url_txt_file_subdomain('Orders_and_Payment_Flow_Certification.txt')
logging.info(f"Total URL Present is: {url_count}")

# Step 01: get url
counter = 0
> df = pd.read_csv('Orders_and_Payment_Flow_Certification.csv', on_bad_lines='skip')

test_prod\test_orders_and_payment_flow.py:50:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\util\_decorators.py:311: in wrapper
return func(*args, **kwargs)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:680: in read_csv
return _read(filepath_or_buffer, kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:575: in _read
parser = TextFileReader(filepath_or_buffer, **kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:933: in __init__
self._engine = self._make_engine(f, self.engine)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:1217: in _make_engine
self.handles = get_handle( # type: ignore[call-overload]
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

path_or_buf = 'Orders_and_Payment_Flow_Certification.csv', mode = 'r'

@doc(compression_options=_shared_docs["compression_options"] % "path_or_buf")
def get_handle(
path_or_buf: FilePath | BaseBuffer,
mode: str,
*,
encoding: str | None = None,
compression: CompressionOptions = None,
memory_map: bool = False,
is_text: bool = True,
errors: str | None = None,
storage_options: StorageOptions = None,
) -> IOHandles[str] | IOHandles[bytes]:
"""
Get file handle for given path/buffer and mode.

Parameters
----------
path_or_buf : str or file handle
File path or object.
mode : str
Mode to open path_or_buf with.
encoding : str or None
Encoding to use.
{compression_options}

.. versionchanged:: 1.0.0
May now be a dict with key 'method' as compression mode
and other keys as compression options if compression
mode is 'zip'.

.. versionchanged:: 1.1.0
Passing compression options as keys in dict is now
supported for compression modes 'gzip', 'bz2', 'zstd' and 'zip'.

.. versionchanged:: 1.4.0 Zstandard support.

memory_map : bool, default False
See parsers._parser_params for more information.
is_text : bool, default True
Whether the type of the content passed to the file/buffer is string or
bytes. This is not the same as `"b" not in mode`. If a string content is
passed to a binary file/buffer, a wrapper is inserted.
errors : str, default 'strict'
Specifies how encoding and decoding errors are to be handled.
See the errors argument for :func:`open` for a full list
of options.
storage_options: StorageOptions = None
Passed to _get_filepath_or_buffer

.. versionchanged:: 1.2.0

Returns the dataclass IOHandles
"""
# Windows does not default to utf-8. Set to utf-8 for a consistent behavior
encoding = encoding or "utf-8"

# read_csv does not know whether the buffer is opened in binary/text mode
if _is_binary_mode(path_or_buf, mode) and "b" not in mode:
mode += "b"

# validate encoding and errors
codecs.lookup(encoding)
if isinstance(errors, str):
codecs.lookup_error(errors)

# open URLs
ioargs = _get_filepath_or_buffer(
path_or_buf,
encoding=encoding,
compression=compression,
mode=mode,
storage_options=storage_options,
)

handle = ioargs.filepath_or_buffer
handles: list[BaseBuffer]

# memory mapping needs to be the first step
handle, memory_map, handles = _maybe_memory_map(
handle,
memory_map,
ioargs.encoding,
ioargs.mode,
errors,
ioargs.compression["method"] not in _compression_to_extension,
)

is_path = isinstance(handle, str)
compression_args = dict(ioargs.compression)
compression = compression_args.pop("method")

# Only for write methods
if "r" not in mode and is_path:
check_parent_directory(str(handle))

if compression:
if compression != "zstd":
# compression libraries do not like an explicit text-mode
ioargs.mode = ioargs.mode.replace("t", "")
elif compression == "zstd" and "b" not in ioargs.mode:
# python-zstandard defaults to text mode, but we always expect
# compression libraries to use binary mode.
ioargs.mode += "b"

# GZ Compression
if compression == "gzip":
if is_path:
assert isinstance(handle, str)
# error: Incompatible types in assignment (expression has type
# "GzipFile", variable has type "Union[str, BaseBuffer]")
handle = gzip.GzipFile( # type: ignore[assignment]
filename=handle,
mode=ioargs.mode,
**compression_args,
)
else:
handle = gzip.GzipFile(
# No overload variant of "GzipFile" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
fileobj=handle, # type: ignore[call-overload]
mode=ioargs.mode,
**compression_args,
)

# BZ Compression
elif compression == "bz2":
# No overload variant of "BZ2File" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
handle = bz2.BZ2File( # type: ignore[call-overload]
handle,
mode=ioargs.mode,
**compression_args,
)

# ZIP Compression
elif compression == "zip":
# error: Argument 1 to "_BytesZipFile" has incompatible type "Union[str,
# BaseBuffer]"; expected "Union[Union[str, PathLike[str]],
# ReadBuffer[bytes], WriteBuffer[bytes]]"
handle = _BytesZipFile(
handle, ioargs.mode, **compression_args # type: ignore[arg-type]
)
if handle.mode == "r":
handles.append(handle)
zip_names = handle.namelist()
if len(zip_names) == 1:
handle = handle.open(zip_names.pop())
elif len(zip_names) == 0:
raise ValueError(f"Zero files found in ZIP file {path_or_buf}")
else:
raise ValueError(
"Multiple files found in ZIP file. "
f"Only one file per ZIP: {zip_names}"
)

# XZ Compression
elif compression == "xz":
handle = get_lzma_file()(handle, ioargs.mode)

# Zstd Compression
elif compression == "zstd":
zstd = import_optional_dependency("zstandard")
if "r" in ioargs.mode:
open_args = {"dctx": zstd.ZstdDecompressor(**compression_args)}
else:
open_args = {"cctx": zstd.ZstdCompressor(**compression_args)}
handle = zstd.open(
handle,
mode=ioargs.mode,
**open_args,
)

# Unrecognized Compression
else:
msg = f"Unrecognized compression type: {compression}"
raise ValueError(msg)

assert not isinstance(handle, str)
handles.append(handle)

elif isinstance(handle, str):
# Check whether the filename is to be opened in binary mode.
# Binary mode does not support 'encoding' and 'newline'.
if ioargs.encoding and "b" not in ioargs.mode:
# Encoding
> handle = open(
handle,
ioargs.mode,
encoding=ioargs.encoding,
errors=errors,
newline="",
)
E FileNotFoundError: [Errno 2] No such file or directory: 'Orders_and_Payment_Flow_Certification.csv'

c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\common.py:789: FileNotFoundError
-------------------------------Captured log call--------------------------------
INFO  setup:test_orders_and_payment_flow.py:46 Total URL Present is: 5

self = <test_orders_and_payment_flow.TestOrderAndPaymentFlowCertificationProgram object at 0x0000020BE10B1EB0>, value = 'X', initialize_pages = None
testdata = {'contact_no': '123456789', 'country': ['in', 'us', 'gb', 'au', 'de', 'sg', ...], 'db_type': 'mysql', 'dynamo_db_type': 'dynamo', ...}

@pytest.mark.test_details("0000","high","Order and Payment Flow","Pradeep")
@pytest.mark.parametrize("value", certification_program_course_read_csv())
def test_Orders_and_Payment_Flow_certification(self,value,initialize_pages,testdata):

'''
Objective: Make payment and validate the data in Dynamo db and mySql

Step 01: get url
Step 02: click on Enroll Now CTA
Step 03: Make payment
Step 04: Validate the Dynamo db and MySql daya for the payment
'''
self.add_rows_in_csv('Report.csv')
url_count = self._count_url_txt_file_subdomain('Orders_and_Payment_Flow_Certification.txt')
logging.info(f"Total URL Present is: {url_count}")

# Step 01: get url
counter = 0
> df = pd.read_csv('Orders_and_Payment_Flow_Certification.csv', on_bad_lines='skip')

test_prod\test_orders_and_payment_flow.py:50:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\util\_decorators.py:311: in wrapper
return func(*args, **kwargs)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:680: in read_csv
return _read(filepath_or_buffer, kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:575: in _read
parser = TextFileReader(filepath_or_buffer, **kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:933: in __init__
self._engine = self._make_engine(f, self.engine)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:1217: in _make_engine
self.handles = get_handle( # type: ignore[call-overload]
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

path_or_buf = 'Orders_and_Payment_Flow_Certification.csv', mode = 'r'

@doc(compression_options=_shared_docs["compression_options"] % "path_or_buf")
def get_handle(
path_or_buf: FilePath | BaseBuffer,
mode: str,
*,
encoding: str | None = None,
compression: CompressionOptions = None,
memory_map: bool = False,
is_text: bool = True,
errors: str | None = None,
storage_options: StorageOptions = None,
) -> IOHandles[str] | IOHandles[bytes]:
"""
Get file handle for given path/buffer and mode.

Parameters
----------
path_or_buf : str or file handle
File path or object.
mode : str
Mode to open path_or_buf with.
encoding : str or None
Encoding to use.
{compression_options}

.. versionchanged:: 1.0.0
May now be a dict with key 'method' as compression mode
and other keys as compression options if compression
mode is 'zip'.

.. versionchanged:: 1.1.0
Passing compression options as keys in dict is now
supported for compression modes 'gzip', 'bz2', 'zstd' and 'zip'.

.. versionchanged:: 1.4.0 Zstandard support.

memory_map : bool, default False
See parsers._parser_params for more information.
is_text : bool, default True
Whether the type of the content passed to the file/buffer is string or
bytes. This is not the same as `"b" not in mode`. If a string content is
passed to a binary file/buffer, a wrapper is inserted.
errors : str, default 'strict'
Specifies how encoding and decoding errors are to be handled.
See the errors argument for :func:`open` for a full list
of options.
storage_options: StorageOptions = None
Passed to _get_filepath_or_buffer

.. versionchanged:: 1.2.0

Returns the dataclass IOHandles
"""
# Windows does not default to utf-8. Set to utf-8 for a consistent behavior
encoding = encoding or "utf-8"

# read_csv does not know whether the buffer is opened in binary/text mode
if _is_binary_mode(path_or_buf, mode) and "b" not in mode:
mode += "b"

# validate encoding and errors
codecs.lookup(encoding)
if isinstance(errors, str):
codecs.lookup_error(errors)

# open URLs
ioargs = _get_filepath_or_buffer(
path_or_buf,
encoding=encoding,
compression=compression,
mode=mode,
storage_options=storage_options,
)

handle = ioargs.filepath_or_buffer
handles: list[BaseBuffer]

# memory mapping needs to be the first step
handle, memory_map, handles = _maybe_memory_map(
handle,
memory_map,
ioargs.encoding,
ioargs.mode,
errors,
ioargs.compression["method"] not in _compression_to_extension,
)

is_path = isinstance(handle, str)
compression_args = dict(ioargs.compression)
compression = compression_args.pop("method")

# Only for write methods
if "r" not in mode and is_path:
check_parent_directory(str(handle))

if compression:
if compression != "zstd":
# compression libraries do not like an explicit text-mode
ioargs.mode = ioargs.mode.replace("t", "")
elif compression == "zstd" and "b" not in ioargs.mode:
# python-zstandard defaults to text mode, but we always expect
# compression libraries to use binary mode.
ioargs.mode += "b"

# GZ Compression
if compression == "gzip":
if is_path:
assert isinstance(handle, str)
# error: Incompatible types in assignment (expression has type
# "GzipFile", variable has type "Union[str, BaseBuffer]")
handle = gzip.GzipFile( # type: ignore[assignment]
filename=handle,
mode=ioargs.mode,
**compression_args,
)
else:
handle = gzip.GzipFile(
# No overload variant of "GzipFile" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
fileobj=handle, # type: ignore[call-overload]
mode=ioargs.mode,
**compression_args,
)

# BZ Compression
elif compression == "bz2":
# No overload variant of "BZ2File" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
handle = bz2.BZ2File( # type: ignore[call-overload]
handle,
mode=ioargs.mode,
**compression_args,
)

# ZIP Compression
elif compression == "zip":
# error: Argument 1 to "_BytesZipFile" has incompatible type "Union[str,
# BaseBuffer]"; expected "Union[Union[str, PathLike[str]],
# ReadBuffer[bytes], WriteBuffer[bytes]]"
handle = _BytesZipFile(
handle, ioargs.mode, **compression_args # type: ignore[arg-type]
)
if handle.mode == "r":
handles.append(handle)
zip_names = handle.namelist()
if len(zip_names) == 1:
handle = handle.open(zip_names.pop())
elif len(zip_names) == 0:
raise ValueError(f"Zero files found in ZIP file {path_or_buf}")
else:
raise ValueError(
"Multiple files found in ZIP file. "
f"Only one file per ZIP: {zip_names}"
)

# XZ Compression
elif compression == "xz":
handle = get_lzma_file()(handle, ioargs.mode)

# Zstd Compression
elif compression == "zstd":
zstd = import_optional_dependency("zstandard")
if "r" in ioargs.mode:
open_args = {"dctx": zstd.ZstdDecompressor(**compression_args)}
else:
open_args = {"cctx": zstd.ZstdCompressor(**compression_args)}
handle = zstd.open(
handle,
mode=ioargs.mode,
**open_args,
)

# Unrecognized Compression
else:
msg = f"Unrecognized compression type: {compression}"
raise ValueError(msg)

assert not isinstance(handle, str)
handles.append(handle)

elif isinstance(handle, str):
# Check whether the filename is to be opened in binary mode.
# Binary mode does not support 'encoding' and 'newline'.
if ioargs.encoding and "b" not in ioargs.mode:
# Encoding
> handle = open(
handle,
ioargs.mode,
encoding=ioargs.encoding,
errors=errors,
newline="",
)
E FileNotFoundError: [Errno 2] No such file or directory: 'Orders_and_Payment_Flow_Certification.csv'

c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\common.py:789: FileNotFoundError
-------------------------------Captured log call--------------------------------
INFO  setup:test_orders_and_payment_flow.py:46 Total URL Present is: 5

self = <test_orders_and_payment_flow.TestOrderAndPaymentFlowCertificationProgram object at 0x0000020BE10C5850>, value = 'Y', initialize_pages = None
testdata = {'contact_no': '123456789', 'country': ['in', 'us', 'gb', 'au', 'de', 'sg', ...], 'db_type': 'mysql', 'dynamo_db_type': 'dynamo', ...}

@pytest.mark.test_details("0000","high","Order and Payment Flow","Pradeep")
@pytest.mark.parametrize("value", certification_program_course_read_csv())
def test_Orders_and_Payment_Flow_certification(self,value,initialize_pages,testdata):

'''
Objective: Make payment and validate the data in Dynamo db and mySql

Step 01: get url
Step 02: click on Enroll Now CTA
Step 03: Make payment
Step 04: Validate the Dynamo db and MySql daya for the payment
'''
self.add_rows_in_csv('Report.csv')
url_count = self._count_url_txt_file_subdomain('Orders_and_Payment_Flow_Certification.txt')
logging.info(f"Total URL Present is: {url_count}")

# Step 01: get url
counter = 0
> df = pd.read_csv('Orders_and_Payment_Flow_Certification.csv', on_bad_lines='skip')

test_prod\test_orders_and_payment_flow.py:50:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\util\_decorators.py:311: in wrapper
return func(*args, **kwargs)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:680: in read_csv
return _read(filepath_or_buffer, kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:575: in _read
parser = TextFileReader(filepath_or_buffer, **kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:933: in __init__
self._engine = self._make_engine(f, self.engine)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:1217: in _make_engine
self.handles = get_handle( # type: ignore[call-overload]
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

path_or_buf = 'Orders_and_Payment_Flow_Certification.csv', mode = 'r'

@doc(compression_options=_shared_docs["compression_options"] % "path_or_buf")
def get_handle(
path_or_buf: FilePath | BaseBuffer,
mode: str,
*,
encoding: str | None = None,
compression: CompressionOptions = None,
memory_map: bool = False,
is_text: bool = True,
errors: str | None = None,
storage_options: StorageOptions = None,
) -> IOHandles[str] | IOHandles[bytes]:
"""
Get file handle for given path/buffer and mode.

Parameters
----------
path_or_buf : str or file handle
File path or object.
mode : str
Mode to open path_or_buf with.
encoding : str or None
Encoding to use.
{compression_options}

.. versionchanged:: 1.0.0
May now be a dict with key 'method' as compression mode
and other keys as compression options if compression
mode is 'zip'.

.. versionchanged:: 1.1.0
Passing compression options as keys in dict is now
supported for compression modes 'gzip', 'bz2', 'zstd' and 'zip'.

.. versionchanged:: 1.4.0 Zstandard support.

memory_map : bool, default False
See parsers._parser_params for more information.
is_text : bool, default True
Whether the type of the content passed to the file/buffer is string or
bytes. This is not the same as `"b" not in mode`. If a string content is
passed to a binary file/buffer, a wrapper is inserted.
errors : str, default 'strict'
Specifies how encoding and decoding errors are to be handled.
See the errors argument for :func:`open` for a full list
of options.
storage_options: StorageOptions = None
Passed to _get_filepath_or_buffer

.. versionchanged:: 1.2.0

Returns the dataclass IOHandles
"""
# Windows does not default to utf-8. Set to utf-8 for a consistent behavior
encoding = encoding or "utf-8"

# read_csv does not know whether the buffer is opened in binary/text mode
if _is_binary_mode(path_or_buf, mode) and "b" not in mode:
mode += "b"

# validate encoding and errors
codecs.lookup(encoding)
if isinstance(errors, str):
codecs.lookup_error(errors)

# open URLs
ioargs = _get_filepath_or_buffer(
path_or_buf,
encoding=encoding,
compression=compression,
mode=mode,
storage_options=storage_options,
)

handle = ioargs.filepath_or_buffer
handles: list[BaseBuffer]

# memory mapping needs to be the first step
handle, memory_map, handles = _maybe_memory_map(
handle,
memory_map,
ioargs.encoding,
ioargs.mode,
errors,
ioargs.compression["method"] not in _compression_to_extension,
)

is_path = isinstance(handle, str)
compression_args = dict(ioargs.compression)
compression = compression_args.pop("method")

# Only for write methods
if "r" not in mode and is_path:
check_parent_directory(str(handle))

if compression:
if compression != "zstd":
# compression libraries do not like an explicit text-mode
ioargs.mode = ioargs.mode.replace("t", "")
elif compression == "zstd" and "b" not in ioargs.mode:
# python-zstandard defaults to text mode, but we always expect
# compression libraries to use binary mode.
ioargs.mode += "b"

# GZ Compression
if compression == "gzip":
if is_path:
assert isinstance(handle, str)
# error: Incompatible types in assignment (expression has type
# "GzipFile", variable has type "Union[str, BaseBuffer]")
handle = gzip.GzipFile( # type: ignore[assignment]
filename=handle,
mode=ioargs.mode,
**compression_args,
)
else:
handle = gzip.GzipFile(
# No overload variant of "GzipFile" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
fileobj=handle, # type: ignore[call-overload]
mode=ioargs.mode,
**compression_args,
)

# BZ Compression
elif compression == "bz2":
# No overload variant of "BZ2File" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
handle = bz2.BZ2File( # type: ignore[call-overload]
handle,
mode=ioargs.mode,
**compression_args,
)

# ZIP Compression
elif compression == "zip":
# error: Argument 1 to "_BytesZipFile" has incompatible type "Union[str,
# BaseBuffer]"; expected "Union[Union[str, PathLike[str]],
# ReadBuffer[bytes], WriteBuffer[bytes]]"
handle = _BytesZipFile(
handle, ioargs.mode, **compression_args # type: ignore[arg-type]
)
if handle.mode == "r":
handles.append(handle)
zip_names = handle.namelist()
if len(zip_names) == 1:
handle = handle.open(zip_names.pop())
elif len(zip_names) == 0:
raise ValueError(f"Zero files found in ZIP file {path_or_buf}")
else:
raise ValueError(
"Multiple files found in ZIP file. "
f"Only one file per ZIP: {zip_names}"
)

# XZ Compression
elif compression == "xz":
handle = get_lzma_file()(handle, ioargs.mode)

# Zstd Compression
elif compression == "zstd":
zstd = import_optional_dependency("zstandard")
if "r" in ioargs.mode:
open_args = {"dctx": zstd.ZstdDecompressor(**compression_args)}
else:
open_args = {"cctx": zstd.ZstdCompressor(**compression_args)}
handle = zstd.open(
handle,
mode=ioargs.mode,
**open_args,
)

# Unrecognized Compression
else:
msg = f"Unrecognized compression type: {compression}"
raise ValueError(msg)

assert not isinstance(handle, str)
handles.append(handle)

elif isinstance(handle, str):
# Check whether the filename is to be opened in binary mode.
# Binary mode does not support 'encoding' and 'newline'.
if ioargs.encoding and "b" not in ioargs.mode:
# Encoding
> handle = open(
handle,
ioargs.mode,
encoding=ioargs.encoding,
errors=errors,
newline="",
)
E FileNotFoundError: [Errno 2] No such file or directory: 'Orders_and_Payment_Flow_Certification.csv'

c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\common.py:789: FileNotFoundError
-------------------------------Captured log call--------------------------------
INFO  setup:test_orders_and_payment_flow.py:46 Total URL Present is: 5

self = <test_orders_and_payment_flow.TestOrderAndPaymentFlowCertificationProgram object at 0x0000020BE1517550>, value = 'Z', initialize_pages = None
testdata = {'contact_no': '123456789', 'country': ['in', 'us', 'gb', 'au', 'de', 'sg', ...], 'db_type': 'mysql', 'dynamo_db_type': 'dynamo', ...}

@pytest.mark.test_details("0000","high","Order and Payment Flow","Pradeep")
@pytest.mark.parametrize("value", certification_program_course_read_csv())
def test_Orders_and_Payment_Flow_certification(self,value,initialize_pages,testdata):

'''
Objective: Make payment and validate the data in Dynamo db and mySql

Step 01: get url
Step 02: click on Enroll Now CTA
Step 03: Make payment
Step 04: Validate the Dynamo db and MySql daya for the payment
'''
self.add_rows_in_csv('Report.csv')
url_count = self._count_url_txt_file_subdomain('Orders_and_Payment_Flow_Certification.txt')
logging.info(f"Total URL Present is: {url_count}")

# Step 01: get url
counter = 0
> df = pd.read_csv('Orders_and_Payment_Flow_Certification.csv', on_bad_lines='skip')

test_prod\test_orders_and_payment_flow.py:50:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\util\_decorators.py:311: in wrapper
return func(*args, **kwargs)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:680: in read_csv
return _read(filepath_or_buffer, kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:575: in _read
parser = TextFileReader(filepath_or_buffer, **kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:933: in __init__
self._engine = self._make_engine(f, self.engine)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:1217: in _make_engine
self.handles = get_handle( # type: ignore[call-overload]
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

path_or_buf = 'Orders_and_Payment_Flow_Certification.csv', mode = 'r'

@doc(compression_options=_shared_docs["compression_options"] % "path_or_buf")
def get_handle(
path_or_buf: FilePath | BaseBuffer,
mode: str,
*,
encoding: str | None = None,
compression: CompressionOptions = None,
memory_map: bool = False,
is_text: bool = True,
errors: str | None = None,
storage_options: StorageOptions = None,
) -> IOHandles[str] | IOHandles[bytes]:
"""
Get file handle for given path/buffer and mode.

Parameters
----------
path_or_buf : str or file handle
File path or object.
mode : str
Mode to open path_or_buf with.
encoding : str or None
Encoding to use.
{compression_options}

.. versionchanged:: 1.0.0
May now be a dict with key 'method' as compression mode
and other keys as compression options if compression
mode is 'zip'.

.. versionchanged:: 1.1.0
Passing compression options as keys in dict is now
supported for compression modes 'gzip', 'bz2', 'zstd' and 'zip'.

.. versionchanged:: 1.4.0 Zstandard support.

memory_map : bool, default False
See parsers._parser_params for more information.
is_text : bool, default True
Whether the type of the content passed to the file/buffer is string or
bytes. This is not the same as `"b" not in mode`. If a string content is
passed to a binary file/buffer, a wrapper is inserted.
errors : str, default 'strict'
Specifies how encoding and decoding errors are to be handled.
See the errors argument for :func:`open` for a full list
of options.
storage_options: StorageOptions = None
Passed to _get_filepath_or_buffer

.. versionchanged:: 1.2.0

Returns the dataclass IOHandles
"""
# Windows does not default to utf-8. Set to utf-8 for a consistent behavior
encoding = encoding or "utf-8"

# read_csv does not know whether the buffer is opened in binary/text mode
if _is_binary_mode(path_or_buf, mode) and "b" not in mode:
mode += "b"

# validate encoding and errors
codecs.lookup(encoding)
if isinstance(errors, str):
codecs.lookup_error(errors)

# open URLs
ioargs = _get_filepath_or_buffer(
path_or_buf,
encoding=encoding,
compression=compression,
mode=mode,
storage_options=storage_options,
)

handle = ioargs.filepath_or_buffer
handles: list[BaseBuffer]

# memory mapping needs to be the first step
handle, memory_map, handles = _maybe_memory_map(
handle,
memory_map,
ioargs.encoding,
ioargs.mode,
errors,
ioargs.compression["method"] not in _compression_to_extension,
)

is_path = isinstance(handle, str)
compression_args = dict(ioargs.compression)
compression = compression_args.pop("method")

# Only for write methods
if "r" not in mode and is_path:
check_parent_directory(str(handle))

if compression:
if compression != "zstd":
# compression libraries do not like an explicit text-mode
ioargs.mode = ioargs.mode.replace("t", "")
elif compression == "zstd" and "b" not in ioargs.mode:
# python-zstandard defaults to text mode, but we always expect
# compression libraries to use binary mode.
ioargs.mode += "b"

# GZ Compression
if compression == "gzip":
if is_path:
assert isinstance(handle, str)
# error: Incompatible types in assignment (expression has type
# "GzipFile", variable has type "Union[str, BaseBuffer]")
handle = gzip.GzipFile( # type: ignore[assignment]
filename=handle,
mode=ioargs.mode,
**compression_args,
)
else:
handle = gzip.GzipFile(
# No overload variant of "GzipFile" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
fileobj=handle, # type: ignore[call-overload]
mode=ioargs.mode,
**compression_args,
)

# BZ Compression
elif compression == "bz2":
# No overload variant of "BZ2File" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
handle = bz2.BZ2File( # type: ignore[call-overload]
handle,
mode=ioargs.mode,
**compression_args,
)

# ZIP Compression
elif compression == "zip":
# error: Argument 1 to "_BytesZipFile" has incompatible type "Union[str,
# BaseBuffer]"; expected "Union[Union[str, PathLike[str]],
# ReadBuffer[bytes], WriteBuffer[bytes]]"
handle = _BytesZipFile(
handle, ioargs.mode, **compression_args # type: ignore[arg-type]
)
if handle.mode == "r":
handles.append(handle)
zip_names = handle.namelist()
if len(zip_names) == 1:
handle = handle.open(zip_names.pop())
elif len(zip_names) == 0:
raise ValueError(f"Zero files found in ZIP file {path_or_buf}")
else:
raise ValueError(
"Multiple files found in ZIP file. "
f"Only one file per ZIP: {zip_names}"
)

# XZ Compression
elif compression == "xz":
handle = get_lzma_file()(handle, ioargs.mode)

# Zstd Compression
elif compression == "zstd":
zstd = import_optional_dependency("zstandard")
if "r" in ioargs.mode:
open_args = {"dctx": zstd.ZstdDecompressor(**compression_args)}
else:
open_args = {"cctx": zstd.ZstdCompressor(**compression_args)}
handle = zstd.open(
handle,
mode=ioargs.mode,
**open_args,
)

# Unrecognized Compression
else:
msg = f"Unrecognized compression type: {compression}"
raise ValueError(msg)

assert not isinstance(handle, str)
handles.append(handle)

elif isinstance(handle, str):
# Check whether the filename is to be opened in binary mode.
# Binary mode does not support 'encoding' and 'newline'.
if ioargs.encoding and "b" not in ioargs.mode:
# Encoding
> handle = open(
handle,
ioargs.mode,
encoding=ioargs.encoding,
errors=errors,
newline="",
)
E FileNotFoundError: [Errno 2] No such file or directory: 'Orders_and_Payment_Flow_Certification.csv'

c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\common.py:789: FileNotFoundError
-------------------------------Captured log call--------------------------------
INFO  setup:test_orders_and_payment_flow.py:46 Total URL Present is: 5

self = <test_orders_and_payment_flow.TestOrderAndPaymentFlowCertificationProgram object at 0x0000020BE11FD7F0>, value = 'AA', initialize_pages = None
testdata = {'contact_no': '123456789', 'country': ['in', 'us', 'gb', 'au', 'de', 'sg', ...], 'db_type': 'mysql', 'dynamo_db_type': 'dynamo', ...}

@pytest.mark.test_details("0000","high","Order and Payment Flow","Pradeep")
@pytest.mark.parametrize("value", certification_program_course_read_csv())
def test_Orders_and_Payment_Flow_certification(self,value,initialize_pages,testdata):

'''
Objective: Make payment and validate the data in Dynamo db and mySql

Step 01: get url
Step 02: click on Enroll Now CTA
Step 03: Make payment
Step 04: Validate the Dynamo db and MySql daya for the payment
'''
self.add_rows_in_csv('Report.csv')
url_count = self._count_url_txt_file_subdomain('Orders_and_Payment_Flow_Certification.txt')
logging.info(f"Total URL Present is: {url_count}")

# Step 01: get url
counter = 0
> df = pd.read_csv('Orders_and_Payment_Flow_Certification.csv', on_bad_lines='skip')

test_prod\test_orders_and_payment_flow.py:50:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\util\_decorators.py:311: in wrapper
return func(*args, **kwargs)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:680: in read_csv
return _read(filepath_or_buffer, kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:575: in _read
parser = TextFileReader(filepath_or_buffer, **kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:933: in __init__
self._engine = self._make_engine(f, self.engine)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:1217: in _make_engine
self.handles = get_handle( # type: ignore[call-overload]
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

path_or_buf = 'Orders_and_Payment_Flow_Certification.csv', mode = 'r'

@doc(compression_options=_shared_docs["compression_options"] % "path_or_buf")
def get_handle(
path_or_buf: FilePath | BaseBuffer,
mode: str,
*,
encoding: str | None = None,
compression: CompressionOptions = None,
memory_map: bool = False,
is_text: bool = True,
errors: str | None = None,
storage_options: StorageOptions = None,
) -> IOHandles[str] | IOHandles[bytes]:
"""
Get file handle for given path/buffer and mode.

Parameters
----------
path_or_buf : str or file handle
File path or object.
mode : str
Mode to open path_or_buf with.
encoding : str or None
Encoding to use.
{compression_options}

.. versionchanged:: 1.0.0
May now be a dict with key 'method' as compression mode
and other keys as compression options if compression
mode is 'zip'.

.. versionchanged:: 1.1.0
Passing compression options as keys in dict is now
supported for compression modes 'gzip', 'bz2', 'zstd' and 'zip'.

.. versionchanged:: 1.4.0 Zstandard support.

memory_map : bool, default False
See parsers._parser_params for more information.
is_text : bool, default True
Whether the type of the content passed to the file/buffer is string or
bytes. This is not the same as `"b" not in mode`. If a string content is
passed to a binary file/buffer, a wrapper is inserted.
errors : str, default 'strict'
Specifies how encoding and decoding errors are to be handled.
See the errors argument for :func:`open` for a full list
of options.
storage_options: StorageOptions = None
Passed to _get_filepath_or_buffer

.. versionchanged:: 1.2.0

Returns the dataclass IOHandles
"""
# Windows does not default to utf-8. Set to utf-8 for a consistent behavior
encoding = encoding or "utf-8"

# read_csv does not know whether the buffer is opened in binary/text mode
if _is_binary_mode(path_or_buf, mode) and "b" not in mode:
mode += "b"

# validate encoding and errors
codecs.lookup(encoding)
if isinstance(errors, str):
codecs.lookup_error(errors)

# open URLs
ioargs = _get_filepath_or_buffer(
path_or_buf,
encoding=encoding,
compression=compression,
mode=mode,
storage_options=storage_options,
)

handle = ioargs.filepath_or_buffer
handles: list[BaseBuffer]

# memory mapping needs to be the first step
handle, memory_map, handles = _maybe_memory_map(
handle,
memory_map,
ioargs.encoding,
ioargs.mode,
errors,
ioargs.compression["method"] not in _compression_to_extension,
)

is_path = isinstance(handle, str)
compression_args = dict(ioargs.compression)
compression = compression_args.pop("method")

# Only for write methods
if "r" not in mode and is_path:
check_parent_directory(str(handle))

if compression:
if compression != "zstd":
# compression libraries do not like an explicit text-mode
ioargs.mode = ioargs.mode.replace("t", "")
elif compression == "zstd" and "b" not in ioargs.mode:
# python-zstandard defaults to text mode, but we always expect
# compression libraries to use binary mode.
ioargs.mode += "b"

# GZ Compression
if compression == "gzip":
if is_path:
assert isinstance(handle, str)
# error: Incompatible types in assignment (expression has type
# "GzipFile", variable has type "Union[str, BaseBuffer]")
handle = gzip.GzipFile( # type: ignore[assignment]
filename=handle,
mode=ioargs.mode,
**compression_args,
)
else:
handle = gzip.GzipFile(
# No overload variant of "GzipFile" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
fileobj=handle, # type: ignore[call-overload]
mode=ioargs.mode,
**compression_args,
)

# BZ Compression
elif compression == "bz2":
# No overload variant of "BZ2File" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
handle = bz2.BZ2File( # type: ignore[call-overload]
handle,
mode=ioargs.mode,
**compression_args,
)

# ZIP Compression
elif compression == "zip":
# error: Argument 1 to "_BytesZipFile" has incompatible type "Union[str,
# BaseBuffer]"; expected "Union[Union[str, PathLike[str]],
# ReadBuffer[bytes], WriteBuffer[bytes]]"
handle = _BytesZipFile(
handle, ioargs.mode, **compression_args # type: ignore[arg-type]
)
if handle.mode == "r":
handles.append(handle)
zip_names = handle.namelist()
if len(zip_names) == 1:
handle = handle.open(zip_names.pop())
elif len(zip_names) == 0:
raise ValueError(f"Zero files found in ZIP file {path_or_buf}")
else:
raise ValueError(
"Multiple files found in ZIP file. "
f"Only one file per ZIP: {zip_names}"
)

# XZ Compression
elif compression == "xz":
handle = get_lzma_file()(handle, ioargs.mode)

# Zstd Compression
elif compression == "zstd":
zstd = import_optional_dependency("zstandard")
if "r" in ioargs.mode:
open_args = {"dctx": zstd.ZstdDecompressor(**compression_args)}
else:
open_args = {"cctx": zstd.ZstdCompressor(**compression_args)}
handle = zstd.open(
handle,
mode=ioargs.mode,
**open_args,
)

# Unrecognized Compression
else:
msg = f"Unrecognized compression type: {compression}"
raise ValueError(msg)

assert not isinstance(handle, str)
handles.append(handle)

elif isinstance(handle, str):
# Check whether the filename is to be opened in binary mode.
# Binary mode does not support 'encoding' and 'newline'.
if ioargs.encoding and "b" not in ioargs.mode:
# Encoding
> handle = open(
handle,
ioargs.mode,
encoding=ioargs.encoding,
errors=errors,
newline="",
)
E FileNotFoundError: [Errno 2] No such file or directory: 'Orders_and_Payment_Flow_Certification.csv'

c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\common.py:789: FileNotFoundError
-------------------------------Captured log call--------------------------------
INFO  setup:test_orders_and_payment_flow.py:46 Total URL Present is: 5

self = <test_orders_and_payment_flow.TestOrderAndPaymentFlowCertificationProgram object at 0x0000020BE109E280>, value = 'AB', initialize_pages = None
testdata = {'contact_no': '123456789', 'country': ['in', 'us', 'gb', 'au', 'de', 'sg', ...], 'db_type': 'mysql', 'dynamo_db_type': 'dynamo', ...}

@pytest.mark.test_details("0000","high","Order and Payment Flow","Pradeep")
@pytest.mark.parametrize("value", certification_program_course_read_csv())
def test_Orders_and_Payment_Flow_certification(self,value,initialize_pages,testdata):

'''
Objective: Make payment and validate the data in Dynamo db and mySql

Step 01: get url
Step 02: click on Enroll Now CTA
Step 03: Make payment
Step 04: Validate the Dynamo db and MySql daya for the payment
'''
self.add_rows_in_csv('Report.csv')
url_count = self._count_url_txt_file_subdomain('Orders_and_Payment_Flow_Certification.txt')
logging.info(f"Total URL Present is: {url_count}")

# Step 01: get url
counter = 0
> df = pd.read_csv('Orders_and_Payment_Flow_Certification.csv', on_bad_lines='skip')

test_prod\test_orders_and_payment_flow.py:50:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\util\_decorators.py:311: in wrapper
return func(*args, **kwargs)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:680: in read_csv
return _read(filepath_or_buffer, kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:575: in _read
parser = TextFileReader(filepath_or_buffer, **kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:933: in __init__
self._engine = self._make_engine(f, self.engine)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:1217: in _make_engine
self.handles = get_handle( # type: ignore[call-overload]
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

path_or_buf = 'Orders_and_Payment_Flow_Certification.csv', mode = 'r'

@doc(compression_options=_shared_docs["compression_options"] % "path_or_buf")
def get_handle(
path_or_buf: FilePath | BaseBuffer,
mode: str,
*,
encoding: str | None = None,
compression: CompressionOptions = None,
memory_map: bool = False,
is_text: bool = True,
errors: str | None = None,
storage_options: StorageOptions = None,
) -> IOHandles[str] | IOHandles[bytes]:
"""
Get file handle for given path/buffer and mode.

Parameters
----------
path_or_buf : str or file handle
File path or object.
mode : str
Mode to open path_or_buf with.
encoding : str or None
Encoding to use.
{compression_options}

.. versionchanged:: 1.0.0
May now be a dict with key 'method' as compression mode
and other keys as compression options if compression
mode is 'zip'.

.. versionchanged:: 1.1.0
Passing compression options as keys in dict is now
supported for compression modes 'gzip', 'bz2', 'zstd' and 'zip'.

.. versionchanged:: 1.4.0 Zstandard support.

memory_map : bool, default False
See parsers._parser_params for more information.
is_text : bool, default True
Whether the type of the content passed to the file/buffer is string or
bytes. This is not the same as `"b" not in mode`. If a string content is
passed to a binary file/buffer, a wrapper is inserted.
errors : str, default 'strict'
Specifies how encoding and decoding errors are to be handled.
See the errors argument for :func:`open` for a full list
of options.
storage_options: StorageOptions = None
Passed to _get_filepath_or_buffer

.. versionchanged:: 1.2.0

Returns the dataclass IOHandles
"""
# Windows does not default to utf-8. Set to utf-8 for a consistent behavior
encoding = encoding or "utf-8"

# read_csv does not know whether the buffer is opened in binary/text mode
if _is_binary_mode(path_or_buf, mode) and "b" not in mode:
mode += "b"

# validate encoding and errors
codecs.lookup(encoding)
if isinstance(errors, str):
codecs.lookup_error(errors)

# open URLs
ioargs = _get_filepath_or_buffer(
path_or_buf,
encoding=encoding,
compression=compression,
mode=mode,
storage_options=storage_options,
)

handle = ioargs.filepath_or_buffer
handles: list[BaseBuffer]

# memory mapping needs to be the first step
handle, memory_map, handles = _maybe_memory_map(
handle,
memory_map,
ioargs.encoding,
ioargs.mode,
errors,
ioargs.compression["method"] not in _compression_to_extension,
)

is_path = isinstance(handle, str)
compression_args = dict(ioargs.compression)
compression = compression_args.pop("method")

# Only for write methods
if "r" not in mode and is_path:
check_parent_directory(str(handle))

if compression:
if compression != "zstd":
# compression libraries do not like an explicit text-mode
ioargs.mode = ioargs.mode.replace("t", "")
elif compression == "zstd" and "b" not in ioargs.mode:
# python-zstandard defaults to text mode, but we always expect
# compression libraries to use binary mode.
ioargs.mode += "b"

# GZ Compression
if compression == "gzip":
if is_path:
assert isinstance(handle, str)
# error: Incompatible types in assignment (expression has type
# "GzipFile", variable has type "Union[str, BaseBuffer]")
handle = gzip.GzipFile( # type: ignore[assignment]
filename=handle,
mode=ioargs.mode,
**compression_args,
)
else:
handle = gzip.GzipFile(
# No overload variant of "GzipFile" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
fileobj=handle, # type: ignore[call-overload]
mode=ioargs.mode,
**compression_args,
)

# BZ Compression
elif compression == "bz2":
# No overload variant of "BZ2File" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
handle = bz2.BZ2File( # type: ignore[call-overload]
handle,
mode=ioargs.mode,
**compression_args,
)

# ZIP Compression
elif compression == "zip":
# error: Argument 1 to "_BytesZipFile" has incompatible type "Union[str,
# BaseBuffer]"; expected "Union[Union[str, PathLike[str]],
# ReadBuffer[bytes], WriteBuffer[bytes]]"
handle = _BytesZipFile(
handle, ioargs.mode, **compression_args # type: ignore[arg-type]
)
if handle.mode == "r":
handles.append(handle)
zip_names = handle.namelist()
if len(zip_names) == 1:
handle = handle.open(zip_names.pop())
elif len(zip_names) == 0:
raise ValueError(f"Zero files found in ZIP file {path_or_buf}")
else:
raise ValueError(
"Multiple files found in ZIP file. "
f"Only one file per ZIP: {zip_names}"
)

# XZ Compression
elif compression == "xz":
handle = get_lzma_file()(handle, ioargs.mode)

# Zstd Compression
elif compression == "zstd":
zstd = import_optional_dependency("zstandard")
if "r" in ioargs.mode:
open_args = {"dctx": zstd.ZstdDecompressor(**compression_args)}
else:
open_args = {"cctx": zstd.ZstdCompressor(**compression_args)}
handle = zstd.open(
handle,
mode=ioargs.mode,
**open_args,
)

# Unrecognized Compression
else:
msg = f"Unrecognized compression type: {compression}"
raise ValueError(msg)

assert not isinstance(handle, str)
handles.append(handle)

elif isinstance(handle, str):
# Check whether the filename is to be opened in binary mode.
# Binary mode does not support 'encoding' and 'newline'.
if ioargs.encoding and "b" not in ioargs.mode:
# Encoding
> handle = open(
handle,
ioargs.mode,
encoding=ioargs.encoding,
errors=errors,
newline="",
)
E FileNotFoundError: [Errno 2] No such file or directory: 'Orders_and_Payment_Flow_Certification.csv'

c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\common.py:789: FileNotFoundError
-------------------------------Captured log call--------------------------------
INFO  setup:test_orders_and_payment_flow.py:46 Total URL Present is: 5

self = <test_orders_and_payment_flow.TestOrderAndPaymentFlowCertificationProgram object at 0x0000020BE140FB80>, value = 'AC', initialize_pages = None
testdata = {'contact_no': '123456789', 'country': ['in', 'us', 'gb', 'au', 'de', 'sg', ...], 'db_type': 'mysql', 'dynamo_db_type': 'dynamo', ...}

@pytest.mark.test_details("0000","high","Order and Payment Flow","Pradeep")
@pytest.mark.parametrize("value", certification_program_course_read_csv())
def test_Orders_and_Payment_Flow_certification(self,value,initialize_pages,testdata):

'''
Objective: Make payment and validate the data in Dynamo db and mySql

Step 01: get url
Step 02: click on Enroll Now CTA
Step 03: Make payment
Step 04: Validate the Dynamo db and MySql daya for the payment
'''
self.add_rows_in_csv('Report.csv')
url_count = self._count_url_txt_file_subdomain('Orders_and_Payment_Flow_Certification.txt')
logging.info(f"Total URL Present is: {url_count}")

# Step 01: get url
counter = 0
> df = pd.read_csv('Orders_and_Payment_Flow_Certification.csv', on_bad_lines='skip')

test_prod\test_orders_and_payment_flow.py:50:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\util\_decorators.py:311: in wrapper
return func(*args, **kwargs)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:680: in read_csv
return _read(filepath_or_buffer, kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:575: in _read
parser = TextFileReader(filepath_or_buffer, **kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:933: in __init__
self._engine = self._make_engine(f, self.engine)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:1217: in _make_engine
self.handles = get_handle( # type: ignore[call-overload]
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

path_or_buf = 'Orders_and_Payment_Flow_Certification.csv', mode = 'r'

@doc(compression_options=_shared_docs["compression_options"] % "path_or_buf")
def get_handle(
path_or_buf: FilePath | BaseBuffer,
mode: str,
*,
encoding: str | None = None,
compression: CompressionOptions = None,
memory_map: bool = False,
is_text: bool = True,
errors: str | None = None,
storage_options: StorageOptions = None,
) -> IOHandles[str] | IOHandles[bytes]:
"""
Get file handle for given path/buffer and mode.

Parameters
----------
path_or_buf : str or file handle
File path or object.
mode : str
Mode to open path_or_buf with.
encoding : str or None
Encoding to use.
{compression_options}

.. versionchanged:: 1.0.0
May now be a dict with key 'method' as compression mode
and other keys as compression options if compression
mode is 'zip'.

.. versionchanged:: 1.1.0
Passing compression options as keys in dict is now
supported for compression modes 'gzip', 'bz2', 'zstd' and 'zip'.

.. versionchanged:: 1.4.0 Zstandard support.

memory_map : bool, default False
See parsers._parser_params for more information.
is_text : bool, default True
Whether the type of the content passed to the file/buffer is string or
bytes. This is not the same as `"b" not in mode`. If a string content is
passed to a binary file/buffer, a wrapper is inserted.
errors : str, default 'strict'
Specifies how encoding and decoding errors are to be handled.
See the errors argument for :func:`open` for a full list
of options.
storage_options: StorageOptions = None
Passed to _get_filepath_or_buffer

.. versionchanged:: 1.2.0

Returns the dataclass IOHandles
"""
# Windows does not default to utf-8. Set to utf-8 for a consistent behavior
encoding = encoding or "utf-8"

# read_csv does not know whether the buffer is opened in binary/text mode
if _is_binary_mode(path_or_buf, mode) and "b" not in mode:
mode += "b"

# validate encoding and errors
codecs.lookup(encoding)
if isinstance(errors, str):
codecs.lookup_error(errors)

# open URLs
ioargs = _get_filepath_or_buffer(
path_or_buf,
encoding=encoding,
compression=compression,
mode=mode,
storage_options=storage_options,
)

handle = ioargs.filepath_or_buffer
handles: list[BaseBuffer]

# memory mapping needs to be the first step
handle, memory_map, handles = _maybe_memory_map(
handle,
memory_map,
ioargs.encoding,
ioargs.mode,
errors,
ioargs.compression["method"] not in _compression_to_extension,
)

is_path = isinstance(handle, str)
compression_args = dict(ioargs.compression)
compression = compression_args.pop("method")

# Only for write methods
if "r" not in mode and is_path:
check_parent_directory(str(handle))

if compression:
if compression != "zstd":
# compression libraries do not like an explicit text-mode
ioargs.mode = ioargs.mode.replace("t", "")
elif compression == "zstd" and "b" not in ioargs.mode:
# python-zstandard defaults to text mode, but we always expect
# compression libraries to use binary mode.
ioargs.mode += "b"

# GZ Compression
if compression == "gzip":
if is_path:
assert isinstance(handle, str)
# error: Incompatible types in assignment (expression has type
# "GzipFile", variable has type "Union[str, BaseBuffer]")
handle = gzip.GzipFile( # type: ignore[assignment]
filename=handle,
mode=ioargs.mode,
**compression_args,
)
else:
handle = gzip.GzipFile(
# No overload variant of "GzipFile" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
fileobj=handle, # type: ignore[call-overload]
mode=ioargs.mode,
**compression_args,
)

# BZ Compression
elif compression == "bz2":
# No overload variant of "BZ2File" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
handle = bz2.BZ2File( # type: ignore[call-overload]
handle,
mode=ioargs.mode,
**compression_args,
)

# ZIP Compression
elif compression == "zip":
# error: Argument 1 to "_BytesZipFile" has incompatible type "Union[str,
# BaseBuffer]"; expected "Union[Union[str, PathLike[str]],
# ReadBuffer[bytes], WriteBuffer[bytes]]"
handle = _BytesZipFile(
handle, ioargs.mode, **compression_args # type: ignore[arg-type]
)
if handle.mode == "r":
handles.append(handle)
zip_names = handle.namelist()
if len(zip_names) == 1:
handle = handle.open(zip_names.pop())
elif len(zip_names) == 0:
raise ValueError(f"Zero files found in ZIP file {path_or_buf}")
else:
raise ValueError(
"Multiple files found in ZIP file. "
f"Only one file per ZIP: {zip_names}"
)

# XZ Compression
elif compression == "xz":
handle = get_lzma_file()(handle, ioargs.mode)

# Zstd Compression
elif compression == "zstd":
zstd = import_optional_dependency("zstandard")
if "r" in ioargs.mode:
open_args = {"dctx": zstd.ZstdDecompressor(**compression_args)}
else:
open_args = {"cctx": zstd.ZstdCompressor(**compression_args)}
handle = zstd.open(
handle,
mode=ioargs.mode,
**open_args,
)

# Unrecognized Compression
else:
msg = f"Unrecognized compression type: {compression}"
raise ValueError(msg)

assert not isinstance(handle, str)
handles.append(handle)

elif isinstance(handle, str):
# Check whether the filename is to be opened in binary mode.
# Binary mode does not support 'encoding' and 'newline'.
if ioargs.encoding and "b" not in ioargs.mode:
# Encoding
> handle = open(
handle,
ioargs.mode,
encoding=ioargs.encoding,
errors=errors,
newline="",
)
E FileNotFoundError: [Errno 2] No such file or directory: 'Orders_and_Payment_Flow_Certification.csv'

c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\common.py:789: FileNotFoundError
-------------------------------Captured log call--------------------------------
INFO  setup:test_orders_and_payment_flow.py:46 Total URL Present is: 5

self = <test_orders_and_payment_flow.TestOrderAndPaymentFlowCertificationProgram object at 0x0000020BE1282730>, value = 'AD', initialize_pages = None
testdata = {'contact_no': '123456789', 'country': ['in', 'us', 'gb', 'au', 'de', 'sg', ...], 'db_type': 'mysql', 'dynamo_db_type': 'dynamo', ...}

@pytest.mark.test_details("0000","high","Order and Payment Flow","Pradeep")
@pytest.mark.parametrize("value", certification_program_course_read_csv())
def test_Orders_and_Payment_Flow_certification(self,value,initialize_pages,testdata):

'''
Objective: Make payment and validate the data in Dynamo db and mySql

Step 01: get url
Step 02: click on Enroll Now CTA
Step 03: Make payment
Step 04: Validate the Dynamo db and MySql daya for the payment
'''
self.add_rows_in_csv('Report.csv')
url_count = self._count_url_txt_file_subdomain('Orders_and_Payment_Flow_Certification.txt')
logging.info(f"Total URL Present is: {url_count}")

# Step 01: get url
counter = 0
> df = pd.read_csv('Orders_and_Payment_Flow_Certification.csv', on_bad_lines='skip')

test_prod\test_orders_and_payment_flow.py:50:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\util\_decorators.py:311: in wrapper
return func(*args, **kwargs)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:680: in read_csv
return _read(filepath_or_buffer, kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:575: in _read
parser = TextFileReader(filepath_or_buffer, **kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:933: in __init__
self._engine = self._make_engine(f, self.engine)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:1217: in _make_engine
self.handles = get_handle( # type: ignore[call-overload]
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

path_or_buf = 'Orders_and_Payment_Flow_Certification.csv', mode = 'r'

@doc(compression_options=_shared_docs["compression_options"] % "path_or_buf")
def get_handle(
path_or_buf: FilePath | BaseBuffer,
mode: str,
*,
encoding: str | None = None,
compression: CompressionOptions = None,
memory_map: bool = False,
is_text: bool = True,
errors: str | None = None,
storage_options: StorageOptions = None,
) -> IOHandles[str] | IOHandles[bytes]:
"""
Get file handle for given path/buffer and mode.

Parameters
----------
path_or_buf : str or file handle
File path or object.
mode : str
Mode to open path_or_buf with.
encoding : str or None
Encoding to use.
{compression_options}

.. versionchanged:: 1.0.0
May now be a dict with key 'method' as compression mode
and other keys as compression options if compression
mode is 'zip'.

.. versionchanged:: 1.1.0
Passing compression options as keys in dict is now
supported for compression modes 'gzip', 'bz2', 'zstd' and 'zip'.

.. versionchanged:: 1.4.0 Zstandard support.

memory_map : bool, default False
See parsers._parser_params for more information.
is_text : bool, default True
Whether the type of the content passed to the file/buffer is string or
bytes. This is not the same as `"b" not in mode`. If a string content is
passed to a binary file/buffer, a wrapper is inserted.
errors : str, default 'strict'
Specifies how encoding and decoding errors are to be handled.
See the errors argument for :func:`open` for a full list
of options.
storage_options: StorageOptions = None
Passed to _get_filepath_or_buffer

.. versionchanged:: 1.2.0

Returns the dataclass IOHandles
"""
# Windows does not default to utf-8. Set to utf-8 for a consistent behavior
encoding = encoding or "utf-8"

# read_csv does not know whether the buffer is opened in binary/text mode
if _is_binary_mode(path_or_buf, mode) and "b" not in mode:
mode += "b"

# validate encoding and errors
codecs.lookup(encoding)
if isinstance(errors, str):
codecs.lookup_error(errors)

# open URLs
ioargs = _get_filepath_or_buffer(
path_or_buf,
encoding=encoding,
compression=compression,
mode=mode,
storage_options=storage_options,
)

handle = ioargs.filepath_or_buffer
handles: list[BaseBuffer]

# memory mapping needs to be the first step
handle, memory_map, handles = _maybe_memory_map(
handle,
memory_map,
ioargs.encoding,
ioargs.mode,
errors,
ioargs.compression["method"] not in _compression_to_extension,
)

is_path = isinstance(handle, str)
compression_args = dict(ioargs.compression)
compression = compression_args.pop("method")

# Only for write methods
if "r" not in mode and is_path:
check_parent_directory(str(handle))

if compression:
if compression != "zstd":
# compression libraries do not like an explicit text-mode
ioargs.mode = ioargs.mode.replace("t", "")
elif compression == "zstd" and "b" not in ioargs.mode:
# python-zstandard defaults to text mode, but we always expect
# compression libraries to use binary mode.
ioargs.mode += "b"

# GZ Compression
if compression == "gzip":
if is_path:
assert isinstance(handle, str)
# error: Incompatible types in assignment (expression has type
# "GzipFile", variable has type "Union[str, BaseBuffer]")
handle = gzip.GzipFile( # type: ignore[assignment]
filename=handle,
mode=ioargs.mode,
**compression_args,
)
else:
handle = gzip.GzipFile(
# No overload variant of "GzipFile" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
fileobj=handle, # type: ignore[call-overload]
mode=ioargs.mode,
**compression_args,
)

# BZ Compression
elif compression == "bz2":
# No overload variant of "BZ2File" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
handle = bz2.BZ2File( # type: ignore[call-overload]
handle,
mode=ioargs.mode,
**compression_args,
)

# ZIP Compression
elif compression == "zip":
# error: Argument 1 to "_BytesZipFile" has incompatible type "Union[str,
# BaseBuffer]"; expected "Union[Union[str, PathLike[str]],
# ReadBuffer[bytes], WriteBuffer[bytes]]"
handle = _BytesZipFile(
handle, ioargs.mode, **compression_args # type: ignore[arg-type]
)
if handle.mode == "r":
handles.append(handle)
zip_names = handle.namelist()
if len(zip_names) == 1:
handle = handle.open(zip_names.pop())
elif len(zip_names) == 0:
raise ValueError(f"Zero files found in ZIP file {path_or_buf}")
else:
raise ValueError(
"Multiple files found in ZIP file. "
f"Only one file per ZIP: {zip_names}"
)

# XZ Compression
elif compression == "xz":
handle = get_lzma_file()(handle, ioargs.mode)

# Zstd Compression
elif compression == "zstd":
zstd = import_optional_dependency("zstandard")
if "r" in ioargs.mode:
open_args = {"dctx": zstd.ZstdDecompressor(**compression_args)}
else:
open_args = {"cctx": zstd.ZstdCompressor(**compression_args)}
handle = zstd.open(
handle,
mode=ioargs.mode,
**open_args,
)

# Unrecognized Compression
else:
msg = f"Unrecognized compression type: {compression}"
raise ValueError(msg)

assert not isinstance(handle, str)
handles.append(handle)

elif isinstance(handle, str):
# Check whether the filename is to be opened in binary mode.
# Binary mode does not support 'encoding' and 'newline'.
if ioargs.encoding and "b" not in ioargs.mode:
# Encoding
> handle = open(
handle,
ioargs.mode,
encoding=ioargs.encoding,
errors=errors,
newline="",
)
E FileNotFoundError: [Errno 2] No such file or directory: 'Orders_and_Payment_Flow_Certification.csv'

c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\common.py:789: FileNotFoundError
-------------------------------Captured log call--------------------------------
INFO  setup:test_orders_and_payment_flow.py:46 Total URL Present is: 5

self = <test_orders_and_payment_flow.TestOrderAndPaymentFlowCertificationProgram object at 0x0000020BE0D79460>, value = 'AE', initialize_pages = None
testdata = {'contact_no': '123456789', 'country': ['in', 'us', 'gb', 'au', 'de', 'sg', ...], 'db_type': 'mysql', 'dynamo_db_type': 'dynamo', ...}

@pytest.mark.test_details("0000","high","Order and Payment Flow","Pradeep")
@pytest.mark.parametrize("value", certification_program_course_read_csv())
def test_Orders_and_Payment_Flow_certification(self,value,initialize_pages,testdata):

'''
Objective: Make payment and validate the data in Dynamo db and mySql

Step 01: get url
Step 02: click on Enroll Now CTA
Step 03: Make payment
Step 04: Validate the Dynamo db and MySql daya for the payment
'''
self.add_rows_in_csv('Report.csv')
url_count = self._count_url_txt_file_subdomain('Orders_and_Payment_Flow_Certification.txt')
logging.info(f"Total URL Present is: {url_count}")

# Step 01: get url
counter = 0
> df = pd.read_csv('Orders_and_Payment_Flow_Certification.csv', on_bad_lines='skip')

test_prod\test_orders_and_payment_flow.py:50:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\util\_decorators.py:311: in wrapper
return func(*args, **kwargs)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:680: in read_csv
return _read(filepath_or_buffer, kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:575: in _read
parser = TextFileReader(filepath_or_buffer, **kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:933: in __init__
self._engine = self._make_engine(f, self.engine)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:1217: in _make_engine
self.handles = get_handle( # type: ignore[call-overload]
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

path_or_buf = 'Orders_and_Payment_Flow_Certification.csv', mode = 'r'

@doc(compression_options=_shared_docs["compression_options"] % "path_or_buf")
def get_handle(
path_or_buf: FilePath | BaseBuffer,
mode: str,
*,
encoding: str | None = None,
compression: CompressionOptions = None,
memory_map: bool = False,
is_text: bool = True,
errors: str | None = None,
storage_options: StorageOptions = None,
) -> IOHandles[str] | IOHandles[bytes]:
"""
Get file handle for given path/buffer and mode.

Parameters
----------
path_or_buf : str or file handle
File path or object.
mode : str
Mode to open path_or_buf with.
encoding : str or None
Encoding to use.
{compression_options}

.. versionchanged:: 1.0.0
May now be a dict with key 'method' as compression mode
and other keys as compression options if compression
mode is 'zip'.

.. versionchanged:: 1.1.0
Passing compression options as keys in dict is now
supported for compression modes 'gzip', 'bz2', 'zstd' and 'zip'.

.. versionchanged:: 1.4.0 Zstandard support.

memory_map : bool, default False
See parsers._parser_params for more information.
is_text : bool, default True
Whether the type of the content passed to the file/buffer is string or
bytes. This is not the same as `"b" not in mode`. If a string content is
passed to a binary file/buffer, a wrapper is inserted.
errors : str, default 'strict'
Specifies how encoding and decoding errors are to be handled.
See the errors argument for :func:`open` for a full list
of options.
storage_options: StorageOptions = None
Passed to _get_filepath_or_buffer

.. versionchanged:: 1.2.0

Returns the dataclass IOHandles
"""
# Windows does not default to utf-8. Set to utf-8 for a consistent behavior
encoding = encoding or "utf-8"

# read_csv does not know whether the buffer is opened in binary/text mode
if _is_binary_mode(path_or_buf, mode) and "b" not in mode:
mode += "b"

# validate encoding and errors
codecs.lookup(encoding)
if isinstance(errors, str):
codecs.lookup_error(errors)

# open URLs
ioargs = _get_filepath_or_buffer(
path_or_buf,
encoding=encoding,
compression=compression,
mode=mode,
storage_options=storage_options,
)

handle = ioargs.filepath_or_buffer
handles: list[BaseBuffer]

# memory mapping needs to be the first step
handle, memory_map, handles = _maybe_memory_map(
handle,
memory_map,
ioargs.encoding,
ioargs.mode,
errors,
ioargs.compression["method"] not in _compression_to_extension,
)

is_path = isinstance(handle, str)
compression_args = dict(ioargs.compression)
compression = compression_args.pop("method")

# Only for write methods
if "r" not in mode and is_path:
check_parent_directory(str(handle))

if compression:
if compression != "zstd":
# compression libraries do not like an explicit text-mode
ioargs.mode = ioargs.mode.replace("t", "")
elif compression == "zstd" and "b" not in ioargs.mode:
# python-zstandard defaults to text mode, but we always expect
# compression libraries to use binary mode.
ioargs.mode += "b"

# GZ Compression
if compression == "gzip":
if is_path:
assert isinstance(handle, str)
# error: Incompatible types in assignment (expression has type
# "GzipFile", variable has type "Union[str, BaseBuffer]")
handle = gzip.GzipFile( # type: ignore[assignment]
filename=handle,
mode=ioargs.mode,
**compression_args,
)
else:
handle = gzip.GzipFile(
# No overload variant of "GzipFile" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
fileobj=handle, # type: ignore[call-overload]
mode=ioargs.mode,
**compression_args,
)

# BZ Compression
elif compression == "bz2":
# No overload variant of "BZ2File" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
handle = bz2.BZ2File( # type: ignore[call-overload]
handle,
mode=ioargs.mode,
**compression_args,
)

# ZIP Compression
elif compression == "zip":
# error: Argument 1 to "_BytesZipFile" has incompatible type "Union[str,
# BaseBuffer]"; expected "Union[Union[str, PathLike[str]],
# ReadBuffer[bytes], WriteBuffer[bytes]]"
handle = _BytesZipFile(
handle, ioargs.mode, **compression_args # type: ignore[arg-type]
)
if handle.mode == "r":
handles.append(handle)
zip_names = handle.namelist()
if len(zip_names) == 1:
handle = handle.open(zip_names.pop())
elif len(zip_names) == 0:
raise ValueError(f"Zero files found in ZIP file {path_or_buf}")
else:
raise ValueError(
"Multiple files found in ZIP file. "
f"Only one file per ZIP: {zip_names}"
)

# XZ Compression
elif compression == "xz":
handle = get_lzma_file()(handle, ioargs.mode)

# Zstd Compression
elif compression == "zstd":
zstd = import_optional_dependency("zstandard")
if "r" in ioargs.mode:
open_args = {"dctx": zstd.ZstdDecompressor(**compression_args)}
else:
open_args = {"cctx": zstd.ZstdCompressor(**compression_args)}
handle = zstd.open(
handle,
mode=ioargs.mode,
**open_args,
)

# Unrecognized Compression
else:
msg = f"Unrecognized compression type: {compression}"
raise ValueError(msg)

assert not isinstance(handle, str)
handles.append(handle)

elif isinstance(handle, str):
# Check whether the filename is to be opened in binary mode.
# Binary mode does not support 'encoding' and 'newline'.
if ioargs.encoding and "b" not in ioargs.mode:
# Encoding
> handle = open(
handle,
ioargs.mode,
encoding=ioargs.encoding,
errors=errors,
newline="",
)
E FileNotFoundError: [Errno 2] No such file or directory: 'Orders_and_Payment_Flow_Certification.csv'

c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\common.py:789: FileNotFoundError
-------------------------------Captured log call--------------------------------
INFO  setup:test_orders_and_payment_flow.py:46 Total URL Present is: 5

self = <test_orders_and_payment_flow.TestOrderAndPaymentFlowCertificationProgram object at 0x0000020BE111C850>, value = 'AF', initialize_pages = None
testdata = {'contact_no': '123456789', 'country': ['in', 'us', 'gb', 'au', 'de', 'sg', ...], 'db_type': 'mysql', 'dynamo_db_type': 'dynamo', ...}

@pytest.mark.test_details("0000","high","Order and Payment Flow","Pradeep")
@pytest.mark.parametrize("value", certification_program_course_read_csv())
def test_Orders_and_Payment_Flow_certification(self,value,initialize_pages,testdata):

'''
Objective: Make payment and validate the data in Dynamo db and mySql

Step 01: get url
Step 02: click on Enroll Now CTA
Step 03: Make payment
Step 04: Validate the Dynamo db and MySql daya for the payment
'''
self.add_rows_in_csv('Report.csv')
url_count = self._count_url_txt_file_subdomain('Orders_and_Payment_Flow_Certification.txt')
logging.info(f"Total URL Present is: {url_count}")

# Step 01: get url
counter = 0
> df = pd.read_csv('Orders_and_Payment_Flow_Certification.csv', on_bad_lines='skip')

test_prod\test_orders_and_payment_flow.py:50:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\util\_decorators.py:311: in wrapper
return func(*args, **kwargs)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:680: in read_csv
return _read(filepath_or_buffer, kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:575: in _read
parser = TextFileReader(filepath_or_buffer, **kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:933: in __init__
self._engine = self._make_engine(f, self.engine)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:1217: in _make_engine
self.handles = get_handle( # type: ignore[call-overload]
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

path_or_buf = 'Orders_and_Payment_Flow_Certification.csv', mode = 'r'

@doc(compression_options=_shared_docs["compression_options"] % "path_or_buf")
def get_handle(
path_or_buf: FilePath | BaseBuffer,
mode: str,
*,
encoding: str | None = None,
compression: CompressionOptions = None,
memory_map: bool = False,
is_text: bool = True,
errors: str | None = None,
storage_options: StorageOptions = None,
) -> IOHandles[str] | IOHandles[bytes]:
"""
Get file handle for given path/buffer and mode.

Parameters
----------
path_or_buf : str or file handle
File path or object.
mode : str
Mode to open path_or_buf with.
encoding : str or None
Encoding to use.
{compression_options}

.. versionchanged:: 1.0.0
May now be a dict with key 'method' as compression mode
and other keys as compression options if compression
mode is 'zip'.

.. versionchanged:: 1.1.0
Passing compression options as keys in dict is now
supported for compression modes 'gzip', 'bz2', 'zstd' and 'zip'.

.. versionchanged:: 1.4.0 Zstandard support.

memory_map : bool, default False
See parsers._parser_params for more information.
is_text : bool, default True
Whether the type of the content passed to the file/buffer is string or
bytes. This is not the same as `"b" not in mode`. If a string content is
passed to a binary file/buffer, a wrapper is inserted.
errors : str, default 'strict'
Specifies how encoding and decoding errors are to be handled.
See the errors argument for :func:`open` for a full list
of options.
storage_options: StorageOptions = None
Passed to _get_filepath_or_buffer

.. versionchanged:: 1.2.0

Returns the dataclass IOHandles
"""
# Windows does not default to utf-8. Set to utf-8 for a consistent behavior
encoding = encoding or "utf-8"

# read_csv does not know whether the buffer is opened in binary/text mode
if _is_binary_mode(path_or_buf, mode) and "b" not in mode:
mode += "b"

# validate encoding and errors
codecs.lookup(encoding)
if isinstance(errors, str):
codecs.lookup_error(errors)

# open URLs
ioargs = _get_filepath_or_buffer(
path_or_buf,
encoding=encoding,
compression=compression,
mode=mode,
storage_options=storage_options,
)

handle = ioargs.filepath_or_buffer
handles: list[BaseBuffer]

# memory mapping needs to be the first step
handle, memory_map, handles = _maybe_memory_map(
handle,
memory_map,
ioargs.encoding,
ioargs.mode,
errors,
ioargs.compression["method"] not in _compression_to_extension,
)

is_path = isinstance(handle, str)
compression_args = dict(ioargs.compression)
compression = compression_args.pop("method")

# Only for write methods
if "r" not in mode and is_path:
check_parent_directory(str(handle))

if compression:
if compression != "zstd":
# compression libraries do not like an explicit text-mode
ioargs.mode = ioargs.mode.replace("t", "")
elif compression == "zstd" and "b" not in ioargs.mode:
# python-zstandard defaults to text mode, but we always expect
# compression libraries to use binary mode.
ioargs.mode += "b"

# GZ Compression
if compression == "gzip":
if is_path:
assert isinstance(handle, str)
# error: Incompatible types in assignment (expression has type
# "GzipFile", variable has type "Union[str, BaseBuffer]")
handle = gzip.GzipFile( # type: ignore[assignment]
filename=handle,
mode=ioargs.mode,
**compression_args,
)
else:
handle = gzip.GzipFile(
# No overload variant of "GzipFile" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
fileobj=handle, # type: ignore[call-overload]
mode=ioargs.mode,
**compression_args,
)

# BZ Compression
elif compression == "bz2":
# No overload variant of "BZ2File" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
handle = bz2.BZ2File( # type: ignore[call-overload]
handle,
mode=ioargs.mode,
**compression_args,
)

# ZIP Compression
elif compression == "zip":
# error: Argument 1 to "_BytesZipFile" has incompatible type "Union[str,
# BaseBuffer]"; expected "Union[Union[str, PathLike[str]],
# ReadBuffer[bytes], WriteBuffer[bytes]]"
handle = _BytesZipFile(
handle, ioargs.mode, **compression_args # type: ignore[arg-type]
)
if handle.mode == "r":
handles.append(handle)
zip_names = handle.namelist()
if len(zip_names) == 1:
handle = handle.open(zip_names.pop())
elif len(zip_names) == 0:
raise ValueError(f"Zero files found in ZIP file {path_or_buf}")
else:
raise ValueError(
"Multiple files found in ZIP file. "
f"Only one file per ZIP: {zip_names}"
)

# XZ Compression
elif compression == "xz":
handle = get_lzma_file()(handle, ioargs.mode)

# Zstd Compression
elif compression == "zstd":
zstd = import_optional_dependency("zstandard")
if "r" in ioargs.mode:
open_args = {"dctx": zstd.ZstdDecompressor(**compression_args)}
else:
open_args = {"cctx": zstd.ZstdCompressor(**compression_args)}
handle = zstd.open(
handle,
mode=ioargs.mode,
**open_args,
)

# Unrecognized Compression
else:
msg = f"Unrecognized compression type: {compression}"
raise ValueError(msg)

assert not isinstance(handle, str)
handles.append(handle)

elif isinstance(handle, str):
# Check whether the filename is to be opened in binary mode.
# Binary mode does not support 'encoding' and 'newline'.
if ioargs.encoding and "b" not in ioargs.mode:
# Encoding
> handle = open(
handle,
ioargs.mode,
encoding=ioargs.encoding,
errors=errors,
newline="",
)
E FileNotFoundError: [Errno 2] No such file or directory: 'Orders_and_Payment_Flow_Certification.csv'

c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\common.py:789: FileNotFoundError
-------------------------------Captured log call--------------------------------
INFO  setup:test_orders_and_payment_flow.py:46 Total URL Present is: 5

self = <test_orders_and_payment_flow.TestOrderAndPaymentFlowCertificationProgram object at 0x0000020BE138BF10>, value = 'AG', initialize_pages = None
testdata = {'contact_no': '123456789', 'country': ['in', 'us', 'gb', 'au', 'de', 'sg', ...], 'db_type': 'mysql', 'dynamo_db_type': 'dynamo', ...}

@pytest.mark.test_details("0000","high","Order and Payment Flow","Pradeep")
@pytest.mark.parametrize("value", certification_program_course_read_csv())
def test_Orders_and_Payment_Flow_certification(self,value,initialize_pages,testdata):

'''
Objective: Make payment and validate the data in Dynamo db and mySql

Step 01: get url
Step 02: click on Enroll Now CTA
Step 03: Make payment
Step 04: Validate the Dynamo db and MySql daya for the payment
'''
self.add_rows_in_csv('Report.csv')
url_count = self._count_url_txt_file_subdomain('Orders_and_Payment_Flow_Certification.txt')
logging.info(f"Total URL Present is: {url_count}")

# Step 01: get url
counter = 0
> df = pd.read_csv('Orders_and_Payment_Flow_Certification.csv', on_bad_lines='skip')

test_prod\test_orders_and_payment_flow.py:50:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\util\_decorators.py:311: in wrapper
return func(*args, **kwargs)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:680: in read_csv
return _read(filepath_or_buffer, kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:575: in _read
parser = TextFileReader(filepath_or_buffer, **kwds)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:933: in __init__
self._engine = self._make_engine(f, self.engine)
c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\parsers\readers.py:1217: in _make_engine
self.handles = get_handle( # type: ignore[call-overload]
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

path_or_buf = 'Orders_and_Payment_Flow_Certification.csv', mode = 'r'

@doc(compression_options=_shared_docs["compression_options"] % "path_or_buf")
def get_handle(
path_or_buf: FilePath | BaseBuffer,
mode: str,
*,
encoding: str | None = None,
compression: CompressionOptions = None,
memory_map: bool = False,
is_text: bool = True,
errors: str | None = None,
storage_options: StorageOptions = None,
) -> IOHandles[str] | IOHandles[bytes]:
"""
Get file handle for given path/buffer and mode.

Parameters
----------
path_or_buf : str or file handle
File path or object.
mode : str
Mode to open path_or_buf with.
encoding : str or None
Encoding to use.
{compression_options}

.. versionchanged:: 1.0.0
May now be a dict with key 'method' as compression mode
and other keys as compression options if compression
mode is 'zip'.

.. versionchanged:: 1.1.0
Passing compression options as keys in dict is now
supported for compression modes 'gzip', 'bz2', 'zstd' and 'zip'.

.. versionchanged:: 1.4.0 Zstandard support.

memory_map : bool, default False
See parsers._parser_params for more information.
is_text : bool, default True
Whether the type of the content passed to the file/buffer is string or
bytes. This is not the same as `"b" not in mode`. If a string content is
passed to a binary file/buffer, a wrapper is inserted.
errors : str, default 'strict'
Specifies how encoding and decoding errors are to be handled.
See the errors argument for :func:`open` for a full list
of options.
storage_options: StorageOptions = None
Passed to _get_filepath_or_buffer

.. versionchanged:: 1.2.0

Returns the dataclass IOHandles
"""
# Windows does not default to utf-8. Set to utf-8 for a consistent behavior
encoding = encoding or "utf-8"

# read_csv does not know whether the buffer is opened in binary/text mode
if _is_binary_mode(path_or_buf, mode) and "b" not in mode:
mode += "b"

# validate encoding and errors
codecs.lookup(encoding)
if isinstance(errors, str):
codecs.lookup_error(errors)

# open URLs
ioargs = _get_filepath_or_buffer(
path_or_buf,
encoding=encoding,
compression=compression,
mode=mode,
storage_options=storage_options,
)

handle = ioargs.filepath_or_buffer
handles: list[BaseBuffer]

# memory mapping needs to be the first step
handle, memory_map, handles = _maybe_memory_map(
handle,
memory_map,
ioargs.encoding,
ioargs.mode,
errors,
ioargs.compression["method"] not in _compression_to_extension,
)

is_path = isinstance(handle, str)
compression_args = dict(ioargs.compression)
compression = compression_args.pop("method")

# Only for write methods
if "r" not in mode and is_path:
check_parent_directory(str(handle))

if compression:
if compression != "zstd":
# compression libraries do not like an explicit text-mode
ioargs.mode = ioargs.mode.replace("t", "")
elif compression == "zstd" and "b" not in ioargs.mode:
# python-zstandard defaults to text mode, but we always expect
# compression libraries to use binary mode.
ioargs.mode += "b"

# GZ Compression
if compression == "gzip":
if is_path:
assert isinstance(handle, str)
# error: Incompatible types in assignment (expression has type
# "GzipFile", variable has type "Union[str, BaseBuffer]")
handle = gzip.GzipFile( # type: ignore[assignment]
filename=handle,
mode=ioargs.mode,
**compression_args,
)
else:
handle = gzip.GzipFile(
# No overload variant of "GzipFile" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
fileobj=handle, # type: ignore[call-overload]
mode=ioargs.mode,
**compression_args,
)

# BZ Compression
elif compression == "bz2":
# No overload variant of "BZ2File" matches argument types
# "Union[str, BaseBuffer]", "str", "Dict[str, Any]"
handle = bz2.BZ2File( # type: ignore[call-overload]
handle,
mode=ioargs.mode,
**compression_args,
)

# ZIP Compression
elif compression == "zip":
# error: Argument 1 to "_BytesZipFile" has incompatible type "Union[str,
# BaseBuffer]"; expected "Union[Union[str, PathLike[str]],
# ReadBuffer[bytes], WriteBuffer[bytes]]"
handle = _BytesZipFile(
handle, ioargs.mode, **compression_args # type: ignore[arg-type]
)
if handle.mode == "r":
handles.append(handle)
zip_names = handle.namelist()
if len(zip_names) == 1:
handle = handle.open(zip_names.pop())
elif len(zip_names) == 0:
raise ValueError(f"Zero files found in ZIP file {path_or_buf}")
else:
raise ValueError(
"Multiple files found in ZIP file. "
f"Only one file per ZIP: {zip_names}"
)

# XZ Compression
elif compression == "xz":
handle = get_lzma_file()(handle, ioargs.mode)

# Zstd Compression
elif compression == "zstd":
zstd = import_optional_dependency("zstandard")
if "r" in ioargs.mode:
open_args = {"dctx": zstd.ZstdDecompressor(**compression_args)}
else:
open_args = {"cctx": zstd.ZstdCompressor(**compression_args)}
handle = zstd.open(
handle,
mode=ioargs.mode,
**open_args,
)

# Unrecognized Compression
else:
msg = f"Unrecognized compression type: {compression}"
raise ValueError(msg)

assert not isinstance(handle, str)
handles.append(handle)

elif isinstance(handle, str):
# Check whether the filename is to be opened in binary mode.
# Binary mode does not support 'encoding' and 'newline'.
if ioargs.encoding and "b" not in ioargs.mode:
# Encoding
> handle = open(
handle,
ioargs.mode,
encoding=ioargs.encoding,
errors=errors,
newline="",
)
E FileNotFoundError: [Errno 2] No such file or directory: 'Orders_and_Payment_Flow_Certification.csv'

c:\users\qateam\appdata\local\programs\python\python38\lib\site-packages\pandas\io\common.py:789: FileNotFoundError
-------------------------------Captured log call--------------------------------
INFO  setup:test_orders_and_payment_flow.py:46 Total URL Present is: 5