def class_link(cls, text):
""" Generates an intra-document link for the given class. Example:
>>> from labelbox import Project
>>> class_link(Project, "blah")
>>> <a href="#class_labelbox_schema_project">blah</a>
"""
header_id = "class_" + snake_case(qual_class_name(cls).replace(".", "_"))
return header_link(text, header_id)
def create_labeler_performance(client, result):
result["user"] = Entity.User(client, result["user"])
result["lastActivityTime"] = datetime.fromtimestamp(
result["lastActivityTime"] / 1000, timezone.utc)
return LabelerPerformance(**{
utils.snake_case(key): value
for key, value in result.items()
})
def create_labeler_performance(client, result):
result["user"] = Entity.User(client, result["user"])
# python isoformat doesn't accept Z as utc timezone
result["lastActivityTime"] = datetime.fromisoformat(
result["lastActivityTime"].replace('Z', '+00:00'))
return LabelerPerformance(**{
utils.snake_case(key): value
for key, value in result.items()
})
def generate_class(cls):
""" Generates HelpDocs style documentation for the given class.
Args:
cls (type): The class to generate docs for.
Return:
HelpDocs style documentation for `cls` containing class description,
methods and fields and relationships if `schema_class`.
"""
text = []
schema_class = issubclass(cls, Entity)
text.append(header(2, cls.__name__, snake_case(cls.__name__)))
package_and_superclasses = "Class " + cls.__module__ + "." + cls.__name__
if schema_class:
superclasses = [
plugin.__name__
for plugin in (Updateable, Deletable, BulkDeletable)
if issubclass(cls, plugin)
]
if superclasses:
package_and_superclasses += " (%s)" % ", ".join(superclasses)
package_and_superclasses += "."
text.append(paragraph(package_and_superclasses, False))
text.append(preprocess_docstring(cls.__doc__))
constants = generate_constants(cls)
if constants:
text.append(header(3, "Constants"))
text.append(constants)
if schema_class:
text.append(header(3, "Fields"))
text.append(generate_fields(cls))
text.append(header(3, "Relationships"))
text.append(generate_relationships(cls))
for name, predicate in (("Static Methods",
lambda attr: type(attr) == staticmethod),
("Class Methods",
lambda attr: type(attr) == classmethod),
("Object Methods", is_method)):
functions = generate_functions(cls, predicate).strip()
if len(functions):
text.append(header(3, name))
text.append(functions)
return "\n".join(text)
def invite_limit(self) -> InviteLimit:
""" Retrieve invite limits for the org
This already accounts for users currently in the org
Meaining that `used = users + invites, remaining = limit - (users + invites)`
Returns:
InviteLimit
"""
org_id_param = "organizationId"
res = self.client.execute("""query InvitesLimitPyApi($%s: ID!) {
invitesLimit(where: {id: $%s}) { used limit remaining }
}""" % (org_id_param, org_id_param), {org_id_param: self.uid},
experimental=True)
return InviteLimit(
**{utils.snake_case(k): v
for k, v in res['invitesLimit'].items()})
def inject_class_links(text):
""" Finds all occurences of known class names in the given text and
replaces them with relative links to those classes.
"""
pattern_link_pairs = [(r"\b(%s.)?%ss?\b" % (cls.__module__, cls.__name__),
"#" + snake_case(cls.__name__))
for cls in _ALL_CLASSES]
pattern_link_pairs.append(
(r"\bPaginatedCollection\b", "general-concepts#pagination"))
for pattern, link in pattern_link_pairs:
matches = list(re.finditer(pattern, text))
for match in reversed(matches):
start, end = match.span()
link = tag(match.group(), "a", {"href": link})
text = text[:start] + link + text[end:]
return text
def __init__(self,
relationship_type,
destination_type_name,
filter_deleted=True,
name=None,
graphql_name=None):
self.relationship_type = relationship_type
self.destination_type_name = destination_type_name
self.filter_deleted = filter_deleted
if name is None:
name = utils.snake_case(destination_type_name) + (
"s" if relationship_type == Relationship.Type.ToMany else "")
self.name = name
if graphql_name is None:
graphql_name = utils.camel_case(name)
self.graphql_name = graphql_name
def header(level, text, header_id=None):
""" Wraps `text` into a <h> (header) tag ov the given level.
Automatically increases the level by 2 to be inline with HelpDocs
standards (h1 -> h3).
Example:
>>> header(2, "My Chapter")
>>> "<h4>My Chapter</h4>
Args:
level (int): Level of header.
text (str): Header text.
header_id (str or None): The ID of the header. If None it's
generated from text by converting to snake_case and
replacing all whitespace with "_".
"""
if header_id == None:
header_id = snake_case(text).replace(" ", "_")
# Convert to level + 2 for HelpDocs standard.
return tag(text, "h" + str(level + 2), {"id": header_id})
def test_snake():
assert utils.snake_case(SNAKE) == SNAKE
assert utils.snake_case(TITLE) == SNAKE
assert utils.snake_case(CAMEL) == SNAKE
assert utils.snake_case(MIXED) == SNAKE