class AboutGitHubButton:
""" The github button block in the About sidebar """
github_button: Annotated[bool, Get(ThemeConfig, attr='github_button')]
github_count: Annotated[str, Get(ThemeConfig, attr='github_count')]
github_repo: Annotated[Optional[str], Get(ThemeConfig, attr='github_repo')]
github_type: Annotated[str, Get(ThemeConfig, attr='github_type')]
github_user: Annotated[Optional[str], Get(ThemeConfig, attr='github_user')]
show_button: bool = field(init=False)
def __post_init__(self):
if self.github_button and self.github_repo and self.github_user:
self.show_button = True
else:
self.show_button = False
def __call__(self) -> Optional[VDOM]:
if self.show_button:
return html('''\n
<p>
<iframe src="https://ghbtns.com/github-btn.html?user={self.github_user}&repo={self.github_repo}&type={self.github_type}&count={self.github_count}&size=large&v=2"
allowtransparency="true" frameborder="0" scrolling="0" width="200px" height="35px"></iframe>
</p>
''')
return None
class Relations:
master_doc: Annotated[str, Get(SphinxConfig, attr='master_doc')]
pathto: Annotated[Callable[[str], str], Get(PageContext, attr='pathto')]
toctree: Annotated[Optional[Callable[[], str]],
Get(PageContext, attr='toctree')]
resolved_pathto: str = field(init=False)
resolved_toctree: Markup = field(init=False)
def __post_init__(self):
self.resolved_pathto = self.pathto(self.master_doc)
self.resolved_toctree = Markup(self.toctree())
def __call__(self) -> VDOM:
# Alabaster has a weird relations.html which isn't really well-formed
# on looping. This makes it not-well-formed on snippets.
return html('''\n
<div class="relations">
<h3>Contents</h3>
<ul>
<li><a href={self.resolved_pathto}>Documentation overview</a>
</li>
</ul>
{self.resolved_toctree}
</div>
''')
class Document:
""" A block in content, holding most of the info on this resource """
body: Annotated[
Markup,
Get(PageContext, attr='body'),
]
nosidebar: Annotated[
bool,
Get(HTMLConfig),
Attr('nosidebar'),
]
inner: VDOM = field(init=False)
def __post_init__(self):
# Alabaster wraps the main content in <div class="bodywrapper">
# if nosidebar is true. Thus, get the main content first, then
# insert in the two flavors of response.
main_content = html('''\n
<{Relbar1}/>
<div class="body" role="main">
{self.body}
</div>
<{Relbar2}/>
''')
self.inner = main_content if self.nosidebar else html('<div class="bodywrapper">{main_content}</div>')
def __call__(self) -> VDOM:
return html('''\n
<div class="documentwrapper">
{self.inner}
</div>
''')
class RellinkMarkup:
""" Markup for rellink bars. """
previous: Annotated[Link, Get(PageContext, attr='prev'), ]
next: Annotated[Link, Get(PageContext, attr='next'), ]
resolved_previous: VDOM = field(init=False)
resolved_next: VDOM = field(init=False)
def __post_init__(self):
self.resolved_previous = html('''\n
<li>
←
<a href="{self.previous.link}" title="Previous Document">{self.previous.title}</a>
</li>
''') if self.previous else None
self.resolved_next = html('''\n
<li>
<a href="{self.next.link}" title="Next Document">{self.next.title}</a>
→
</li>
''') if self.previous else None
def __call__(self) -> VDOM:
return html('''\n
<nav id="rellinks">
<ul>
{self.resolved_previous}
{self.resolved_next}
</ul>
</nav>
''')
class SearchBox:
builder: Annotated[str, Get(PageContext, attr='builder')]
pagename: Annotated[str, Get(PageContext, attr='pagename')]
pathto: Annotated[Callable[[str], str], Get(PageContext, attr='pathto')]
resolved_pathto: str = field(init=False)
def __post_init__(self):
self.resolved_pathto = self.pathto('search')
def __call__(self) -> VDOM:
if self.pagename != 'search' and self.builder != 'singlehtml':
return html('''\n
<div id="searchbox" style="display: none" role="search" data-testid="searchbox">
<h3>{{ _('Quick search') }}</h3>
<div class="searchformwrapper">
<form class="search" action="{self.resolved_pathto}" method="get">
<input type="text" name="q" />
<input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form>
</div>
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
''')
return html('')
class AboutCodeCovButton:
""" The travis button block in the About sidebar """
github_repo: Annotated[Optional[str], Get(ThemeConfig, attr='github_repo')]
github_user: Annotated[Optional[str], Get(ThemeConfig, attr='github_user')]
codecov_button: Annotated[bool, Get(ThemeConfig, attr='codecov_button')]
codecov_path: Annotated[str, Get(ThemeConfig, attr='codecov_path')]
badge_branch: Annotated[str, Get(ThemeConfig, attr='badge_branch')]
resolved_path: str = field(init=False)
def __post_init__(self):
if self.codecov_path:
self.resolved_path = self.codecov_path
else:
self.resolved_path = f'{self.github_user}/{self.github_repo}'
def __call__(self) -> Optional[VDOM]:
path = self.resolved_path
if self.codecov_button:
return html('''\n
<p>
<a class="badge" href="https://codecov.io/github/{path}">
<img
alt="https://codecov.io/github/{path}/coverage.svg?branch={self.badge_branch}"
src="https://codecov.io/github/{path}/coverage.svg?branch={self.badge_branch}"
/>
</a>
</p>
''')
return None
class AboutLogo:
""" The logo block in the About sidebar """
logo: Annotated[Optional[str], Get(HTMLConfig, attr='logo')]
master_doc: Annotated[str, Get(SphinxConfig, attr='master_doc')]
pathto: Annotated[Callable[[str, Optional[int]], str],
Get(PageContext, attr='pathto')]
resolved_master: str = field(init=False)
resolved_logo: str = field(init=False)
def __post_init__(self):
self.resolved_master = self.pathto(self.master_doc, 0)
self.resolved_logo = self.pathto(f'_static/{self.logo}',
1) if self.logo else ''
def __call__(self) -> Optional[VDOM]:
if self.logo:
return html('''\n
<p class="logo">
<a href={self.resolved_master}>
<img class="logo" src={self.resolved_logo} alt="Logo"/>
</a>
</p>
''')
return None
class Title:
resource_title: Annotated[str, Get(Resource, attr='title'), ]
site_title: Annotated[Optional[str], Get(SphinxConfig, attr='project'), ]
resolved_title: str = field(init=False)
def __post_init__(self):
if self.site_title:
raw_title = f'{self.resource_title} - {self.site_title}'
else:
raw_title = f'{self.resource_title}'
self.resolved_title = Markup(raw_title).striptags()
def __call__(self) -> VDOM:
return html('<title>{self.resolved_title}</title>')
class Relbar2:
""" Relation bar usually at the bottom. """
show_relbar_bottom: Annotated[bool,
Get(ThemeConfig, attr='show_relbar_top')]
show_relbars: Annotated[bool, Get(ThemeConfig, attr='show_relbar_top')]
show_relbar_top: bool = field(init=False)
def __post_init__(self):
self.show_relbar_top = self.show_relbar_bottom or self.show_relbars
def __call__(self) -> VDOM:
return html('''\n
<div class="related top"><{RellinkMarkup} /> </div>
''') if self.show_relbar_top else []
def test_get_then_attr(french_container):
get = Get(View)
start = View
result1 = get(start, french_container)
attr = Attr('name')
result = attr(result1, french_container)
assert 'French View' == result
class View:
settings: Annotated[MySettings, Get(BaseSettings)]
@property
def name(self):
site_name = self.settings.site_name
return f'View - {site_name}'
def target(
french_view: Annotated[
FrenchView,
Get(View),
]
):
return french_view
class HelloWorld:
name: str
title: Annotated[str, Get(Resource, attr='title')]
def __call__(self) -> VDOM:
return html(
'<h1>Resource: {self.title}</h1><span>Hello {self.name}</span>')
class Head:
pathto: Annotated[Callable[[str, int], str],
Get(PageContext, attr='pathto'), ]
extrahead: Optional[Tuple[VDOM, ...]] = None
charset: str = 'utf-8'
resolved_custom_css: str = field(init=False)
resolved_docs_src: str = field(init=False)
resolved_static_root: str = field(init=False)
def __post_init__(self):
self.resolved_custom_css = self.pathto('_static/custom.css', 1)
self.resolved_docs_src = self.pathto(
'_static/documentation_options.js', 1)
self.resolved_static_root = self.pathto('', 1)
def __call__(self) -> VDOM:
return html('''\n
<head>
<meta charset="{self.charset}" />
<meta name="viewport" content="width=device-width, initial-scale=1"/>
<{Title} />
<{CSSFiles} />
<script id="documentation_options" data-url_root="{self.resolved_static_root}" src="{self.resolved_docs_src}">//</script>
<{JSFiles} />
<link rel="stylesheet" href="{self.resolved_custom_css}" type="text/css"/>
<{CanonicalLink} />
<{FaviconSet}/>
<{Linktags} />
{self.extrahead}
</head>
''')
class Heading:
person: str
name: Annotated[str, Context(), Attr('name')]
greeting: Annotated[str, Get(Settings), Attr('greeting')]
def __call__(self):
return html('''<h1>{self.greeting} {self.person}, {self.name}</h1>''')
class DummyComponent2:
""" Test passing in singletons"""
singleton_title: Annotated[str, Get(DummySingleton, attr='title')]
def __call__(self) -> VDOM:
return html('<div>Hello {self.singleton_title}</div>')
class View:
site_name: Annotated[str, Get(BaseSettings, attr='site_name'), ]
@property
def name(self):
site_name = self.site_name
return f'View - {site_name}'
class Relbar1:
""" Relation bar usually at the top. """
show_relbar_top: Annotated[bool,
Get(ThemeConfig),
Attr('show_relbar_top'), ]
show_relbars: Annotated[bool, Get(ThemeConfig), Attr('show_relbar_top'), ]
resolved_show_relbars: bool = field(init=False)
def __post_init__(self):
self.resolved_show_relbars = self.show_relbar_top or self.show_relbars
def __call__(self) -> VDOM:
return html('''\n
<div class="related top"><{RellinkMarkup} /> </div>
''') if self.resolved_show_relbars else []
def test_pipeline_one(french_container):
pipeline = (Get(View), )
result: FrenchView = process_pipeline(
french_container,
pipeline,
start=View,
)
assert result.name == 'French View'
def test_pipeline_two(french_container):
pipeline = (Get(View), Attr('name'))
result = process_pipeline(
french_container,
pipeline,
start=View,
)
assert result == 'French View'
def target(
view_name: Annotated[
str,
Get(Foo),
Attr('name'),
] = 'View Name'
):
return view_name
class CanonicalLink:
baseurl: Annotated[Optional[str], Get(HTMLConfig), Attr('baseurl')]
canonical_href: Optional[str] = field(init=False)
file_suffix: Annotated[str, Get(HTMLConfig), Attr('file_suffix'), ]
pagename: Annotated[str, Get(PageContext, attr='pagename'), ]
def __post_init__(self):
if self.baseurl:
self.canonical_href = join(self.baseurl,
self.pagename + self.file_suffix)
else:
self.canonical_href = None
def __call__(self) -> Optional[VDOM]:
if self.canonical_href:
return html('<link rel="canonical" href={self.canonical_href}/>')
return None
def target(
view_name: Annotated[
str,
Get(View),
Attr('name'),
],
):
return view_name
def test_is_pipeline_get(regular_container):
# There is a pipeline that does one thing
pipeline = (Get(View), )
fi = FieldInfo('foo', str, None, True, pipeline)
field_make_pipeline = FieldMakePipeline(fi, {}, regular_container)
with pytest.raises(FoundValueField) as exc:
field_make_pipeline()
assert exc.value.value.name == 'View'
class CSSFiles:
site_files: Annotated[Paths,
Get(HTMLConfig, attr='css_files'),
StaticPathTo(), ]
theme_files: Annotated[Paths,
Get(ThemeConfig, attr='css_files'),
StaticPathTo(), ]
page_files: Annotated[Paths,
Get(PageContext, attr='css_files'),
StaticPathTo(), ]
hrefs: Tuple[str, ...] = field(init=False)
def __post_init__(self):
self.hrefs = self.site_files + self.theme_files + self.page_files
def __call__(self) -> VDOM:
return html('{[CSSFile(href) for href in self.hrefs]}')
class JSFiles:
site_files: Annotated[Paths,
Get(HTMLConfig, attr='js_files'),
StaticPathTo(), ]
theme_files: Annotated[Paths,
Get(ThemeConfig, 'js_files'),
StaticPathTo(), ]
page_files: Annotated[Paths,
Get(PageContext, 'js_files'),
StaticPathTo(), ]
srcs: Tuple[str, ...] = field(init=False)
def __post_init__(self):
self.srcs = self.site_files + self.theme_files + self.page_files
def __call__(self) -> VDOM:
return html('{[JSFile(src) for src in self.srcs]}')
def target(
container: ServiceContainer,
french_customer: Annotated[
FrenchView,
Get(View),
],
):
return french_customer
class LocalToc:
display_toc: Annotated[bool, Get(PageContext, attr='display_toc')]
master_doc: Annotated[str, Get(SphinxConfig, attr='master_doc')]
pathto: Annotated[Callable[[str], str], Get(PageContext, attr='pathto')]
toc: Annotated[Markup, Get(PageContext, attr='toc')]
resolved_pathto: str = field(init=False)
def __post_init__(self):
self.resolved_pathto = self.pathto(self.master_doc)
def __call__(self) -> VDOM:
if self.display_toc:
return html('''\n
<h3><a href={self.resolved_pathto}>Table of Contents</a></h3>
{self.toc}
''')
return html('')
class AboutDescription:
""" The description block in the About sidebar """
description: Annotated[Optional[str], Get(ThemeConfig, attr='description')]
def __call__(self) -> Optional[VDOM]:
if self.description:
return html('<p class="blurb">{self.description}</p>')
return None
def test_annotation_optional():
def target(customer: Optional[Annotated[Customer, Get(FrenchCustomer)]]):
return 99
field_infos = _get_field_infos(target)
assert field_infos[0].field_name == 'customer'
assert field_infos[0].field_type is Customer
assert field_infos[0].default_value is None
assert field_infos[0].pipeline == (Get(FrenchCustomer), )