def main() -> None:
parser = get_cli_parser()
args = parser.parse_args()
if args.version:
print(version)
return
get_logger(verbose=args.debug)
session = Session(region_name=DUMMY_REGION)
args.output_path.mkdir(exist_ok=True)
# available_services = session.get_available_services()
if not args.skip_services:
for service_name in args.service_names:
service_output_path = (
args.output_path
/ f"{service_name.module_name}_package"
/ service_name.module_name
)
service_output_path.parent.mkdir(exist_ok=True)
service_output_path.mkdir(exist_ok=True)
write_submodule(
session, service_name=service_name, output_path=service_output_path,
)
write_submodule_assets(
service_output_path=service_output_path, service_name=service_name,
)
if args.format:
format_path(service_output_path)
if not args.skip_master:
master_output_path = args.output_path / f"{MODULE_NAME}_package" / MODULE_NAME
master_output_path.parent.mkdir(exist_ok=True)
master_output_path.mkdir(exist_ok=True)
write_master_module(
output_path=master_output_path, service_names=args.service_names,
)
for service_name in args.service_names:
if not service_name.is_with_docs():
continue
service_output_path = (
args.output_path
/ f"{service_name.module_name}_package"
/ service_name.module_name
)
write_master_module_service_stub(
master_output_path, service_name, service_output_path,
)
if args.format:
format_path(master_output_path.parent)
def test_get_logger(self, logging_mock: MagicMock) -> None:
logger_mock = MagicMock()
logging_mock.getLogger.return_value = logger_mock
logger_mock.handlers = []
result = get_logger(logging_mock.DEBUG)
assert result == logger_mock
logging_mock.StreamHandler.assert_called_with()
logger_mock.setLevel.assert_called_with(logging_mock.DEBUG)
logging_mock.reset_mock()
HandlerMock = MagicMock()
logger_mock.handlers = [HandlerMock]
result = get_logger()
logging_mock.StreamHandler.assert_not_called()
logger_mock.setLevel.assert_not_called()
def parse_method(parent_name: str, name: str, method: FunctionType,
service_name: ServiceName) -> Method:
"""
Parse method to a structure.
Arguments:
parent_name -- Parent class name.
method -- Inspect method.
Returns:
Method structure.
"""
logger = get_logger()
docstring = textwrap.dedent(inspect.getdoc(method) or "")
method_name = f"{parent_name}.{name}"
logger.debug(f"Slow parsing of {method_name}: {len(docstring)} chars")
prefix = f"{get_class_prefix(parent_name)}{get_class_prefix(name)}"
arg_spec_parser = ArgSpecParser(prefix, service_name)
arguments = get_method_arguments_stub(service_name, parent_name, name)
if arguments is None:
arguments = arg_spec_parser.get_arguments(parent_name, name, method)
docstring_parser = DocstringParser(service_name, parent_name, name,
arguments)
arguments = docstring_parser.get_arguments(docstring)
return_type = arg_spec_parser.get_return_type(parent_name, name)
if return_type is None:
return_type = DocstringParser(service_name, parent_name, name,
[]).get_return_type(docstring)
return Method(name=name, arguments=arguments, return_type=return_type)
def process_master(
session: Session,
output_path: Path,
service_names: List[ServiceName],
generate_setup: bool,
) -> MasterPackage:
"""
Parse and write master package `mypy_boto3`.
Arguments:
session -- boto3 session.
output_path -- Package output path.
service_names -- List of known service names.
generate_setup -- Generate ready-to-install or to-use package.
Return:
Parsed MasterPackage.
"""
logger = get_logger()
logger.debug("Parsing master")
master_package = parse_master_package(session, service_names)
logger.debug(f"Writing master to {NicePath(output_path)}")
write_master_package(master_package,
output_path=output_path,
generate_setup=generate_setup)
return master_package
def generate_docs(args: Namespace, service_names: List[ServiceName],
session: Session) -> None:
"""
Generate service and master docs.
Arguments:
args -- Config namespace
service_names -- Enabled service names
session -- Botocore session
"""
logger = get_logger()
if not args.skip_services:
total_str = f"{len(service_names)}"
for index, service_name in enumerate(service_names):
current_str = f"{{:0{len(total_str)}}}".format(index + 1)
logger.info(
f"[{current_str}/{total_str}] Generating {service_name.module_name} module"
)
process_service_docs(
session=session,
output_path=args.output_path,
service_name=service_name,
)
if not args.skip_master:
logger.info(f"Generating {BOTO3_STUBS_NAME} module")
process_boto3_stubs_docs(
session,
args.output_path,
service_names,
)
def main() -> None:
"""
Main entrypoint for builder.
"""
parser = get_cli_parser()
args = parser.parse_args()
logger = get_logger(verbose=args.debug, panic=args.panic)
session = Session(region_name=DUMMY_REGION)
args.output_path.mkdir(exist_ok=True)
service_names: List[ServiceName] = []
master_service_names = []
available_services = session.get_available_services()
for available_service in available_services:
try:
service_name = ServiceNameCatalog.find(available_service)
master_service_names.append(service_name)
except ValueError:
logger.info(f"Service {available_service} is not supported, skipping.")
for service_name in args.service_names:
if service_name.name not in available_services:
logger.warning(f"Service {service_name.name} is not available, skipping.")
continue
service_name.boto3_version = boto3_version
service_names.append(service_name)
build_version = args.build_version or boto3_version
JinjaManager.update_globals(
master_pypi_name=PYPI_NAME,
master_module_name=MODULE_NAME,
boto3_stubs_name=BOTO3_STUBS_NAME,
boto3_version=boto3_version,
build_version=build_version,
builder_version=version,
)
logger.info(f"Bulding version {build_version}")
if not args.skip_services:
for index, service_name in enumerate(service_names):
logger.info(
f"[{index + 1}/{len(service_names)}] Generating {service_name.module_name} module"
)
output_path = args.output_path / f"{service_name.module_name}_package"
process_service(
session=session, output_path=output_path, service_name=service_name
)
if not args.skip_master:
logger.info(f"Generating {MODULE_NAME} module")
output_path = args.output_path / "master_package"
process_master(session, output_path, master_service_names)
logger.info(f"Generating {BOTO3_STUBS_NAME} module")
output_path = args.output_path / "boto3_stubs_package"
process_boto3_stubs(output_path, master_service_names)
logger.info("Completed")
def process_boto3_stubs_docs(
session: Session,
output_path: Path,
service_names: Iterable[ServiceName],
) -> Boto3StubsPackage:
"""
Parse and write master package docs.
Arguments:
session -- boto3 session
output_path -- Package output path
service_names -- List of known service names
Return:
Parsed Boto3StubsPackage.
"""
logger = get_logger()
package_data = Boto3StubsPackageData
logger.debug(f"Parsing {package_data.PYPI_NAME}")
boto3_stubs_package = parse_boto3_stubs_package(session, service_names,
package_data)
logger.debug(
f"Writing {package_data.PYPI_NAME} to {NicePath(output_path)}")
package_writer = PackageWriter(output_path=output_path)
package_writer.write_docs(
boto3_stubs_package,
templates_path=TEMPLATES_PATH / "boto3_stubs_docs",
)
return boto3_stubs_package
def __init__(self, service_name: ServiceName, prefix: str,
value: Dict[str, Any]) -> None:
self.service_name = service_name
self.logger = get_logger()
self.prefix = prefix
self.raw: Dict[str, Any] = value
self.dict_items: Optional[List[Dict[str,
Any]]] = value.get("dict_items")
if value.get("empty_dict"):
self.dict_items = []
self.set_items: Optional[List[Any]] = value.get("set_items")
self.list_items: Optional[List[Any]] = value.get("list_items")
if value.get("empty_list"):
self.list_items = []
self.func_call: Optional[Dict[str, Any]] = value.get("func_call")
self.union_items: List[Any] = []
if value.get("union_first_item"):
self.union_items.append(value["union_first_item"])
self.union_items.extend(value["union_rest_items"])
self.literal_items: List[Any] = []
if value.get("literal_first_item"):
self.literal_items.append(value["literal_first_item"])
self.literal_items.extend(value["literal_rest_items"])
self.value: Optional[str] = value.get("value")
def process_master(
session: Session,
output_path: Path,
service_names: Iterable[ServiceName],
generate_setup: bool,
version: str,
) -> MasterPackage:
"""
Parse and write master package `mypy_boto3`.
Arguments:
session -- boto3 session
output_path -- Package output path
service_names -- List of known service names
generate_setup -- Generate ready-to-install or to-use package
version -- Package version
Return:
Parsed MasterPackage.
"""
logger = get_logger()
logger.debug("Parsing master")
master_package = parse_master_package(session, service_names)
master_package.version = version
logger.debug(f"Writing master to {NicePath(output_path)}")
package_writer = PackageWriter(output_path=output_path,
generate_setup=generate_setup)
package_writer.write_package(
master_package,
templates_path=TEMPLATES_PATH / "master",
)
return master_package
def generate_docs(self) -> None:
"""
Generate service and master docs.
"""
logger = get_logger()
total_str = f"{len(self.service_names)}"
logger.info(f"Generating {Boto3StubsPackageData.NAME} module docs")
process_boto3_stubs_docs(
self.session,
self.output_path,
self.service_names,
)
for index, service_name in enumerate(self.service_names):
current_str = f"{{:0{len(total_str)}}}".format(index + 1)
package_name = Boto3StubsPackageData.get_service_package_name(
service_name)
logger.info(
f"[{current_str}/{total_str}] Generating {package_name} module docs"
)
process_service_docs(
session=self.session,
output_path=self.output_path,
service_name=service_name,
service_names=self.available_service_names,
)
def process_botocore_stubs(
output_path: Path,
generate_setup: bool,
version: str,
) -> None:
"""
Parse and write stubs package `botocore_stubs`.
Arguments:
output_path -- Package output path
generate_setup -- Generate ready-to-install or to-use package
version -- Package version
"""
logger = get_logger()
logger.debug(f"Writing botocore stubs to {NicePath(output_path)}")
botocore_stubs_package = BotocoreStubsPackage()
botocore_stubs_package.version = version
package_writer = PackageWriter(output_path=output_path,
generate_setup=generate_setup)
package_writer.write_package(
botocore_stubs_package,
templates_path=TEMPLATES_PATH / "botocore-stubs",
static_files_path=BOTOCORE_STUBS_STATIC_PATH,
)
def __init__(self, session: Session, service_name: ServiceName):
loader = session._loader # pylint: disable=protected-access
botocore_session: BotocoreSession = session._session # pylint: disable=protected-access
service_data = botocore_session.get_service_data(service_name.boto3_name)
self.service_name = service_name
self.service_model = ServiceModel(service_data, service_name.boto3_name)
self._typed_dict_map: Dict[str, TypeTypedDict] = {}
self._waiters_shape: Shape = {}
try:
self._waiters_shape = loader.load_service_model(
service_name.boto3_name, "waiters-2"
)
except UnknownServiceError:
pass
self._paginators_shape: Shape = {}
try:
self._paginators_shape = loader.load_service_model(
service_name.boto3_name, "paginators-1"
)
except UnknownServiceError:
pass
self._resources_shape: Shape = {}
try:
self._resources_shape = loader.load_service_model(
service_name.boto3_name, "resources-1"
)
except UnknownServiceError:
pass
self.logger = get_logger()
def process_aiobotocore_stubs_docs(
session: Session,
output_path: Path,
service_names: Iterable[ServiceName],
) -> AioBotocoreStubsPackage:
"""
Parse and write master package docs.
Arguments:
session -- boto3 session
output_path -- Package output path
service_names -- List of known service names
Return:
Parsed AioBotocoreStubsPackage.
"""
logger = get_logger()
aiobotocore_stubs_package = parse_aiobotocore_stubs_package(
session, service_names, TypesAioBotocorePackageData)
logger.debug(
f"Writing {aiobotocore_stubs_package.pypi_name} to {NicePath(output_path)}"
)
package_writer = PackageWriter(output_path=output_path)
package_writer.write_docs(
aiobotocore_stubs_package,
templates_path=TEMPLATES_PATH / "aiobotocore_stubs_docs",
)
return aiobotocore_stubs_package
def process_boto3_stubs(
session: Session,
output_path: Path,
service_names: List[ServiceName],
generate_setup: bool,
) -> Boto3StubsPackage:
"""
Parse and write stubs package `boto3_stubs`.
Arguments:
session -- boto3 session.
output_path -- Package output path.
service_names -- List of known service names.
generate_setup -- Generate ready-to-install or to-use package.
Return:
Parsed Boto3StubsPackage.
"""
logger = get_logger()
logger.debug("Parsing boto3 stubs")
boto3_stubs_package = parse_boto3_stubs_package(
session=session, service_names=service_names)
logger.debug(f"Writing boto3 stubs to {NicePath(output_path)}")
write_boto3_stubs_package(boto3_stubs_package,
output_path,
generate_setup=generate_setup)
return boto3_stubs_package
def process_service(
session: Session,
service_name: ServiceName,
output_path: Path,
generate_setup: bool,
) -> ServicePackage:
"""
Parse and write service package `mypy_boto3_*`.
Arguments:
session -- boto3 session.
service_name -- Target service name.
output_path -- Package output path.
generate_setup -- Generate ready-to-install or to-use package.
Return:
Parsed ServicePackage.
"""
logger = get_logger()
logger.debug(f"Parsing {service_name.boto3_name}")
service_module = parse_service_package(session, service_name)
for typed_dict in service_module.typed_dicts:
typed_dict.replace_self_references()
logger.debug(
f"Writing {service_name.boto3_name} to {NicePath(output_path)}")
write_service_package(service_module,
output_path=output_path,
generate_setup=generate_setup)
return service_module
def test_get_logger(self, logging_mock: MagicMock,
logger_mock: MagicMock) -> None:
logger_mock.handlers = []
result = get_logger(verbose=True)
assert result == logger_mock
logging_mock.StreamHandler.assert_called_with()
logger_mock.set_level.assert_called_with(logging_mock.DEBUG)
logging_mock.reset_mock()
HandlerMock = MagicMock()
logger_mock.handlers = [HandlerMock]
result = get_logger()
logging_mock.StreamHandler.assert_not_called()
logger_mock.setLevel.assert_not_called()
result = get_logger(verbose=True, panic=True)
result.panic = True
def write_service_docs(package: ServicePackage, output_path: Path) -> None:
"""
Create service docs files.
Arguments:
package -- Service package.
output_path -- Path to output folder.
"""
logger = get_logger()
docs_path = output_path / f"{package.service_name.module_name}"
docs_path.mkdir(exist_ok=True)
templates_path = Path("service_docs")
file_paths = [
(docs_path / "README.md", templates_path / "README.md.jinja2"),
(docs_path / "client.md", templates_path / "client.md.jinja2"),
]
if package.literals:
file_paths.append(
(docs_path / "literals.md", templates_path / "literals.md.jinja2"))
if package.typed_dicts:
file_paths.append((docs_path / "type_defs.md",
templates_path / "type_defs.md.jinja2"))
if package.waiters:
file_paths.append(
(docs_path / "waiters.md", templates_path / "waiters.md.jinja2"))
if package.paginators:
file_paths.append((docs_path / "paginators.md",
templates_path / "paginators.md.jinja2"))
if package.service_resource:
file_paths.append((docs_path / "service_resource.md",
templates_path / "service_resource.md.jinja2"))
for file_path, template_path in file_paths:
content = render_jinja2_template(
template_path,
package=package,
service_name=package.service_name,
)
content = insert_md_toc(content)
content = format_md(content)
if not file_path.exists() or file_path.read_text() != content:
file_path.write_text(content)
logger.debug(f"Updated {NicePath(file_path)}")
valid_paths = dict(file_paths).keys()
for unknown_path in NicePath(docs_path).walk(valid_paths):
unknown_path.unlink()
logger.debug(f"Deleted {NicePath(unknown_path)}")
def __init__(
self,
data: type[BasePackageData],
service_names: Iterable[ServiceName] = tuple(),
) -> None:
self.data = data
self.name = data.NAME
self.pypi_name = data.PYPI_NAME
self.library_name = data.LIBRARY_NAME
self.library_version = data.get_library_version()
self.version = "0.0.0"
self.service_names: list[ServiceName] = list(service_names)
self.logger = get_logger()
def __init__(
self,
service_name: ServiceName,
class_name: str,
method_name: str,
arguments: List[Argument],
) -> None:
self.prefix = f"{get_class_prefix(class_name)}{get_class_prefix(method_name)}"
self.service_name = service_name
self.class_name = class_name
self.method_name = method_name
self.logger = get_logger()
self.arguments_map: Dict[str, Argument] = {a.name: a for a in arguments if not a.prefix}
def process_botocore_stubs(
output_path: Path,
generate_setup: bool,
) -> None:
"""
Parse and write stubs package `botocore_stubs`.
Arguments:
output_path -- Package output path.
generate_setup -- Generate ready-to-install or to-use package.
"""
logger = get_logger()
logger.debug(f"Writing botocore stubs to {NicePath(output_path)}")
write_botocore_stubs_package(output_path, generate_setup=generate_setup)
def process_aiobotocore_service(
session: Session,
service_name: ServiceName,
output_path: Path,
generate_setup: bool,
service_names: Iterable[ServiceName],
version: str,
) -> ServicePackage:
"""
Parse and write service package `types_aiobotocore_*`.
Arguments:
session -- boto3 session
service_name -- Target service name
output_path -- Package output path
generate_setup -- Generate ready-to-install or to-use package
service_names -- List of known service names
version -- Package version
Return:
Parsed ServicePackage.
"""
logger = get_logger()
logger.debug(f"Parsing {service_name.boto3_name}")
service_package = parse_service_package(session, service_name,
TypesAioBotocorePackageData)
service_package.version = version
service_package.extend_literals(service_names)
postprocessor = ServicePackagePostprocessor(service_package)
postprocessor.generate_docstrings()
postprocessor.make_async()
postprocessor.add_contextmanager_methods()
for typed_dict in service_package.typed_dicts:
typed_dict.replace_self_references()
logger.debug(
f"Writing {service_name.boto3_name} to {NicePath(output_path)}")
package_writer = PackageWriter(output_path=output_path,
generate_setup=generate_setup)
package_writer.write_service_package(
service_package,
templates_path=TEMPLATES_PATH / "aiobotocore_service",
)
return service_package
def process_boto3_stubs_lite(
session: Session,
output_path: Path,
service_names: Iterable[ServiceName],
generate_setup: bool,
version: str,
) -> Boto3StubsPackage:
"""
Parse and write stubs package `boto3-stubs-lite`.
Arguments:
session -- boto3 session
output_path -- Package output path
service_names -- List of known service names
generate_setup -- Generate ready-to-install or to-use package
version -- Package version
Return:
Parsed Boto3StubsPackage.
"""
logger = get_logger()
package_data = Boto3StubsLitePackageData
logger.debug(f"Parsing {package_data.PYPI_NAME}")
boto3_stubs_package = parse_boto3_stubs_package(
session=session,
service_names=service_names,
package_data=package_data,
)
boto3_stubs_package.version = version
logger.debug(
f"Writing {package_data.PYPI_NAME} to {NicePath(output_path)}")
package_writer = PackageWriter(output_path=output_path,
generate_setup=generate_setup)
package_writer.write_package(
boto3_stubs_package,
templates_path=TEMPLATES_PATH / "boto3-stubs",
static_files_path=BOTO3_STUBS_STATIC_PATH,
exclude_template_names=[
"session.pyi.jinja2",
"__init__.pyi.jinja2",
],
)
return boto3_stubs_package
def parse_method(
parent_name: str, name: str, method: MethodType, service_name: ServiceName
) -> Method:
"""
Parse method to a structure.
Arguments:
parent_name -- Parent class name.
method -- Inspect method.
Returns:
Method structure.
"""
logger = get_logger()
docstring = textwrap.dedent(inspect.getdoc(method) or "")
method_name = f"{parent_name}.{name}"
logger.debug(f"Slow parsing of {method_name}: {len(docstring)} chars")
prefix = f"{get_class_prefix(parent_name)}{get_class_prefix(name)}"
arg_spec_parser = ArgSpecParser(prefix, service_name)
arguments = get_method_arguments_stub(service_name, parent_name, name)
if arguments is None:
arguments = arg_spec_parser.get_arguments(parent_name, name, method)
docstring_parser = DocstringParser(service_name, parent_name, name, arguments)
arguments = docstring_parser.get_arguments(docstring)
# do not add kwonly flag to resource generators
if len(arguments) > 1 and not name[0].isupper():
arguments.insert(1, Argument.kwflag())
return_type = arg_spec_parser.get_return_type(parent_name, name)
if return_type is None:
return_type = DocstringParser(service_name, parent_name, name, []).get_return_type(
docstring
)
result = Method(name=name, arguments=arguments, return_type=return_type)
result.request_type_annotation = result.get_request_type_annotation(
f"{parent_name}{get_class_prefix(name)}RequestTypeDef"
)
return result
def __init__(self, session: Session, service_name: ServiceName):
loader = session._loader
botocore_session: BotocoreSession = session._session
service_data = botocore_session.get_service_data(
service_name.boto3_name)
self.service_name = service_name
self.service_model = ServiceModel(service_data,
service_name.boto3_name)
self._typed_dict_map: dict[str, TypeTypedDict] = {}
self._waiters_shape: Mapping[str, Any] | None = None
try:
self._waiters_shape = loader.load_service_model(
service_name.boto3_name, "waiters-2")
except UnknownServiceError:
pass
self._paginators_shape: Mapping[str, Any] | None = None
try:
self._paginators_shape = loader.load_service_model(
service_name.boto3_name, "paginators-1")
except UnknownServiceError:
pass
self._resources_shape: Mapping[str, Any] | None = None
try:
self._resources_shape = loader.load_service_model(
service_name.boto3_name, "resources-1")
except UnknownServiceError:
pass
self.logger = get_logger()
self.response_metadata_typed_dict = TypeTypedDict(
"ResponseMetadataTypeDef",
[
TypedDictAttribute("RequestId", Type.str, True),
TypedDictAttribute("HostId", Type.str, True),
TypedDictAttribute("HTTPStatusCode", Type.int, True),
TypedDictAttribute("HTTPHeaders", Type.DictStrStr, True),
TypedDictAttribute("RetryAttempts", Type.int, True),
],
)
self.proxy_operation_model = OperationModel({}, self.service_model)
def get_selected_service_names(
selected: Iterable[str],
available: Iterable[ServiceName],
) -> list[ServiceName]:
"""
Get a list of selected service names.
Supports `updated` to select only services updated in currect `boto3` release.
Supports `all` to select all available service names.
Arguments:
selected -- Selected service names as strings.
available -- All ServiceNames available in current boto3 release.
Returns:
A list of selected ServiceNames.
"""
logger = get_logger()
available_map = {i.name: i for i in available}
result: list[ServiceName] = []
selected_service_names = list(selected)
botocore_version = get_botocore_version()
if ServiceName.ALL in selected_service_names:
return list(available)
if ServiceName.UPDATED in selected_service_names:
selected_service_names.remove(ServiceName.UPDATED)
for updated_service_name in BotocoreChangelog(
).get_updated_service_names(botocore_version):
if updated_service_name in available_map:
selected_service_names.append(updated_service_name)
for service_name_str in selected_service_names:
if service_name_str not in available_map:
logger.info(
f"Service {service_name_str} is not provided by botocore, skipping"
)
continue
result.append(available_map[service_name_str])
return result
def __init__(
self,
service_names: Sequence[ServiceName],
available_service_names: Iterable[ServiceName],
master_service_names: Sequence[ServiceName],
session: Session,
output_path: Path,
generate_setup: bool,
skip_published: bool,
disable_smart_version: bool,
version: str,
):
self.session = session
self.service_names = service_names
self.available_service_names = available_service_names
self.master_service_names = master_service_names
self.output_path = output_path
self.logger = get_logger()
self.generate_setup = generate_setup
self.skip_published = skip_published
self.disable_smart_version = disable_smart_version
self.version = version or get_boto3_version()
def process_service_docs(
session: Session,
service_name: ServiceName,
output_path: Path,
service_names: Iterable[ServiceName],
) -> ServicePackage:
"""
Parse and write service package docs.
Arguments:
session -- boto3 session
service_name -- Target service name
output_path -- Package output path
service_names -- List of known service names
Return:
Parsed ServicePackage.
"""
logger = get_logger()
logger.debug(f"Parsing {service_name.boto3_name}")
service_package = parse_service_package(session, service_name,
Boto3StubsPackageData)
service_package.extend_literals(service_names)
postprocessor = ServicePackagePostprocessor(service_package)
postprocessor.generate_docstrings()
for typed_dict in service_package.typed_dicts:
typed_dict.replace_self_references()
logger.debug(
f"Writing {service_name.boto3_name} to {NicePath(output_path)}")
package_writer = PackageWriter(output_path=output_path)
package_writer.write_service_docs(
service_package,
templates_path=TEMPLATES_PATH / "boto3_service_docs",
)
return service_package
def __init__(self, session: Session, service_name: ServiceName):
loader = session._loader # pylint: disable=protected-access
botocore_session: BotocoreSession = session._session # pylint: disable=protected-access
service_data = botocore_session.get_service_data(
service_name.boto3_name)
self.service_name = service_name
self.service_model = ServiceModel(service_data,
service_name.boto3_name)
self._typed_dict_map: Dict[str, TypeTypedDict] = {}
self._waiters_shape: Optional[Shape] = None
try:
self._waiters_shape = loader.load_service_model(
service_name.boto3_name, "waiters-2")
except UnknownServiceError:
pass
self._paginators_shape: Optional[Shape] = None
try:
self._paginators_shape = loader.load_service_model(
service_name.boto3_name, "paginators-1")
except UnknownServiceError:
pass
self._resources_shape: Optional[Shape] = None
try:
self._resources_shape = loader.load_service_model(
service_name.boto3_name, "resources-1")
except UnknownServiceError:
pass
self.logger = get_logger()
self.response_metadata_typed_dict = TypeTypedDict(
"ResponseMetadata",
[
TypedDictAttribute("RequestId", Type.str, True),
TypedDictAttribute("HostId", Type.str, True),
TypedDictAttribute("HTTPStatusCode", Type.int, True),
TypedDictAttribute("HTTPHeaders", Type.DictStrAny, True),
TypedDictAttribute("RetryAttempts", Type.int, True),
],
)
def process_boto3_stubs_docs(
session: Session,
output_path: Path,
service_names: List[ServiceName],
) -> Boto3StubsPackage:
"""
Parse and write master package docs.
Arguments:
session -- boto3 session.
output_path -- Package output path.
service_names -- List of known service names.
Return:
Parsed Boto3StubsPackage.
"""
logger = get_logger()
logger.debug("Parsing boto3 stubs")
boto3_stubs_package = parse_boto3_stubs_package(session, service_names)
logger.debug(f"Writing boto3 stubs to {NicePath(output_path)}")
write_boto3_stubs_docs(boto3_stubs_package, output_path=output_path)
return boto3_stubs_package
def process_aiobotocore_stubs_lite(
session: Session,
output_path: Path,
service_names: Iterable[ServiceName],
generate_setup: bool,
version: str,
) -> AioBotocoreStubsPackage:
"""
Parse and write stubs package `aiobotocore-stubs-lite`.
Arguments:
session -- boto3 session
output_path -- Package output path
service_names -- List of known service names
generate_setup -- Generate ready-to-install or to-use package
version -- Package version
Return:
Parsed AioBotocoreStubsPackage.
"""
logger = get_logger()
aiobotocore_stubs_package = parse_aiobotocore_stubs_package(
session, service_names, TypesAioBotocoreLitePackageData)
aiobotocore_stubs_package.version = version
logger.debug(
f"Writing {aiobotocore_stubs_package.pypi_name} to {NicePath(output_path)}"
)
package_writer = PackageWriter(output_path=output_path,
generate_setup=generate_setup)
package_writer.write_package(
aiobotocore_stubs_package,
templates_path=TEMPLATES_PATH / "aiobotocore-stubs",
static_files_path=AIOBOTOCORE_STUBS_STATIC_PATH,
exclude_template_names=["session.pyi.jinja2"],
)
return aiobotocore_stubs_package